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 // Activates the client based on the certificate ID.
13 //
14 // @param request - ActivateClientCertificateRequest
15 //
16 // @param runtime - runtime options for this request RuntimeOptions
17 //
18 // @return ActivateClientCertificateResponse
19 func ActivateClientCertificateWithContext(ctx context.Context, client *Client, request *ActivateClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *ActivateClientCertificateResponse, _err error) {
20 if dara.BoolValue(client.EnableValidate) == true {
21 _err = request.Validate()
22 if _err != nil {
23 return _result, _err
24 }
25 }
26 query := openapiutil.Query(dara.ToMap(request))
27 req := &openapiutil.OpenApiRequest{
28 Query: openapiutil.Query(query),
29 }
30 params := &openapiutil.Params{
31 Action: dara.String("ActivateClientCertificate"),
32 Version: dara.String("2024-09-10"),
33 Protocol: dara.String("HTTPS"),
34 Pathname: dara.String("/"),
35 Method: dara.String("GET"),
36 AuthType: dara.String("AK"),
37 Style: dara.String("RPC"),
38 ReqBodyType: dara.String("formData"),
39 BodyType: dara.String("json"),
40 }
41 _result = &ActivateClientCertificateResponse{}
42 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
43 if _err != nil {
44 return _result, _err
45 }
46 _err = dara.Convert(_body, &_result)
47 return _result, _err
48 }
49
50 // Summary:
51 //
52 // # Enable Version Management
53 //
54 // @param request - ActivateVersionManagementRequest
55 //
56 // @param runtime - runtime options for this request RuntimeOptions
57 //
58 // @return ActivateVersionManagementResponse
59 func ActivateVersionManagementWithContext(ctx context.Context, client *Client, request *ActivateVersionManagementRequest, runtime *dara.RuntimeOptions) (_result *ActivateVersionManagementResponse, _err error) {
60 if dara.BoolValue(client.EnableValidate) == true {
61 _err = request.Validate()
62 if _err != nil {
63 return _result, _err
64 }
65 }
66 query := map[string]interface{}{}
67 if !dara.IsNil(request.SiteId) {
68 query["SiteId"] = request.SiteId
69 }
70
71 req := &openapiutil.OpenApiRequest{
72 Query: openapiutil.Query(query),
73 }
74 params := &openapiutil.Params{
75 Action: dara.String("ActivateVersionManagement"),
76 Version: dara.String("2024-09-10"),
77 Protocol: dara.String("HTTPS"),
78 Pathname: dara.String("/"),
79 Method: dara.String("POST"),
80 AuthType: dara.String("AK"),
81 Style: dara.String("RPC"),
82 ReqBodyType: dara.String("formData"),
83 BodyType: dara.String("json"),
84 }
85 _result = &ActivateVersionManagementResponse{}
86 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
87 if _err != nil {
88 return _result, _err
89 }
90 _err = dara.Convert(_body, &_result)
91 return _result, _err
92 }
93
94 // Summary:
95 //
96 // Applies for a free SSL certificate.
97 //
98 // @param request - ApplyCertificateRequest
99 //
100 // @param runtime - runtime options for this request RuntimeOptions
101 //
102 // @return ApplyCertificateResponse
103 func ApplyCertificateWithContext(ctx context.Context, client *Client, request *ApplyCertificateRequest, runtime *dara.RuntimeOptions) (_result *ApplyCertificateResponse, _err error) {
104 if dara.BoolValue(client.EnableValidate) == true {
105 _err = request.Validate()
106 if _err != nil {
107 return _result, _err
108 }
109 }
110 query := openapiutil.Query(dara.ToMap(request))
111 req := &openapiutil.OpenApiRequest{
112 Query: openapiutil.Query(query),
113 }
114 params := &openapiutil.Params{
115 Action: dara.String("ApplyCertificate"),
116 Version: dara.String("2024-09-10"),
117 Protocol: dara.String("HTTPS"),
118 Pathname: dara.String("/"),
119 Method: dara.String("GET"),
120 AuthType: dara.String("AK"),
121 Style: dara.String("RPC"),
122 ReqBodyType: dara.String("formData"),
123 BodyType: dara.String("json"),
124 }
125 _result = &ApplyCertificateResponse{}
126 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
127 if _err != nil {
128 return _result, _err
129 }
130 _err = dara.Convert(_body, &_result)
131 return _result, _err
132 }
133
134 // Summary:
135 //
136 // Adds DNS records of different record types at a time..
137 //
138 // Description:
139 //
140 // This operation allows you to create or update multiple DNS records at a time. It is suitable for managing a large number of DNS configurations. Supported record types include but are not limited to A/AAAA, CNAME, NS, MX, TXT, CAA, SRV, and URI. The operation allows you to configure the priority, flag, tag, and weight for DNS records. In addition, for specific types of records, such as CERT, SSHFP, SMIMEA, and TLSA, advanced settings such as certificate information and encryption algorithms are also supported.
141 //
142 // Successful and failed records along with error messages are listed in the response.
143 //
144 // @param tmpReq - BatchCreateRecordsRequest
145 //
146 // @param runtime - runtime options for this request RuntimeOptions
147 //
148 // @return BatchCreateRecordsResponse
149 func BatchCreateRecordsWithContext(ctx context.Context, client *Client, tmpReq *BatchCreateRecordsRequest, runtime *dara.RuntimeOptions) (_result *BatchCreateRecordsResponse, _err error) {
150 if dara.BoolValue(client.EnableValidate) == true {
151 _err = tmpReq.Validate()
152 if _err != nil {
153 return _result, _err
154 }
155 }
156 request := &BatchCreateRecordsShrinkRequest{}
157 openapiutil.Convert(tmpReq, request)
158 if !dara.IsNil(tmpReq.RecordList) {
159 request.RecordListShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RecordList, dara.String("RecordList"), dara.String("json"))
160 }
161
162 query := map[string]interface{}{}
163 if !dara.IsNil(request.RecordListShrink) {
164 query["RecordList"] = request.RecordListShrink
165 }
166
167 if !dara.IsNil(request.SiteId) {
168 query["SiteId"] = request.SiteId
169 }
170
171 req := &openapiutil.OpenApiRequest{
172 Query: openapiutil.Query(query),
173 }
174 params := &openapiutil.Params{
175 Action: dara.String("BatchCreateRecords"),
176 Version: dara.String("2024-09-10"),
177 Protocol: dara.String("HTTPS"),
178 Pathname: dara.String("/"),
179 Method: dara.String("POST"),
180 AuthType: dara.String("AK"),
181 Style: dara.String("RPC"),
182 ReqBodyType: dara.String("formData"),
183 BodyType: dara.String("json"),
184 }
185 _result = &BatchCreateRecordsResponse{}
186 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
187 if _err != nil {
188 return _result, _err
189 }
190 _err = dara.Convert(_body, &_result)
191 return _result, _err
192 }
193
194 // Summary:
195 //
196 // # Batch Create WAF Rules
197 //
198 // @param tmpReq - BatchCreateWafRulesRequest
199 //
200 // @param runtime - runtime options for this request RuntimeOptions
201 //
202 // @return BatchCreateWafRulesResponse
203 func BatchCreateWafRulesWithContext(ctx context.Context, client *Client, tmpReq *BatchCreateWafRulesRequest, runtime *dara.RuntimeOptions) (_result *BatchCreateWafRulesResponse, _err error) {
204 if dara.BoolValue(client.EnableValidate) == true {
205 _err = tmpReq.Validate()
206 if _err != nil {
207 return _result, _err
208 }
209 }
210 request := &BatchCreateWafRulesShrinkRequest{}
211 openapiutil.Convert(tmpReq, request)
212 if !dara.IsNil(tmpReq.Configs) {
213 request.ConfigsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Configs, dara.String("Configs"), dara.String("json"))
214 }
215
216 if !dara.IsNil(tmpReq.Shared) {
217 request.SharedShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Shared, dara.String("Shared"), dara.String("json"))
218 }
219
220 query := map[string]interface{}{}
221 if !dara.IsNil(request.SiteId) {
222 query["SiteId"] = request.SiteId
223 }
224
225 if !dara.IsNil(request.SiteVersion) {
226 query["SiteVersion"] = request.SiteVersion
227 }
228
229 body := map[string]interface{}{}
230 if !dara.IsNil(request.ConfigsShrink) {
231 body["Configs"] = request.ConfigsShrink
232 }
233
234 if !dara.IsNil(request.Phase) {
235 body["Phase"] = request.Phase
236 }
237
238 if !dara.IsNil(request.RulesetId) {
239 body["RulesetId"] = request.RulesetId
240 }
241
242 if !dara.IsNil(request.SharedShrink) {
243 body["Shared"] = request.SharedShrink
244 }
245
246 req := &openapiutil.OpenApiRequest{
247 Query: openapiutil.Query(query),
248 Body: openapiutil.ParseToMap(body),
249 }
250 params := &openapiutil.Params{
251 Action: dara.String("BatchCreateWafRules"),
252 Version: dara.String("2024-09-10"),
253 Protocol: dara.String("HTTPS"),
254 Pathname: dara.String("/"),
255 Method: dara.String("POST"),
256 AuthType: dara.String("AK"),
257 Style: dara.String("RPC"),
258 ReqBodyType: dara.String("formData"),
259 BodyType: dara.String("json"),
260 }
261 _result = &BatchCreateWafRulesResponse{}
262 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
263 if _err != nil {
264 return _result, _err
265 }
266 _err = dara.Convert(_body, &_result)
267 return _result, _err
268 }
269
270 // Summary:
271 //
272 // Deletes key-value pairs from a namespace at a time based on keys.
273 //
274 // @param tmpReq - BatchDeleteKvRequest
275 //
276 // @param runtime - runtime options for this request RuntimeOptions
277 //
278 // @return BatchDeleteKvResponse
279 func BatchDeleteKvWithContext(ctx context.Context, client *Client, tmpReq *BatchDeleteKvRequest, runtime *dara.RuntimeOptions) (_result *BatchDeleteKvResponse, _err error) {
280 if dara.BoolValue(client.EnableValidate) == true {
281 _err = tmpReq.Validate()
282 if _err != nil {
283 return _result, _err
284 }
285 }
286 request := &BatchDeleteKvShrinkRequest{}
287 openapiutil.Convert(tmpReq, request)
288 if !dara.IsNil(tmpReq.Keys) {
289 request.KeysShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Keys, dara.String("Keys"), dara.String("json"))
290 }
291
292 query := map[string]interface{}{}
293 if !dara.IsNil(request.Namespace) {
294 query["Namespace"] = request.Namespace
295 }
296
297 body := map[string]interface{}{}
298 if !dara.IsNil(request.KeysShrink) {
299 body["Keys"] = request.KeysShrink
300 }
301
302 req := &openapiutil.OpenApiRequest{
303 Query: openapiutil.Query(query),
304 Body: openapiutil.ParseToMap(body),
305 }
306 params := &openapiutil.Params{
307 Action: dara.String("BatchDeleteKv"),
308 Version: dara.String("2024-09-10"),
309 Protocol: dara.String("HTTPS"),
310 Pathname: dara.String("/"),
311 Method: dara.String("POST"),
312 AuthType: dara.String("AK"),
313 Style: dara.String("RPC"),
314 ReqBodyType: dara.String("formData"),
315 BodyType: dara.String("json"),
316 }
317 _result = &BatchDeleteKvResponse{}
318 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
319 if _err != nil {
320 return _result, _err
321 }
322 _err = dara.Convert(_body, &_result)
323 return _result, _err
324 }
325
326 // Summary:
327 //
328 // Deletes multiple key-value pairs from a namespace at a time based on specified keys. The request body can be up to 100 MB.
329 //
330 // Description:
331 //
332 // This operation allows you to upload a larger request body than by using [BatchDeleteKv](https://help.aliyun.com/document_detail/2850204.html). For small request bodies, we recommend that you use [BatchDeleteKv](https://help.aliyun.com/document_detail/2850204.html) to minimize the server processing time. This operation must be called by using SDKs. The following sample code uses the Golang SDK and BatchDeleteKvWithHighCapacityAdvance to call the operation.
333 //
334 // func TestBatchDeleteWithHighCapacity() error {
335 //
336 // // Initialize the configurations.
337 //
338 // cfg := new(openapi.Config)
339 //
340 // cfg.SetAccessKeyId("xxxxxxxxx")
341 //
342 // cfg.SetAccessKeySecret("xxxxxxxxxx")
343 //
344 // cli, err := NewClient(cfg)
345 //
346 // if err != nil {
347 //
348 // return err
349 //
350 // }
351 //
352 // runtime := &util.RuntimeOptions{}
353 //
354 // // Construct a request for deleting key-value pairs at a time.
355 //
356 // namespace := "test_batch_put"
357 //
358 // rawReq := BatchDeleteKvRequest{
359 //
360 // Namespace: &namespace,
361 //
362 // }
363 //
364 // for i := 0; i < 10000; i++ {
365 //
366 // key := fmt.Sprintf("test_key_%d", i)
367 //
368 // rawReq.Keys = append(rawReq.Keys, &key)
369 //
370 // }
371 //
372 // payload, err := json.Marshal(rawReq)
373 //
374 // if err != nil {
375 //
376 // return err
377 //
378 // }
379 //
380 // // If the payload is greater than 2 MB, call the BatchDeleteKvWithHighCapacity operation for deletion.
381 //
382 // reqHighCapacity := BatchDeleteKvWithHighCapacityAdvanceRequest{
383 //
384 // Namespace: &namespace,
385 //
386 // UrlObject: bytes.NewReader(payload),
387 //
388 // }
389 //
390 // resp, err := cli.BatchDeleteKvWithHighCapacityAdvance(&reqHighCapacity, runtime)
391 //
392 // if err != nil {
393 //
394 // return err
395 //
396 // }
397 //
398 // return nil
399 //
400 // }
401 //
402 // @param request - BatchDeleteKvWithHighCapacityRequest
403 //
404 // @param runtime - runtime options for this request RuntimeOptions
405 //
406 // @return BatchDeleteKvWithHighCapacityResponse
407 func BatchDeleteKvWithHighCapacityWithContext(ctx context.Context, client *Client, request *BatchDeleteKvWithHighCapacityRequest, runtime *dara.RuntimeOptions) (_result *BatchDeleteKvWithHighCapacityResponse, _err error) {
408 if dara.BoolValue(client.EnableValidate) == true {
409 _err = request.Validate()
410 if _err != nil {
411 return _result, _err
412 }
413 }
414 query := map[string]interface{}{}
415 if !dara.IsNil(request.Namespace) {
416 query["Namespace"] = request.Namespace
417 }
418
419 if !dara.IsNil(request.Url) {
420 query["Url"] = request.Url
421 }
422
423 req := &openapiutil.OpenApiRequest{
424 Query: openapiutil.Query(query),
425 }
426 params := &openapiutil.Params{
427 Action: dara.String("BatchDeleteKvWithHighCapacity"),
428 Version: dara.String("2024-09-10"),
429 Protocol: dara.String("HTTPS"),
430 Pathname: dara.String("/"),
431 Method: dara.String("POST"),
432 AuthType: dara.String("AK"),
433 Style: dara.String("RPC"),
434 ReqBodyType: dara.String("formData"),
435 BodyType: dara.String("json"),
436 }
437 _result = &BatchDeleteKvWithHighCapacityResponse{}
438 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
439 if _err != nil {
440 return _result, _err
441 }
442 _err = dara.Convert(_body, &_result)
443 return _result, _err
444 }
445
446 // Summary:
447 //
448 // # Batch Get Expression Matches
449 //
450 // @param tmpReq - BatchGetExpressionFieldsRequest
451 //
452 // @param runtime - runtime options for this request RuntimeOptions
453 //
454 // @return BatchGetExpressionFieldsResponse
455 func BatchGetExpressionFieldsWithContext(ctx context.Context, client *Client, tmpReq *BatchGetExpressionFieldsRequest, runtime *dara.RuntimeOptions) (_result *BatchGetExpressionFieldsResponse, _err error) {
456 if dara.BoolValue(client.EnableValidate) == true {
457 _err = tmpReq.Validate()
458 if _err != nil {
459 return _result, _err
460 }
461 }
462 request := &BatchGetExpressionFieldsShrinkRequest{}
463 openapiutil.Convert(tmpReq, request)
464 if !dara.IsNil(tmpReq.Expressions) {
465 request.ExpressionsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Expressions, dara.String("Expressions"), dara.String("json"))
466 }
467
468 query := map[string]interface{}{}
469 if !dara.IsNil(request.InstanceId) {
470 query["InstanceId"] = request.InstanceId
471 }
472
473 if !dara.IsNil(request.PlanNameEn) {
474 query["PlanNameEn"] = request.PlanNameEn
475 }
476
477 if !dara.IsNil(request.SiteId) {
478 query["SiteId"] = request.SiteId
479 }
480
481 body := map[string]interface{}{}
482 if !dara.IsNil(request.ExpressionsShrink) {
483 body["Expressions"] = request.ExpressionsShrink
484 }
485
486 if !dara.IsNil(request.Kind) {
487 body["Kind"] = request.Kind
488 }
489
490 if !dara.IsNil(request.Phase) {
491 body["Phase"] = request.Phase
492 }
493
494 req := &openapiutil.OpenApiRequest{
495 Query: openapiutil.Query(query),
496 Body: openapiutil.ParseToMap(body),
497 }
498 params := &openapiutil.Params{
499 Action: dara.String("BatchGetExpressionFields"),
500 Version: dara.String("2024-09-10"),
501 Protocol: dara.String("HTTPS"),
502 Pathname: dara.String("/"),
503 Method: dara.String("POST"),
504 AuthType: dara.String("AK"),
505 Style: dara.String("RPC"),
506 ReqBodyType: dara.String("formData"),
507 BodyType: dara.String("json"),
508 }
509 _result = &BatchGetExpressionFieldsResponse{}
510 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
511 if _err != nil {
512 return _result, _err
513 }
514 _err = dara.Convert(_body, &_result)
515 return _result, _err
516 }
517
518 // Summary:
519 //
520 // Configures key-value pairs for a namespace at a time based on specified keys.
521 //
522 // @param tmpReq - BatchPutKvRequest
523 //
524 // @param runtime - runtime options for this request RuntimeOptions
525 //
526 // @return BatchPutKvResponse
527 func BatchPutKvWithContext(ctx context.Context, client *Client, tmpReq *BatchPutKvRequest, runtime *dara.RuntimeOptions) (_result *BatchPutKvResponse, _err error) {
528 if dara.BoolValue(client.EnableValidate) == true {
529 _err = tmpReq.Validate()
530 if _err != nil {
531 return _result, _err
532 }
533 }
534 request := &BatchPutKvShrinkRequest{}
535 openapiutil.Convert(tmpReq, request)
536 if !dara.IsNil(tmpReq.KvList) {
537 request.KvListShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.KvList, dara.String("KvList"), dara.String("json"))
538 }
539
540 query := map[string]interface{}{}
541 if !dara.IsNil(request.Namespace) {
542 query["Namespace"] = request.Namespace
543 }
544
545 body := map[string]interface{}{}
546 if !dara.IsNil(request.KvListShrink) {
547 body["KvList"] = request.KvListShrink
548 }
549
550 req := &openapiutil.OpenApiRequest{
551 Query: openapiutil.Query(query),
552 Body: openapiutil.ParseToMap(body),
553 }
554 params := &openapiutil.Params{
555 Action: dara.String("BatchPutKv"),
556 Version: dara.String("2024-09-10"),
557 Protocol: dara.String("HTTPS"),
558 Pathname: dara.String("/"),
559 Method: dara.String("POST"),
560 AuthType: dara.String("AK"),
561 Style: dara.String("RPC"),
562 ReqBodyType: dara.String("formData"),
563 BodyType: dara.String("json"),
564 }
565 _result = &BatchPutKvResponse{}
566 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
567 if _err != nil {
568 return _result, _err
569 }
570 _err = dara.Convert(_body, &_result)
571 return _result, _err
572 }
573
574 // Summary:
575 //
576 // Configures key-value pairs for a namespace at a time based on specified keys. The request body can be up to 100 MB.
577 //
578 // Description:
579 //
580 // This operation allows you to upload a larger request body than by using [BatchPutKv](https://help.aliyun.com/document_detail/2850203.html). For small request bodies, we recommend that you use [BatchPutKv](https://help.aliyun.com/document_detail/2850203.html) to minimize the server processing time. This operation must be called by using SDKs. The following sample code uses the Golang SDK and BatchPutKvWithHighCapacityAdvance to call the operation.
581 //
582 // func TestBatchPutKvWithHighCapacity() error {
583 //
584 // // Initialize the configurations.
585 //
586 // cfg := new(openapi.Config)
587 //
588 // cfg.SetAccessKeyId("xxxxxxxxx")
589 //
590 // cfg.SetAccessKeySecret("xxxxxxxxxx")
591 //
592 // cli, err := NewClient(cfg)
593 //
594 // if err != nil {
595 //
596 // return err
597 //
598 // }
599 //
600 // runtime := &util.RuntimeOptions{}
601 //
602 // // Construct a request for uploading key-value pairs at a time.
603 //
604 // namespace := "test_batch_put"
605 //
606 // numKv := 10000
607 //
608 // kvList := make([]*BatchPutKvRequestKvList, numKv)
609 //
610 // test_value := strings.Repeat("a", 10*1024)
611 //
612 // for i := 0; i < numKv; i++ {
613 //
614 // key := fmt.Sprintf("test_key_%d", i)
615 //
616 // value := test_value
617 //
618 // kvList[i] = &BatchPutKvRequestKvList{
619 //
620 // Key: &key,
621 //
622 // Value: &value,
623 //
624 // }
625 //
626 // }
627 //
628 // rawReq := BatchPutKvRequest{
629 //
630 // Namespace: &namespace,
631 //
632 // KvList: kvList,
633 //
634 // }
635 //
636 // payload, err := json.Marshal(rawReq)
637 //
638 // if err != nil {
639 //
640 // return err
641 //
642 // }
643 //
644 // // If the payload is greater than 2 MB, call the BatchPutKvWithHighCapacity operation for upload.
645 //
646 // reqHighCapacity := BatchPutKvWithHighCapacityAdvanceRequest{
647 //
648 // Namespace: &namespace,
649 //
650 // UrlObject: bytes.NewReader(payload),
651 //
652 // }
653 //
654 // resp, err := cli.BatchPutKvWithHighCapacityAdvance(&reqHighCapacity, runtime)
655 //
656 // if err != nil {
657 //
658 // return err
659 //
660 // }
661 //
662 // return nil
663 //
664 // }
665 //
666 // @param request - BatchPutKvWithHighCapacityRequest
667 //
668 // @param runtime - runtime options for this request RuntimeOptions
669 //
670 // @return BatchPutKvWithHighCapacityResponse
671 func BatchPutKvWithHighCapacityWithContext(ctx context.Context, client *Client, request *BatchPutKvWithHighCapacityRequest, runtime *dara.RuntimeOptions) (_result *BatchPutKvWithHighCapacityResponse, _err error) {
672 if dara.BoolValue(client.EnableValidate) == true {
673 _err = request.Validate()
674 if _err != nil {
675 return _result, _err
676 }
677 }
678 query := map[string]interface{}{}
679 if !dara.IsNil(request.Namespace) {
680 query["Namespace"] = request.Namespace
681 }
682
683 if !dara.IsNil(request.Url) {
684 query["Url"] = request.Url
685 }
686
687 req := &openapiutil.OpenApiRequest{
688 Query: openapiutil.Query(query),
689 }
690 params := &openapiutil.Params{
691 Action: dara.String("BatchPutKvWithHighCapacity"),
692 Version: dara.String("2024-09-10"),
693 Protocol: dara.String("HTTPS"),
694 Pathname: dara.String("/"),
695 Method: dara.String("POST"),
696 AuthType: dara.String("AK"),
697 Style: dara.String("RPC"),
698 ReqBodyType: dara.String("formData"),
699 BodyType: dara.String("json"),
700 }
701 _result = &BatchPutKvWithHighCapacityResponse{}
702 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
703 if _err != nil {
704 return _result, _err
705 }
706 _err = dara.Convert(_body, &_result)
707 return _result, _err
708 }
709
710 // Summary:
711 //
712 // Modifies multiple rules in a specific Web Application Firewall (WAF) ruleset at a time.
713 //
714 // @param tmpReq - BatchUpdateWafRulesRequest
715 //
716 // @param runtime - runtime options for this request RuntimeOptions
717 //
718 // @return BatchUpdateWafRulesResponse
719 func BatchUpdateWafRulesWithContext(ctx context.Context, client *Client, tmpReq *BatchUpdateWafRulesRequest, runtime *dara.RuntimeOptions) (_result *BatchUpdateWafRulesResponse, _err error) {
720 if dara.BoolValue(client.EnableValidate) == true {
721 _err = tmpReq.Validate()
722 if _err != nil {
723 return _result, _err
724 }
725 }
726 request := &BatchUpdateWafRulesShrinkRequest{}
727 openapiutil.Convert(tmpReq, request)
728 if !dara.IsNil(tmpReq.Configs) {
729 request.ConfigsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Configs, dara.String("Configs"), dara.String("json"))
730 }
731
732 if !dara.IsNil(tmpReq.Shared) {
733 request.SharedShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Shared, dara.String("Shared"), dara.String("json"))
734 }
735
736 query := map[string]interface{}{}
737 if !dara.IsNil(request.SiteId) {
738 query["SiteId"] = request.SiteId
739 }
740
741 if !dara.IsNil(request.SiteVersion) {
742 query["SiteVersion"] = request.SiteVersion
743 }
744
745 body := map[string]interface{}{}
746 if !dara.IsNil(request.ConfigsShrink) {
747 body["Configs"] = request.ConfigsShrink
748 }
749
750 if !dara.IsNil(request.Phase) {
751 body["Phase"] = request.Phase
752 }
753
754 if !dara.IsNil(request.RulesetId) {
755 body["RulesetId"] = request.RulesetId
756 }
757
758 if !dara.IsNil(request.SharedShrink) {
759 body["Shared"] = request.SharedShrink
760 }
761
762 req := &openapiutil.OpenApiRequest{
763 Query: openapiutil.Query(query),
764 Body: openapiutil.ParseToMap(body),
765 }
766 params := &openapiutil.Params{
767 Action: dara.String("BatchUpdateWafRules"),
768 Version: dara.String("2024-09-10"),
769 Protocol: dara.String("HTTPS"),
770 Pathname: dara.String("/"),
771 Method: dara.String("POST"),
772 AuthType: dara.String("AK"),
773 Style: dara.String("RPC"),
774 ReqBodyType: dara.String("formData"),
775 BodyType: dara.String("json"),
776 }
777 _result = &BatchUpdateWafRulesResponse{}
778 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
779 if _err != nil {
780 return _result, _err
781 }
782 _err = dara.Convert(_body, &_result)
783 return _result, _err
784 }
785
786 // Summary:
787 //
788 // Blocks URLs.
789 //
790 // @param tmpReq - BlockObjectRequest
791 //
792 // @param runtime - runtime options for this request RuntimeOptions
793 //
794 // @return BlockObjectResponse
795 func BlockObjectWithContext(ctx context.Context, client *Client, tmpReq *BlockObjectRequest, runtime *dara.RuntimeOptions) (_result *BlockObjectResponse, _err error) {
796 if dara.BoolValue(client.EnableValidate) == true {
797 _err = tmpReq.Validate()
798 if _err != nil {
799 return _result, _err
800 }
801 }
802 request := &BlockObjectShrinkRequest{}
803 openapiutil.Convert(tmpReq, request)
804 if !dara.IsNil(tmpReq.Content) {
805 request.ContentShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Content, dara.String("Content"), dara.String("json"))
806 }
807
808 query := map[string]interface{}{}
809 if !dara.IsNil(request.ContentShrink) {
810 query["Content"] = request.ContentShrink
811 }
812
813 if !dara.IsNil(request.Extension) {
814 query["Extension"] = request.Extension
815 }
816
817 if !dara.IsNil(request.Maxage) {
818 query["Maxage"] = request.Maxage
819 }
820
821 if !dara.IsNil(request.SiteId) {
822 query["SiteId"] = request.SiteId
823 }
824
825 if !dara.IsNil(request.Type) {
826 query["Type"] = request.Type
827 }
828
829 req := &openapiutil.OpenApiRequest{
830 Query: openapiutil.Query(query),
831 }
832 params := &openapiutil.Params{
833 Action: dara.String("BlockObject"),
834 Version: dara.String("2024-09-10"),
835 Protocol: dara.String("HTTPS"),
836 Pathname: dara.String("/"),
837 Method: dara.String("POST"),
838 AuthType: dara.String("AK"),
839 Style: dara.String("RPC"),
840 ReqBodyType: dara.String("formData"),
841 BodyType: dara.String("json"),
842 }
843 _result = &BlockObjectResponse{}
844 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
845 if _err != nil {
846 return _result, _err
847 }
848 _err = dara.Convert(_body, &_result)
849 return _result, _err
850 }
851
852 // Summary:
853 //
854 // Checks whether a specified website name is available.
855 //
856 // @param request - CheckSiteNameRequest
857 //
858 // @param runtime - runtime options for this request RuntimeOptions
859 //
860 // @return CheckSiteNameResponse
861 func CheckSiteNameWithContext(ctx context.Context, client *Client, request *CheckSiteNameRequest, runtime *dara.RuntimeOptions) (_result *CheckSiteNameResponse, _err error) {
862 if dara.BoolValue(client.EnableValidate) == true {
863 _err = request.Validate()
864 if _err != nil {
865 return _result, _err
866 }
867 }
868 query := map[string]interface{}{}
869 if !dara.IsNil(request.SiteName) {
870 query["SiteName"] = request.SiteName
871 }
872
873 req := &openapiutil.OpenApiRequest{
874 Query: openapiutil.Query(query),
875 }
876 params := &openapiutil.Params{
877 Action: dara.String("CheckSiteName"),
878 Version: dara.String("2024-09-10"),
879 Protocol: dara.String("HTTPS"),
880 Pathname: dara.String("/"),
881 Method: dara.String("POST"),
882 AuthType: dara.String("AK"),
883 Style: dara.String("RPC"),
884 ReqBodyType: dara.String("formData"),
885 BodyType: dara.String("json"),
886 }
887 _result = &CheckSiteNameResponse{}
888 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
889 if _err != nil {
890 return _result, _err
891 }
892 _err = dara.Convert(_body, &_result)
893 return _result, _err
894 }
895
896 // Summary:
897 //
898 // Checks the name of a real-time log delivery task.
899 //
900 // @param request - CheckSiteProjectNameRequest
901 //
902 // @param runtime - runtime options for this request RuntimeOptions
903 //
904 // @return CheckSiteProjectNameResponse
905 func CheckSiteProjectNameWithContext(ctx context.Context, client *Client, request *CheckSiteProjectNameRequest, runtime *dara.RuntimeOptions) (_result *CheckSiteProjectNameResponse, _err error) {
906 if dara.BoolValue(client.EnableValidate) == true {
907 _err = request.Validate()
908 if _err != nil {
909 return _result, _err
910 }
911 }
912 query := openapiutil.Query(dara.ToMap(request))
913 req := &openapiutil.OpenApiRequest{
914 Query: openapiutil.Query(query),
915 }
916 params := &openapiutil.Params{
917 Action: dara.String("CheckSiteProjectName"),
918 Version: dara.String("2024-09-10"),
919 Protocol: dara.String("HTTPS"),
920 Pathname: dara.String("/"),
921 Method: dara.String("GET"),
922 AuthType: dara.String("AK"),
923 Style: dara.String("RPC"),
924 ReqBodyType: dara.String("formData"),
925 BodyType: dara.String("json"),
926 }
927 _result = &CheckSiteProjectNameResponse{}
928 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
929 if _err != nil {
930 return _result, _err
931 }
932 _err = dara.Convert(_body, &_result)
933 return _result, _err
934 }
935
936 // Summary:
937 //
938 // Checks the name of a real-time log delivery task by account.
939 //
940 // @param request - CheckUserProjectNameRequest
941 //
942 // @param runtime - runtime options for this request RuntimeOptions
943 //
944 // @return CheckUserProjectNameResponse
945 func CheckUserProjectNameWithContext(ctx context.Context, client *Client, request *CheckUserProjectNameRequest, runtime *dara.RuntimeOptions) (_result *CheckUserProjectNameResponse, _err error) {
946 if dara.BoolValue(client.EnableValidate) == true {
947 _err = request.Validate()
948 if _err != nil {
949 return _result, _err
950 }
951 }
952 query := openapiutil.Query(dara.ToMap(request))
953 req := &openapiutil.OpenApiRequest{
954 Query: openapiutil.Query(query),
955 }
956 params := &openapiutil.Params{
957 Action: dara.String("CheckUserProjectName"),
958 Version: dara.String("2024-09-10"),
959 Protocol: dara.String("HTTPS"),
960 Pathname: dara.String("/"),
961 Method: dara.String("GET"),
962 AuthType: dara.String("AK"),
963 Style: dara.String("RPC"),
964 ReqBodyType: dara.String("formData"),
965 BodyType: dara.String("json"),
966 }
967 _result = &CheckUserProjectNameResponse{}
968 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
969 if _err != nil {
970 return _result, _err
971 }
972 _err = dara.Convert(_body, &_result)
973 return _result, _err
974 }
975
976 // Summary:
977 //
978 // Commits the unstable code in the staging environment to generate an official code version.
979 //
980 // @param request - CommitRoutineStagingCodeRequest
981 //
982 // @param runtime - runtime options for this request RuntimeOptions
983 //
984 // @return CommitRoutineStagingCodeResponse
985 func CommitRoutineStagingCodeWithContext(ctx context.Context, client *Client, request *CommitRoutineStagingCodeRequest, runtime *dara.RuntimeOptions) (_result *CommitRoutineStagingCodeResponse, _err error) {
986 if dara.BoolValue(client.EnableValidate) == true {
987 _err = request.Validate()
988 if _err != nil {
989 return _result, _err
990 }
991 }
992 body := map[string]interface{}{}
993 if !dara.IsNil(request.CodeDescription) {
994 body["CodeDescription"] = request.CodeDescription
995 }
996
997 if !dara.IsNil(request.Name) {
998 body["Name"] = request.Name
999 }
1000
1001 req := &openapiutil.OpenApiRequest{
1002 Body: openapiutil.ParseToMap(body),
1003 }
1004 params := &openapiutil.Params{
1005 Action: dara.String("CommitRoutineStagingCode"),
1006 Version: dara.String("2024-09-10"),
1007 Protocol: dara.String("HTTPS"),
1008 Pathname: dara.String("/"),
1009 Method: dara.String("POST"),
1010 AuthType: dara.String("AK"),
1011 Style: dara.String("RPC"),
1012 ReqBodyType: dara.String("formData"),
1013 BodyType: dara.String("json"),
1014 }
1015 _result = &CommitRoutineStagingCodeResponse{}
1016 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1017 if _err != nil {
1018 return _result, _err
1019 }
1020 _err = dara.Convert(_body, &_result)
1021 return _result, _err
1022 }
1023
1024 // Summary:
1025 //
1026 // # Create a new site cache configuration
1027 //
1028 // @param request - CreateCacheRuleRequest
1029 //
1030 // @param runtime - runtime options for this request RuntimeOptions
1031 //
1032 // @return CreateCacheRuleResponse
1033 func CreateCacheRuleWithContext(ctx context.Context, client *Client, request *CreateCacheRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateCacheRuleResponse, _err error) {
1034 if dara.BoolValue(client.EnableValidate) == true {
1035 _err = request.Validate()
1036 if _err != nil {
1037 return _result, _err
1038 }
1039 }
1040 query := map[string]interface{}{}
1041 if !dara.IsNil(request.AdditionalCacheablePorts) {
1042 query["AdditionalCacheablePorts"] = request.AdditionalCacheablePorts
1043 }
1044
1045 if !dara.IsNil(request.BrowserCacheMode) {
1046 query["BrowserCacheMode"] = request.BrowserCacheMode
1047 }
1048
1049 if !dara.IsNil(request.BrowserCacheTtl) {
1050 query["BrowserCacheTtl"] = request.BrowserCacheTtl
1051 }
1052
1053 if !dara.IsNil(request.BypassCache) {
1054 query["BypassCache"] = request.BypassCache
1055 }
1056
1057 if !dara.IsNil(request.CacheDeceptionArmor) {
1058 query["CacheDeceptionArmor"] = request.CacheDeceptionArmor
1059 }
1060
1061 if !dara.IsNil(request.CacheReserveEligibility) {
1062 query["CacheReserveEligibility"] = request.CacheReserveEligibility
1063 }
1064
1065 if !dara.IsNil(request.CheckPresenceCookie) {
1066 query["CheckPresenceCookie"] = request.CheckPresenceCookie
1067 }
1068
1069 if !dara.IsNil(request.CheckPresenceHeader) {
1070 query["CheckPresenceHeader"] = request.CheckPresenceHeader
1071 }
1072
1073 if !dara.IsNil(request.EdgeCacheMode) {
1074 query["EdgeCacheMode"] = request.EdgeCacheMode
1075 }
1076
1077 if !dara.IsNil(request.EdgeCacheTtl) {
1078 query["EdgeCacheTtl"] = request.EdgeCacheTtl
1079 }
1080
1081 if !dara.IsNil(request.EdgeStatusCodeCacheTtl) {
1082 query["EdgeStatusCodeCacheTtl"] = request.EdgeStatusCodeCacheTtl
1083 }
1084
1085 if !dara.IsNil(request.IncludeCookie) {
1086 query["IncludeCookie"] = request.IncludeCookie
1087 }
1088
1089 if !dara.IsNil(request.IncludeHeader) {
1090 query["IncludeHeader"] = request.IncludeHeader
1091 }
1092
1093 if !dara.IsNil(request.PostBodyCacheKey) {
1094 query["PostBodyCacheKey"] = request.PostBodyCacheKey
1095 }
1096
1097 if !dara.IsNil(request.PostBodySizeLimit) {
1098 query["PostBodySizeLimit"] = request.PostBodySizeLimit
1099 }
1100
1101 if !dara.IsNil(request.PostCache) {
1102 query["PostCache"] = request.PostCache
1103 }
1104
1105 if !dara.IsNil(request.QueryString) {
1106 query["QueryString"] = request.QueryString
1107 }
1108
1109 if !dara.IsNil(request.QueryStringMode) {
1110 query["QueryStringMode"] = request.QueryStringMode
1111 }
1112
1113 if !dara.IsNil(request.Rule) {
1114 query["Rule"] = request.Rule
1115 }
1116
1117 if !dara.IsNil(request.RuleEnable) {
1118 query["RuleEnable"] = request.RuleEnable
1119 }
1120
1121 if !dara.IsNil(request.RuleName) {
1122 query["RuleName"] = request.RuleName
1123 }
1124
1125 if !dara.IsNil(request.Sequence) {
1126 query["Sequence"] = request.Sequence
1127 }
1128
1129 if !dara.IsNil(request.ServeStale) {
1130 query["ServeStale"] = request.ServeStale
1131 }
1132
1133 if !dara.IsNil(request.SiteId) {
1134 query["SiteId"] = request.SiteId
1135 }
1136
1137 if !dara.IsNil(request.SiteVersion) {
1138 query["SiteVersion"] = request.SiteVersion
1139 }
1140
1141 if !dara.IsNil(request.SortQueryStringForCache) {
1142 query["SortQueryStringForCache"] = request.SortQueryStringForCache
1143 }
1144
1145 if !dara.IsNil(request.UserDeviceType) {
1146 query["UserDeviceType"] = request.UserDeviceType
1147 }
1148
1149 if !dara.IsNil(request.UserGeo) {
1150 query["UserGeo"] = request.UserGeo
1151 }
1152
1153 if !dara.IsNil(request.UserLanguage) {
1154 query["UserLanguage"] = request.UserLanguage
1155 }
1156
1157 req := &openapiutil.OpenApiRequest{
1158 Query: openapiutil.Query(query),
1159 }
1160 params := &openapiutil.Params{
1161 Action: dara.String("CreateCacheRule"),
1162 Version: dara.String("2024-09-10"),
1163 Protocol: dara.String("HTTPS"),
1164 Pathname: dara.String("/"),
1165 Method: dara.String("POST"),
1166 AuthType: dara.String("AK"),
1167 Style: dara.String("RPC"),
1168 ReqBodyType: dara.String("formData"),
1169 BodyType: dara.String("json"),
1170 }
1171 _result = &CreateCacheRuleResponse{}
1172 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1173 if _err != nil {
1174 return _result, _err
1175 }
1176 _err = dara.Convert(_body, &_result)
1177 return _result, _err
1178 }
1179
1180 // Summary:
1181 //
1182 // Uses the ESA-managed certificate authority (CA) to issue client certificates.
1183 //
1184 // @param request - CreateClientCertificateRequest
1185 //
1186 // @param runtime - runtime options for this request RuntimeOptions
1187 //
1188 // @return CreateClientCertificateResponse
1189 func CreateClientCertificateWithContext(ctx context.Context, client *Client, request *CreateClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *CreateClientCertificateResponse, _err error) {
1190 if dara.BoolValue(client.EnableValidate) == true {
1191 _err = request.Validate()
1192 if _err != nil {
1193 return _result, _err
1194 }
1195 }
1196 query := map[string]interface{}{}
1197 if !dara.IsNil(request.SiteId) {
1198 query["SiteId"] = request.SiteId
1199 }
1200
1201 body := map[string]interface{}{}
1202 if !dara.IsNil(request.CSR) {
1203 body["CSR"] = request.CSR
1204 }
1205
1206 if !dara.IsNil(request.PkeyType) {
1207 body["PkeyType"] = request.PkeyType
1208 }
1209
1210 if !dara.IsNil(request.ValidityDays) {
1211 body["ValidityDays"] = request.ValidityDays
1212 }
1213
1214 req := &openapiutil.OpenApiRequest{
1215 Query: openapiutil.Query(query),
1216 Body: openapiutil.ParseToMap(body),
1217 }
1218 params := &openapiutil.Params{
1219 Action: dara.String("CreateClientCertificate"),
1220 Version: dara.String("2024-09-10"),
1221 Protocol: dara.String("HTTPS"),
1222 Pathname: dara.String("/"),
1223 Method: dara.String("POST"),
1224 AuthType: dara.String("AK"),
1225 Style: dara.String("RPC"),
1226 ReqBodyType: dara.String("formData"),
1227 BodyType: dara.String("json"),
1228 }
1229 _result = &CreateClientCertificateResponse{}
1230 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1231 if _err != nil {
1232 return _result, _err
1233 }
1234 _err = dara.Convert(_body, &_result)
1235 return _result, _err
1236 }
1237
1238 // Summary:
1239 //
1240 // # Add a compression rule
1241 //
1242 // @param request - CreateCompressionRuleRequest
1243 //
1244 // @param runtime - runtime options for this request RuntimeOptions
1245 //
1246 // @return CreateCompressionRuleResponse
1247 func CreateCompressionRuleWithContext(ctx context.Context, client *Client, request *CreateCompressionRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateCompressionRuleResponse, _err error) {
1248 if dara.BoolValue(client.EnableValidate) == true {
1249 _err = request.Validate()
1250 if _err != nil {
1251 return _result, _err
1252 }
1253 }
1254 query := map[string]interface{}{}
1255 if !dara.IsNil(request.Brotli) {
1256 query["Brotli"] = request.Brotli
1257 }
1258
1259 if !dara.IsNil(request.Gzip) {
1260 query["Gzip"] = request.Gzip
1261 }
1262
1263 if !dara.IsNil(request.Rule) {
1264 query["Rule"] = request.Rule
1265 }
1266
1267 if !dara.IsNil(request.RuleEnable) {
1268 query["RuleEnable"] = request.RuleEnable
1269 }
1270
1271 if !dara.IsNil(request.RuleName) {
1272 query["RuleName"] = request.RuleName
1273 }
1274
1275 if !dara.IsNil(request.Sequence) {
1276 query["Sequence"] = request.Sequence
1277 }
1278
1279 if !dara.IsNil(request.SiteId) {
1280 query["SiteId"] = request.SiteId
1281 }
1282
1283 if !dara.IsNil(request.SiteVersion) {
1284 query["SiteVersion"] = request.SiteVersion
1285 }
1286
1287 if !dara.IsNil(request.Zstd) {
1288 query["Zstd"] = request.Zstd
1289 }
1290
1291 req := &openapiutil.OpenApiRequest{
1292 Query: openapiutil.Query(query),
1293 }
1294 params := &openapiutil.Params{
1295 Action: dara.String("CreateCompressionRule"),
1296 Version: dara.String("2024-09-10"),
1297 Protocol: dara.String("HTTPS"),
1298 Pathname: dara.String("/"),
1299 Method: dara.String("POST"),
1300 AuthType: dara.String("AK"),
1301 Style: dara.String("RPC"),
1302 ReqBodyType: dara.String("formData"),
1303 BodyType: dara.String("json"),
1304 }
1305 _result = &CreateCompressionRuleResponse{}
1306 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1307 if _err != nil {
1308 return _result, _err
1309 }
1310 _err = dara.Convert(_body, &_result)
1311 return _result, _err
1312 }
1313
1314 // Summary:
1315 //
1316 // Creates an account-level custom scenario policy. You can execute a policy after you associate the policy with a website.
1317 //
1318 // @param request - CreateCustomScenePolicyRequest
1319 //
1320 // @param runtime - runtime options for this request RuntimeOptions
1321 //
1322 // @return CreateCustomScenePolicyResponse
1323 func CreateCustomScenePolicyWithContext(ctx context.Context, client *Client, request *CreateCustomScenePolicyRequest, runtime *dara.RuntimeOptions) (_result *CreateCustomScenePolicyResponse, _err error) {
1324 if dara.BoolValue(client.EnableValidate) == true {
1325 _err = request.Validate()
1326 if _err != nil {
1327 return _result, _err
1328 }
1329 }
1330 query := map[string]interface{}{}
1331 if !dara.IsNil(request.EndTime) {
1332 query["EndTime"] = request.EndTime
1333 }
1334
1335 if !dara.IsNil(request.Name) {
1336 query["Name"] = request.Name
1337 }
1338
1339 if !dara.IsNil(request.Objects) {
1340 query["Objects"] = request.Objects
1341 }
1342
1343 if !dara.IsNil(request.SiteIds) {
1344 query["SiteIds"] = request.SiteIds
1345 }
1346
1347 if !dara.IsNil(request.StartTime) {
1348 query["StartTime"] = request.StartTime
1349 }
1350
1351 if !dara.IsNil(request.Template) {
1352 query["Template"] = request.Template
1353 }
1354
1355 req := &openapiutil.OpenApiRequest{
1356 Query: openapiutil.Query(query),
1357 }
1358 params := &openapiutil.Params{
1359 Action: dara.String("CreateCustomScenePolicy"),
1360 Version: dara.String("2024-09-10"),
1361 Protocol: dara.String("HTTPS"),
1362 Pathname: dara.String("/"),
1363 Method: dara.String("POST"),
1364 AuthType: dara.String("AK"),
1365 Style: dara.String("RPC"),
1366 ReqBodyType: dara.String("formData"),
1367 BodyType: dara.String("json"),
1368 }
1369 _result = &CreateCustomScenePolicyResponse{}
1370 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1371 if _err != nil {
1372 return _result, _err
1373 }
1374 _err = dara.Convert(_body, &_result)
1375 return _result, _err
1376 }
1377
1378 // Summary:
1379 //
1380 // Creates a containerized application. You can deploy and release a version of the application across points of presence (POPs).
1381 //
1382 // @param request - CreateEdgeContainerAppRequest
1383 //
1384 // @param runtime - runtime options for this request RuntimeOptions
1385 //
1386 // @return CreateEdgeContainerAppResponse
1387 func CreateEdgeContainerAppWithContext(ctx context.Context, client *Client, request *CreateEdgeContainerAppRequest, runtime *dara.RuntimeOptions) (_result *CreateEdgeContainerAppResponse, _err error) {
1388 if dara.BoolValue(client.EnableValidate) == true {
1389 _err = request.Validate()
1390 if _err != nil {
1391 return _result, _err
1392 }
1393 }
1394 body := map[string]interface{}{}
1395 if !dara.IsNil(request.HealthCheckFailTimes) {
1396 body["HealthCheckFailTimes"] = request.HealthCheckFailTimes
1397 }
1398
1399 if !dara.IsNil(request.HealthCheckHost) {
1400 body["HealthCheckHost"] = request.HealthCheckHost
1401 }
1402
1403 if !dara.IsNil(request.HealthCheckHttpCode) {
1404 body["HealthCheckHttpCode"] = request.HealthCheckHttpCode
1405 }
1406
1407 if !dara.IsNil(request.HealthCheckInterval) {
1408 body["HealthCheckInterval"] = request.HealthCheckInterval
1409 }
1410
1411 if !dara.IsNil(request.HealthCheckMethod) {
1412 body["HealthCheckMethod"] = request.HealthCheckMethod
1413 }
1414
1415 if !dara.IsNil(request.HealthCheckPort) {
1416 body["HealthCheckPort"] = request.HealthCheckPort
1417 }
1418
1419 if !dara.IsNil(request.HealthCheckSuccTimes) {
1420 body["HealthCheckSuccTimes"] = request.HealthCheckSuccTimes
1421 }
1422
1423 if !dara.IsNil(request.HealthCheckTimeout) {
1424 body["HealthCheckTimeout"] = request.HealthCheckTimeout
1425 }
1426
1427 if !dara.IsNil(request.HealthCheckType) {
1428 body["HealthCheckType"] = request.HealthCheckType
1429 }
1430
1431 if !dara.IsNil(request.HealthCheckURI) {
1432 body["HealthCheckURI"] = request.HealthCheckURI
1433 }
1434
1435 if !dara.IsNil(request.Name) {
1436 body["Name"] = request.Name
1437 }
1438
1439 if !dara.IsNil(request.Remarks) {
1440 body["Remarks"] = request.Remarks
1441 }
1442
1443 if !dara.IsNil(request.ServicePort) {
1444 body["ServicePort"] = request.ServicePort
1445 }
1446
1447 if !dara.IsNil(request.TargetPort) {
1448 body["TargetPort"] = request.TargetPort
1449 }
1450
1451 req := &openapiutil.OpenApiRequest{
1452 Body: openapiutil.ParseToMap(body),
1453 }
1454 params := &openapiutil.Params{
1455 Action: dara.String("CreateEdgeContainerApp"),
1456 Version: dara.String("2024-09-10"),
1457 Protocol: dara.String("HTTPS"),
1458 Pathname: dara.String("/"),
1459 Method: dara.String("POST"),
1460 AuthType: dara.String("AK"),
1461 Style: dara.String("RPC"),
1462 ReqBodyType: dara.String("formData"),
1463 BodyType: dara.String("json"),
1464 }
1465 _result = &CreateEdgeContainerAppResponse{}
1466 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1467 if _err != nil {
1468 return _result, _err
1469 }
1470 _err = dara.Convert(_body, &_result)
1471 return _result, _err
1472 }
1473
1474 // Summary:
1475 //
1476 // 创建边缘容器应用的镜像秘钥
1477 //
1478 // @param request - CreateEdgeContainerAppImageSecretRequest
1479 //
1480 // @param runtime - runtime options for this request RuntimeOptions
1481 //
1482 // @return CreateEdgeContainerAppImageSecretResponse
1483 func CreateEdgeContainerAppImageSecretWithContext(ctx context.Context, client *Client, request *CreateEdgeContainerAppImageSecretRequest, runtime *dara.RuntimeOptions) (_result *CreateEdgeContainerAppImageSecretResponse, _err error) {
1484 if dara.BoolValue(client.EnableValidate) == true {
1485 _err = request.Validate()
1486 if _err != nil {
1487 return _result, _err
1488 }
1489 }
1490 query := map[string]interface{}{}
1491 if !dara.IsNil(request.AppId) {
1492 query["AppId"] = request.AppId
1493 }
1494
1495 if !dara.IsNil(request.Password) {
1496 query["Password"] = request.Password
1497 }
1498
1499 if !dara.IsNil(request.Registry) {
1500 query["Registry"] = request.Registry
1501 }
1502
1503 if !dara.IsNil(request.Username) {
1504 query["Username"] = request.Username
1505 }
1506
1507 req := &openapiutil.OpenApiRequest{
1508 Query: openapiutil.Query(query),
1509 }
1510 params := &openapiutil.Params{
1511 Action: dara.String("CreateEdgeContainerAppImageSecret"),
1512 Version: dara.String("2024-09-10"),
1513 Protocol: dara.String("HTTPS"),
1514 Pathname: dara.String("/"),
1515 Method: dara.String("POST"),
1516 AuthType: dara.String("AK"),
1517 Style: dara.String("RPC"),
1518 ReqBodyType: dara.String("formData"),
1519 BodyType: dara.String("json"),
1520 }
1521 _result = &CreateEdgeContainerAppImageSecretResponse{}
1522 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1523 if _err != nil {
1524 return _result, _err
1525 }
1526 _err = dara.Convert(_body, &_result)
1527 return _result, _err
1528 }
1529
1530 // Summary:
1531 //
1532 // Associates a domain name with a containerized application. This way, requests destined for the associated domain name are forwarded to the application.
1533 //
1534 // @param request - CreateEdgeContainerAppRecordRequest
1535 //
1536 // @param runtime - runtime options for this request RuntimeOptions
1537 //
1538 // @return CreateEdgeContainerAppRecordResponse
1539 func CreateEdgeContainerAppRecordWithContext(ctx context.Context, client *Client, request *CreateEdgeContainerAppRecordRequest, runtime *dara.RuntimeOptions) (_result *CreateEdgeContainerAppRecordResponse, _err error) {
1540 if dara.BoolValue(client.EnableValidate) == true {
1541 _err = request.Validate()
1542 if _err != nil {
1543 return _result, _err
1544 }
1545 }
1546 body := map[string]interface{}{}
1547 if !dara.IsNil(request.AppId) {
1548 body["AppId"] = request.AppId
1549 }
1550
1551 if !dara.IsNil(request.RecordName) {
1552 body["RecordName"] = request.RecordName
1553 }
1554
1555 if !dara.IsNil(request.SiteId) {
1556 body["SiteId"] = request.SiteId
1557 }
1558
1559 req := &openapiutil.OpenApiRequest{
1560 Body: openapiutil.ParseToMap(body),
1561 }
1562 params := &openapiutil.Params{
1563 Action: dara.String("CreateEdgeContainerAppRecord"),
1564 Version: dara.String("2024-09-10"),
1565 Protocol: dara.String("HTTPS"),
1566 Pathname: dara.String("/"),
1567 Method: dara.String("POST"),
1568 AuthType: dara.String("AK"),
1569 Style: dara.String("RPC"),
1570 ReqBodyType: dara.String("formData"),
1571 BodyType: dara.String("json"),
1572 }
1573 _result = &CreateEdgeContainerAppRecordResponse{}
1574 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1575 if _err != nil {
1576 return _result, _err
1577 }
1578 _err = dara.Convert(_body, &_result)
1579 return _result, _err
1580 }
1581
1582 // Summary:
1583 //
1584 // Creates a version for a containerized application. You can iterate the application based on the version.
1585 //
1586 // @param tmpReq - CreateEdgeContainerAppVersionRequest
1587 //
1588 // @param runtime - runtime options for this request RuntimeOptions
1589 //
1590 // @return CreateEdgeContainerAppVersionResponse
1591 func CreateEdgeContainerAppVersionWithContext(ctx context.Context, client *Client, tmpReq *CreateEdgeContainerAppVersionRequest, runtime *dara.RuntimeOptions) (_result *CreateEdgeContainerAppVersionResponse, _err error) {
1592 if dara.BoolValue(client.EnableValidate) == true {
1593 _err = tmpReq.Validate()
1594 if _err != nil {
1595 return _result, _err
1596 }
1597 }
1598 request := &CreateEdgeContainerAppVersionShrinkRequest{}
1599 openapiutil.Convert(tmpReq, request)
1600 if !dara.IsNil(tmpReq.Containers) {
1601 request.ContainersShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Containers, dara.String("Containers"), dara.String("json"))
1602 }
1603
1604 body := map[string]interface{}{}
1605 if !dara.IsNil(request.AppId) {
1606 body["AppId"] = request.AppId
1607 }
1608
1609 if !dara.IsNil(request.ContainersShrink) {
1610 body["Containers"] = request.ContainersShrink
1611 }
1612
1613 if !dara.IsNil(request.Name) {
1614 body["Name"] = request.Name
1615 }
1616
1617 if !dara.IsNil(request.Remarks) {
1618 body["Remarks"] = request.Remarks
1619 }
1620
1621 req := &openapiutil.OpenApiRequest{
1622 Body: openapiutil.ParseToMap(body),
1623 }
1624 params := &openapiutil.Params{
1625 Action: dara.String("CreateEdgeContainerAppVersion"),
1626 Version: dara.String("2024-09-10"),
1627 Protocol: dara.String("HTTPS"),
1628 Pathname: dara.String("/"),
1629 Method: dara.String("POST"),
1630 AuthType: dara.String("AK"),
1631 Style: dara.String("RPC"),
1632 ReqBodyType: dara.String("formData"),
1633 BodyType: dara.String("json"),
1634 }
1635 _result = &CreateEdgeContainerAppVersionResponse{}
1636 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1637 if _err != nil {
1638 return _result, _err
1639 }
1640 _err = dara.Convert(_body, &_result)
1641 return _result, _err
1642 }
1643
1644 // Summary:
1645 //
1646 // Adds the configuration of modifying HTTP request headers for a website.
1647 //
1648 // @param tmpReq - CreateHttpIncomingRequestHeaderModificationRuleRequest
1649 //
1650 // @param runtime - runtime options for this request RuntimeOptions
1651 //
1652 // @return CreateHttpIncomingRequestHeaderModificationRuleResponse
1653 func CreateHttpIncomingRequestHeaderModificationRuleWithContext(ctx context.Context, client *Client, tmpReq *CreateHttpIncomingRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateHttpIncomingRequestHeaderModificationRuleResponse, _err error) {
1654 if dara.BoolValue(client.EnableValidate) == true {
1655 _err = tmpReq.Validate()
1656 if _err != nil {
1657 return _result, _err
1658 }
1659 }
1660 request := &CreateHttpIncomingRequestHeaderModificationRuleShrinkRequest{}
1661 openapiutil.Convert(tmpReq, request)
1662 if !dara.IsNil(tmpReq.RequestHeaderModification) {
1663 request.RequestHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RequestHeaderModification, dara.String("RequestHeaderModification"), dara.String("json"))
1664 }
1665
1666 query := map[string]interface{}{}
1667 if !dara.IsNil(request.RequestHeaderModificationShrink) {
1668 query["RequestHeaderModification"] = request.RequestHeaderModificationShrink
1669 }
1670
1671 if !dara.IsNil(request.Rule) {
1672 query["Rule"] = request.Rule
1673 }
1674
1675 if !dara.IsNil(request.RuleEnable) {
1676 query["RuleEnable"] = request.RuleEnable
1677 }
1678
1679 if !dara.IsNil(request.RuleName) {
1680 query["RuleName"] = request.RuleName
1681 }
1682
1683 if !dara.IsNil(request.Sequence) {
1684 query["Sequence"] = request.Sequence
1685 }
1686
1687 if !dara.IsNil(request.SiteId) {
1688 query["SiteId"] = request.SiteId
1689 }
1690
1691 if !dara.IsNil(request.SiteVersion) {
1692 query["SiteVersion"] = request.SiteVersion
1693 }
1694
1695 req := &openapiutil.OpenApiRequest{
1696 Query: openapiutil.Query(query),
1697 }
1698 params := &openapiutil.Params{
1699 Action: dara.String("CreateHttpIncomingRequestHeaderModificationRule"),
1700 Version: dara.String("2024-09-10"),
1701 Protocol: dara.String("HTTPS"),
1702 Pathname: dara.String("/"),
1703 Method: dara.String("POST"),
1704 AuthType: dara.String("AK"),
1705 Style: dara.String("RPC"),
1706 ReqBodyType: dara.String("formData"),
1707 BodyType: dara.String("json"),
1708 }
1709 _result = &CreateHttpIncomingRequestHeaderModificationRuleResponse{}
1710 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1711 if _err != nil {
1712 return _result, _err
1713 }
1714 _err = dara.Convert(_body, &_result)
1715 return _result, _err
1716 }
1717
1718 // Summary:
1719 //
1720 // Adds the configuration of modifying HTTP response headers for a website.
1721 //
1722 // @param tmpReq - CreateHttpIncomingResponseHeaderModificationRuleRequest
1723 //
1724 // @param runtime - runtime options for this request RuntimeOptions
1725 //
1726 // @return CreateHttpIncomingResponseHeaderModificationRuleResponse
1727 func CreateHttpIncomingResponseHeaderModificationRuleWithContext(ctx context.Context, client *Client, tmpReq *CreateHttpIncomingResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateHttpIncomingResponseHeaderModificationRuleResponse, _err error) {
1728 if dara.BoolValue(client.EnableValidate) == true {
1729 _err = tmpReq.Validate()
1730 if _err != nil {
1731 return _result, _err
1732 }
1733 }
1734 request := &CreateHttpIncomingResponseHeaderModificationRuleShrinkRequest{}
1735 openapiutil.Convert(tmpReq, request)
1736 if !dara.IsNil(tmpReq.ResponseHeaderModification) {
1737 request.ResponseHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ResponseHeaderModification, dara.String("ResponseHeaderModification"), dara.String("json"))
1738 }
1739
1740 query := map[string]interface{}{}
1741 if !dara.IsNil(request.ResponseHeaderModificationShrink) {
1742 query["ResponseHeaderModification"] = request.ResponseHeaderModificationShrink
1743 }
1744
1745 if !dara.IsNil(request.Rule) {
1746 query["Rule"] = request.Rule
1747 }
1748
1749 if !dara.IsNil(request.RuleEnable) {
1750 query["RuleEnable"] = request.RuleEnable
1751 }
1752
1753 if !dara.IsNil(request.RuleName) {
1754 query["RuleName"] = request.RuleName
1755 }
1756
1757 if !dara.IsNil(request.Sequence) {
1758 query["Sequence"] = request.Sequence
1759 }
1760
1761 if !dara.IsNil(request.SiteId) {
1762 query["SiteId"] = request.SiteId
1763 }
1764
1765 if !dara.IsNil(request.SiteVersion) {
1766 query["SiteVersion"] = request.SiteVersion
1767 }
1768
1769 req := &openapiutil.OpenApiRequest{
1770 Query: openapiutil.Query(query),
1771 }
1772 params := &openapiutil.Params{
1773 Action: dara.String("CreateHttpIncomingResponseHeaderModificationRule"),
1774 Version: dara.String("2024-09-10"),
1775 Protocol: dara.String("HTTPS"),
1776 Pathname: dara.String("/"),
1777 Method: dara.String("POST"),
1778 AuthType: dara.String("AK"),
1779 Style: dara.String("RPC"),
1780 ReqBodyType: dara.String("formData"),
1781 BodyType: dara.String("json"),
1782 }
1783 _result = &CreateHttpIncomingResponseHeaderModificationRuleResponse{}
1784 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1785 if _err != nil {
1786 return _result, _err
1787 }
1788 _err = dara.Convert(_body, &_result)
1789 return _result, _err
1790 }
1791
1792 // Summary:
1793 //
1794 // # Add HTTP Request Header Rule
1795 //
1796 // @param tmpReq - CreateHttpRequestHeaderModificationRuleRequest
1797 //
1798 // @param runtime - runtime options for this request RuntimeOptions
1799 //
1800 // @return CreateHttpRequestHeaderModificationRuleResponse
1801 func CreateHttpRequestHeaderModificationRuleWithContext(ctx context.Context, client *Client, tmpReq *CreateHttpRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateHttpRequestHeaderModificationRuleResponse, _err error) {
1802 if dara.BoolValue(client.EnableValidate) == true {
1803 _err = tmpReq.Validate()
1804 if _err != nil {
1805 return _result, _err
1806 }
1807 }
1808 request := &CreateHttpRequestHeaderModificationRuleShrinkRequest{}
1809 openapiutil.Convert(tmpReq, request)
1810 if !dara.IsNil(tmpReq.RequestHeaderModification) {
1811 request.RequestHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RequestHeaderModification, dara.String("RequestHeaderModification"), dara.String("json"))
1812 }
1813
1814 query := map[string]interface{}{}
1815 if !dara.IsNil(request.RequestHeaderModificationShrink) {
1816 query["RequestHeaderModification"] = request.RequestHeaderModificationShrink
1817 }
1818
1819 if !dara.IsNil(request.Rule) {
1820 query["Rule"] = request.Rule
1821 }
1822
1823 if !dara.IsNil(request.RuleEnable) {
1824 query["RuleEnable"] = request.RuleEnable
1825 }
1826
1827 if !dara.IsNil(request.RuleName) {
1828 query["RuleName"] = request.RuleName
1829 }
1830
1831 if !dara.IsNil(request.Sequence) {
1832 query["Sequence"] = request.Sequence
1833 }
1834
1835 if !dara.IsNil(request.SiteId) {
1836 query["SiteId"] = request.SiteId
1837 }
1838
1839 if !dara.IsNil(request.SiteVersion) {
1840 query["SiteVersion"] = request.SiteVersion
1841 }
1842
1843 req := &openapiutil.OpenApiRequest{
1844 Query: openapiutil.Query(query),
1845 }
1846 params := &openapiutil.Params{
1847 Action: dara.String("CreateHttpRequestHeaderModificationRule"),
1848 Version: dara.String("2024-09-10"),
1849 Protocol: dara.String("HTTPS"),
1850 Pathname: dara.String("/"),
1851 Method: dara.String("POST"),
1852 AuthType: dara.String("AK"),
1853 Style: dara.String("RPC"),
1854 ReqBodyType: dara.String("formData"),
1855 BodyType: dara.String("json"),
1856 }
1857 _result = &CreateHttpRequestHeaderModificationRuleResponse{}
1858 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1859 if _err != nil {
1860 return _result, _err
1861 }
1862 _err = dara.Convert(_body, &_result)
1863 return _result, _err
1864 }
1865
1866 // Summary:
1867 //
1868 // # Add HTTP Response Header Rule
1869 //
1870 // @param tmpReq - CreateHttpResponseHeaderModificationRuleRequest
1871 //
1872 // @param runtime - runtime options for this request RuntimeOptions
1873 //
1874 // @return CreateHttpResponseHeaderModificationRuleResponse
1875 func CreateHttpResponseHeaderModificationRuleWithContext(ctx context.Context, client *Client, tmpReq *CreateHttpResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateHttpResponseHeaderModificationRuleResponse, _err error) {
1876 if dara.BoolValue(client.EnableValidate) == true {
1877 _err = tmpReq.Validate()
1878 if _err != nil {
1879 return _result, _err
1880 }
1881 }
1882 request := &CreateHttpResponseHeaderModificationRuleShrinkRequest{}
1883 openapiutil.Convert(tmpReq, request)
1884 if !dara.IsNil(tmpReq.ResponseHeaderModification) {
1885 request.ResponseHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ResponseHeaderModification, dara.String("ResponseHeaderModification"), dara.String("json"))
1886 }
1887
1888 query := map[string]interface{}{}
1889 if !dara.IsNil(request.ResponseHeaderModificationShrink) {
1890 query["ResponseHeaderModification"] = request.ResponseHeaderModificationShrink
1891 }
1892
1893 if !dara.IsNil(request.Rule) {
1894 query["Rule"] = request.Rule
1895 }
1896
1897 if !dara.IsNil(request.RuleEnable) {
1898 query["RuleEnable"] = request.RuleEnable
1899 }
1900
1901 if !dara.IsNil(request.RuleName) {
1902 query["RuleName"] = request.RuleName
1903 }
1904
1905 if !dara.IsNil(request.Sequence) {
1906 query["Sequence"] = request.Sequence
1907 }
1908
1909 if !dara.IsNil(request.SiteId) {
1910 query["SiteId"] = request.SiteId
1911 }
1912
1913 if !dara.IsNil(request.SiteVersion) {
1914 query["SiteVersion"] = request.SiteVersion
1915 }
1916
1917 req := &openapiutil.OpenApiRequest{
1918 Query: openapiutil.Query(query),
1919 }
1920 params := &openapiutil.Params{
1921 Action: dara.String("CreateHttpResponseHeaderModificationRule"),
1922 Version: dara.String("2024-09-10"),
1923 Protocol: dara.String("HTTPS"),
1924 Pathname: dara.String("/"),
1925 Method: dara.String("POST"),
1926 AuthType: dara.String("AK"),
1927 Style: dara.String("RPC"),
1928 ReqBodyType: dara.String("formData"),
1929 BodyType: dara.String("json"),
1930 }
1931 _result = &CreateHttpResponseHeaderModificationRuleResponse{}
1932 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
1933 if _err != nil {
1934 return _result, _err
1935 }
1936 _err = dara.Convert(_body, &_result)
1937 return _result, _err
1938 }
1939
1940 // Summary:
1941 //
1942 // # Create a new site HTTPS application configuration
1943 //
1944 // @param request - CreateHttpsApplicationConfigurationRequest
1945 //
1946 // @param runtime - runtime options for this request RuntimeOptions
1947 //
1948 // @return CreateHttpsApplicationConfigurationResponse
1949 func CreateHttpsApplicationConfigurationWithContext(ctx context.Context, client *Client, request *CreateHttpsApplicationConfigurationRequest, runtime *dara.RuntimeOptions) (_result *CreateHttpsApplicationConfigurationResponse, _err error) {
1950 if dara.BoolValue(client.EnableValidate) == true {
1951 _err = request.Validate()
1952 if _err != nil {
1953 return _result, _err
1954 }
1955 }
1956 query := map[string]interface{}{}
1957 if !dara.IsNil(request.AltSvc) {
1958 query["AltSvc"] = request.AltSvc
1959 }
1960
1961 if !dara.IsNil(request.AltSvcClear) {
1962 query["AltSvcClear"] = request.AltSvcClear
1963 }
1964
1965 if !dara.IsNil(request.AltSvcMa) {
1966 query["AltSvcMa"] = request.AltSvcMa
1967 }
1968
1969 if !dara.IsNil(request.AltSvcPersist) {
1970 query["AltSvcPersist"] = request.AltSvcPersist
1971 }
1972
1973 if !dara.IsNil(request.Hsts) {
1974 query["Hsts"] = request.Hsts
1975 }
1976
1977 if !dara.IsNil(request.HstsIncludeSubdomains) {
1978 query["HstsIncludeSubdomains"] = request.HstsIncludeSubdomains
1979 }
1980
1981 if !dara.IsNil(request.HstsMaxAge) {
1982 query["HstsMaxAge"] = request.HstsMaxAge
1983 }
1984
1985 if !dara.IsNil(request.HstsPreload) {
1986 query["HstsPreload"] = request.HstsPreload
1987 }
1988
1989 if !dara.IsNil(request.HttpsForce) {
1990 query["HttpsForce"] = request.HttpsForce
1991 }
1992
1993 if !dara.IsNil(request.HttpsForceCode) {
1994 query["HttpsForceCode"] = request.HttpsForceCode
1995 }
1996
1997 if !dara.IsNil(request.HttpsNoSniDeny) {
1998 query["HttpsNoSniDeny"] = request.HttpsNoSniDeny
1999 }
2000
2001 if !dara.IsNil(request.HttpsSniVerify) {
2002 query["HttpsSniVerify"] = request.HttpsSniVerify
2003 }
2004
2005 if !dara.IsNil(request.HttpsSniWhitelist) {
2006 query["HttpsSniWhitelist"] = request.HttpsSniWhitelist
2007 }
2008
2009 if !dara.IsNil(request.Rule) {
2010 query["Rule"] = request.Rule
2011 }
2012
2013 if !dara.IsNil(request.RuleEnable) {
2014 query["RuleEnable"] = request.RuleEnable
2015 }
2016
2017 if !dara.IsNil(request.RuleName) {
2018 query["RuleName"] = request.RuleName
2019 }
2020
2021 if !dara.IsNil(request.Sequence) {
2022 query["Sequence"] = request.Sequence
2023 }
2024
2025 if !dara.IsNil(request.SiteId) {
2026 query["SiteId"] = request.SiteId
2027 }
2028
2029 if !dara.IsNil(request.SiteVersion) {
2030 query["SiteVersion"] = request.SiteVersion
2031 }
2032
2033 req := &openapiutil.OpenApiRequest{
2034 Query: openapiutil.Query(query),
2035 }
2036 params := &openapiutil.Params{
2037 Action: dara.String("CreateHttpsApplicationConfiguration"),
2038 Version: dara.String("2024-09-10"),
2039 Protocol: dara.String("HTTPS"),
2040 Pathname: dara.String("/"),
2041 Method: dara.String("POST"),
2042 AuthType: dara.String("AK"),
2043 Style: dara.String("RPC"),
2044 ReqBodyType: dara.String("formData"),
2045 BodyType: dara.String("json"),
2046 }
2047 _result = &CreateHttpsApplicationConfigurationResponse{}
2048 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2049 if _err != nil {
2050 return _result, _err
2051 }
2052 _err = dara.Convert(_body, &_result)
2053 return _result, _err
2054 }
2055
2056 // Summary:
2057 //
2058 // # Create a new site HTTPS basic configuration
2059 //
2060 // @param request - CreateHttpsBasicConfigurationRequest
2061 //
2062 // @param runtime - runtime options for this request RuntimeOptions
2063 //
2064 // @return CreateHttpsBasicConfigurationResponse
2065 func CreateHttpsBasicConfigurationWithContext(ctx context.Context, client *Client, request *CreateHttpsBasicConfigurationRequest, runtime *dara.RuntimeOptions) (_result *CreateHttpsBasicConfigurationResponse, _err error) {
2066 if dara.BoolValue(client.EnableValidate) == true {
2067 _err = request.Validate()
2068 if _err != nil {
2069 return _result, _err
2070 }
2071 }
2072 query := map[string]interface{}{}
2073 if !dara.IsNil(request.Ciphersuite) {
2074 query["Ciphersuite"] = request.Ciphersuite
2075 }
2076
2077 if !dara.IsNil(request.CiphersuiteGroup) {
2078 query["CiphersuiteGroup"] = request.CiphersuiteGroup
2079 }
2080
2081 if !dara.IsNil(request.Http2) {
2082 query["Http2"] = request.Http2
2083 }
2084
2085 if !dara.IsNil(request.Http3) {
2086 query["Http3"] = request.Http3
2087 }
2088
2089 if !dara.IsNil(request.Https) {
2090 query["Https"] = request.Https
2091 }
2092
2093 if !dara.IsNil(request.OcspStapling) {
2094 query["OcspStapling"] = request.OcspStapling
2095 }
2096
2097 if !dara.IsNil(request.Rule) {
2098 query["Rule"] = request.Rule
2099 }
2100
2101 if !dara.IsNil(request.RuleEnable) {
2102 query["RuleEnable"] = request.RuleEnable
2103 }
2104
2105 if !dara.IsNil(request.RuleName) {
2106 query["RuleName"] = request.RuleName
2107 }
2108
2109 if !dara.IsNil(request.Sequence) {
2110 query["Sequence"] = request.Sequence
2111 }
2112
2113 if !dara.IsNil(request.SiteId) {
2114 query["SiteId"] = request.SiteId
2115 }
2116
2117 if !dara.IsNil(request.Tls10) {
2118 query["Tls10"] = request.Tls10
2119 }
2120
2121 if !dara.IsNil(request.Tls11) {
2122 query["Tls11"] = request.Tls11
2123 }
2124
2125 if !dara.IsNil(request.Tls12) {
2126 query["Tls12"] = request.Tls12
2127 }
2128
2129 if !dara.IsNil(request.Tls13) {
2130 query["Tls13"] = request.Tls13
2131 }
2132
2133 req := &openapiutil.OpenApiRequest{
2134 Query: openapiutil.Query(query),
2135 }
2136 params := &openapiutil.Params{
2137 Action: dara.String("CreateHttpsBasicConfiguration"),
2138 Version: dara.String("2024-09-10"),
2139 Protocol: dara.String("HTTPS"),
2140 Pathname: dara.String("/"),
2141 Method: dara.String("POST"),
2142 AuthType: dara.String("AK"),
2143 Style: dara.String("RPC"),
2144 ReqBodyType: dara.String("formData"),
2145 BodyType: dara.String("json"),
2146 }
2147 _result = &CreateHttpsBasicConfigurationResponse{}
2148 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2149 if _err != nil {
2150 return _result, _err
2151 }
2152 _err = dara.Convert(_body, &_result)
2153 return _result, _err
2154 }
2155
2156 // Summary:
2157 //
2158 // # Add Site Image Transformation Configuration
2159 //
2160 // @param request - CreateImageTransformRequest
2161 //
2162 // @param runtime - runtime options for this request RuntimeOptions
2163 //
2164 // @return CreateImageTransformResponse
2165 func CreateImageTransformWithContext(ctx context.Context, client *Client, request *CreateImageTransformRequest, runtime *dara.RuntimeOptions) (_result *CreateImageTransformResponse, _err error) {
2166 if dara.BoolValue(client.EnableValidate) == true {
2167 _err = request.Validate()
2168 if _err != nil {
2169 return _result, _err
2170 }
2171 }
2172 query := map[string]interface{}{}
2173 if !dara.IsNil(request.Enable) {
2174 query["Enable"] = request.Enable
2175 }
2176
2177 if !dara.IsNil(request.Rule) {
2178 query["Rule"] = request.Rule
2179 }
2180
2181 if !dara.IsNil(request.RuleEnable) {
2182 query["RuleEnable"] = request.RuleEnable
2183 }
2184
2185 if !dara.IsNil(request.RuleName) {
2186 query["RuleName"] = request.RuleName
2187 }
2188
2189 if !dara.IsNil(request.Sequence) {
2190 query["Sequence"] = request.Sequence
2191 }
2192
2193 if !dara.IsNil(request.SiteId) {
2194 query["SiteId"] = request.SiteId
2195 }
2196
2197 if !dara.IsNil(request.SiteVersion) {
2198 query["SiteVersion"] = request.SiteVersion
2199 }
2200
2201 req := &openapiutil.OpenApiRequest{
2202 Query: openapiutil.Query(query),
2203 }
2204 params := &openapiutil.Params{
2205 Action: dara.String("CreateImageTransform"),
2206 Version: dara.String("2024-09-10"),
2207 Protocol: dara.String("HTTPS"),
2208 Pathname: dara.String("/"),
2209 Method: dara.String("POST"),
2210 AuthType: dara.String("AK"),
2211 Style: dara.String("RPC"),
2212 ReqBodyType: dara.String("formData"),
2213 BodyType: dara.String("json"),
2214 }
2215 _result = &CreateImageTransformResponse{}
2216 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2217 if _err != nil {
2218 return _result, _err
2219 }
2220 _err = dara.Convert(_body, &_result)
2221 return _result, _err
2222 }
2223
2224 // Summary:
2225 //
2226 // Create a namespace in your Alibaba Cloud account.
2227 //
2228 // @param request - CreateKvNamespaceRequest
2229 //
2230 // @param runtime - runtime options for this request RuntimeOptions
2231 //
2232 // @return CreateKvNamespaceResponse
2233 func CreateKvNamespaceWithContext(ctx context.Context, client *Client, request *CreateKvNamespaceRequest, runtime *dara.RuntimeOptions) (_result *CreateKvNamespaceResponse, _err error) {
2234 if dara.BoolValue(client.EnableValidate) == true {
2235 _err = request.Validate()
2236 if _err != nil {
2237 return _result, _err
2238 }
2239 }
2240 body := map[string]interface{}{}
2241 if !dara.IsNil(request.Description) {
2242 body["Description"] = request.Description
2243 }
2244
2245 if !dara.IsNil(request.Namespace) {
2246 body["Namespace"] = request.Namespace
2247 }
2248
2249 req := &openapiutil.OpenApiRequest{
2250 Body: openapiutil.ParseToMap(body),
2251 }
2252 params := &openapiutil.Params{
2253 Action: dara.String("CreateKvNamespace"),
2254 Version: dara.String("2024-09-10"),
2255 Protocol: dara.String("HTTPS"),
2256 Pathname: dara.String("/"),
2257 Method: dara.String("POST"),
2258 AuthType: dara.String("AK"),
2259 Style: dara.String("RPC"),
2260 ReqBodyType: dara.String("formData"),
2261 BodyType: dara.String("json"),
2262 }
2263 _result = &CreateKvNamespaceResponse{}
2264 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2265 if _err != nil {
2266 return _result, _err
2267 }
2268 _err = dara.Convert(_body, &_result)
2269 return _result, _err
2270 }
2271
2272 // Summary:
2273 //
2274 // Creates a list. Lists are used for the referencing of values in the rules engine to implement complex logic and control in security policies.
2275 //
2276 // @param tmpReq - CreateListRequest
2277 //
2278 // @param runtime - runtime options for this request RuntimeOptions
2279 //
2280 // @return CreateListResponse
2281 func CreateListWithContext(ctx context.Context, client *Client, tmpReq *CreateListRequest, runtime *dara.RuntimeOptions) (_result *CreateListResponse, _err error) {
2282 if dara.BoolValue(client.EnableValidate) == true {
2283 _err = tmpReq.Validate()
2284 if _err != nil {
2285 return _result, _err
2286 }
2287 }
2288 request := &CreateListShrinkRequest{}
2289 openapiutil.Convert(tmpReq, request)
2290 if !dara.IsNil(tmpReq.Items) {
2291 request.ItemsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Items, dara.String("Items"), dara.String("json"))
2292 }
2293
2294 body := map[string]interface{}{}
2295 if !dara.IsNil(request.Description) {
2296 body["Description"] = request.Description
2297 }
2298
2299 if !dara.IsNil(request.ItemsShrink) {
2300 body["Items"] = request.ItemsShrink
2301 }
2302
2303 if !dara.IsNil(request.Kind) {
2304 body["Kind"] = request.Kind
2305 }
2306
2307 if !dara.IsNil(request.Name) {
2308 body["Name"] = request.Name
2309 }
2310
2311 req := &openapiutil.OpenApiRequest{
2312 Body: openapiutil.ParseToMap(body),
2313 }
2314 params := &openapiutil.Params{
2315 Action: dara.String("CreateList"),
2316 Version: dara.String("2024-09-10"),
2317 Protocol: dara.String("HTTPS"),
2318 Pathname: dara.String("/"),
2319 Method: dara.String("POST"),
2320 AuthType: dara.String("AK"),
2321 Style: dara.String("RPC"),
2322 ReqBodyType: dara.String("formData"),
2323 BodyType: dara.String("json"),
2324 }
2325 _result = &CreateListResponse{}
2326 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2327 if _err != nil {
2328 return _result, _err
2329 }
2330 _err = dara.Convert(_body, &_result)
2331 return _result, _err
2332 }
2333
2334 // Summary:
2335 //
2336 // # Add a New Load Balancer
2337 //
2338 // Description:
2339 //
2340 // Through this API, users can configure load balancing services according to their business needs, including but not limited to adaptive routing, weighted round-robin, rule matching, health checks, and more, to achieve effective traffic management and optimization.
2341 //
2342 // @param tmpReq - CreateLoadBalancerRequest
2343 //
2344 // @param runtime - runtime options for this request RuntimeOptions
2345 //
2346 // @return CreateLoadBalancerResponse
2347 func CreateLoadBalancerWithContext(ctx context.Context, client *Client, tmpReq *CreateLoadBalancerRequest, runtime *dara.RuntimeOptions) (_result *CreateLoadBalancerResponse, _err error) {
2348 if dara.BoolValue(client.EnableValidate) == true {
2349 _err = tmpReq.Validate()
2350 if _err != nil {
2351 return _result, _err
2352 }
2353 }
2354 request := &CreateLoadBalancerShrinkRequest{}
2355 openapiutil.Convert(tmpReq, request)
2356 if !dara.IsNil(tmpReq.AdaptiveRouting) {
2357 request.AdaptiveRoutingShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AdaptiveRouting, dara.String("AdaptiveRouting"), dara.String("json"))
2358 }
2359
2360 if !dara.IsNil(tmpReq.DefaultPools) {
2361 request.DefaultPoolsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.DefaultPools, dara.String("DefaultPools"), dara.String("json"))
2362 }
2363
2364 if !dara.IsNil(tmpReq.Monitor) {
2365 request.MonitorShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Monitor, dara.String("Monitor"), dara.String("json"))
2366 }
2367
2368 if !dara.IsNil(tmpReq.RandomSteering) {
2369 request.RandomSteeringShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RandomSteering, dara.String("RandomSteering"), dara.String("json"))
2370 }
2371
2372 if !dara.IsNil(tmpReq.Rules) {
2373 request.RulesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Rules, dara.String("Rules"), dara.String("json"))
2374 }
2375
2376 query := map[string]interface{}{}
2377 if !dara.IsNil(request.AdaptiveRoutingShrink) {
2378 query["AdaptiveRouting"] = request.AdaptiveRoutingShrink
2379 }
2380
2381 if !dara.IsNil(request.DefaultPoolsShrink) {
2382 query["DefaultPools"] = request.DefaultPoolsShrink
2383 }
2384
2385 if !dara.IsNil(request.Description) {
2386 query["Description"] = request.Description
2387 }
2388
2389 if !dara.IsNil(request.Enabled) {
2390 query["Enabled"] = request.Enabled
2391 }
2392
2393 if !dara.IsNil(request.FallbackPool) {
2394 query["FallbackPool"] = request.FallbackPool
2395 }
2396
2397 if !dara.IsNil(request.MonitorShrink) {
2398 query["Monitor"] = request.MonitorShrink
2399 }
2400
2401 if !dara.IsNil(request.Name) {
2402 query["Name"] = request.Name
2403 }
2404
2405 if !dara.IsNil(request.RandomSteeringShrink) {
2406 query["RandomSteering"] = request.RandomSteeringShrink
2407 }
2408
2409 if !dara.IsNil(request.RegionPools) {
2410 query["RegionPools"] = request.RegionPools
2411 }
2412
2413 if !dara.IsNil(request.RulesShrink) {
2414 query["Rules"] = request.RulesShrink
2415 }
2416
2417 if !dara.IsNil(request.SessionAffinity) {
2418 query["SessionAffinity"] = request.SessionAffinity
2419 }
2420
2421 if !dara.IsNil(request.SiteId) {
2422 query["SiteId"] = request.SiteId
2423 }
2424
2425 if !dara.IsNil(request.SteeringPolicy) {
2426 query["SteeringPolicy"] = request.SteeringPolicy
2427 }
2428
2429 if !dara.IsNil(request.SubRegionPools) {
2430 query["SubRegionPools"] = request.SubRegionPools
2431 }
2432
2433 if !dara.IsNil(request.Ttl) {
2434 query["Ttl"] = request.Ttl
2435 }
2436
2437 req := &openapiutil.OpenApiRequest{
2438 Query: openapiutil.Query(query),
2439 }
2440 params := &openapiutil.Params{
2441 Action: dara.String("CreateLoadBalancer"),
2442 Version: dara.String("2024-09-10"),
2443 Protocol: dara.String("HTTPS"),
2444 Pathname: dara.String("/"),
2445 Method: dara.String("POST"),
2446 AuthType: dara.String("AK"),
2447 Style: dara.String("RPC"),
2448 ReqBodyType: dara.String("formData"),
2449 BodyType: dara.String("json"),
2450 }
2451 _result = &CreateLoadBalancerResponse{}
2452 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2453 if _err != nil {
2454 return _result, _err
2455 }
2456 _err = dara.Convert(_body, &_result)
2457 return _result, _err
2458 }
2459
2460 // Summary:
2461 //
2462 // # Create a new site network optimization configuration
2463 //
2464 // @param request - CreateNetworkOptimizationRequest
2465 //
2466 // @param runtime - runtime options for this request RuntimeOptions
2467 //
2468 // @return CreateNetworkOptimizationResponse
2469 func CreateNetworkOptimizationWithContext(ctx context.Context, client *Client, request *CreateNetworkOptimizationRequest, runtime *dara.RuntimeOptions) (_result *CreateNetworkOptimizationResponse, _err error) {
2470 if dara.BoolValue(client.EnableValidate) == true {
2471 _err = request.Validate()
2472 if _err != nil {
2473 return _result, _err
2474 }
2475 }
2476 query := map[string]interface{}{}
2477 if !dara.IsNil(request.Grpc) {
2478 query["Grpc"] = request.Grpc
2479 }
2480
2481 if !dara.IsNil(request.Http2Origin) {
2482 query["Http2Origin"] = request.Http2Origin
2483 }
2484
2485 if !dara.IsNil(request.Rule) {
2486 query["Rule"] = request.Rule
2487 }
2488
2489 if !dara.IsNil(request.RuleEnable) {
2490 query["RuleEnable"] = request.RuleEnable
2491 }
2492
2493 if !dara.IsNil(request.RuleName) {
2494 query["RuleName"] = request.RuleName
2495 }
2496
2497 if !dara.IsNil(request.Sequence) {
2498 query["Sequence"] = request.Sequence
2499 }
2500
2501 if !dara.IsNil(request.SiteId) {
2502 query["SiteId"] = request.SiteId
2503 }
2504
2505 if !dara.IsNil(request.SiteVersion) {
2506 query["SiteVersion"] = request.SiteVersion
2507 }
2508
2509 if !dara.IsNil(request.SmartRouting) {
2510 query["SmartRouting"] = request.SmartRouting
2511 }
2512
2513 if !dara.IsNil(request.UploadMaxFilesize) {
2514 query["UploadMaxFilesize"] = request.UploadMaxFilesize
2515 }
2516
2517 if !dara.IsNil(request.Websocket) {
2518 query["Websocket"] = request.Websocket
2519 }
2520
2521 req := &openapiutil.OpenApiRequest{
2522 Query: openapiutil.Query(query),
2523 }
2524 params := &openapiutil.Params{
2525 Action: dara.String("CreateNetworkOptimization"),
2526 Version: dara.String("2024-09-10"),
2527 Protocol: dara.String("HTTPS"),
2528 Pathname: dara.String("/"),
2529 Method: dara.String("POST"),
2530 AuthType: dara.String("AK"),
2531 Style: dara.String("RPC"),
2532 ReqBodyType: dara.String("formData"),
2533 BodyType: dara.String("json"),
2534 }
2535 _result = &CreateNetworkOptimizationResponse{}
2536 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2537 if _err != nil {
2538 return _result, _err
2539 }
2540 _err = dara.Convert(_body, &_result)
2541 return _result, _err
2542 }
2543
2544 // Summary:
2545 //
2546 // # Add a new origin address pool
2547 //
2548 // Description:
2549 //
2550 // Multiple origins can be added under the origin address, supporting domain names, IPs, OSS, S3, and other types of origins. It supports authentication for OSS and S3 type origins.
2551 //
2552 // @param tmpReq - CreateOriginPoolRequest
2553 //
2554 // @param runtime - runtime options for this request RuntimeOptions
2555 //
2556 // @return CreateOriginPoolResponse
2557 func CreateOriginPoolWithContext(ctx context.Context, client *Client, tmpReq *CreateOriginPoolRequest, runtime *dara.RuntimeOptions) (_result *CreateOriginPoolResponse, _err error) {
2558 if dara.BoolValue(client.EnableValidate) == true {
2559 _err = tmpReq.Validate()
2560 if _err != nil {
2561 return _result, _err
2562 }
2563 }
2564 request := &CreateOriginPoolShrinkRequest{}
2565 openapiutil.Convert(tmpReq, request)
2566 if !dara.IsNil(tmpReq.Origins) {
2567 request.OriginsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Origins, dara.String("Origins"), dara.String("json"))
2568 }
2569
2570 query := map[string]interface{}{}
2571 if !dara.IsNil(request.Enabled) {
2572 query["Enabled"] = request.Enabled
2573 }
2574
2575 if !dara.IsNil(request.Name) {
2576 query["Name"] = request.Name
2577 }
2578
2579 if !dara.IsNil(request.OriginsShrink) {
2580 query["Origins"] = request.OriginsShrink
2581 }
2582
2583 if !dara.IsNil(request.SiteId) {
2584 query["SiteId"] = request.SiteId
2585 }
2586
2587 req := &openapiutil.OpenApiRequest{
2588 Query: openapiutil.Query(query),
2589 }
2590 params := &openapiutil.Params{
2591 Action: dara.String("CreateOriginPool"),
2592 Version: dara.String("2024-09-10"),
2593 Protocol: dara.String("HTTPS"),
2594 Pathname: dara.String("/"),
2595 Method: dara.String("POST"),
2596 AuthType: dara.String("AK"),
2597 Style: dara.String("RPC"),
2598 ReqBodyType: dara.String("formData"),
2599 BodyType: dara.String("json"),
2600 }
2601 _result = &CreateOriginPoolResponse{}
2602 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2603 if _err != nil {
2604 return _result, _err
2605 }
2606 _err = dara.Convert(_body, &_result)
2607 return _result, _err
2608 }
2609
2610 // Summary:
2611 //
2612 // Enables origin protection.
2613 //
2614 // @param request - CreateOriginProtectionRequest
2615 //
2616 // @param runtime - runtime options for this request RuntimeOptions
2617 //
2618 // @return CreateOriginProtectionResponse
2619 func CreateOriginProtectionWithContext(ctx context.Context, client *Client, request *CreateOriginProtectionRequest, runtime *dara.RuntimeOptions) (_result *CreateOriginProtectionResponse, _err error) {
2620 if dara.BoolValue(client.EnableValidate) == true {
2621 _err = request.Validate()
2622 if _err != nil {
2623 return _result, _err
2624 }
2625 }
2626 query := map[string]interface{}{}
2627 if !dara.IsNil(request.AutoConfirmIPList) {
2628 query["AutoConfirmIPList"] = request.AutoConfirmIPList
2629 }
2630
2631 if !dara.IsNil(request.SiteId) {
2632 query["SiteId"] = request.SiteId
2633 }
2634
2635 req := &openapiutil.OpenApiRequest{
2636 Query: openapiutil.Query(query),
2637 }
2638 params := &openapiutil.Params{
2639 Action: dara.String("CreateOriginProtection"),
2640 Version: dara.String("2024-09-10"),
2641 Protocol: dara.String("HTTPS"),
2642 Pathname: dara.String("/"),
2643 Method: dara.String("POST"),
2644 AuthType: dara.String("AK"),
2645 Style: dara.String("RPC"),
2646 ReqBodyType: dara.String("formData"),
2647 BodyType: dara.String("json"),
2648 }
2649 _result = &CreateOriginProtectionResponse{}
2650 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2651 if _err != nil {
2652 return _result, _err
2653 }
2654 _err = dara.Convert(_body, &_result)
2655 return _result, _err
2656 }
2657
2658 // Summary:
2659 //
2660 // # Create a new origin rule configuration for the site
2661 //
2662 // @param request - CreateOriginRuleRequest
2663 //
2664 // @param runtime - runtime options for this request RuntimeOptions
2665 //
2666 // @return CreateOriginRuleResponse
2667 func CreateOriginRuleWithContext(ctx context.Context, client *Client, request *CreateOriginRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateOriginRuleResponse, _err error) {
2668 if dara.BoolValue(client.EnableValidate) == true {
2669 _err = request.Validate()
2670 if _err != nil {
2671 return _result, _err
2672 }
2673 }
2674 query := map[string]interface{}{}
2675 if !dara.IsNil(request.DnsRecord) {
2676 query["DnsRecord"] = request.DnsRecord
2677 }
2678
2679 if !dara.IsNil(request.Follow302Enable) {
2680 query["Follow302Enable"] = request.Follow302Enable
2681 }
2682
2683 if !dara.IsNil(request.Follow302MaxTries) {
2684 query["Follow302MaxTries"] = request.Follow302MaxTries
2685 }
2686
2687 if !dara.IsNil(request.Follow302RetainArgs) {
2688 query["Follow302RetainArgs"] = request.Follow302RetainArgs
2689 }
2690
2691 if !dara.IsNil(request.Follow302RetainHeader) {
2692 query["Follow302RetainHeader"] = request.Follow302RetainHeader
2693 }
2694
2695 if !dara.IsNil(request.Follow302TargetHost) {
2696 query["Follow302TargetHost"] = request.Follow302TargetHost
2697 }
2698
2699 if !dara.IsNil(request.OriginHost) {
2700 query["OriginHost"] = request.OriginHost
2701 }
2702
2703 if !dara.IsNil(request.OriginHttpPort) {
2704 query["OriginHttpPort"] = request.OriginHttpPort
2705 }
2706
2707 if !dara.IsNil(request.OriginHttpsPort) {
2708 query["OriginHttpsPort"] = request.OriginHttpsPort
2709 }
2710
2711 if !dara.IsNil(request.OriginMtls) {
2712 query["OriginMtls"] = request.OriginMtls
2713 }
2714
2715 if !dara.IsNil(request.OriginReadTimeout) {
2716 query["OriginReadTimeout"] = request.OriginReadTimeout
2717 }
2718
2719 if !dara.IsNil(request.OriginScheme) {
2720 query["OriginScheme"] = request.OriginScheme
2721 }
2722
2723 if !dara.IsNil(request.OriginSni) {
2724 query["OriginSni"] = request.OriginSni
2725 }
2726
2727 if !dara.IsNil(request.OriginVerify) {
2728 query["OriginVerify"] = request.OriginVerify
2729 }
2730
2731 if !dara.IsNil(request.Range) {
2732 query["Range"] = request.Range
2733 }
2734
2735 if !dara.IsNil(request.RangeChunkSize) {
2736 query["RangeChunkSize"] = request.RangeChunkSize
2737 }
2738
2739 if !dara.IsNil(request.Rule) {
2740 query["Rule"] = request.Rule
2741 }
2742
2743 if !dara.IsNil(request.RuleEnable) {
2744 query["RuleEnable"] = request.RuleEnable
2745 }
2746
2747 if !dara.IsNil(request.RuleName) {
2748 query["RuleName"] = request.RuleName
2749 }
2750
2751 if !dara.IsNil(request.Sequence) {
2752 query["Sequence"] = request.Sequence
2753 }
2754
2755 if !dara.IsNil(request.SiteId) {
2756 query["SiteId"] = request.SiteId
2757 }
2758
2759 if !dara.IsNil(request.SiteVersion) {
2760 query["SiteVersion"] = request.SiteVersion
2761 }
2762
2763 req := &openapiutil.OpenApiRequest{
2764 Query: openapiutil.Query(query),
2765 }
2766 params := &openapiutil.Params{
2767 Action: dara.String("CreateOriginRule"),
2768 Version: dara.String("2024-09-10"),
2769 Protocol: dara.String("HTTPS"),
2770 Pathname: dara.String("/"),
2771 Method: dara.String("POST"),
2772 AuthType: dara.String("AK"),
2773 Style: dara.String("RPC"),
2774 ReqBodyType: dara.String("formData"),
2775 BodyType: dara.String("json"),
2776 }
2777 _result = &CreateOriginRuleResponse{}
2778 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2779 if _err != nil {
2780 return _result, _err
2781 }
2782 _err = dara.Convert(_body, &_result)
2783 return _result, _err
2784 }
2785
2786 // Summary:
2787 //
2788 // Creates a custom error page, which is displayed when a request is blocked by Web Application Firewall (WAF). You can configure the HTML content, page type, and description, and submit the Base64-encoded page content.
2789 //
2790 // @param request - CreatePageRequest
2791 //
2792 // @param runtime - runtime options for this request RuntimeOptions
2793 //
2794 // @return CreatePageResponse
2795 func CreatePageWithContext(ctx context.Context, client *Client, request *CreatePageRequest, runtime *dara.RuntimeOptions) (_result *CreatePageResponse, _err error) {
2796 if dara.BoolValue(client.EnableValidate) == true {
2797 _err = request.Validate()
2798 if _err != nil {
2799 return _result, _err
2800 }
2801 }
2802 body := map[string]interface{}{}
2803 if !dara.IsNil(request.Content) {
2804 body["Content"] = request.Content
2805 }
2806
2807 if !dara.IsNil(request.ContentType) {
2808 body["ContentType"] = request.ContentType
2809 }
2810
2811 if !dara.IsNil(request.Description) {
2812 body["Description"] = request.Description
2813 }
2814
2815 if !dara.IsNil(request.Name) {
2816 body["Name"] = request.Name
2817 }
2818
2819 req := &openapiutil.OpenApiRequest{
2820 Body: openapiutil.ParseToMap(body),
2821 }
2822 params := &openapiutil.Params{
2823 Action: dara.String("CreatePage"),
2824 Version: dara.String("2024-09-10"),
2825 Protocol: dara.String("HTTPS"),
2826 Pathname: dara.String("/"),
2827 Method: dara.String("POST"),
2828 AuthType: dara.String("AK"),
2829 Style: dara.String("RPC"),
2830 ReqBodyType: dara.String("formData"),
2831 BodyType: dara.String("json"),
2832 }
2833 _result = &CreatePageResponse{}
2834 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2835 if _err != nil {
2836 return _result, _err
2837 }
2838 _err = dara.Convert(_body, &_result)
2839 return _result, _err
2840 }
2841
2842 // Summary:
2843 //
2844 // Creates a DNS record for a specific website.
2845 //
2846 // @param tmpReq - CreateRecordRequest
2847 //
2848 // @param runtime - runtime options for this request RuntimeOptions
2849 //
2850 // @return CreateRecordResponse
2851 func CreateRecordWithContext(ctx context.Context, client *Client, tmpReq *CreateRecordRequest, runtime *dara.RuntimeOptions) (_result *CreateRecordResponse, _err error) {
2852 if dara.BoolValue(client.EnableValidate) == true {
2853 _err = tmpReq.Validate()
2854 if _err != nil {
2855 return _result, _err
2856 }
2857 }
2858 request := &CreateRecordShrinkRequest{}
2859 openapiutil.Convert(tmpReq, request)
2860 if !dara.IsNil(tmpReq.AuthConf) {
2861 request.AuthConfShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AuthConf, dara.String("AuthConf"), dara.String("json"))
2862 }
2863
2864 if !dara.IsNil(tmpReq.Data) {
2865 request.DataShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Data, dara.String("Data"), dara.String("json"))
2866 }
2867
2868 query := map[string]interface{}{}
2869 if !dara.IsNil(request.AuthConfShrink) {
2870 query["AuthConf"] = request.AuthConfShrink
2871 }
2872
2873 if !dara.IsNil(request.BizName) {
2874 query["BizName"] = request.BizName
2875 }
2876
2877 if !dara.IsNil(request.Comment) {
2878 query["Comment"] = request.Comment
2879 }
2880
2881 if !dara.IsNil(request.DataShrink) {
2882 query["Data"] = request.DataShrink
2883 }
2884
2885 if !dara.IsNil(request.HostPolicy) {
2886 query["HostPolicy"] = request.HostPolicy
2887 }
2888
2889 if !dara.IsNil(request.Proxied) {
2890 query["Proxied"] = request.Proxied
2891 }
2892
2893 if !dara.IsNil(request.RecordName) {
2894 query["RecordName"] = request.RecordName
2895 }
2896
2897 if !dara.IsNil(request.SiteId) {
2898 query["SiteId"] = request.SiteId
2899 }
2900
2901 if !dara.IsNil(request.SourceType) {
2902 query["SourceType"] = request.SourceType
2903 }
2904
2905 if !dara.IsNil(request.Ttl) {
2906 query["Ttl"] = request.Ttl
2907 }
2908
2909 if !dara.IsNil(request.Type) {
2910 query["Type"] = request.Type
2911 }
2912
2913 req := &openapiutil.OpenApiRequest{
2914 Query: openapiutil.Query(query),
2915 }
2916 params := &openapiutil.Params{
2917 Action: dara.String("CreateRecord"),
2918 Version: dara.String("2024-09-10"),
2919 Protocol: dara.String("HTTPS"),
2920 Pathname: dara.String("/"),
2921 Method: dara.String("POST"),
2922 AuthType: dara.String("AK"),
2923 Style: dara.String("RPC"),
2924 ReqBodyType: dara.String("formData"),
2925 BodyType: dara.String("json"),
2926 }
2927 _result = &CreateRecordResponse{}
2928 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
2929 if _err != nil {
2930 return _result, _err
2931 }
2932 _err = dara.Convert(_body, &_result)
2933 return _result, _err
2934 }
2935
2936 // Summary:
2937 //
2938 // # Add a Redirect Rule
2939 //
2940 // @param request - CreateRedirectRuleRequest
2941 //
2942 // @param runtime - runtime options for this request RuntimeOptions
2943 //
2944 // @return CreateRedirectRuleResponse
2945 func CreateRedirectRuleWithContext(ctx context.Context, client *Client, request *CreateRedirectRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateRedirectRuleResponse, _err error) {
2946 if dara.BoolValue(client.EnableValidate) == true {
2947 _err = request.Validate()
2948 if _err != nil {
2949 return _result, _err
2950 }
2951 }
2952 query := map[string]interface{}{}
2953 if !dara.IsNil(request.ReserveQueryString) {
2954 query["ReserveQueryString"] = request.ReserveQueryString
2955 }
2956
2957 if !dara.IsNil(request.Rule) {
2958 query["Rule"] = request.Rule
2959 }
2960
2961 if !dara.IsNil(request.RuleEnable) {
2962 query["RuleEnable"] = request.RuleEnable
2963 }
2964
2965 if !dara.IsNil(request.RuleName) {
2966 query["RuleName"] = request.RuleName
2967 }
2968
2969 if !dara.IsNil(request.Sequence) {
2970 query["Sequence"] = request.Sequence
2971 }
2972
2973 if !dara.IsNil(request.SiteId) {
2974 query["SiteId"] = request.SiteId
2975 }
2976
2977 if !dara.IsNil(request.SiteVersion) {
2978 query["SiteVersion"] = request.SiteVersion
2979 }
2980
2981 if !dara.IsNil(request.StatusCode) {
2982 query["StatusCode"] = request.StatusCode
2983 }
2984
2985 if !dara.IsNil(request.TargetUrl) {
2986 query["TargetUrl"] = request.TargetUrl
2987 }
2988
2989 if !dara.IsNil(request.Type) {
2990 query["Type"] = request.Type
2991 }
2992
2993 req := &openapiutil.OpenApiRequest{
2994 Query: openapiutil.Query(query),
2995 }
2996 params := &openapiutil.Params{
2997 Action: dara.String("CreateRedirectRule"),
2998 Version: dara.String("2024-09-10"),
2999 Protocol: dara.String("HTTPS"),
3000 Pathname: dara.String("/"),
3001 Method: dara.String("POST"),
3002 AuthType: dara.String("AK"),
3003 Style: dara.String("RPC"),
3004 ReqBodyType: dara.String("formData"),
3005 BodyType: dara.String("json"),
3006 }
3007 _result = &CreateRedirectRuleResponse{}
3008 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3009 if _err != nil {
3010 return _result, _err
3011 }
3012 _err = dara.Convert(_body, &_result)
3013 return _result, _err
3014 }
3015
3016 // Summary:
3017 //
3018 // # Add Rewrite URL Rule
3019 //
3020 // @param request - CreateRewriteUrlRuleRequest
3021 //
3022 // @param runtime - runtime options for this request RuntimeOptions
3023 //
3024 // @return CreateRewriteUrlRuleResponse
3025 func CreateRewriteUrlRuleWithContext(ctx context.Context, client *Client, request *CreateRewriteUrlRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateRewriteUrlRuleResponse, _err error) {
3026 if dara.BoolValue(client.EnableValidate) == true {
3027 _err = request.Validate()
3028 if _err != nil {
3029 return _result, _err
3030 }
3031 }
3032 query := map[string]interface{}{}
3033 if !dara.IsNil(request.QueryString) {
3034 query["QueryString"] = request.QueryString
3035 }
3036
3037 if !dara.IsNil(request.RewriteQueryStringType) {
3038 query["RewriteQueryStringType"] = request.RewriteQueryStringType
3039 }
3040
3041 if !dara.IsNil(request.RewriteUriType) {
3042 query["RewriteUriType"] = request.RewriteUriType
3043 }
3044
3045 if !dara.IsNil(request.Rule) {
3046 query["Rule"] = request.Rule
3047 }
3048
3049 if !dara.IsNil(request.RuleEnable) {
3050 query["RuleEnable"] = request.RuleEnable
3051 }
3052
3053 if !dara.IsNil(request.RuleName) {
3054 query["RuleName"] = request.RuleName
3055 }
3056
3057 if !dara.IsNil(request.Sequence) {
3058 query["Sequence"] = request.Sequence
3059 }
3060
3061 if !dara.IsNil(request.SiteId) {
3062 query["SiteId"] = request.SiteId
3063 }
3064
3065 if !dara.IsNil(request.SiteVersion) {
3066 query["SiteVersion"] = request.SiteVersion
3067 }
3068
3069 if !dara.IsNil(request.Uri) {
3070 query["Uri"] = request.Uri
3071 }
3072
3073 req := &openapiutil.OpenApiRequest{
3074 Query: openapiutil.Query(query),
3075 }
3076 params := &openapiutil.Params{
3077 Action: dara.String("CreateRewriteUrlRule"),
3078 Version: dara.String("2024-09-10"),
3079 Protocol: dara.String("HTTPS"),
3080 Pathname: dara.String("/"),
3081 Method: dara.String("POST"),
3082 AuthType: dara.String("AK"),
3083 Style: dara.String("RPC"),
3084 ReqBodyType: dara.String("formData"),
3085 BodyType: dara.String("json"),
3086 }
3087 _result = &CreateRewriteUrlRuleResponse{}
3088 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3089 if _err != nil {
3090 return _result, _err
3091 }
3092 _err = dara.Convert(_body, &_result)
3093 return _result, _err
3094 }
3095
3096 // Summary:
3097 //
3098 // Creates a routine.
3099 //
3100 // @param request - CreateRoutineRequest
3101 //
3102 // @param runtime - runtime options for this request RuntimeOptions
3103 //
3104 // @return CreateRoutineResponse
3105 func CreateRoutineWithContext(ctx context.Context, client *Client, request *CreateRoutineRequest, runtime *dara.RuntimeOptions) (_result *CreateRoutineResponse, _err error) {
3106 if dara.BoolValue(client.EnableValidate) == true {
3107 _err = request.Validate()
3108 if _err != nil {
3109 return _result, _err
3110 }
3111 }
3112 body := map[string]interface{}{}
3113 if !dara.IsNil(request.Description) {
3114 body["Description"] = request.Description
3115 }
3116
3117 if !dara.IsNil(request.HasAssets) {
3118 body["HasAssets"] = request.HasAssets
3119 }
3120
3121 if !dara.IsNil(request.Name) {
3122 body["Name"] = request.Name
3123 }
3124
3125 req := &openapiutil.OpenApiRequest{
3126 Body: openapiutil.ParseToMap(body),
3127 }
3128 params := &openapiutil.Params{
3129 Action: dara.String("CreateRoutine"),
3130 Version: dara.String("2024-09-10"),
3131 Protocol: dara.String("HTTPS"),
3132 Pathname: dara.String("/"),
3133 Method: dara.String("POST"),
3134 AuthType: dara.String("AK"),
3135 Style: dara.String("RPC"),
3136 ReqBodyType: dara.String("formData"),
3137 BodyType: dara.String("json"),
3138 }
3139 _result = &CreateRoutineResponse{}
3140 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3141 if _err != nil {
3142 return _result, _err
3143 }
3144 _err = dara.Convert(_body, &_result)
3145 return _result, _err
3146 }
3147
3148 // Summary:
3149 //
3150 // Release the version of the function code in proportion to the specified environment.
3151 //
3152 // Description:
3153 //
3154 // ## [](#)Request description
3155 //
3156 // - When you create a version for deployment, you can set the environment name `Env` parameter only to the test environment `staging` or the production environment `production`.
3157 //
3158 // - `CodeVersions` parameter supports up to two versions of a phased release, and the sum of the proportions of these versions must be equal to 100%.
3159 //
3160 // @param tmpReq - CreateRoutineCodeDeploymentRequest
3161 //
3162 // @param runtime - runtime options for this request RuntimeOptions
3163 //
3164 // @return CreateRoutineCodeDeploymentResponse
3165 func CreateRoutineCodeDeploymentWithContext(ctx context.Context, client *Client, tmpReq *CreateRoutineCodeDeploymentRequest, runtime *dara.RuntimeOptions) (_result *CreateRoutineCodeDeploymentResponse, _err error) {
3166 if dara.BoolValue(client.EnableValidate) == true {
3167 _err = tmpReq.Validate()
3168 if _err != nil {
3169 return _result, _err
3170 }
3171 }
3172 request := &CreateRoutineCodeDeploymentShrinkRequest{}
3173 openapiutil.Convert(tmpReq, request)
3174 if !dara.IsNil(tmpReq.CodeVersions) {
3175 request.CodeVersionsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.CodeVersions, dara.String("CodeVersions"), dara.String("json"))
3176 }
3177
3178 body := map[string]interface{}{}
3179 if !dara.IsNil(request.CodeVersionsShrink) {
3180 body["CodeVersions"] = request.CodeVersionsShrink
3181 }
3182
3183 if !dara.IsNil(request.Env) {
3184 body["Env"] = request.Env
3185 }
3186
3187 if !dara.IsNil(request.Name) {
3188 body["Name"] = request.Name
3189 }
3190
3191 if !dara.IsNil(request.Strategy) {
3192 body["Strategy"] = request.Strategy
3193 }
3194
3195 req := &openapiutil.OpenApiRequest{
3196 Body: openapiutil.ParseToMap(body),
3197 }
3198 params := &openapiutil.Params{
3199 Action: dara.String("CreateRoutineCodeDeployment"),
3200 Version: dara.String("2024-09-10"),
3201 Protocol: dara.String("HTTPS"),
3202 Pathname: dara.String("/"),
3203 Method: dara.String("POST"),
3204 AuthType: dara.String("AK"),
3205 Style: dara.String("RPC"),
3206 ReqBodyType: dara.String("formData"),
3207 BodyType: dara.String("json"),
3208 }
3209 _result = &CreateRoutineCodeDeploymentResponse{}
3210 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3211 if _err != nil {
3212 return _result, _err
3213 }
3214 _err = dara.Convert(_body, &_result)
3215 return _result, _err
3216 }
3217
3218 // Summary:
3219 //
3220 // Adds a record to map a domain that is associated with a routine. This record is used to trigger the associated routine code.
3221 //
3222 // @param request - CreateRoutineRelatedRecordRequest
3223 //
3224 // @param runtime - runtime options for this request RuntimeOptions
3225 //
3226 // @return CreateRoutineRelatedRecordResponse
3227 func CreateRoutineRelatedRecordWithContext(ctx context.Context, client *Client, request *CreateRoutineRelatedRecordRequest, runtime *dara.RuntimeOptions) (_result *CreateRoutineRelatedRecordResponse, _err error) {
3228 if dara.BoolValue(client.EnableValidate) == true {
3229 _err = request.Validate()
3230 if _err != nil {
3231 return _result, _err
3232 }
3233 }
3234 body := map[string]interface{}{}
3235 if !dara.IsNil(request.Name) {
3236 body["Name"] = request.Name
3237 }
3238
3239 if !dara.IsNil(request.RecordName) {
3240 body["RecordName"] = request.RecordName
3241 }
3242
3243 if !dara.IsNil(request.SiteId) {
3244 body["SiteId"] = request.SiteId
3245 }
3246
3247 req := &openapiutil.OpenApiRequest{
3248 Body: openapiutil.ParseToMap(body),
3249 }
3250 params := &openapiutil.Params{
3251 Action: dara.String("CreateRoutineRelatedRecord"),
3252 Version: dara.String("2024-09-10"),
3253 Protocol: dara.String("HTTPS"),
3254 Pathname: dara.String("/"),
3255 Method: dara.String("POST"),
3256 AuthType: dara.String("AK"),
3257 Style: dara.String("RPC"),
3258 ReqBodyType: dara.String("formData"),
3259 BodyType: dara.String("json"),
3260 }
3261 _result = &CreateRoutineRelatedRecordResponse{}
3262 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3263 if _err != nil {
3264 return _result, _err
3265 }
3266 _err = dara.Convert(_body, &_result)
3267 return _result, _err
3268 }
3269
3270 // Summary:
3271 //
3272 // Adds edge function routing configurations.
3273 //
3274 // @param request - CreateRoutineRouteRequest
3275 //
3276 // @param runtime - runtime options for this request RuntimeOptions
3277 //
3278 // @return CreateRoutineRouteResponse
3279 func CreateRoutineRouteWithContext(ctx context.Context, client *Client, request *CreateRoutineRouteRequest, runtime *dara.RuntimeOptions) (_result *CreateRoutineRouteResponse, _err error) {
3280 if dara.BoolValue(client.EnableValidate) == true {
3281 _err = request.Validate()
3282 if _err != nil {
3283 return _result, _err
3284 }
3285 }
3286 query := map[string]interface{}{}
3287 if !dara.IsNil(request.Bypass) {
3288 query["Bypass"] = request.Bypass
3289 }
3290
3291 if !dara.IsNil(request.Fallback) {
3292 query["Fallback"] = request.Fallback
3293 }
3294
3295 if !dara.IsNil(request.RouteEnable) {
3296 query["RouteEnable"] = request.RouteEnable
3297 }
3298
3299 if !dara.IsNil(request.RouteName) {
3300 query["RouteName"] = request.RouteName
3301 }
3302
3303 if !dara.IsNil(request.RoutineName) {
3304 query["RoutineName"] = request.RoutineName
3305 }
3306
3307 if !dara.IsNil(request.Rule) {
3308 query["Rule"] = request.Rule
3309 }
3310
3311 if !dara.IsNil(request.Sequence) {
3312 query["Sequence"] = request.Sequence
3313 }
3314
3315 if !dara.IsNil(request.SiteId) {
3316 query["SiteId"] = request.SiteId
3317 }
3318
3319 req := &openapiutil.OpenApiRequest{
3320 Query: openapiutil.Query(query),
3321 }
3322 params := &openapiutil.Params{
3323 Action: dara.String("CreateRoutineRoute"),
3324 Version: dara.String("2024-09-10"),
3325 Protocol: dara.String("HTTPS"),
3326 Pathname: dara.String("/"),
3327 Method: dara.String("POST"),
3328 AuthType: dara.String("AK"),
3329 Style: dara.String("RPC"),
3330 ReqBodyType: dara.String("formData"),
3331 BodyType: dara.String("json"),
3332 }
3333 _result = &CreateRoutineRouteResponse{}
3334 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3335 if _err != nil {
3336 return _result, _err
3337 }
3338 _err = dara.Convert(_body, &_result)
3339 return _result, _err
3340 }
3341
3342 // Summary:
3343 //
3344 // 创建带Assets资源的Routine代码版本
3345 //
3346 // @param tmpReq - CreateRoutineWithAssetsCodeVersionRequest
3347 //
3348 // @param runtime - runtime options for this request RuntimeOptions
3349 //
3350 // @return CreateRoutineWithAssetsCodeVersionResponse
3351 func CreateRoutineWithAssetsCodeVersionWithContext(ctx context.Context, client *Client, tmpReq *CreateRoutineWithAssetsCodeVersionRequest, runtime *dara.RuntimeOptions) (_result *CreateRoutineWithAssetsCodeVersionResponse, _err error) {
3352 if dara.BoolValue(client.EnableValidate) == true {
3353 _err = tmpReq.Validate()
3354 if _err != nil {
3355 return _result, _err
3356 }
3357 }
3358 request := &CreateRoutineWithAssetsCodeVersionShrinkRequest{}
3359 openapiutil.Convert(tmpReq, request)
3360 if !dara.IsNil(tmpReq.ConfOptions) {
3361 request.ConfOptionsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ConfOptions, dara.String("ConfOptions"), dara.String("json"))
3362 }
3363
3364 body := map[string]interface{}{}
3365 if !dara.IsNil(request.BuildId) {
3366 body["BuildId"] = request.BuildId
3367 }
3368
3369 if !dara.IsNil(request.CodeDescription) {
3370 body["CodeDescription"] = request.CodeDescription
3371 }
3372
3373 if !dara.IsNil(request.ConfOptionsShrink) {
3374 body["ConfOptions"] = request.ConfOptionsShrink
3375 }
3376
3377 if !dara.IsNil(request.ExtraInfo) {
3378 body["ExtraInfo"] = request.ExtraInfo
3379 }
3380
3381 if !dara.IsNil(request.Name) {
3382 body["Name"] = request.Name
3383 }
3384
3385 req := &openapiutil.OpenApiRequest{
3386 Body: openapiutil.ParseToMap(body),
3387 }
3388 params := &openapiutil.Params{
3389 Action: dara.String("CreateRoutineWithAssetsCodeVersion"),
3390 Version: dara.String("2024-09-10"),
3391 Protocol: dara.String("HTTPS"),
3392 Pathname: dara.String("/"),
3393 Method: dara.String("POST"),
3394 AuthType: dara.String("AK"),
3395 Style: dara.String("RPC"),
3396 ReqBodyType: dara.String("formData"),
3397 BodyType: dara.String("json"),
3398 }
3399 _result = &CreateRoutineWithAssetsCodeVersionResponse{}
3400 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3401 if _err != nil {
3402 return _result, _err
3403 }
3404 _err = dara.Convert(_body, &_result)
3405 return _result, _err
3406 }
3407
3408 // Summary:
3409 //
3410 // Creates scheduled prefetch plans.
3411 //
3412 // @param tmpReq - CreateScheduledPreloadExecutionsRequest
3413 //
3414 // @param runtime - runtime options for this request RuntimeOptions
3415 //
3416 // @return CreateScheduledPreloadExecutionsResponse
3417 func CreateScheduledPreloadExecutionsWithContext(ctx context.Context, client *Client, tmpReq *CreateScheduledPreloadExecutionsRequest, runtime *dara.RuntimeOptions) (_result *CreateScheduledPreloadExecutionsResponse, _err error) {
3418 if dara.BoolValue(client.EnableValidate) == true {
3419 _err = tmpReq.Validate()
3420 if _err != nil {
3421 return _result, _err
3422 }
3423 }
3424 request := &CreateScheduledPreloadExecutionsShrinkRequest{}
3425 openapiutil.Convert(tmpReq, request)
3426 if !dara.IsNil(tmpReq.Executions) {
3427 request.ExecutionsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Executions, dara.String("Executions"), dara.String("json"))
3428 }
3429
3430 query := map[string]interface{}{}
3431 if !dara.IsNil(request.Id) {
3432 query["Id"] = request.Id
3433 }
3434
3435 body := map[string]interface{}{}
3436 if !dara.IsNil(request.ExecutionsShrink) {
3437 body["Executions"] = request.ExecutionsShrink
3438 }
3439
3440 req := &openapiutil.OpenApiRequest{
3441 Query: openapiutil.Query(query),
3442 Body: openapiutil.ParseToMap(body),
3443 }
3444 params := &openapiutil.Params{
3445 Action: dara.String("CreateScheduledPreloadExecutions"),
3446 Version: dara.String("2024-09-10"),
3447 Protocol: dara.String("HTTPS"),
3448 Pathname: dara.String("/"),
3449 Method: dara.String("POST"),
3450 AuthType: dara.String("AK"),
3451 Style: dara.String("RPC"),
3452 ReqBodyType: dara.String("formData"),
3453 BodyType: dara.String("json"),
3454 }
3455 _result = &CreateScheduledPreloadExecutionsResponse{}
3456 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3457 if _err != nil {
3458 return _result, _err
3459 }
3460 _err = dara.Convert(_body, &_result)
3461 return _result, _err
3462 }
3463
3464 // Summary:
3465 //
3466 // Adds a scheduled prefetch task.
3467 //
3468 // @param request - CreateScheduledPreloadJobRequest
3469 //
3470 // @param runtime - runtime options for this request RuntimeOptions
3471 //
3472 // @return CreateScheduledPreloadJobResponse
3473 func CreateScheduledPreloadJobWithContext(ctx context.Context, client *Client, request *CreateScheduledPreloadJobRequest, runtime *dara.RuntimeOptions) (_result *CreateScheduledPreloadJobResponse, _err error) {
3474 if dara.BoolValue(client.EnableValidate) == true {
3475 _err = request.Validate()
3476 if _err != nil {
3477 return _result, _err
3478 }
3479 }
3480 body := map[string]interface{}{}
3481 if !dara.IsNil(request.InsertWay) {
3482 body["InsertWay"] = request.InsertWay
3483 }
3484
3485 if !dara.IsNil(request.Name) {
3486 body["Name"] = request.Name
3487 }
3488
3489 if !dara.IsNil(request.OssUrl) {
3490 body["OssUrl"] = request.OssUrl
3491 }
3492
3493 if !dara.IsNil(request.SiteId) {
3494 body["SiteId"] = request.SiteId
3495 }
3496
3497 if !dara.IsNil(request.UrlList) {
3498 body["UrlList"] = request.UrlList
3499 }
3500
3501 req := &openapiutil.OpenApiRequest{
3502 Body: openapiutil.ParseToMap(body),
3503 }
3504 params := &openapiutil.Params{
3505 Action: dara.String("CreateScheduledPreloadJob"),
3506 Version: dara.String("2024-09-10"),
3507 Protocol: dara.String("HTTPS"),
3508 Pathname: dara.String("/"),
3509 Method: dara.String("POST"),
3510 AuthType: dara.String("AK"),
3511 Style: dara.String("RPC"),
3512 ReqBodyType: dara.String("formData"),
3513 BodyType: dara.String("json"),
3514 }
3515 _result = &CreateScheduledPreloadJobResponse{}
3516 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3517 if _err != nil {
3518 return _result, _err
3519 }
3520 _err = dara.Convert(_body, &_result)
3521 return _result, _err
3522 }
3523
3524 // Summary:
3525 //
3526 // Adds a website.
3527 //
3528 // Description:
3529 //
3530 // Make sure that you have an available plan before you add a website.
3531 //
3532 // - Make sure that your website domain name has an ICP filing if the location you want to specify covers the Chinese mainland.
3533 //
3534 // @param request - CreateSiteRequest
3535 //
3536 // @param runtime - runtime options for this request RuntimeOptions
3537 //
3538 // @return CreateSiteResponse
3539 func CreateSiteWithContext(ctx context.Context, client *Client, request *CreateSiteRequest, runtime *dara.RuntimeOptions) (_result *CreateSiteResponse, _err error) {
3540 if dara.BoolValue(client.EnableValidate) == true {
3541 _err = request.Validate()
3542 if _err != nil {
3543 return _result, _err
3544 }
3545 }
3546 query := map[string]interface{}{}
3547 if !dara.IsNil(request.AccessType) {
3548 query["AccessType"] = request.AccessType
3549 }
3550
3551 if !dara.IsNil(request.Coverage) {
3552 query["Coverage"] = request.Coverage
3553 }
3554
3555 if !dara.IsNil(request.InstanceId) {
3556 query["InstanceId"] = request.InstanceId
3557 }
3558
3559 if !dara.IsNil(request.ResourceGroupId) {
3560 query["ResourceGroupId"] = request.ResourceGroupId
3561 }
3562
3563 if !dara.IsNil(request.SiteName) {
3564 query["SiteName"] = request.SiteName
3565 }
3566
3567 req := &openapiutil.OpenApiRequest{
3568 Query: openapiutil.Query(query),
3569 }
3570 params := &openapiutil.Params{
3571 Action: dara.String("CreateSite"),
3572 Version: dara.String("2024-09-10"),
3573 Protocol: dara.String("HTTPS"),
3574 Pathname: dara.String("/"),
3575 Method: dara.String("POST"),
3576 AuthType: dara.String("AK"),
3577 Style: dara.String("RPC"),
3578 ReqBodyType: dara.String("formData"),
3579 BodyType: dara.String("json"),
3580 }
3581 _result = &CreateSiteResponse{}
3582 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3583 if _err != nil {
3584 return _result, _err
3585 }
3586 _err = dara.Convert(_body, &_result)
3587 return _result, _err
3588 }
3589
3590 // Summary:
3591 //
3592 // Adds the configuration of custom request header, response header, and cookie fields that are used to capture logs of a website.
3593 //
3594 // Description:
3595 //
3596 // **Custom field limits**: The key name of a custom field can contain only letters, digits, underscores (_), and spaces. The key name cannot contain other characters. Otherwise, errors may occur.
3597 //
3598 // - **Parameter passing**: Submit `SiteId`, `RequestHeaders`, `ResponseHeaders`, and `Cookies` by using `formData`. Each array element matches a custom field name.
3599 //
3600 // - **(Required) SiteId**: Although `SiteId` is not marked as required in the Required column, you must specify a website ID by using this parameter when you can call this API operation.
3601 //
3602 // @param tmpReq - CreateSiteCustomLogRequest
3603 //
3604 // @param runtime - runtime options for this request RuntimeOptions
3605 //
3606 // @return CreateSiteCustomLogResponse
3607 func CreateSiteCustomLogWithContext(ctx context.Context, client *Client, tmpReq *CreateSiteCustomLogRequest, runtime *dara.RuntimeOptions) (_result *CreateSiteCustomLogResponse, _err error) {
3608 if dara.BoolValue(client.EnableValidate) == true {
3609 _err = tmpReq.Validate()
3610 if _err != nil {
3611 return _result, _err
3612 }
3613 }
3614 request := &CreateSiteCustomLogShrinkRequest{}
3615 openapiutil.Convert(tmpReq, request)
3616 if !dara.IsNil(tmpReq.Cookies) {
3617 request.CookiesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Cookies, dara.String("Cookies"), dara.String("json"))
3618 }
3619
3620 if !dara.IsNil(tmpReq.RequestHeaders) {
3621 request.RequestHeadersShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RequestHeaders, dara.String("RequestHeaders"), dara.String("json"))
3622 }
3623
3624 if !dara.IsNil(tmpReq.ResponseHeaders) {
3625 request.ResponseHeadersShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ResponseHeaders, dara.String("ResponseHeaders"), dara.String("json"))
3626 }
3627
3628 body := map[string]interface{}{}
3629 if !dara.IsNil(request.CookiesShrink) {
3630 body["Cookies"] = request.CookiesShrink
3631 }
3632
3633 if !dara.IsNil(request.RequestHeadersShrink) {
3634 body["RequestHeaders"] = request.RequestHeadersShrink
3635 }
3636
3637 if !dara.IsNil(request.ResponseHeadersShrink) {
3638 body["ResponseHeaders"] = request.ResponseHeadersShrink
3639 }
3640
3641 if !dara.IsNil(request.SiteId) {
3642 body["SiteId"] = request.SiteId
3643 }
3644
3645 req := &openapiutil.OpenApiRequest{
3646 Body: openapiutil.ParseToMap(body),
3647 }
3648 params := &openapiutil.Params{
3649 Action: dara.String("CreateSiteCustomLog"),
3650 Version: dara.String("2024-09-10"),
3651 Protocol: dara.String("HTTPS"),
3652 Pathname: dara.String("/"),
3653 Method: dara.String("POST"),
3654 AuthType: dara.String("AK"),
3655 Style: dara.String("RPC"),
3656 ReqBodyType: dara.String("formData"),
3657 BodyType: dara.String("json"),
3658 }
3659 _result = &CreateSiteCustomLogResponse{}
3660 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3661 if _err != nil {
3662 return _result, _err
3663 }
3664 _err = dara.Convert(_body, &_result)
3665 return _result, _err
3666 }
3667
3668 // Summary:
3669 //
3670 // Creates a real-time log delivery task.
3671 //
3672 // @param tmpReq - CreateSiteDeliveryTaskRequest
3673 //
3674 // @param runtime - runtime options for this request RuntimeOptions
3675 //
3676 // @return CreateSiteDeliveryTaskResponse
3677 func CreateSiteDeliveryTaskWithContext(ctx context.Context, client *Client, tmpReq *CreateSiteDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *CreateSiteDeliveryTaskResponse, _err error) {
3678 if dara.BoolValue(client.EnableValidate) == true {
3679 _err = tmpReq.Validate()
3680 if _err != nil {
3681 return _result, _err
3682 }
3683 }
3684 request := &CreateSiteDeliveryTaskShrinkRequest{}
3685 openapiutil.Convert(tmpReq, request)
3686 if !dara.IsNil(tmpReq.HttpDelivery) {
3687 request.HttpDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.HttpDelivery, dara.String("HttpDelivery"), dara.String("json"))
3688 }
3689
3690 if !dara.IsNil(tmpReq.KafkaDelivery) {
3691 request.KafkaDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.KafkaDelivery, dara.String("KafkaDelivery"), dara.String("json"))
3692 }
3693
3694 if !dara.IsNil(tmpReq.OssDelivery) {
3695 request.OssDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.OssDelivery, dara.String("OssDelivery"), dara.String("json"))
3696 }
3697
3698 if !dara.IsNil(tmpReq.S3Delivery) {
3699 request.S3DeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.S3Delivery, dara.String("S3Delivery"), dara.String("json"))
3700 }
3701
3702 if !dara.IsNil(tmpReq.SlsDelivery) {
3703 request.SlsDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.SlsDelivery, dara.String("SlsDelivery"), dara.String("json"))
3704 }
3705
3706 body := map[string]interface{}{}
3707 if !dara.IsNil(request.BusinessType) {
3708 body["BusinessType"] = request.BusinessType
3709 }
3710
3711 if !dara.IsNil(request.DataCenter) {
3712 body["DataCenter"] = request.DataCenter
3713 }
3714
3715 if !dara.IsNil(request.DeliveryType) {
3716 body["DeliveryType"] = request.DeliveryType
3717 }
3718
3719 if !dara.IsNil(request.DiscardRate) {
3720 body["DiscardRate"] = request.DiscardRate
3721 }
3722
3723 if !dara.IsNil(request.FieldName) {
3724 body["FieldName"] = request.FieldName
3725 }
3726
3727 if !dara.IsNil(request.FilterVer) {
3728 body["FilterVer"] = request.FilterVer
3729 }
3730
3731 if !dara.IsNil(request.HttpDeliveryShrink) {
3732 body["HttpDelivery"] = request.HttpDeliveryShrink
3733 }
3734
3735 if !dara.IsNil(request.KafkaDeliveryShrink) {
3736 body["KafkaDelivery"] = request.KafkaDeliveryShrink
3737 }
3738
3739 if !dara.IsNil(request.OssDeliveryShrink) {
3740 body["OssDelivery"] = request.OssDeliveryShrink
3741 }
3742
3743 if !dara.IsNil(request.S3DeliveryShrink) {
3744 body["S3Delivery"] = request.S3DeliveryShrink
3745 }
3746
3747 if !dara.IsNil(request.SiteId) {
3748 body["SiteId"] = request.SiteId
3749 }
3750
3751 if !dara.IsNil(request.SlsDeliveryShrink) {
3752 body["SlsDelivery"] = request.SlsDeliveryShrink
3753 }
3754
3755 if !dara.IsNil(request.TaskName) {
3756 body["TaskName"] = request.TaskName
3757 }
3758
3759 req := &openapiutil.OpenApiRequest{
3760 Body: openapiutil.ParseToMap(body),
3761 }
3762 params := &openapiutil.Params{
3763 Action: dara.String("CreateSiteDeliveryTask"),
3764 Version: dara.String("2024-09-10"),
3765 Protocol: dara.String("HTTPS"),
3766 Pathname: dara.String("/"),
3767 Method: dara.String("POST"),
3768 AuthType: dara.String("AK"),
3769 Style: dara.String("RPC"),
3770 ReqBodyType: dara.String("formData"),
3771 BodyType: dara.String("json"),
3772 }
3773 _result = &CreateSiteDeliveryTaskResponse{}
3774 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3775 if _err != nil {
3776 return _result, _err
3777 }
3778 _err = dara.Convert(_body, &_result)
3779 return _result, _err
3780 }
3781
3782 // Summary:
3783 //
3784 // # Create Transport Layer Application
3785 //
3786 // @param tmpReq - CreateTransportLayerApplicationRequest
3787 //
3788 // @param runtime - runtime options for this request RuntimeOptions
3789 //
3790 // @return CreateTransportLayerApplicationResponse
3791 func CreateTransportLayerApplicationWithContext(ctx context.Context, client *Client, tmpReq *CreateTransportLayerApplicationRequest, runtime *dara.RuntimeOptions) (_result *CreateTransportLayerApplicationResponse, _err error) {
3792 if dara.BoolValue(client.EnableValidate) == true {
3793 _err = tmpReq.Validate()
3794 if _err != nil {
3795 return _result, _err
3796 }
3797 }
3798 request := &CreateTransportLayerApplicationShrinkRequest{}
3799 openapiutil.Convert(tmpReq, request)
3800 if !dara.IsNil(tmpReq.Rules) {
3801 request.RulesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Rules, dara.String("Rules"), dara.String("json"))
3802 }
3803
3804 query := map[string]interface{}{}
3805 if !dara.IsNil(request.CrossBorderOptimization) {
3806 query["CrossBorderOptimization"] = request.CrossBorderOptimization
3807 }
3808
3809 if !dara.IsNil(request.IpAccessRule) {
3810 query["IpAccessRule"] = request.IpAccessRule
3811 }
3812
3813 if !dara.IsNil(request.Ipv6) {
3814 query["Ipv6"] = request.Ipv6
3815 }
3816
3817 if !dara.IsNil(request.RecordName) {
3818 query["RecordName"] = request.RecordName
3819 }
3820
3821 if !dara.IsNil(request.RulesShrink) {
3822 query["Rules"] = request.RulesShrink
3823 }
3824
3825 if !dara.IsNil(request.SiteId) {
3826 query["SiteId"] = request.SiteId
3827 }
3828
3829 if !dara.IsNil(request.StaticIp) {
3830 query["StaticIp"] = request.StaticIp
3831 }
3832
3833 req := &openapiutil.OpenApiRequest{
3834 Query: openapiutil.Query(query),
3835 }
3836 params := &openapiutil.Params{
3837 Action: dara.String("CreateTransportLayerApplication"),
3838 Version: dara.String("2024-09-10"),
3839 Protocol: dara.String("HTTPS"),
3840 Pathname: dara.String("/"),
3841 Method: dara.String("POST"),
3842 AuthType: dara.String("AK"),
3843 Style: dara.String("RPC"),
3844 ReqBodyType: dara.String("formData"),
3845 BodyType: dara.String("json"),
3846 }
3847 _result = &CreateTransportLayerApplicationResponse{}
3848 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3849 if _err != nil {
3850 return _result, _err
3851 }
3852 _err = dara.Convert(_body, &_result)
3853 return _result, _err
3854 }
3855
3856 // Summary:
3857 //
3858 // Create a web page monitoring configuration.
3859 //
3860 // @param request - CreateUrlObservationRequest
3861 //
3862 // @param runtime - runtime options for this request RuntimeOptions
3863 //
3864 // @return CreateUrlObservationResponse
3865 func CreateUrlObservationWithContext(ctx context.Context, client *Client, request *CreateUrlObservationRequest, runtime *dara.RuntimeOptions) (_result *CreateUrlObservationResponse, _err error) {
3866 if dara.BoolValue(client.EnableValidate) == true {
3867 _err = request.Validate()
3868 if _err != nil {
3869 return _result, _err
3870 }
3871 }
3872 query := map[string]interface{}{}
3873 if !dara.IsNil(request.SdkType) {
3874 query["SdkType"] = request.SdkType
3875 }
3876
3877 if !dara.IsNil(request.SiteId) {
3878 query["SiteId"] = request.SiteId
3879 }
3880
3881 if !dara.IsNil(request.Url) {
3882 query["Url"] = request.Url
3883 }
3884
3885 req := &openapiutil.OpenApiRequest{
3886 Query: openapiutil.Query(query),
3887 }
3888 params := &openapiutil.Params{
3889 Action: dara.String("CreateUrlObservation"),
3890 Version: dara.String("2024-09-10"),
3891 Protocol: dara.String("HTTPS"),
3892 Pathname: dara.String("/"),
3893 Method: dara.String("POST"),
3894 AuthType: dara.String("AK"),
3895 Style: dara.String("RPC"),
3896 ReqBodyType: dara.String("formData"),
3897 BodyType: dara.String("json"),
3898 }
3899 _result = &CreateUrlObservationResponse{}
3900 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
3901 if _err != nil {
3902 return _result, _err
3903 }
3904 _err = dara.Convert(_body, &_result)
3905 return _result, _err
3906 }
3907
3908 // Summary:
3909 //
3910 // Creates a log delivery task to ship logs to the specified destination.
3911 //
3912 // Description:
3913 //
3914 // This API operation allows you to deliver logs to destinations such as Simple Log Service (SLS), HTTP servers, Object Storage Service (OSS), Amazon Simple Storage Service (S3), and Kafka. You can specify the task name, log fields to deliver, data center, discard rate, delivery type, and delivery details.
3915 //
3916 // - **Field filtering**: Use the `FieldName` parameter to specify log fields to deliver.
3917 //
3918 // - **Filtering rules**: Use the `FilterRules` parameter to pre-process and filter log data.
3919 //
3920 // - **Diverse delivery destinations**: Logs can be delivered to different destinations. Configuration parameters vary with delivery destinations.
3921 //
3922 // ## [](#)Precautions
3923 //
3924 // - Make sure that you have sufficient permissions to perform delivery tasks.
3925 //
3926 // - If you enable encryption or authentication, properly configure corresponding parameters.
3927 //
3928 // - Verify the syntax of `FilterRules` to make sure that filtering logic works as expected.
3929 //
3930 // - Specify advanced settings such as the number of retries and timeout period based on your needs to have optimal delivery efficiency and stability.
3931 //
3932 // @param tmpReq - CreateUserDeliveryTaskRequest
3933 //
3934 // @param runtime - runtime options for this request RuntimeOptions
3935 //
3936 // @return CreateUserDeliveryTaskResponse
3937 func CreateUserDeliveryTaskWithContext(ctx context.Context, client *Client, tmpReq *CreateUserDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *CreateUserDeliveryTaskResponse, _err error) {
3938 if dara.BoolValue(client.EnableValidate) == true {
3939 _err = tmpReq.Validate()
3940 if _err != nil {
3941 return _result, _err
3942 }
3943 }
3944 request := &CreateUserDeliveryTaskShrinkRequest{}
3945 openapiutil.Convert(tmpReq, request)
3946 if !dara.IsNil(tmpReq.HttpDelivery) {
3947 request.HttpDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.HttpDelivery, dara.String("HttpDelivery"), dara.String("json"))
3948 }
3949
3950 if !dara.IsNil(tmpReq.KafkaDelivery) {
3951 request.KafkaDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.KafkaDelivery, dara.String("KafkaDelivery"), dara.String("json"))
3952 }
3953
3954 if !dara.IsNil(tmpReq.OssDelivery) {
3955 request.OssDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.OssDelivery, dara.String("OssDelivery"), dara.String("json"))
3956 }
3957
3958 if !dara.IsNil(tmpReq.S3Delivery) {
3959 request.S3DeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.S3Delivery, dara.String("S3Delivery"), dara.String("json"))
3960 }
3961
3962 if !dara.IsNil(tmpReq.SlsDelivery) {
3963 request.SlsDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.SlsDelivery, dara.String("SlsDelivery"), dara.String("json"))
3964 }
3965
3966 body := map[string]interface{}{}
3967 if !dara.IsNil(request.BusinessType) {
3968 body["BusinessType"] = request.BusinessType
3969 }
3970
3971 if !dara.IsNil(request.DataCenter) {
3972 body["DataCenter"] = request.DataCenter
3973 }
3974
3975 if !dara.IsNil(request.DeliveryType) {
3976 body["DeliveryType"] = request.DeliveryType
3977 }
3978
3979 if !dara.IsNil(request.Details) {
3980 body["Details"] = request.Details
3981 }
3982
3983 if !dara.IsNil(request.DiscardRate) {
3984 body["DiscardRate"] = request.DiscardRate
3985 }
3986
3987 if !dara.IsNil(request.FieldName) {
3988 body["FieldName"] = request.FieldName
3989 }
3990
3991 if !dara.IsNil(request.FilterVer) {
3992 body["FilterVer"] = request.FilterVer
3993 }
3994
3995 if !dara.IsNil(request.HttpDeliveryShrink) {
3996 body["HttpDelivery"] = request.HttpDeliveryShrink
3997 }
3998
3999 if !dara.IsNil(request.KafkaDeliveryShrink) {
4000 body["KafkaDelivery"] = request.KafkaDeliveryShrink
4001 }
4002
4003 if !dara.IsNil(request.OssDeliveryShrink) {
4004 body["OssDelivery"] = request.OssDeliveryShrink
4005 }
4006
4007 if !dara.IsNil(request.S3DeliveryShrink) {
4008 body["S3Delivery"] = request.S3DeliveryShrink
4009 }
4010
4011 if !dara.IsNil(request.SlsDeliveryShrink) {
4012 body["SlsDelivery"] = request.SlsDeliveryShrink
4013 }
4014
4015 if !dara.IsNil(request.TaskName) {
4016 body["TaskName"] = request.TaskName
4017 }
4018
4019 req := &openapiutil.OpenApiRequest{
4020 Body: openapiutil.ParseToMap(body),
4021 }
4022 params := &openapiutil.Params{
4023 Action: dara.String("CreateUserDeliveryTask"),
4024 Version: dara.String("2024-09-10"),
4025 Protocol: dara.String("HTTPS"),
4026 Pathname: dara.String("/"),
4027 Method: dara.String("POST"),
4028 AuthType: dara.String("AK"),
4029 Style: dara.String("RPC"),
4030 ReqBodyType: dara.String("formData"),
4031 BodyType: dara.String("json"),
4032 }
4033 _result = &CreateUserDeliveryTaskResponse{}
4034 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4035 if _err != nil {
4036 return _result, _err
4037 }
4038 _err = dara.Convert(_body, &_result)
4039 return _result, _err
4040 }
4041
4042 // Summary:
4043 //
4044 // 用于创建实例级别的Web应用防火墙规则集，支持多种类型的防护规则。
4045 //
4046 // Description:
4047 //
4048 // ## 请求说明
4049 //
4050 // - 本API允许用户为指定实例创建新的WAF（Web Application Firewall）规则集。
4051 //
4052 // - `InstanceId` 是必需参数，指定了要为其创建规则集的具体实例。
4053 //
4054 // - `Phase` 参数定义了规则集的应用阶段，例如自定义规则、频次控制等。
4055 //
4056 // - `Name` 和 `Expression` 是必填项，分别代表规则集的名字和具体的匹配表达式。
4057 //
4058 // - 可选参数 `Description` 提供了对规则集功能或用途的文字描述。
4059 //
4060 // - `Status` 控制着规则集是否立即生效 (`on`) 或者处于关闭状态 (`off`)。
4061 //
4062 // - 通过 `Rules` 参数可以进一步配置更详细的规则列表，每个规则都包含名称、位置、表达式及动作等属性。
4063 //
4064 // - 成功响应将返回新创建规则集的唯一标识符 `Id` 以及所有关联规则的ID列表 `RuleIds`。
4065 //
4066 // @param tmpReq - CreateUserWafRulesetRequest
4067 //
4068 // @param runtime - runtime options for this request RuntimeOptions
4069 //
4070 // @return CreateUserWafRulesetResponse
4071 func CreateUserWafRulesetWithContext(ctx context.Context, client *Client, tmpReq *CreateUserWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *CreateUserWafRulesetResponse, _err error) {
4072 if dara.BoolValue(client.EnableValidate) == true {
4073 _err = tmpReq.Validate()
4074 if _err != nil {
4075 return _result, _err
4076 }
4077 }
4078 request := &CreateUserWafRulesetShrinkRequest{}
4079 openapiutil.Convert(tmpReq, request)
4080 if !dara.IsNil(tmpReq.Rules) {
4081 request.RulesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Rules, dara.String("Rules"), dara.String("json"))
4082 }
4083
4084 if !dara.IsNil(tmpReq.Shared) {
4085 request.SharedShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Shared, dara.String("Shared"), dara.String("json"))
4086 }
4087
4088 query := map[string]interface{}{}
4089 if !dara.IsNil(request.InstanceId) {
4090 query["InstanceId"] = request.InstanceId
4091 }
4092
4093 body := map[string]interface{}{}
4094 if !dara.IsNil(request.Description) {
4095 body["Description"] = request.Description
4096 }
4097
4098 if !dara.IsNil(request.Expression) {
4099 body["Expression"] = request.Expression
4100 }
4101
4102 if !dara.IsNil(request.Name) {
4103 body["Name"] = request.Name
4104 }
4105
4106 if !dara.IsNil(request.Phase) {
4107 body["Phase"] = request.Phase
4108 }
4109
4110 if !dara.IsNil(request.RulesShrink) {
4111 body["Rules"] = request.RulesShrink
4112 }
4113
4114 if !dara.IsNil(request.SharedShrink) {
4115 body["Shared"] = request.SharedShrink
4116 }
4117
4118 if !dara.IsNil(request.Status) {
4119 body["Status"] = request.Status
4120 }
4121
4122 req := &openapiutil.OpenApiRequest{
4123 Query: openapiutil.Query(query),
4124 Body: openapiutil.ParseToMap(body),
4125 }
4126 params := &openapiutil.Params{
4127 Action: dara.String("CreateUserWafRuleset"),
4128 Version: dara.String("2024-09-10"),
4129 Protocol: dara.String("HTTPS"),
4130 Pathname: dara.String("/"),
4131 Method: dara.String("POST"),
4132 AuthType: dara.String("AK"),
4133 Style: dara.String("RPC"),
4134 ReqBodyType: dara.String("formData"),
4135 BodyType: dara.String("json"),
4136 }
4137 _result = &CreateUserWafRulesetResponse{}
4138 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4139 if _err != nil {
4140 return _result, _err
4141 }
4142 _err = dara.Convert(_body, &_result)
4143 return _result, _err
4144 }
4145
4146 // Summary:
4147 //
4148 // Add video processing configurations for a website.
4149 //
4150 // @param request - CreateVideoProcessingRequest
4151 //
4152 // @param runtime - runtime options for this request RuntimeOptions
4153 //
4154 // @return CreateVideoProcessingResponse
4155 func CreateVideoProcessingWithContext(ctx context.Context, client *Client, request *CreateVideoProcessingRequest, runtime *dara.RuntimeOptions) (_result *CreateVideoProcessingResponse, _err error) {
4156 if dara.BoolValue(client.EnableValidate) == true {
4157 _err = request.Validate()
4158 if _err != nil {
4159 return _result, _err
4160 }
4161 }
4162 query := map[string]interface{}{}
4163 if !dara.IsNil(request.FlvSeekEnd) {
4164 query["FlvSeekEnd"] = request.FlvSeekEnd
4165 }
4166
4167 if !dara.IsNil(request.FlvSeekStart) {
4168 query["FlvSeekStart"] = request.FlvSeekStart
4169 }
4170
4171 if !dara.IsNil(request.FlvVideoSeekMode) {
4172 query["FlvVideoSeekMode"] = request.FlvVideoSeekMode
4173 }
4174
4175 if !dara.IsNil(request.Mp4SeekEnd) {
4176 query["Mp4SeekEnd"] = request.Mp4SeekEnd
4177 }
4178
4179 if !dara.IsNil(request.Mp4SeekStart) {
4180 query["Mp4SeekStart"] = request.Mp4SeekStart
4181 }
4182
4183 if !dara.IsNil(request.Rule) {
4184 query["Rule"] = request.Rule
4185 }
4186
4187 if !dara.IsNil(request.RuleEnable) {
4188 query["RuleEnable"] = request.RuleEnable
4189 }
4190
4191 if !dara.IsNil(request.RuleName) {
4192 query["RuleName"] = request.RuleName
4193 }
4194
4195 if !dara.IsNil(request.Sequence) {
4196 query["Sequence"] = request.Sequence
4197 }
4198
4199 if !dara.IsNil(request.SiteId) {
4200 query["SiteId"] = request.SiteId
4201 }
4202
4203 if !dara.IsNil(request.SiteVersion) {
4204 query["SiteVersion"] = request.SiteVersion
4205 }
4206
4207 if !dara.IsNil(request.VideoSeekEnable) {
4208 query["VideoSeekEnable"] = request.VideoSeekEnable
4209 }
4210
4211 req := &openapiutil.OpenApiRequest{
4212 Query: openapiutil.Query(query),
4213 }
4214 params := &openapiutil.Params{
4215 Action: dara.String("CreateVideoProcessing"),
4216 Version: dara.String("2024-09-10"),
4217 Protocol: dara.String("HTTPS"),
4218 Pathname: dara.String("/"),
4219 Method: dara.String("POST"),
4220 AuthType: dara.String("AK"),
4221 Style: dara.String("RPC"),
4222 ReqBodyType: dara.String("formData"),
4223 BodyType: dara.String("json"),
4224 }
4225 _result = &CreateVideoProcessingResponse{}
4226 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4227 if _err != nil {
4228 return _result, _err
4229 }
4230 _err = dara.Convert(_body, &_result)
4231 return _result, _err
4232 }
4233
4234 // Summary:
4235 //
4236 // # Create WAF Rule
4237 //
4238 // @param tmpReq - CreateWafRuleRequest
4239 //
4240 // @param runtime - runtime options for this request RuntimeOptions
4241 //
4242 // @return CreateWafRuleResponse
4243 func CreateWafRuleWithContext(ctx context.Context, client *Client, tmpReq *CreateWafRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateWafRuleResponse, _err error) {
4244 if dara.BoolValue(client.EnableValidate) == true {
4245 _err = tmpReq.Validate()
4246 if _err != nil {
4247 return _result, _err
4248 }
4249 }
4250 request := &CreateWafRuleShrinkRequest{}
4251 openapiutil.Convert(tmpReq, request)
4252 if !dara.IsNil(tmpReq.Config) {
4253 request.ConfigShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Config, dara.String("Config"), dara.String("json"))
4254 }
4255
4256 query := map[string]interface{}{}
4257 if !dara.IsNil(request.SiteId) {
4258 query["SiteId"] = request.SiteId
4259 }
4260
4261 if !dara.IsNil(request.SiteVersion) {
4262 query["SiteVersion"] = request.SiteVersion
4263 }
4264
4265 body := map[string]interface{}{}
4266 if !dara.IsNil(request.ConfigShrink) {
4267 body["Config"] = request.ConfigShrink
4268 }
4269
4270 if !dara.IsNil(request.Phase) {
4271 body["Phase"] = request.Phase
4272 }
4273
4274 if !dara.IsNil(request.RulesetId) {
4275 body["RulesetId"] = request.RulesetId
4276 }
4277
4278 req := &openapiutil.OpenApiRequest{
4279 Query: openapiutil.Query(query),
4280 Body: openapiutil.ParseToMap(body),
4281 }
4282 params := &openapiutil.Params{
4283 Action: dara.String("CreateWafRule"),
4284 Version: dara.String("2024-09-10"),
4285 Protocol: dara.String("HTTPS"),
4286 Pathname: dara.String("/"),
4287 Method: dara.String("POST"),
4288 AuthType: dara.String("AK"),
4289 Style: dara.String("RPC"),
4290 ReqBodyType: dara.String("formData"),
4291 BodyType: dara.String("json"),
4292 }
4293 _result = &CreateWafRuleResponse{}
4294 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4295 if _err != nil {
4296 return _result, _err
4297 }
4298 _err = dara.Convert(_body, &_result)
4299 return _result, _err
4300 }
4301
4302 // Summary:
4303 //
4304 // # Create WAF Ruleset
4305 //
4306 // @param request - CreateWafRulesetRequest
4307 //
4308 // @param runtime - runtime options for this request RuntimeOptions
4309 //
4310 // @return CreateWafRulesetResponse
4311 func CreateWafRulesetWithContext(ctx context.Context, client *Client, request *CreateWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *CreateWafRulesetResponse, _err error) {
4312 if dara.BoolValue(client.EnableValidate) == true {
4313 _err = request.Validate()
4314 if _err != nil {
4315 return _result, _err
4316 }
4317 }
4318 query := map[string]interface{}{}
4319 if !dara.IsNil(request.SiteId) {
4320 query["SiteId"] = request.SiteId
4321 }
4322
4323 if !dara.IsNil(request.SiteVersion) {
4324 query["SiteVersion"] = request.SiteVersion
4325 }
4326
4327 body := map[string]interface{}{}
4328 if !dara.IsNil(request.Name) {
4329 body["Name"] = request.Name
4330 }
4331
4332 if !dara.IsNil(request.Phase) {
4333 body["Phase"] = request.Phase
4334 }
4335
4336 req := &openapiutil.OpenApiRequest{
4337 Query: openapiutil.Query(query),
4338 Body: openapiutil.ParseToMap(body),
4339 }
4340 params := &openapiutil.Params{
4341 Action: dara.String("CreateWafRuleset"),
4342 Version: dara.String("2024-09-10"),
4343 Protocol: dara.String("HTTPS"),
4344 Pathname: dara.String("/"),
4345 Method: dara.String("POST"),
4346 AuthType: dara.String("AK"),
4347 Style: dara.String("RPC"),
4348 ReqBodyType: dara.String("formData"),
4349 BodyType: dara.String("json"),
4350 }
4351 _result = &CreateWafRulesetResponse{}
4352 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4353 if _err != nil {
4354 return _result, _err
4355 }
4356 _err = dara.Convert(_body, &_result)
4357 return _result, _err
4358 }
4359
4360 // Summary:
4361 //
4362 // Creates a waiting room for a website.
4363 //
4364 // @param tmpReq - CreateWaitingRoomRequest
4365 //
4366 // @param runtime - runtime options for this request RuntimeOptions
4367 //
4368 // @return CreateWaitingRoomResponse
4369 func CreateWaitingRoomWithContext(ctx context.Context, client *Client, tmpReq *CreateWaitingRoomRequest, runtime *dara.RuntimeOptions) (_result *CreateWaitingRoomResponse, _err error) {
4370 if dara.BoolValue(client.EnableValidate) == true {
4371 _err = tmpReq.Validate()
4372 if _err != nil {
4373 return _result, _err
4374 }
4375 }
4376 request := &CreateWaitingRoomShrinkRequest{}
4377 openapiutil.Convert(tmpReq, request)
4378 if !dara.IsNil(tmpReq.HostNameAndPath) {
4379 request.HostNameAndPathShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.HostNameAndPath, dara.String("HostNameAndPath"), dara.String("json"))
4380 }
4381
4382 query := map[string]interface{}{}
4383 if !dara.IsNil(request.CookieName) {
4384 query["CookieName"] = request.CookieName
4385 }
4386
4387 if !dara.IsNil(request.CustomPageHtml) {
4388 query["CustomPageHtml"] = request.CustomPageHtml
4389 }
4390
4391 if !dara.IsNil(request.Description) {
4392 query["Description"] = request.Description
4393 }
4394
4395 if !dara.IsNil(request.DisableSessionRenewalEnable) {
4396 query["DisableSessionRenewalEnable"] = request.DisableSessionRenewalEnable
4397 }
4398
4399 if !dara.IsNil(request.Enable) {
4400 query["Enable"] = request.Enable
4401 }
4402
4403 if !dara.IsNil(request.HostNameAndPathShrink) {
4404 query["HostNameAndPath"] = request.HostNameAndPathShrink
4405 }
4406
4407 if !dara.IsNil(request.JsonResponseEnable) {
4408 query["JsonResponseEnable"] = request.JsonResponseEnable
4409 }
4410
4411 if !dara.IsNil(request.Language) {
4412 query["Language"] = request.Language
4413 }
4414
4415 if !dara.IsNil(request.Name) {
4416 query["Name"] = request.Name
4417 }
4418
4419 if !dara.IsNil(request.NewUsersPerMinute) {
4420 query["NewUsersPerMinute"] = request.NewUsersPerMinute
4421 }
4422
4423 if !dara.IsNil(request.QueueAllEnable) {
4424 query["QueueAllEnable"] = request.QueueAllEnable
4425 }
4426
4427 if !dara.IsNil(request.QueuingMethod) {
4428 query["QueuingMethod"] = request.QueuingMethod
4429 }
4430
4431 if !dara.IsNil(request.QueuingStatusCode) {
4432 query["QueuingStatusCode"] = request.QueuingStatusCode
4433 }
4434
4435 if !dara.IsNil(request.SessionDuration) {
4436 query["SessionDuration"] = request.SessionDuration
4437 }
4438
4439 if !dara.IsNil(request.SiteId) {
4440 query["SiteId"] = request.SiteId
4441 }
4442
4443 if !dara.IsNil(request.TotalActiveUsers) {
4444 query["TotalActiveUsers"] = request.TotalActiveUsers
4445 }
4446
4447 if !dara.IsNil(request.WaitingRoomType) {
4448 query["WaitingRoomType"] = request.WaitingRoomType
4449 }
4450
4451 req := &openapiutil.OpenApiRequest{
4452 Query: openapiutil.Query(query),
4453 }
4454 params := &openapiutil.Params{
4455 Action: dara.String("CreateWaitingRoom"),
4456 Version: dara.String("2024-09-10"),
4457 Protocol: dara.String("HTTPS"),
4458 Pathname: dara.String("/"),
4459 Method: dara.String("POST"),
4460 AuthType: dara.String("AK"),
4461 Style: dara.String("RPC"),
4462 ReqBodyType: dara.String("formData"),
4463 BodyType: dara.String("json"),
4464 }
4465 _result = &CreateWaitingRoomResponse{}
4466 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4467 if _err != nil {
4468 return _result, _err
4469 }
4470 _err = dara.Convert(_body, &_result)
4471 return _result, _err
4472 }
4473
4474 // Summary:
4475 //
4476 // Creates a waiting room event.
4477 //
4478 // @param request - CreateWaitingRoomEventRequest
4479 //
4480 // @param runtime - runtime options for this request RuntimeOptions
4481 //
4482 // @return CreateWaitingRoomEventResponse
4483 func CreateWaitingRoomEventWithContext(ctx context.Context, client *Client, request *CreateWaitingRoomEventRequest, runtime *dara.RuntimeOptions) (_result *CreateWaitingRoomEventResponse, _err error) {
4484 if dara.BoolValue(client.EnableValidate) == true {
4485 _err = request.Validate()
4486 if _err != nil {
4487 return _result, _err
4488 }
4489 }
4490 query := map[string]interface{}{}
4491 if !dara.IsNil(request.CustomPageHtml) {
4492 query["CustomPageHtml"] = request.CustomPageHtml
4493 }
4494
4495 if !dara.IsNil(request.Description) {
4496 query["Description"] = request.Description
4497 }
4498
4499 if !dara.IsNil(request.DisableSessionRenewalEnable) {
4500 query["DisableSessionRenewalEnable"] = request.DisableSessionRenewalEnable
4501 }
4502
4503 if !dara.IsNil(request.Enable) {
4504 query["Enable"] = request.Enable
4505 }
4506
4507 if !dara.IsNil(request.EndTime) {
4508 query["EndTime"] = request.EndTime
4509 }
4510
4511 if !dara.IsNil(request.JsonResponseEnable) {
4512 query["JsonResponseEnable"] = request.JsonResponseEnable
4513 }
4514
4515 if !dara.IsNil(request.Language) {
4516 query["Language"] = request.Language
4517 }
4518
4519 if !dara.IsNil(request.Name) {
4520 query["Name"] = request.Name
4521 }
4522
4523 if !dara.IsNil(request.NewUsersPerMinute) {
4524 query["NewUsersPerMinute"] = request.NewUsersPerMinute
4525 }
4526
4527 if !dara.IsNil(request.PreQueueEnable) {
4528 query["PreQueueEnable"] = request.PreQueueEnable
4529 }
4530
4531 if !dara.IsNil(request.PreQueueStartTime) {
4532 query["PreQueueStartTime"] = request.PreQueueStartTime
4533 }
4534
4535 if !dara.IsNil(request.QueuingMethod) {
4536 query["QueuingMethod"] = request.QueuingMethod
4537 }
4538
4539 if !dara.IsNil(request.QueuingStatusCode) {
4540 query["QueuingStatusCode"] = request.QueuingStatusCode
4541 }
4542
4543 if !dara.IsNil(request.RandomPreQueueEnable) {
4544 query["RandomPreQueueEnable"] = request.RandomPreQueueEnable
4545 }
4546
4547 if !dara.IsNil(request.SessionDuration) {
4548 query["SessionDuration"] = request.SessionDuration
4549 }
4550
4551 if !dara.IsNil(request.SiteId) {
4552 query["SiteId"] = request.SiteId
4553 }
4554
4555 if !dara.IsNil(request.StartTime) {
4556 query["StartTime"] = request.StartTime
4557 }
4558
4559 if !dara.IsNil(request.TotalActiveUsers) {
4560 query["TotalActiveUsers"] = request.TotalActiveUsers
4561 }
4562
4563 if !dara.IsNil(request.WaitingRoomId) {
4564 query["WaitingRoomId"] = request.WaitingRoomId
4565 }
4566
4567 if !dara.IsNil(request.WaitingRoomType) {
4568 query["WaitingRoomType"] = request.WaitingRoomType
4569 }
4570
4571 req := &openapiutil.OpenApiRequest{
4572 Query: openapiutil.Query(query),
4573 }
4574 params := &openapiutil.Params{
4575 Action: dara.String("CreateWaitingRoomEvent"),
4576 Version: dara.String("2024-09-10"),
4577 Protocol: dara.String("HTTPS"),
4578 Pathname: dara.String("/"),
4579 Method: dara.String("POST"),
4580 AuthType: dara.String("AK"),
4581 Style: dara.String("RPC"),
4582 ReqBodyType: dara.String("formData"),
4583 BodyType: dara.String("json"),
4584 }
4585 _result = &CreateWaitingRoomEventResponse{}
4586 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4587 if _err != nil {
4588 return _result, _err
4589 }
4590 _err = dara.Convert(_body, &_result)
4591 return _result, _err
4592 }
4593
4594 // Summary:
4595 //
4596 // # Create Waiting Room Rule
4597 //
4598 // @param request - CreateWaitingRoomRuleRequest
4599 //
4600 // @param runtime - runtime options for this request RuntimeOptions
4601 //
4602 // @return CreateWaitingRoomRuleResponse
4603 func CreateWaitingRoomRuleWithContext(ctx context.Context, client *Client, request *CreateWaitingRoomRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateWaitingRoomRuleResponse, _err error) {
4604 if dara.BoolValue(client.EnableValidate) == true {
4605 _err = request.Validate()
4606 if _err != nil {
4607 return _result, _err
4608 }
4609 }
4610 query := map[string]interface{}{}
4611 if !dara.IsNil(request.Rule) {
4612 query["Rule"] = request.Rule
4613 }
4614
4615 if !dara.IsNil(request.RuleEnable) {
4616 query["RuleEnable"] = request.RuleEnable
4617 }
4618
4619 if !dara.IsNil(request.RuleName) {
4620 query["RuleName"] = request.RuleName
4621 }
4622
4623 if !dara.IsNil(request.SiteId) {
4624 query["SiteId"] = request.SiteId
4625 }
4626
4627 if !dara.IsNil(request.WaitingRoomId) {
4628 query["WaitingRoomId"] = request.WaitingRoomId
4629 }
4630
4631 req := &openapiutil.OpenApiRequest{
4632 Query: openapiutil.Query(query),
4633 }
4634 params := &openapiutil.Params{
4635 Action: dara.String("CreateWaitingRoomRule"),
4636 Version: dara.String("2024-09-10"),
4637 Protocol: dara.String("HTTPS"),
4638 Pathname: dara.String("/"),
4639 Method: dara.String("POST"),
4640 AuthType: dara.String("AK"),
4641 Style: dara.String("RPC"),
4642 ReqBodyType: dara.String("formData"),
4643 BodyType: dara.String("json"),
4644 }
4645 _result = &CreateWaitingRoomRuleResponse{}
4646 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4647 if _err != nil {
4648 return _result, _err
4649 }
4650 _err = dara.Convert(_body, &_result)
4651 return _result, _err
4652 }
4653
4654 // Summary:
4655 //
4656 // Disables version management for a website.
4657 //
4658 // Description:
4659 //
4660 // You can disable version management only when the default environment and version 0 exist.
4661 //
4662 // @param request - DeactivateVersionManagementRequest
4663 //
4664 // @param runtime - runtime options for this request RuntimeOptions
4665 //
4666 // @return DeactivateVersionManagementResponse
4667 func DeactivateVersionManagementWithContext(ctx context.Context, client *Client, request *DeactivateVersionManagementRequest, runtime *dara.RuntimeOptions) (_result *DeactivateVersionManagementResponse, _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.SiteId) {
4676 query["SiteId"] = request.SiteId
4677 }
4678
4679 req := &openapiutil.OpenApiRequest{
4680 Query: openapiutil.Query(query),
4681 }
4682 params := &openapiutil.Params{
4683 Action: dara.String("DeactivateVersionManagement"),
4684 Version: dara.String("2024-09-10"),
4685 Protocol: dara.String("HTTPS"),
4686 Pathname: dara.String("/"),
4687 Method: dara.String("POST"),
4688 AuthType: dara.String("AK"),
4689 Style: dara.String("RPC"),
4690 ReqBodyType: dara.String("formData"),
4691 BodyType: dara.String("json"),
4692 }
4693 _result = &DeactivateVersionManagementResponse{}
4694 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4695 if _err != nil {
4696 return _result, _err
4697 }
4698 _err = dara.Convert(_body, &_result)
4699 return _result, _err
4700 }
4701
4702 // Summary:
4703 //
4704 // # Delete Cache Configuration
4705 //
4706 // @param request - DeleteCacheRuleRequest
4707 //
4708 // @param runtime - runtime options for this request RuntimeOptions
4709 //
4710 // @return DeleteCacheRuleResponse
4711 func DeleteCacheRuleWithContext(ctx context.Context, client *Client, request *DeleteCacheRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteCacheRuleResponse, _err error) {
4712 if dara.BoolValue(client.EnableValidate) == true {
4713 _err = request.Validate()
4714 if _err != nil {
4715 return _result, _err
4716 }
4717 }
4718 query := map[string]interface{}{}
4719 if !dara.IsNil(request.ConfigId) {
4720 query["ConfigId"] = request.ConfigId
4721 }
4722
4723 if !dara.IsNil(request.SiteId) {
4724 query["SiteId"] = request.SiteId
4725 }
4726
4727 req := &openapiutil.OpenApiRequest{
4728 Query: openapiutil.Query(query),
4729 }
4730 params := &openapiutil.Params{
4731 Action: dara.String("DeleteCacheRule"),
4732 Version: dara.String("2024-09-10"),
4733 Protocol: dara.String("HTTPS"),
4734 Pathname: dara.String("/"),
4735 Method: dara.String("POST"),
4736 AuthType: dara.String("AK"),
4737 Style: dara.String("RPC"),
4738 ReqBodyType: dara.String("formData"),
4739 BodyType: dara.String("json"),
4740 }
4741 _result = &DeleteCacheRuleResponse{}
4742 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4743 if _err != nil {
4744 return _result, _err
4745 }
4746 _err = dara.Convert(_body, &_result)
4747 return _result, _err
4748 }
4749
4750 // Summary:
4751 //
4752 // Deletes a certificate for a website.
4753 //
4754 // @param request - DeleteCertificateRequest
4755 //
4756 // @param runtime - runtime options for this request RuntimeOptions
4757 //
4758 // @return DeleteCertificateResponse
4759 func DeleteCertificateWithContext(ctx context.Context, client *Client, request *DeleteCertificateRequest, runtime *dara.RuntimeOptions) (_result *DeleteCertificateResponse, _err error) {
4760 if dara.BoolValue(client.EnableValidate) == true {
4761 _err = request.Validate()
4762 if _err != nil {
4763 return _result, _err
4764 }
4765 }
4766 query := openapiutil.Query(dara.ToMap(request))
4767 req := &openapiutil.OpenApiRequest{
4768 Query: openapiutil.Query(query),
4769 }
4770 params := &openapiutil.Params{
4771 Action: dara.String("DeleteCertificate"),
4772 Version: dara.String("2024-09-10"),
4773 Protocol: dara.String("HTTPS"),
4774 Pathname: dara.String("/"),
4775 Method: dara.String("GET"),
4776 AuthType: dara.String("AK"),
4777 Style: dara.String("RPC"),
4778 ReqBodyType: dara.String("formData"),
4779 BodyType: dara.String("json"),
4780 }
4781 _result = &DeleteCertificateResponse{}
4782 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4783 if _err != nil {
4784 return _result, _err
4785 }
4786 _err = dara.Convert(_body, &_result)
4787 return _result, _err
4788 }
4789
4790 // Summary:
4791 //
4792 // Deletes a client CA certificate.
4793 //
4794 // @param request - DeleteClientCaCertificateRequest
4795 //
4796 // @param runtime - runtime options for this request RuntimeOptions
4797 //
4798 // @return DeleteClientCaCertificateResponse
4799 func DeleteClientCaCertificateWithContext(ctx context.Context, client *Client, request *DeleteClientCaCertificateRequest, runtime *dara.RuntimeOptions) (_result *DeleteClientCaCertificateResponse, _err error) {
4800 if dara.BoolValue(client.EnableValidate) == true {
4801 _err = request.Validate()
4802 if _err != nil {
4803 return _result, _err
4804 }
4805 }
4806 query := openapiutil.Query(dara.ToMap(request))
4807 req := &openapiutil.OpenApiRequest{
4808 Query: openapiutil.Query(query),
4809 }
4810 params := &openapiutil.Params{
4811 Action: dara.String("DeleteClientCaCertificate"),
4812 Version: dara.String("2024-09-10"),
4813 Protocol: dara.String("HTTPS"),
4814 Pathname: dara.String("/"),
4815 Method: dara.String("GET"),
4816 AuthType: dara.String("AK"),
4817 Style: dara.String("RPC"),
4818 ReqBodyType: dara.String("formData"),
4819 BodyType: dara.String("json"),
4820 }
4821 _result = &DeleteClientCaCertificateResponse{}
4822 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4823 if _err != nil {
4824 return _result, _err
4825 }
4826 _err = dara.Convert(_body, &_result)
4827 return _result, _err
4828 }
4829
4830 // Summary:
4831 //
4832 // Deletes a revoked client certificate.
4833 //
4834 // @param request - DeleteClientCertificateRequest
4835 //
4836 // @param runtime - runtime options for this request RuntimeOptions
4837 //
4838 // @return DeleteClientCertificateResponse
4839 func DeleteClientCertificateWithContext(ctx context.Context, client *Client, request *DeleteClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *DeleteClientCertificateResponse, _err error) {
4840 if dara.BoolValue(client.EnableValidate) == true {
4841 _err = request.Validate()
4842 if _err != nil {
4843 return _result, _err
4844 }
4845 }
4846 query := openapiutil.Query(dara.ToMap(request))
4847 req := &openapiutil.OpenApiRequest{
4848 Query: openapiutil.Query(query),
4849 }
4850 params := &openapiutil.Params{
4851 Action: dara.String("DeleteClientCertificate"),
4852 Version: dara.String("2024-09-10"),
4853 Protocol: dara.String("HTTPS"),
4854 Pathname: dara.String("/"),
4855 Method: dara.String("GET"),
4856 AuthType: dara.String("AK"),
4857 Style: dara.String("RPC"),
4858 ReqBodyType: dara.String("formData"),
4859 BodyType: dara.String("json"),
4860 }
4861 _result = &DeleteClientCertificateResponse{}
4862 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4863 if _err != nil {
4864 return _result, _err
4865 }
4866 _err = dara.Convert(_body, &_result)
4867 return _result, _err
4868 }
4869
4870 // Summary:
4871 //
4872 // # Delete compression rule
4873 //
4874 // @param request - DeleteCompressionRuleRequest
4875 //
4876 // @param runtime - runtime options for this request RuntimeOptions
4877 //
4878 // @return DeleteCompressionRuleResponse
4879 func DeleteCompressionRuleWithContext(ctx context.Context, client *Client, request *DeleteCompressionRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteCompressionRuleResponse, _err error) {
4880 if dara.BoolValue(client.EnableValidate) == true {
4881 _err = request.Validate()
4882 if _err != nil {
4883 return _result, _err
4884 }
4885 }
4886 query := map[string]interface{}{}
4887 if !dara.IsNil(request.ConfigId) {
4888 query["ConfigId"] = request.ConfigId
4889 }
4890
4891 if !dara.IsNil(request.SiteId) {
4892 query["SiteId"] = request.SiteId
4893 }
4894
4895 req := &openapiutil.OpenApiRequest{
4896 Query: openapiutil.Query(query),
4897 }
4898 params := &openapiutil.Params{
4899 Action: dara.String("DeleteCompressionRule"),
4900 Version: dara.String("2024-09-10"),
4901 Protocol: dara.String("HTTPS"),
4902 Pathname: dara.String("/"),
4903 Method: dara.String("POST"),
4904 AuthType: dara.String("AK"),
4905 Style: dara.String("RPC"),
4906 ReqBodyType: dara.String("formData"),
4907 BodyType: dara.String("json"),
4908 }
4909 _result = &DeleteCompressionRuleResponse{}
4910 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4911 if _err != nil {
4912 return _result, _err
4913 }
4914 _err = dara.Convert(_body, &_result)
4915 return _result, _err
4916 }
4917
4918 // Summary:
4919 //
4920 // Deletes a scenario-specific custom policy.
4921 //
4922 // @param request - DeleteCustomScenePolicyRequest
4923 //
4924 // @param runtime - runtime options for this request RuntimeOptions
4925 //
4926 // @return DeleteCustomScenePolicyResponse
4927 func DeleteCustomScenePolicyWithContext(ctx context.Context, client *Client, request *DeleteCustomScenePolicyRequest, runtime *dara.RuntimeOptions) (_result *DeleteCustomScenePolicyResponse, _err error) {
4928 if dara.BoolValue(client.EnableValidate) == true {
4929 _err = request.Validate()
4930 if _err != nil {
4931 return _result, _err
4932 }
4933 }
4934 query := map[string]interface{}{}
4935 if !dara.IsNil(request.PolicyId) {
4936 query["PolicyId"] = request.PolicyId
4937 }
4938
4939 req := &openapiutil.OpenApiRequest{
4940 Query: openapiutil.Query(query),
4941 }
4942 params := &openapiutil.Params{
4943 Action: dara.String("DeleteCustomScenePolicy"),
4944 Version: dara.String("2024-09-10"),
4945 Protocol: dara.String("HTTPS"),
4946 Pathname: dara.String("/"),
4947 Method: dara.String("POST"),
4948 AuthType: dara.String("AK"),
4949 Style: dara.String("RPC"),
4950 ReqBodyType: dara.String("formData"),
4951 BodyType: dara.String("json"),
4952 }
4953 _result = &DeleteCustomScenePolicyResponse{}
4954 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4955 if _err != nil {
4956 return _result, _err
4957 }
4958 _err = dara.Convert(_body, &_result)
4959 return _result, _err
4960 }
4961
4962 // Summary:
4963 //
4964 // Deletes a containerized application.
4965 //
4966 // @param request - DeleteEdgeContainerAppRequest
4967 //
4968 // @param runtime - runtime options for this request RuntimeOptions
4969 //
4970 // @return DeleteEdgeContainerAppResponse
4971 func DeleteEdgeContainerAppWithContext(ctx context.Context, client *Client, request *DeleteEdgeContainerAppRequest, runtime *dara.RuntimeOptions) (_result *DeleteEdgeContainerAppResponse, _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.AppId) {
4980 query["AppId"] = request.AppId
4981 }
4982
4983 req := &openapiutil.OpenApiRequest{
4984 Query: openapiutil.Query(query),
4985 }
4986 params := &openapiutil.Params{
4987 Action: dara.String("DeleteEdgeContainerApp"),
4988 Version: dara.String("2024-09-10"),
4989 Protocol: dara.String("HTTPS"),
4990 Pathname: dara.String("/"),
4991 Method: dara.String("POST"),
4992 AuthType: dara.String("AK"),
4993 Style: dara.String("RPC"),
4994 ReqBodyType: dara.String("formData"),
4995 BodyType: dara.String("json"),
4996 }
4997 _result = &DeleteEdgeContainerAppResponse{}
4998 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
4999 if _err != nil {
5000 return _result, _err
5001 }
5002 _err = dara.Convert(_body, &_result)
5003 return _result, _err
5004 }
5005
5006 // Summary:
5007 //
5008 // 删除边缘容器应用的镜像秘钥
5009 //
5010 // @param request - DeleteEdgeContainerAppImageSecretRequest
5011 //
5012 // @param runtime - runtime options for this request RuntimeOptions
5013 //
5014 // @return DeleteEdgeContainerAppImageSecretResponse
5015 func DeleteEdgeContainerAppImageSecretWithContext(ctx context.Context, client *Client, request *DeleteEdgeContainerAppImageSecretRequest, runtime *dara.RuntimeOptions) (_result *DeleteEdgeContainerAppImageSecretResponse, _err error) {
5016 if dara.BoolValue(client.EnableValidate) == true {
5017 _err = request.Validate()
5018 if _err != nil {
5019 return _result, _err
5020 }
5021 }
5022 query := map[string]interface{}{}
5023 if !dara.IsNil(request.AppId) {
5024 query["AppId"] = request.AppId
5025 }
5026
5027 if !dara.IsNil(request.Name) {
5028 query["Name"] = request.Name
5029 }
5030
5031 req := &openapiutil.OpenApiRequest{
5032 Query: openapiutil.Query(query),
5033 }
5034 params := &openapiutil.Params{
5035 Action: dara.String("DeleteEdgeContainerAppImageSecret"),
5036 Version: dara.String("2024-09-10"),
5037 Protocol: dara.String("HTTPS"),
5038 Pathname: dara.String("/"),
5039 Method: dara.String("POST"),
5040 AuthType: dara.String("AK"),
5041 Style: dara.String("RPC"),
5042 ReqBodyType: dara.String("formData"),
5043 BodyType: dara.String("json"),
5044 }
5045 _result = &DeleteEdgeContainerAppImageSecretResponse{}
5046 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5047 if _err != nil {
5048 return _result, _err
5049 }
5050 _err = dara.Convert(_body, &_result)
5051 return _result, _err
5052 }
5053
5054 // Summary:
5055 //
5056 // Disassociates a domain name from a containerized application. After the dissociation, you can no longer use the domain name to access the containerized application.
5057 //
5058 // @param request - DeleteEdgeContainerAppRecordRequest
5059 //
5060 // @param runtime - runtime options for this request RuntimeOptions
5061 //
5062 // @return DeleteEdgeContainerAppRecordResponse
5063 func DeleteEdgeContainerAppRecordWithContext(ctx context.Context, client *Client, request *DeleteEdgeContainerAppRecordRequest, runtime *dara.RuntimeOptions) (_result *DeleteEdgeContainerAppRecordResponse, _err error) {
5064 if dara.BoolValue(client.EnableValidate) == true {
5065 _err = request.Validate()
5066 if _err != nil {
5067 return _result, _err
5068 }
5069 }
5070 body := map[string]interface{}{}
5071 if !dara.IsNil(request.AppId) {
5072 body["AppId"] = request.AppId
5073 }
5074
5075 if !dara.IsNil(request.RecordName) {
5076 body["RecordName"] = request.RecordName
5077 }
5078
5079 if !dara.IsNil(request.SiteId) {
5080 body["SiteId"] = request.SiteId
5081 }
5082
5083 req := &openapiutil.OpenApiRequest{
5084 Body: openapiutil.ParseToMap(body),
5085 }
5086 params := &openapiutil.Params{
5087 Action: dara.String("DeleteEdgeContainerAppRecord"),
5088 Version: dara.String("2024-09-10"),
5089 Protocol: dara.String("HTTPS"),
5090 Pathname: dara.String("/"),
5091 Method: dara.String("POST"),
5092 AuthType: dara.String("AK"),
5093 Style: dara.String("RPC"),
5094 ReqBodyType: dara.String("formData"),
5095 BodyType: dara.String("json"),
5096 }
5097 _result = &DeleteEdgeContainerAppRecordResponse{}
5098 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5099 if _err != nil {
5100 return _result, _err
5101 }
5102 _err = dara.Convert(_body, &_result)
5103 return _result, _err
5104 }
5105
5106 // Summary:
5107 //
5108 // Deletes a version of a containerized application.
5109 //
5110 // @param request - DeleteEdgeContainerAppVersionRequest
5111 //
5112 // @param runtime - runtime options for this request RuntimeOptions
5113 //
5114 // @return DeleteEdgeContainerAppVersionResponse
5115 func DeleteEdgeContainerAppVersionWithContext(ctx context.Context, client *Client, request *DeleteEdgeContainerAppVersionRequest, runtime *dara.RuntimeOptions) (_result *DeleteEdgeContainerAppVersionResponse, _err error) {
5116 if dara.BoolValue(client.EnableValidate) == true {
5117 _err = request.Validate()
5118 if _err != nil {
5119 return _result, _err
5120 }
5121 }
5122 query := map[string]interface{}{}
5123 if !dara.IsNil(request.AppId) {
5124 query["AppId"] = request.AppId
5125 }
5126
5127 if !dara.IsNil(request.VersionId) {
5128 query["VersionId"] = request.VersionId
5129 }
5130
5131 req := &openapiutil.OpenApiRequest{
5132 Query: openapiutil.Query(query),
5133 }
5134 params := &openapiutil.Params{
5135 Action: dara.String("DeleteEdgeContainerAppVersion"),
5136 Version: dara.String("2024-09-10"),
5137 Protocol: dara.String("HTTPS"),
5138 Pathname: dara.String("/"),
5139 Method: dara.String("POST"),
5140 AuthType: dara.String("AK"),
5141 Style: dara.String("RPC"),
5142 ReqBodyType: dara.String("formData"),
5143 BodyType: dara.String("json"),
5144 }
5145 _result = &DeleteEdgeContainerAppVersionResponse{}
5146 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5147 if _err != nil {
5148 return _result, _err
5149 }
5150 _err = dara.Convert(_body, &_result)
5151 return _result, _err
5152 }
5153
5154 // Summary:
5155 //
5156 // 删除深度学习和防护下发的规则
5157 //
5158 // @param request - DeleteHttpDDoSIntelligentRuleRequest
5159 //
5160 // @param runtime - runtime options for this request RuntimeOptions
5161 //
5162 // @return DeleteHttpDDoSIntelligentRuleResponse
5163 func DeleteHttpDDoSIntelligentRuleWithContext(ctx context.Context, client *Client, request *DeleteHttpDDoSIntelligentRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpDDoSIntelligentRuleResponse, _err error) {
5164 if dara.BoolValue(client.EnableValidate) == true {
5165 _err = request.Validate()
5166 if _err != nil {
5167 return _result, _err
5168 }
5169 }
5170 query := map[string]interface{}{}
5171 if !dara.IsNil(request.RecordName) {
5172 query["RecordName"] = request.RecordName
5173 }
5174
5175 if !dara.IsNil(request.RuleId) {
5176 query["RuleId"] = request.RuleId
5177 }
5178
5179 if !dara.IsNil(request.SiteId) {
5180 query["SiteId"] = request.SiteId
5181 }
5182
5183 req := &openapiutil.OpenApiRequest{
5184 Query: openapiutil.Query(query),
5185 }
5186 params := &openapiutil.Params{
5187 Action: dara.String("DeleteHttpDDoSIntelligentRule"),
5188 Version: dara.String("2024-09-10"),
5189 Protocol: dara.String("HTTPS"),
5190 Pathname: dara.String("/"),
5191 Method: dara.String("POST"),
5192 AuthType: dara.String("AK"),
5193 Style: dara.String("RPC"),
5194 ReqBodyType: dara.String("formData"),
5195 BodyType: dara.String("json"),
5196 }
5197 _result = &DeleteHttpDDoSIntelligentRuleResponse{}
5198 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5199 if _err != nil {
5200 return _result, _err
5201 }
5202 _err = dara.Convert(_body, &_result)
5203 return _result, _err
5204 }
5205
5206 // Summary:
5207 //
5208 // Deletes the configuration of modifying incoming HTTP request headers for a website.
5209 //
5210 // @param request - DeleteHttpIncomingRequestHeaderModificationRuleRequest
5211 //
5212 // @param runtime - runtime options for this request RuntimeOptions
5213 //
5214 // @return DeleteHttpIncomingRequestHeaderModificationRuleResponse
5215 func DeleteHttpIncomingRequestHeaderModificationRuleWithContext(ctx context.Context, client *Client, request *DeleteHttpIncomingRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpIncomingRequestHeaderModificationRuleResponse, _err error) {
5216 if dara.BoolValue(client.EnableValidate) == true {
5217 _err = request.Validate()
5218 if _err != nil {
5219 return _result, _err
5220 }
5221 }
5222 query := map[string]interface{}{}
5223 if !dara.IsNil(request.ConfigId) {
5224 query["ConfigId"] = request.ConfigId
5225 }
5226
5227 if !dara.IsNil(request.SiteId) {
5228 query["SiteId"] = request.SiteId
5229 }
5230
5231 req := &openapiutil.OpenApiRequest{
5232 Query: openapiutil.Query(query),
5233 }
5234 params := &openapiutil.Params{
5235 Action: dara.String("DeleteHttpIncomingRequestHeaderModificationRule"),
5236 Version: dara.String("2024-09-10"),
5237 Protocol: dara.String("HTTPS"),
5238 Pathname: dara.String("/"),
5239 Method: dara.String("POST"),
5240 AuthType: dara.String("AK"),
5241 Style: dara.String("RPC"),
5242 ReqBodyType: dara.String("formData"),
5243 BodyType: dara.String("json"),
5244 }
5245 _result = &DeleteHttpIncomingRequestHeaderModificationRuleResponse{}
5246 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5247 if _err != nil {
5248 return _result, _err
5249 }
5250 _err = dara.Convert(_body, &_result)
5251 return _result, _err
5252 }
5253
5254 // Summary:
5255 //
5256 // Deletes the configuration of modifying HTTP response headers for a website.
5257 //
5258 // @param request - DeleteHttpIncomingResponseHeaderModificationRuleRequest
5259 //
5260 // @param runtime - runtime options for this request RuntimeOptions
5261 //
5262 // @return DeleteHttpIncomingResponseHeaderModificationRuleResponse
5263 func DeleteHttpIncomingResponseHeaderModificationRuleWithContext(ctx context.Context, client *Client, request *DeleteHttpIncomingResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpIncomingResponseHeaderModificationRuleResponse, _err error) {
5264 if dara.BoolValue(client.EnableValidate) == true {
5265 _err = request.Validate()
5266 if _err != nil {
5267 return _result, _err
5268 }
5269 }
5270 query := map[string]interface{}{}
5271 if !dara.IsNil(request.ConfigId) {
5272 query["ConfigId"] = request.ConfigId
5273 }
5274
5275 if !dara.IsNil(request.SiteId) {
5276 query["SiteId"] = request.SiteId
5277 }
5278
5279 req := &openapiutil.OpenApiRequest{
5280 Query: openapiutil.Query(query),
5281 }
5282 params := &openapiutil.Params{
5283 Action: dara.String("DeleteHttpIncomingResponseHeaderModificationRule"),
5284 Version: dara.String("2024-09-10"),
5285 Protocol: dara.String("HTTPS"),
5286 Pathname: dara.String("/"),
5287 Method: dara.String("POST"),
5288 AuthType: dara.String("AK"),
5289 Style: dara.String("RPC"),
5290 ReqBodyType: dara.String("formData"),
5291 BodyType: dara.String("json"),
5292 }
5293 _result = &DeleteHttpIncomingResponseHeaderModificationRuleResponse{}
5294 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5295 if _err != nil {
5296 return _result, _err
5297 }
5298 _err = dara.Convert(_body, &_result)
5299 return _result, _err
5300 }
5301
5302 // Summary:
5303 //
5304 // Deletes the configuration of modifying HTTP request headers for a website.
5305 //
5306 // @param request - DeleteHttpRequestHeaderModificationRuleRequest
5307 //
5308 // @param runtime - runtime options for this request RuntimeOptions
5309 //
5310 // @return DeleteHttpRequestHeaderModificationRuleResponse
5311 func DeleteHttpRequestHeaderModificationRuleWithContext(ctx context.Context, client *Client, request *DeleteHttpRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpRequestHeaderModificationRuleResponse, _err error) {
5312 if dara.BoolValue(client.EnableValidate) == true {
5313 _err = request.Validate()
5314 if _err != nil {
5315 return _result, _err
5316 }
5317 }
5318 query := map[string]interface{}{}
5319 if !dara.IsNil(request.ConfigId) {
5320 query["ConfigId"] = request.ConfigId
5321 }
5322
5323 if !dara.IsNil(request.SiteId) {
5324 query["SiteId"] = request.SiteId
5325 }
5326
5327 req := &openapiutil.OpenApiRequest{
5328 Query: openapiutil.Query(query),
5329 }
5330 params := &openapiutil.Params{
5331 Action: dara.String("DeleteHttpRequestHeaderModificationRule"),
5332 Version: dara.String("2024-09-10"),
5333 Protocol: dara.String("HTTPS"),
5334 Pathname: dara.String("/"),
5335 Method: dara.String("POST"),
5336 AuthType: dara.String("AK"),
5337 Style: dara.String("RPC"),
5338 ReqBodyType: dara.String("formData"),
5339 BodyType: dara.String("json"),
5340 }
5341 _result = &DeleteHttpRequestHeaderModificationRuleResponse{}
5342 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5343 if _err != nil {
5344 return _result, _err
5345 }
5346 _err = dara.Convert(_body, &_result)
5347 return _result, _err
5348 }
5349
5350 // Summary:
5351 //
5352 // Deletes the configuration of modifying HTTP response headers for a website.
5353 //
5354 // @param request - DeleteHttpResponseHeaderModificationRuleRequest
5355 //
5356 // @param runtime - runtime options for this request RuntimeOptions
5357 //
5358 // @return DeleteHttpResponseHeaderModificationRuleResponse
5359 func DeleteHttpResponseHeaderModificationRuleWithContext(ctx context.Context, client *Client, request *DeleteHttpResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpResponseHeaderModificationRuleResponse, _err error) {
5360 if dara.BoolValue(client.EnableValidate) == true {
5361 _err = request.Validate()
5362 if _err != nil {
5363 return _result, _err
5364 }
5365 }
5366 query := map[string]interface{}{}
5367 if !dara.IsNil(request.ConfigId) {
5368 query["ConfigId"] = request.ConfigId
5369 }
5370
5371 if !dara.IsNil(request.SiteId) {
5372 query["SiteId"] = request.SiteId
5373 }
5374
5375 req := &openapiutil.OpenApiRequest{
5376 Query: openapiutil.Query(query),
5377 }
5378 params := &openapiutil.Params{
5379 Action: dara.String("DeleteHttpResponseHeaderModificationRule"),
5380 Version: dara.String("2024-09-10"),
5381 Protocol: dara.String("HTTPS"),
5382 Pathname: dara.String("/"),
5383 Method: dara.String("POST"),
5384 AuthType: dara.String("AK"),
5385 Style: dara.String("RPC"),
5386 ReqBodyType: dara.String("formData"),
5387 BodyType: dara.String("json"),
5388 }
5389 _result = &DeleteHttpResponseHeaderModificationRuleResponse{}
5390 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5391 if _err != nil {
5392 return _result, _err
5393 }
5394 _err = dara.Convert(_body, &_result)
5395 return _result, _err
5396 }
5397
5398 // Summary:
5399 //
5400 // # Delete HTTPS Application Configuration
5401 //
5402 // @param request - DeleteHttpsApplicationConfigurationRequest
5403 //
5404 // @param runtime - runtime options for this request RuntimeOptions
5405 //
5406 // @return DeleteHttpsApplicationConfigurationResponse
5407 func DeleteHttpsApplicationConfigurationWithContext(ctx context.Context, client *Client, request *DeleteHttpsApplicationConfigurationRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpsApplicationConfigurationResponse, _err error) {
5408 if dara.BoolValue(client.EnableValidate) == true {
5409 _err = request.Validate()
5410 if _err != nil {
5411 return _result, _err
5412 }
5413 }
5414 query := map[string]interface{}{}
5415 if !dara.IsNil(request.ConfigId) {
5416 query["ConfigId"] = request.ConfigId
5417 }
5418
5419 if !dara.IsNil(request.SiteId) {
5420 query["SiteId"] = request.SiteId
5421 }
5422
5423 req := &openapiutil.OpenApiRequest{
5424 Query: openapiutil.Query(query),
5425 }
5426 params := &openapiutil.Params{
5427 Action: dara.String("DeleteHttpsApplicationConfiguration"),
5428 Version: dara.String("2024-09-10"),
5429 Protocol: dara.String("HTTPS"),
5430 Pathname: dara.String("/"),
5431 Method: dara.String("POST"),
5432 AuthType: dara.String("AK"),
5433 Style: dara.String("RPC"),
5434 ReqBodyType: dara.String("formData"),
5435 BodyType: dara.String("json"),
5436 }
5437 _result = &DeleteHttpsApplicationConfigurationResponse{}
5438 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5439 if _err != nil {
5440 return _result, _err
5441 }
5442 _err = dara.Convert(_body, &_result)
5443 return _result, _err
5444 }
5445
5446 // Summary:
5447 //
5448 // # Delete HTTPS Basic Configuration
5449 //
5450 // @param request - DeleteHttpsBasicConfigurationRequest
5451 //
5452 // @param runtime - runtime options for this request RuntimeOptions
5453 //
5454 // @return DeleteHttpsBasicConfigurationResponse
5455 func DeleteHttpsBasicConfigurationWithContext(ctx context.Context, client *Client, request *DeleteHttpsBasicConfigurationRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpsBasicConfigurationResponse, _err error) {
5456 if dara.BoolValue(client.EnableValidate) == true {
5457 _err = request.Validate()
5458 if _err != nil {
5459 return _result, _err
5460 }
5461 }
5462 query := map[string]interface{}{}
5463 if !dara.IsNil(request.ConfigId) {
5464 query["ConfigId"] = request.ConfigId
5465 }
5466
5467 if !dara.IsNil(request.SiteId) {
5468 query["SiteId"] = request.SiteId
5469 }
5470
5471 req := &openapiutil.OpenApiRequest{
5472 Query: openapiutil.Query(query),
5473 }
5474 params := &openapiutil.Params{
5475 Action: dara.String("DeleteHttpsBasicConfiguration"),
5476 Version: dara.String("2024-09-10"),
5477 Protocol: dara.String("HTTPS"),
5478 Pathname: dara.String("/"),
5479 Method: dara.String("POST"),
5480 AuthType: dara.String("AK"),
5481 Style: dara.String("RPC"),
5482 ReqBodyType: dara.String("formData"),
5483 BodyType: dara.String("json"),
5484 }
5485 _result = &DeleteHttpsBasicConfigurationResponse{}
5486 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5487 if _err != nil {
5488 return _result, _err
5489 }
5490 _err = dara.Convert(_body, &_result)
5491 return _result, _err
5492 }
5493
5494 // Summary:
5495 //
5496 // # Delete Site Image Transformation Configuration
5497 //
5498 // @param request - DeleteImageTransformRequest
5499 //
5500 // @param runtime - runtime options for this request RuntimeOptions
5501 //
5502 // @return DeleteImageTransformResponse
5503 func DeleteImageTransformWithContext(ctx context.Context, client *Client, request *DeleteImageTransformRequest, runtime *dara.RuntimeOptions) (_result *DeleteImageTransformResponse, _err error) {
5504 if dara.BoolValue(client.EnableValidate) == true {
5505 _err = request.Validate()
5506 if _err != nil {
5507 return _result, _err
5508 }
5509 }
5510 query := map[string]interface{}{}
5511 if !dara.IsNil(request.ConfigId) {
5512 query["ConfigId"] = request.ConfigId
5513 }
5514
5515 if !dara.IsNil(request.SiteId) {
5516 query["SiteId"] = request.SiteId
5517 }
5518
5519 req := &openapiutil.OpenApiRequest{
5520 Query: openapiutil.Query(query),
5521 }
5522 params := &openapiutil.Params{
5523 Action: dara.String("DeleteImageTransform"),
5524 Version: dara.String("2024-09-10"),
5525 Protocol: dara.String("HTTPS"),
5526 Pathname: dara.String("/"),
5527 Method: dara.String("POST"),
5528 AuthType: dara.String("AK"),
5529 Style: dara.String("RPC"),
5530 ReqBodyType: dara.String("formData"),
5531 BodyType: dara.String("json"),
5532 }
5533 _result = &DeleteImageTransformResponse{}
5534 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5535 if _err != nil {
5536 return _result, _err
5537 }
5538 _err = dara.Convert(_body, &_result)
5539 return _result, _err
5540 }
5541
5542 // Summary:
5543 //
5544 // Deletes a key-value pair from a namespace.
5545 //
5546 // @param request - DeleteKvRequest
5547 //
5548 // @param runtime - runtime options for this request RuntimeOptions
5549 //
5550 // @return DeleteKvResponse
5551 func DeleteKvWithContext(ctx context.Context, client *Client, request *DeleteKvRequest, runtime *dara.RuntimeOptions) (_result *DeleteKvResponse, _err error) {
5552 if dara.BoolValue(client.EnableValidate) == true {
5553 _err = request.Validate()
5554 if _err != nil {
5555 return _result, _err
5556 }
5557 }
5558 query := openapiutil.Query(dara.ToMap(request))
5559 req := &openapiutil.OpenApiRequest{
5560 Query: openapiutil.Query(query),
5561 }
5562 params := &openapiutil.Params{
5563 Action: dara.String("DeleteKv"),
5564 Version: dara.String("2024-09-10"),
5565 Protocol: dara.String("HTTPS"),
5566 Pathname: dara.String("/"),
5567 Method: dara.String("GET"),
5568 AuthType: dara.String("AK"),
5569 Style: dara.String("RPC"),
5570 ReqBodyType: dara.String("formData"),
5571 BodyType: dara.String("json"),
5572 }
5573 _result = &DeleteKvResponse{}
5574 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5575 if _err != nil {
5576 return _result, _err
5577 }
5578 _err = dara.Convert(_body, &_result)
5579 return _result, _err
5580 }
5581
5582 // Summary:
5583 //
5584 // Deletes a namespace from an Alibaba Cloud account.
5585 //
5586 // @param request - DeleteKvNamespaceRequest
5587 //
5588 // @param runtime - runtime options for this request RuntimeOptions
5589 //
5590 // @return DeleteKvNamespaceResponse
5591 func DeleteKvNamespaceWithContext(ctx context.Context, client *Client, request *DeleteKvNamespaceRequest, runtime *dara.RuntimeOptions) (_result *DeleteKvNamespaceResponse, _err error) {
5592 if dara.BoolValue(client.EnableValidate) == true {
5593 _err = request.Validate()
5594 if _err != nil {
5595 return _result, _err
5596 }
5597 }
5598 query := map[string]interface{}{}
5599 if !dara.IsNil(request.Namespace) {
5600 query["Namespace"] = request.Namespace
5601 }
5602
5603 req := &openapiutil.OpenApiRequest{
5604 Query: openapiutil.Query(query),
5605 }
5606 params := &openapiutil.Params{
5607 Action: dara.String("DeleteKvNamespace"),
5608 Version: dara.String("2024-09-10"),
5609 Protocol: dara.String("HTTPS"),
5610 Pathname: dara.String("/"),
5611 Method: dara.String("POST"),
5612 AuthType: dara.String("AK"),
5613 Style: dara.String("RPC"),
5614 ReqBodyType: dara.String("formData"),
5615 BodyType: dara.String("json"),
5616 }
5617 _result = &DeleteKvNamespaceResponse{}
5618 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5619 if _err != nil {
5620 return _result, _err
5621 }
5622 _err = dara.Convert(_body, &_result)
5623 return _result, _err
5624 }
5625
5626 // Summary:
5627 //
5628 // Deletes a custom list that is no longer needed.
5629 //
5630 // @param request - DeleteListRequest
5631 //
5632 // @param runtime - runtime options for this request RuntimeOptions
5633 //
5634 // @return DeleteListResponse
5635 func DeleteListWithContext(ctx context.Context, client *Client, request *DeleteListRequest, runtime *dara.RuntimeOptions) (_result *DeleteListResponse, _err error) {
5636 if dara.BoolValue(client.EnableValidate) == true {
5637 _err = request.Validate()
5638 if _err != nil {
5639 return _result, _err
5640 }
5641 }
5642 body := map[string]interface{}{}
5643 if !dara.IsNil(request.Id) {
5644 body["Id"] = request.Id
5645 }
5646
5647 req := &openapiutil.OpenApiRequest{
5648 Body: openapiutil.ParseToMap(body),
5649 }
5650 params := &openapiutil.Params{
5651 Action: dara.String("DeleteList"),
5652 Version: dara.String("2024-09-10"),
5653 Protocol: dara.String("HTTPS"),
5654 Pathname: dara.String("/"),
5655 Method: dara.String("POST"),
5656 AuthType: dara.String("AK"),
5657 Style: dara.String("RPC"),
5658 ReqBodyType: dara.String("formData"),
5659 BodyType: dara.String("json"),
5660 }
5661 _result = &DeleteListResponse{}
5662 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5663 if _err != nil {
5664 return _result, _err
5665 }
5666 _err = dara.Convert(_body, &_result)
5667 return _result, _err
5668 }
5669
5670 // Summary:
5671 //
5672 // # Delete Load Balancer
5673 //
5674 // Description:
5675 //
5676 // Delete a load balancer by its ID, only one can be deleted at a time.
5677 //
5678 // @param request - DeleteLoadBalancerRequest
5679 //
5680 // @param runtime - runtime options for this request RuntimeOptions
5681 //
5682 // @return DeleteLoadBalancerResponse
5683 func DeleteLoadBalancerWithContext(ctx context.Context, client *Client, request *DeleteLoadBalancerRequest, runtime *dara.RuntimeOptions) (_result *DeleteLoadBalancerResponse, _err error) {
5684 if dara.BoolValue(client.EnableValidate) == true {
5685 _err = request.Validate()
5686 if _err != nil {
5687 return _result, _err
5688 }
5689 }
5690 query := map[string]interface{}{}
5691 if !dara.IsNil(request.Id) {
5692 query["Id"] = request.Id
5693 }
5694
5695 if !dara.IsNil(request.SiteId) {
5696 query["SiteId"] = request.SiteId
5697 }
5698
5699 req := &openapiutil.OpenApiRequest{
5700 Query: openapiutil.Query(query),
5701 }
5702 params := &openapiutil.Params{
5703 Action: dara.String("DeleteLoadBalancer"),
5704 Version: dara.String("2024-09-10"),
5705 Protocol: dara.String("HTTPS"),
5706 Pathname: dara.String("/"),
5707 Method: dara.String("POST"),
5708 AuthType: dara.String("AK"),
5709 Style: dara.String("RPC"),
5710 ReqBodyType: dara.String("formData"),
5711 BodyType: dara.String("json"),
5712 }
5713 _result = &DeleteLoadBalancerResponse{}
5714 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5715 if _err != nil {
5716 return _result, _err
5717 }
5718 _err = dara.Convert(_body, &_result)
5719 return _result, _err
5720 }
5721
5722 // Summary:
5723 //
5724 // # Delete Network Optimization Configuration
5725 //
5726 // @param request - DeleteNetworkOptimizationRequest
5727 //
5728 // @param runtime - runtime options for this request RuntimeOptions
5729 //
5730 // @return DeleteNetworkOptimizationResponse
5731 func DeleteNetworkOptimizationWithContext(ctx context.Context, client *Client, request *DeleteNetworkOptimizationRequest, runtime *dara.RuntimeOptions) (_result *DeleteNetworkOptimizationResponse, _err error) {
5732 if dara.BoolValue(client.EnableValidate) == true {
5733 _err = request.Validate()
5734 if _err != nil {
5735 return _result, _err
5736 }
5737 }
5738 query := map[string]interface{}{}
5739 if !dara.IsNil(request.ConfigId) {
5740 query["ConfigId"] = request.ConfigId
5741 }
5742
5743 if !dara.IsNil(request.SiteId) {
5744 query["SiteId"] = request.SiteId
5745 }
5746
5747 req := &openapiutil.OpenApiRequest{
5748 Query: openapiutil.Query(query),
5749 }
5750 params := &openapiutil.Params{
5751 Action: dara.String("DeleteNetworkOptimization"),
5752 Version: dara.String("2024-09-10"),
5753 Protocol: dara.String("HTTPS"),
5754 Pathname: dara.String("/"),
5755 Method: dara.String("POST"),
5756 AuthType: dara.String("AK"),
5757 Style: dara.String("RPC"),
5758 ReqBodyType: dara.String("formData"),
5759 BodyType: dara.String("json"),
5760 }
5761 _result = &DeleteNetworkOptimizationResponse{}
5762 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5763 if _err != nil {
5764 return _result, _err
5765 }
5766 _err = dara.Convert(_body, &_result)
5767 return _result, _err
5768 }
5769
5770 // Summary:
5771 //
5772 // 删除源服务器CA证书
5773 //
5774 // @param request - DeleteOriginCaCertificateRequest
5775 //
5776 // @param runtime - runtime options for this request RuntimeOptions
5777 //
5778 // @return DeleteOriginCaCertificateResponse
5779 func DeleteOriginCaCertificateWithContext(ctx context.Context, client *Client, request *DeleteOriginCaCertificateRequest, runtime *dara.RuntimeOptions) (_result *DeleteOriginCaCertificateResponse, _err error) {
5780 if dara.BoolValue(client.EnableValidate) == true {
5781 _err = request.Validate()
5782 if _err != nil {
5783 return _result, _err
5784 }
5785 }
5786 query := openapiutil.Query(dara.ToMap(request))
5787 req := &openapiutil.OpenApiRequest{
5788 Query: openapiutil.Query(query),
5789 }
5790 params := &openapiutil.Params{
5791 Action: dara.String("DeleteOriginCaCertificate"),
5792 Version: dara.String("2024-09-10"),
5793 Protocol: dara.String("HTTPS"),
5794 Pathname: dara.String("/"),
5795 Method: dara.String("GET"),
5796 AuthType: dara.String("AK"),
5797 Style: dara.String("RPC"),
5798 ReqBodyType: dara.String("formData"),
5799 BodyType: dara.String("json"),
5800 }
5801 _result = &DeleteOriginCaCertificateResponse{}
5802 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5803 if _err != nil {
5804 return _result, _err
5805 }
5806 _err = dara.Convert(_body, &_result)
5807 return _result, _err
5808 }
5809
5810 // Summary:
5811 //
5812 // 删除域名回源客户端证书
5813 //
5814 // @param request - DeleteOriginClientCertificateRequest
5815 //
5816 // @param runtime - runtime options for this request RuntimeOptions
5817 //
5818 // @return DeleteOriginClientCertificateResponse
5819 func DeleteOriginClientCertificateWithContext(ctx context.Context, client *Client, request *DeleteOriginClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *DeleteOriginClientCertificateResponse, _err error) {
5820 if dara.BoolValue(client.EnableValidate) == true {
5821 _err = request.Validate()
5822 if _err != nil {
5823 return _result, _err
5824 }
5825 }
5826 query := openapiutil.Query(dara.ToMap(request))
5827 req := &openapiutil.OpenApiRequest{
5828 Query: openapiutil.Query(query),
5829 }
5830 params := &openapiutil.Params{
5831 Action: dara.String("DeleteOriginClientCertificate"),
5832 Version: dara.String("2024-09-10"),
5833 Protocol: dara.String("HTTPS"),
5834 Pathname: dara.String("/"),
5835 Method: dara.String("GET"),
5836 AuthType: dara.String("AK"),
5837 Style: dara.String("RPC"),
5838 ReqBodyType: dara.String("formData"),
5839 BodyType: dara.String("json"),
5840 }
5841 _result = &DeleteOriginClientCertificateResponse{}
5842 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5843 if _err != nil {
5844 return _result, _err
5845 }
5846 _err = dara.Convert(_body, &_result)
5847 return _result, _err
5848 }
5849
5850 // Summary:
5851 //
5852 // # Delete Origin Address Pool
5853 //
5854 // @param request - DeleteOriginPoolRequest
5855 //
5856 // @param runtime - runtime options for this request RuntimeOptions
5857 //
5858 // @return DeleteOriginPoolResponse
5859 func DeleteOriginPoolWithContext(ctx context.Context, client *Client, request *DeleteOriginPoolRequest, runtime *dara.RuntimeOptions) (_result *DeleteOriginPoolResponse, _err error) {
5860 if dara.BoolValue(client.EnableValidate) == true {
5861 _err = request.Validate()
5862 if _err != nil {
5863 return _result, _err
5864 }
5865 }
5866 query := map[string]interface{}{}
5867 if !dara.IsNil(request.Id) {
5868 query["Id"] = request.Id
5869 }
5870
5871 if !dara.IsNil(request.SiteId) {
5872 query["SiteId"] = request.SiteId
5873 }
5874
5875 req := &openapiutil.OpenApiRequest{
5876 Query: openapiutil.Query(query),
5877 }
5878 params := &openapiutil.Params{
5879 Action: dara.String("DeleteOriginPool"),
5880 Version: dara.String("2024-09-10"),
5881 Protocol: dara.String("HTTPS"),
5882 Pathname: dara.String("/"),
5883 Method: dara.String("POST"),
5884 AuthType: dara.String("AK"),
5885 Style: dara.String("RPC"),
5886 ReqBodyType: dara.String("formData"),
5887 BodyType: dara.String("json"),
5888 }
5889 _result = &DeleteOriginPoolResponse{}
5890 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5891 if _err != nil {
5892 return _result, _err
5893 }
5894 _err = dara.Convert(_body, &_result)
5895 return _result, _err
5896 }
5897
5898 // Summary:
5899 //
5900 // Disables origin protection.
5901 //
5902 // @param request - DeleteOriginProtectionRequest
5903 //
5904 // @param runtime - runtime options for this request RuntimeOptions
5905 //
5906 // @return DeleteOriginProtectionResponse
5907 func DeleteOriginProtectionWithContext(ctx context.Context, client *Client, request *DeleteOriginProtectionRequest, runtime *dara.RuntimeOptions) (_result *DeleteOriginProtectionResponse, _err error) {
5908 if dara.BoolValue(client.EnableValidate) == true {
5909 _err = request.Validate()
5910 if _err != nil {
5911 return _result, _err
5912 }
5913 }
5914 query := map[string]interface{}{}
5915 if !dara.IsNil(request.SiteId) {
5916 query["SiteId"] = request.SiteId
5917 }
5918
5919 req := &openapiutil.OpenApiRequest{
5920 Query: openapiutil.Query(query),
5921 }
5922 params := &openapiutil.Params{
5923 Action: dara.String("DeleteOriginProtection"),
5924 Version: dara.String("2024-09-10"),
5925 Protocol: dara.String("HTTPS"),
5926 Pathname: dara.String("/"),
5927 Method: dara.String("POST"),
5928 AuthType: dara.String("AK"),
5929 Style: dara.String("RPC"),
5930 ReqBodyType: dara.String("formData"),
5931 BodyType: dara.String("json"),
5932 }
5933 _result = &DeleteOriginProtectionResponse{}
5934 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5935 if _err != nil {
5936 return _result, _err
5937 }
5938 _err = dara.Convert(_body, &_result)
5939 return _result, _err
5940 }
5941
5942 // Summary:
5943 //
5944 // # Delete Origin Rule Configuration
5945 //
5946 // @param request - DeleteOriginRuleRequest
5947 //
5948 // @param runtime - runtime options for this request RuntimeOptions
5949 //
5950 // @return DeleteOriginRuleResponse
5951 func DeleteOriginRuleWithContext(ctx context.Context, client *Client, request *DeleteOriginRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteOriginRuleResponse, _err error) {
5952 if dara.BoolValue(client.EnableValidate) == true {
5953 _err = request.Validate()
5954 if _err != nil {
5955 return _result, _err
5956 }
5957 }
5958 query := map[string]interface{}{}
5959 if !dara.IsNil(request.ConfigId) {
5960 query["ConfigId"] = request.ConfigId
5961 }
5962
5963 if !dara.IsNil(request.SiteId) {
5964 query["SiteId"] = request.SiteId
5965 }
5966
5967 req := &openapiutil.OpenApiRequest{
5968 Query: openapiutil.Query(query),
5969 }
5970 params := &openapiutil.Params{
5971 Action: dara.String("DeleteOriginRule"),
5972 Version: dara.String("2024-09-10"),
5973 Protocol: dara.String("HTTPS"),
5974 Pathname: dara.String("/"),
5975 Method: dara.String("POST"),
5976 AuthType: dara.String("AK"),
5977 Style: dara.String("RPC"),
5978 ReqBodyType: dara.String("formData"),
5979 BodyType: dara.String("json"),
5980 }
5981 _result = &DeleteOriginRuleResponse{}
5982 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
5983 if _err != nil {
5984 return _result, _err
5985 }
5986 _err = dara.Convert(_body, &_result)
5987 return _result, _err
5988 }
5989
5990 // Summary:
5991 //
5992 // Deletes a custom error page that is no longer needed.
5993 //
5994 // @param request - DeletePageRequest
5995 //
5996 // @param runtime - runtime options for this request RuntimeOptions
5997 //
5998 // @return DeletePageResponse
5999 func DeletePageWithContext(ctx context.Context, client *Client, request *DeletePageRequest, runtime *dara.RuntimeOptions) (_result *DeletePageResponse, _err error) {
6000 if dara.BoolValue(client.EnableValidate) == true {
6001 _err = request.Validate()
6002 if _err != nil {
6003 return _result, _err
6004 }
6005 }
6006 body := map[string]interface{}{}
6007 if !dara.IsNil(request.Id) {
6008 body["Id"] = request.Id
6009 }
6010
6011 req := &openapiutil.OpenApiRequest{
6012 Body: openapiutil.ParseToMap(body),
6013 }
6014 params := &openapiutil.Params{
6015 Action: dara.String("DeletePage"),
6016 Version: dara.String("2024-09-10"),
6017 Protocol: dara.String("HTTPS"),
6018 Pathname: dara.String("/"),
6019 Method: dara.String("POST"),
6020 AuthType: dara.String("AK"),
6021 Style: dara.String("RPC"),
6022 ReqBodyType: dara.String("formData"),
6023 BodyType: dara.String("json"),
6024 }
6025 _result = &DeletePageResponse{}
6026 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6027 if _err != nil {
6028 return _result, _err
6029 }
6030 _err = dara.Convert(_body, &_result)
6031 return _result, _err
6032 }
6033
6034 // Summary:
6035 //
6036 // Deletes a DNS record of a website based on the specified RecordId.
6037 //
6038 // @param request - DeleteRecordRequest
6039 //
6040 // @param runtime - runtime options for this request RuntimeOptions
6041 //
6042 // @return DeleteRecordResponse
6043 func DeleteRecordWithContext(ctx context.Context, client *Client, request *DeleteRecordRequest, runtime *dara.RuntimeOptions) (_result *DeleteRecordResponse, _err error) {
6044 if dara.BoolValue(client.EnableValidate) == true {
6045 _err = request.Validate()
6046 if _err != nil {
6047 return _result, _err
6048 }
6049 }
6050 query := map[string]interface{}{}
6051 if !dara.IsNil(request.RecordId) {
6052 query["RecordId"] = request.RecordId
6053 }
6054
6055 if !dara.IsNil(request.SecurityToken) {
6056 query["SecurityToken"] = request.SecurityToken
6057 }
6058
6059 req := &openapiutil.OpenApiRequest{
6060 Query: openapiutil.Query(query),
6061 }
6062 params := &openapiutil.Params{
6063 Action: dara.String("DeleteRecord"),
6064 Version: dara.String("2024-09-10"),
6065 Protocol: dara.String("HTTPS"),
6066 Pathname: dara.String("/"),
6067 Method: dara.String("POST"),
6068 AuthType: dara.String("AK"),
6069 Style: dara.String("RPC"),
6070 ReqBodyType: dara.String("formData"),
6071 BodyType: dara.String("json"),
6072 }
6073 _result = &DeleteRecordResponse{}
6074 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6075 if _err != nil {
6076 return _result, _err
6077 }
6078 _err = dara.Convert(_body, &_result)
6079 return _result, _err
6080 }
6081
6082 // Summary:
6083 //
6084 // Deletes a URL redirect rule for a website.
6085 //
6086 // @param request - DeleteRedirectRuleRequest
6087 //
6088 // @param runtime - runtime options for this request RuntimeOptions
6089 //
6090 // @return DeleteRedirectRuleResponse
6091 func DeleteRedirectRuleWithContext(ctx context.Context, client *Client, request *DeleteRedirectRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteRedirectRuleResponse, _err error) {
6092 if dara.BoolValue(client.EnableValidate) == true {
6093 _err = request.Validate()
6094 if _err != nil {
6095 return _result, _err
6096 }
6097 }
6098 query := map[string]interface{}{}
6099 if !dara.IsNil(request.ConfigId) {
6100 query["ConfigId"] = request.ConfigId
6101 }
6102
6103 if !dara.IsNil(request.SiteId) {
6104 query["SiteId"] = request.SiteId
6105 }
6106
6107 req := &openapiutil.OpenApiRequest{
6108 Query: openapiutil.Query(query),
6109 }
6110 params := &openapiutil.Params{
6111 Action: dara.String("DeleteRedirectRule"),
6112 Version: dara.String("2024-09-10"),
6113 Protocol: dara.String("HTTPS"),
6114 Pathname: dara.String("/"),
6115 Method: dara.String("POST"),
6116 AuthType: dara.String("AK"),
6117 Style: dara.String("RPC"),
6118 ReqBodyType: dara.String("formData"),
6119 BodyType: dara.String("json"),
6120 }
6121 _result = &DeleteRedirectRuleResponse{}
6122 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6123 if _err != nil {
6124 return _result, _err
6125 }
6126 _err = dara.Convert(_body, &_result)
6127 return _result, _err
6128 }
6129
6130 // Summary:
6131 //
6132 // Deletes a URL rewrite rule for a website.
6133 //
6134 // @param request - DeleteRewriteUrlRuleRequest
6135 //
6136 // @param runtime - runtime options for this request RuntimeOptions
6137 //
6138 // @return DeleteRewriteUrlRuleResponse
6139 func DeleteRewriteUrlRuleWithContext(ctx context.Context, client *Client, request *DeleteRewriteUrlRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteRewriteUrlRuleResponse, _err error) {
6140 if dara.BoolValue(client.EnableValidate) == true {
6141 _err = request.Validate()
6142 if _err != nil {
6143 return _result, _err
6144 }
6145 }
6146 query := map[string]interface{}{}
6147 if !dara.IsNil(request.ConfigId) {
6148 query["ConfigId"] = request.ConfigId
6149 }
6150
6151 if !dara.IsNil(request.SiteId) {
6152 query["SiteId"] = request.SiteId
6153 }
6154
6155 req := &openapiutil.OpenApiRequest{
6156 Query: openapiutil.Query(query),
6157 }
6158 params := &openapiutil.Params{
6159 Action: dara.String("DeleteRewriteUrlRule"),
6160 Version: dara.String("2024-09-10"),
6161 Protocol: dara.String("HTTPS"),
6162 Pathname: dara.String("/"),
6163 Method: dara.String("POST"),
6164 AuthType: dara.String("AK"),
6165 Style: dara.String("RPC"),
6166 ReqBodyType: dara.String("formData"),
6167 BodyType: dara.String("json"),
6168 }
6169 _result = &DeleteRewriteUrlRuleResponse{}
6170 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6171 if _err != nil {
6172 return _result, _err
6173 }
6174 _err = dara.Convert(_body, &_result)
6175 return _result, _err
6176 }
6177
6178 // Summary:
6179 //
6180 // Deletes a routine in Edge Routine.
6181 //
6182 // @param request - DeleteRoutineRequest
6183 //
6184 // @param runtime - runtime options for this request RuntimeOptions
6185 //
6186 // @return DeleteRoutineResponse
6187 func DeleteRoutineWithContext(ctx context.Context, client *Client, request *DeleteRoutineRequest, runtime *dara.RuntimeOptions) (_result *DeleteRoutineResponse, _err error) {
6188 if dara.BoolValue(client.EnableValidate) == true {
6189 _err = request.Validate()
6190 if _err != nil {
6191 return _result, _err
6192 }
6193 }
6194 body := map[string]interface{}{}
6195 if !dara.IsNil(request.Name) {
6196 body["Name"] = request.Name
6197 }
6198
6199 req := &openapiutil.OpenApiRequest{
6200 Body: openapiutil.ParseToMap(body),
6201 }
6202 params := &openapiutil.Params{
6203 Action: dara.String("DeleteRoutine"),
6204 Version: dara.String("2024-09-10"),
6205 Protocol: dara.String("HTTPS"),
6206 Pathname: dara.String("/"),
6207 Method: dara.String("POST"),
6208 AuthType: dara.String("AK"),
6209 Style: dara.String("RPC"),
6210 ReqBodyType: dara.String("formData"),
6211 BodyType: dara.String("json"),
6212 }
6213 _result = &DeleteRoutineResponse{}
6214 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6215 if _err != nil {
6216 return _result, _err
6217 }
6218 _err = dara.Convert(_body, &_result)
6219 return _result, _err
6220 }
6221
6222 // Summary:
6223 //
6224 // Deletes a code version of a routine.
6225 //
6226 // @param request - DeleteRoutineCodeVersionRequest
6227 //
6228 // @param runtime - runtime options for this request RuntimeOptions
6229 //
6230 // @return DeleteRoutineCodeVersionResponse
6231 func DeleteRoutineCodeVersionWithContext(ctx context.Context, client *Client, request *DeleteRoutineCodeVersionRequest, runtime *dara.RuntimeOptions) (_result *DeleteRoutineCodeVersionResponse, _err error) {
6232 if dara.BoolValue(client.EnableValidate) == true {
6233 _err = request.Validate()
6234 if _err != nil {
6235 return _result, _err
6236 }
6237 }
6238 body := map[string]interface{}{}
6239 if !dara.IsNil(request.CodeVersion) {
6240 body["CodeVersion"] = request.CodeVersion
6241 }
6242
6243 if !dara.IsNil(request.Name) {
6244 body["Name"] = request.Name
6245 }
6246
6247 req := &openapiutil.OpenApiRequest{
6248 Body: openapiutil.ParseToMap(body),
6249 }
6250 params := &openapiutil.Params{
6251 Action: dara.String("DeleteRoutineCodeVersion"),
6252 Version: dara.String("2024-09-10"),
6253 Protocol: dara.String("HTTPS"),
6254 Pathname: dara.String("/"),
6255 Method: dara.String("POST"),
6256 AuthType: dara.String("AK"),
6257 Style: dara.String("RPC"),
6258 ReqBodyType: dara.String("formData"),
6259 BodyType: dara.String("json"),
6260 }
6261 _result = &DeleteRoutineCodeVersionResponse{}
6262 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6263 if _err != nil {
6264 return _result, _err
6265 }
6266 _err = dara.Convert(_body, &_result)
6267 return _result, _err
6268 }
6269
6270 // Summary:
6271 //
6272 // Deletes a record that is associated with a routine.
6273 //
6274 // @param request - DeleteRoutineRelatedRecordRequest
6275 //
6276 // @param runtime - runtime options for this request RuntimeOptions
6277 //
6278 // @return DeleteRoutineRelatedRecordResponse
6279 func DeleteRoutineRelatedRecordWithContext(ctx context.Context, client *Client, request *DeleteRoutineRelatedRecordRequest, runtime *dara.RuntimeOptions) (_result *DeleteRoutineRelatedRecordResponse, _err error) {
6280 if dara.BoolValue(client.EnableValidate) == true {
6281 _err = request.Validate()
6282 if _err != nil {
6283 return _result, _err
6284 }
6285 }
6286 query := map[string]interface{}{}
6287 if !dara.IsNil(request.SiteId) {
6288 query["SiteId"] = request.SiteId
6289 }
6290
6291 body := map[string]interface{}{}
6292 if !dara.IsNil(request.Name) {
6293 body["Name"] = request.Name
6294 }
6295
6296 if !dara.IsNil(request.RecordId) {
6297 body["RecordId"] = request.RecordId
6298 }
6299
6300 if !dara.IsNil(request.RecordName) {
6301 body["RecordName"] = request.RecordName
6302 }
6303
6304 req := &openapiutil.OpenApiRequest{
6305 Query: openapiutil.Query(query),
6306 Body: openapiutil.ParseToMap(body),
6307 }
6308 params := &openapiutil.Params{
6309 Action: dara.String("DeleteRoutineRelatedRecord"),
6310 Version: dara.String("2024-09-10"),
6311 Protocol: dara.String("HTTPS"),
6312 Pathname: dara.String("/"),
6313 Method: dara.String("POST"),
6314 AuthType: dara.String("AK"),
6315 Style: dara.String("RPC"),
6316 ReqBodyType: dara.String("formData"),
6317 BodyType: dara.String("json"),
6318 }
6319 _result = &DeleteRoutineRelatedRecordResponse{}
6320 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6321 if _err != nil {
6322 return _result, _err
6323 }
6324 _err = dara.Convert(_body, &_result)
6325 return _result, _err
6326 }
6327
6328 // Summary:
6329 //
6330 // Deletes the route configuration of an edge function.
6331 //
6332 // @param request - DeleteRoutineRouteRequest
6333 //
6334 // @param runtime - runtime options for this request RuntimeOptions
6335 //
6336 // @return DeleteRoutineRouteResponse
6337 func DeleteRoutineRouteWithContext(ctx context.Context, client *Client, request *DeleteRoutineRouteRequest, runtime *dara.RuntimeOptions) (_result *DeleteRoutineRouteResponse, _err error) {
6338 if dara.BoolValue(client.EnableValidate) == true {
6339 _err = request.Validate()
6340 if _err != nil {
6341 return _result, _err
6342 }
6343 }
6344 query := map[string]interface{}{}
6345 if !dara.IsNil(request.ConfigId) {
6346 query["ConfigId"] = request.ConfigId
6347 }
6348
6349 if !dara.IsNil(request.SiteId) {
6350 query["SiteId"] = request.SiteId
6351 }
6352
6353 req := &openapiutil.OpenApiRequest{
6354 Query: openapiutil.Query(query),
6355 }
6356 params := &openapiutil.Params{
6357 Action: dara.String("DeleteRoutineRoute"),
6358 Version: dara.String("2024-09-10"),
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 = &DeleteRoutineRouteResponse{}
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 // Deletes a scheduled prefetch plan based on the plan ID.
6379 //
6380 // @param request - DeleteScheduledPreloadExecutionRequest
6381 //
6382 // @param runtime - runtime options for this request RuntimeOptions
6383 //
6384 // @return DeleteScheduledPreloadExecutionResponse
6385 func DeleteScheduledPreloadExecutionWithContext(ctx context.Context, client *Client, request *DeleteScheduledPreloadExecutionRequest, runtime *dara.RuntimeOptions) (_result *DeleteScheduledPreloadExecutionResponse, _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.Id) {
6394 query["Id"] = request.Id
6395 }
6396
6397 req := &openapiutil.OpenApiRequest{
6398 Query: openapiutil.Query(query),
6399 }
6400 params := &openapiutil.Params{
6401 Action: dara.String("DeleteScheduledPreloadExecution"),
6402 Version: dara.String("2024-09-10"),
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 = &DeleteScheduledPreloadExecutionResponse{}
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 // Deletes a specified scheduled prefetch task based on the task ID.
6423 //
6424 // @param request - DeleteScheduledPreloadJobRequest
6425 //
6426 // @param runtime - runtime options for this request RuntimeOptions
6427 //
6428 // @return DeleteScheduledPreloadJobResponse
6429 func DeleteScheduledPreloadJobWithContext(ctx context.Context, client *Client, request *DeleteScheduledPreloadJobRequest, runtime *dara.RuntimeOptions) (_result *DeleteScheduledPreloadJobResponse, _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.Id) {
6438 query["Id"] = request.Id
6439 }
6440
6441 req := &openapiutil.OpenApiRequest{
6442 Query: openapiutil.Query(query),
6443 }
6444 params := &openapiutil.Params{
6445 Action: dara.String("DeleteScheduledPreloadJob"),
6446 Version: dara.String("2024-09-10"),
6447 Protocol: dara.String("HTTPS"),
6448 Pathname: dara.String("/"),
6449 Method: dara.String("POST"),
6450 AuthType: dara.String("AK"),
6451 Style: dara.String("RPC"),
6452 ReqBodyType: dara.String("formData"),
6453 BodyType: dara.String("json"),
6454 }
6455 _result = &DeleteScheduledPreloadJobResponse{}
6456 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6457 if _err != nil {
6458 return _result, _err
6459 }
6460 _err = dara.Convert(_body, &_result)
6461 return _result, _err
6462 }
6463
6464 // Summary:
6465 //
6466 // Deletes a website based on the specified website ID.
6467 //
6468 // @param request - DeleteSiteRequest
6469 //
6470 // @param runtime - runtime options for this request RuntimeOptions
6471 //
6472 // @return DeleteSiteResponse
6473 func DeleteSiteWithContext(ctx context.Context, client *Client, request *DeleteSiteRequest, runtime *dara.RuntimeOptions) (_result *DeleteSiteResponse, _err error) {
6474 if dara.BoolValue(client.EnableValidate) == true {
6475 _err = request.Validate()
6476 if _err != nil {
6477 return _result, _err
6478 }
6479 }
6480 query := map[string]interface{}{}
6481 if !dara.IsNil(request.OwnerId) {
6482 query["OwnerId"] = request.OwnerId
6483 }
6484
6485 if !dara.IsNil(request.SecurityToken) {
6486 query["SecurityToken"] = request.SecurityToken
6487 }
6488
6489 if !dara.IsNil(request.SiteId) {
6490 query["SiteId"] = request.SiteId
6491 }
6492
6493 req := &openapiutil.OpenApiRequest{
6494 Query: openapiutil.Query(query),
6495 }
6496 params := &openapiutil.Params{
6497 Action: dara.String("DeleteSite"),
6498 Version: dara.String("2024-09-10"),
6499 Protocol: dara.String("HTTPS"),
6500 Pathname: dara.String("/"),
6501 Method: dara.String("POST"),
6502 AuthType: dara.String("AK"),
6503 Style: dara.String("RPC"),
6504 ReqBodyType: dara.String("formData"),
6505 BodyType: dara.String("json"),
6506 }
6507 _result = &DeleteSiteResponse{}
6508 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6509 if _err != nil {
6510 return _result, _err
6511 }
6512 _err = dara.Convert(_body, &_result)
6513 return _result, _err
6514 }
6515
6516 // Summary:
6517 //
6518 // Deletes a real-time log delivery task.
6519 //
6520 // @param request - DeleteSiteDeliveryTaskRequest
6521 //
6522 // @param runtime - runtime options for this request RuntimeOptions
6523 //
6524 // @return DeleteSiteDeliveryTaskResponse
6525 func DeleteSiteDeliveryTaskWithContext(ctx context.Context, client *Client, request *DeleteSiteDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *DeleteSiteDeliveryTaskResponse, _err error) {
6526 if dara.BoolValue(client.EnableValidate) == true {
6527 _err = request.Validate()
6528 if _err != nil {
6529 return _result, _err
6530 }
6531 }
6532 body := map[string]interface{}{}
6533 if !dara.IsNil(request.SiteId) {
6534 body["SiteId"] = request.SiteId
6535 }
6536
6537 if !dara.IsNil(request.TaskName) {
6538 body["TaskName"] = request.TaskName
6539 }
6540
6541 req := &openapiutil.OpenApiRequest{
6542 Body: openapiutil.ParseToMap(body),
6543 }
6544 params := &openapiutil.Params{
6545 Action: dara.String("DeleteSiteDeliveryTask"),
6546 Version: dara.String("2024-09-10"),
6547 Protocol: dara.String("HTTPS"),
6548 Pathname: dara.String("/"),
6549 Method: dara.String("POST"),
6550 AuthType: dara.String("AK"),
6551 Style: dara.String("RPC"),
6552 ReqBodyType: dara.String("formData"),
6553 BodyType: dara.String("json"),
6554 }
6555 _result = &DeleteSiteDeliveryTaskResponse{}
6556 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6557 if _err != nil {
6558 return _result, _err
6559 }
6560 _err = dara.Convert(_body, &_result)
6561 return _result, _err
6562 }
6563
6564 // Summary:
6565 //
6566 // 删除站点回源客户端证书
6567 //
6568 // @param request - DeleteSiteOriginClientCertificateRequest
6569 //
6570 // @param runtime - runtime options for this request RuntimeOptions
6571 //
6572 // @return DeleteSiteOriginClientCertificateResponse
6573 func DeleteSiteOriginClientCertificateWithContext(ctx context.Context, client *Client, request *DeleteSiteOriginClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *DeleteSiteOriginClientCertificateResponse, _err error) {
6574 if dara.BoolValue(client.EnableValidate) == true {
6575 _err = request.Validate()
6576 if _err != nil {
6577 return _result, _err
6578 }
6579 }
6580 query := openapiutil.Query(dara.ToMap(request))
6581 req := &openapiutil.OpenApiRequest{
6582 Query: openapiutil.Query(query),
6583 }
6584 params := &openapiutil.Params{
6585 Action: dara.String("DeleteSiteOriginClientCertificate"),
6586 Version: dara.String("2024-09-10"),
6587 Protocol: dara.String("HTTPS"),
6588 Pathname: dara.String("/"),
6589 Method: dara.String("GET"),
6590 AuthType: dara.String("AK"),
6591 Style: dara.String("RPC"),
6592 ReqBodyType: dara.String("formData"),
6593 BodyType: dara.String("json"),
6594 }
6595 _result = &DeleteSiteOriginClientCertificateResponse{}
6596 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6597 if _err != nil {
6598 return _result, _err
6599 }
6600 _err = dara.Convert(_body, &_result)
6601 return _result, _err
6602 }
6603
6604 // Summary:
6605 //
6606 // # Delete Transport Layer Application
6607 //
6608 // @param request - DeleteTransportLayerApplicationRequest
6609 //
6610 // @param runtime - runtime options for this request RuntimeOptions
6611 //
6612 // @return DeleteTransportLayerApplicationResponse
6613 func DeleteTransportLayerApplicationWithContext(ctx context.Context, client *Client, request *DeleteTransportLayerApplicationRequest, runtime *dara.RuntimeOptions) (_result *DeleteTransportLayerApplicationResponse, _err error) {
6614 if dara.BoolValue(client.EnableValidate) == true {
6615 _err = request.Validate()
6616 if _err != nil {
6617 return _result, _err
6618 }
6619 }
6620 query := map[string]interface{}{}
6621 if !dara.IsNil(request.ApplicationId) {
6622 query["ApplicationId"] = request.ApplicationId
6623 }
6624
6625 if !dara.IsNil(request.SiteId) {
6626 query["SiteId"] = request.SiteId
6627 }
6628
6629 req := &openapiutil.OpenApiRequest{
6630 Query: openapiutil.Query(query),
6631 }
6632 params := &openapiutil.Params{
6633 Action: dara.String("DeleteTransportLayerApplication"),
6634 Version: dara.String("2024-09-10"),
6635 Protocol: dara.String("HTTPS"),
6636 Pathname: dara.String("/"),
6637 Method: dara.String("POST"),
6638 AuthType: dara.String("AK"),
6639 Style: dara.String("RPC"),
6640 ReqBodyType: dara.String("formData"),
6641 BodyType: dara.String("json"),
6642 }
6643 _result = &DeleteTransportLayerApplicationResponse{}
6644 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6645 if _err != nil {
6646 return _result, _err
6647 }
6648 _err = dara.Convert(_body, &_result)
6649 return _result, _err
6650 }
6651
6652 // Summary:
6653 //
6654 // Deletes page monitoring configurations.
6655 //
6656 // @param request - DeleteUrlObservationRequest
6657 //
6658 // @param runtime - runtime options for this request RuntimeOptions
6659 //
6660 // @return DeleteUrlObservationResponse
6661 func DeleteUrlObservationWithContext(ctx context.Context, client *Client, request *DeleteUrlObservationRequest, runtime *dara.RuntimeOptions) (_result *DeleteUrlObservationResponse, _err error) {
6662 if dara.BoolValue(client.EnableValidate) == true {
6663 _err = request.Validate()
6664 if _err != nil {
6665 return _result, _err
6666 }
6667 }
6668 query := map[string]interface{}{}
6669 if !dara.IsNil(request.ConfigId) {
6670 query["ConfigId"] = request.ConfigId
6671 }
6672
6673 if !dara.IsNil(request.SiteId) {
6674 query["SiteId"] = request.SiteId
6675 }
6676
6677 req := &openapiutil.OpenApiRequest{
6678 Query: openapiutil.Query(query),
6679 }
6680 params := &openapiutil.Params{
6681 Action: dara.String("DeleteUrlObservation"),
6682 Version: dara.String("2024-09-10"),
6683 Protocol: dara.String("HTTPS"),
6684 Pathname: dara.String("/"),
6685 Method: dara.String("POST"),
6686 AuthType: dara.String("AK"),
6687 Style: dara.String("RPC"),
6688 ReqBodyType: dara.String("formData"),
6689 BodyType: dara.String("json"),
6690 }
6691 _result = &DeleteUrlObservationResponse{}
6692 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6693 if _err != nil {
6694 return _result, _err
6695 }
6696 _err = dara.Convert(_body, &_result)
6697 return _result, _err
6698 }
6699
6700 // Summary:
6701 //
6702 // Deletes a log delivery task from your Alibaba Cloud account.
6703 //
6704 // Description:
6705 //
6706 // *****>
6707 //
6708 // - Deleted tasks cannot be restored. Proceed with caution.
6709 //
6710 // - To call this operation, you must have an account that has the required permissions.
6711 //
6712 // - The returned `RequestId` value can be used to track the request processing progress and troubleshoot issues.
6713 //
6714 // @param request - DeleteUserDeliveryTaskRequest
6715 //
6716 // @param runtime - runtime options for this request RuntimeOptions
6717 //
6718 // @return DeleteUserDeliveryTaskResponse
6719 func DeleteUserDeliveryTaskWithContext(ctx context.Context, client *Client, request *DeleteUserDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *DeleteUserDeliveryTaskResponse, _err error) {
6720 if dara.BoolValue(client.EnableValidate) == true {
6721 _err = request.Validate()
6722 if _err != nil {
6723 return _result, _err
6724 }
6725 }
6726 body := map[string]interface{}{}
6727 if !dara.IsNil(request.TaskName) {
6728 body["TaskName"] = request.TaskName
6729 }
6730
6731 req := &openapiutil.OpenApiRequest{
6732 Body: openapiutil.ParseToMap(body),
6733 }
6734 params := &openapiutil.Params{
6735 Action: dara.String("DeleteUserDeliveryTask"),
6736 Version: dara.String("2024-09-10"),
6737 Protocol: dara.String("HTTPS"),
6738 Pathname: dara.String("/"),
6739 Method: dara.String("POST"),
6740 AuthType: dara.String("AK"),
6741 Style: dara.String("RPC"),
6742 ReqBodyType: dara.String("formData"),
6743 BodyType: dara.String("json"),
6744 }
6745 _result = &DeleteUserDeliveryTaskResponse{}
6746 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6747 if _err != nil {
6748 return _result, _err
6749 }
6750 _err = dara.Convert(_body, &_result)
6751 return _result, _err
6752 }
6753
6754 // Summary:
6755 //
6756 // 用于删除实例级别的Web应用防火墙规则集。
6757 //
6758 // Description:
6759 //
6760 // ## 请求说明
6761 //
6762 // - 本API允许用户为指定实例创建新的WAF（Web Application Firewall）规则集。
6763 //
6764 // - `InstanceId` 是必需参数，指定了要为其创建规则集的具体实例。
6765 //
6766 // - `Phase` 参数定义了规则集的应用阶段，例如自定义规则、频次控制等。
6767 //
6768 // - `Name` 和 `Expression` 是必填项，分别代表规则集的名字和具体的匹配表达式。
6769 //
6770 // - 可选参数 `Description` 提供了对规则集功能或用途的文字描述。
6771 //
6772 // - `Status` 控制着规则集是否立即生效 (`on`) 或者处于关闭状态 (`off`)。
6773 //
6774 // - 通过 `Rules` 参数可以进一步配置更详细的规则列表，每个规则都包含名称、位置、表达式及动作等属性。
6775 //
6776 // - 成功响应将返回新创建规则集的唯一标识符 `Id` 以及所有关联规则的ID列表 `RuleIds`。
6777 //
6778 // @param request - DeleteUserWafRulesetRequest
6779 //
6780 // @param runtime - runtime options for this request RuntimeOptions
6781 //
6782 // @return DeleteUserWafRulesetResponse
6783 func DeleteUserWafRulesetWithContext(ctx context.Context, client *Client, request *DeleteUserWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *DeleteUserWafRulesetResponse, _err error) {
6784 if dara.BoolValue(client.EnableValidate) == true {
6785 _err = request.Validate()
6786 if _err != nil {
6787 return _result, _err
6788 }
6789 }
6790 query := map[string]interface{}{}
6791 if !dara.IsNil(request.InstanceId) {
6792 query["InstanceId"] = request.InstanceId
6793 }
6794
6795 body := map[string]interface{}{}
6796 if !dara.IsNil(request.Id) {
6797 body["Id"] = request.Id
6798 }
6799
6800 req := &openapiutil.OpenApiRequest{
6801 Query: openapiutil.Query(query),
6802 Body: openapiutil.ParseToMap(body),
6803 }
6804 params := &openapiutil.Params{
6805 Action: dara.String("DeleteUserWafRuleset"),
6806 Version: dara.String("2024-09-10"),
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 = &DeleteUserWafRulesetResponse{}
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 // Deletes a video processing configuration.
6827 //
6828 // @param request - DeleteVideoProcessingRequest
6829 //
6830 // @param runtime - runtime options for this request RuntimeOptions
6831 //
6832 // @return DeleteVideoProcessingResponse
6833 func DeleteVideoProcessingWithContext(ctx context.Context, client *Client, request *DeleteVideoProcessingRequest, runtime *dara.RuntimeOptions) (_result *DeleteVideoProcessingResponse, _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.ConfigId) {
6842 query["ConfigId"] = request.ConfigId
6843 }
6844
6845 if !dara.IsNil(request.SiteId) {
6846 query["SiteId"] = request.SiteId
6847 }
6848
6849 req := &openapiutil.OpenApiRequest{
6850 Query: openapiutil.Query(query),
6851 }
6852 params := &openapiutil.Params{
6853 Action: dara.String("DeleteVideoProcessing"),
6854 Version: dara.String("2024-09-10"),
6855 Protocol: dara.String("HTTPS"),
6856 Pathname: dara.String("/"),
6857 Method: dara.String("POST"),
6858 AuthType: dara.String("AK"),
6859 Style: dara.String("RPC"),
6860 ReqBodyType: dara.String("formData"),
6861 BodyType: dara.String("json"),
6862 }
6863 _result = &DeleteVideoProcessingResponse{}
6864 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6865 if _err != nil {
6866 return _result, _err
6867 }
6868 _err = dara.Convert(_body, &_result)
6869 return _result, _err
6870 }
6871
6872 // Summary:
6873 //
6874 // # Delete WAF Rule
6875 //
6876 // @param request - DeleteWafRuleRequest
6877 //
6878 // @param runtime - runtime options for this request RuntimeOptions
6879 //
6880 // @return DeleteWafRuleResponse
6881 func DeleteWafRuleWithContext(ctx context.Context, client *Client, request *DeleteWafRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteWafRuleResponse, _err error) {
6882 if dara.BoolValue(client.EnableValidate) == true {
6883 _err = request.Validate()
6884 if _err != nil {
6885 return _result, _err
6886 }
6887 }
6888 query := map[string]interface{}{}
6889 if !dara.IsNil(request.SiteId) {
6890 query["SiteId"] = request.SiteId
6891 }
6892
6893 if !dara.IsNil(request.SiteVersion) {
6894 query["SiteVersion"] = request.SiteVersion
6895 }
6896
6897 body := map[string]interface{}{}
6898 if !dara.IsNil(request.Id) {
6899 body["Id"] = request.Id
6900 }
6901
6902 req := &openapiutil.OpenApiRequest{
6903 Query: openapiutil.Query(query),
6904 Body: openapiutil.ParseToMap(body),
6905 }
6906 params := &openapiutil.Params{
6907 Action: dara.String("DeleteWafRule"),
6908 Version: dara.String("2024-09-10"),
6909 Protocol: dara.String("HTTPS"),
6910 Pathname: dara.String("/"),
6911 Method: dara.String("POST"),
6912 AuthType: dara.String("AK"),
6913 Style: dara.String("RPC"),
6914 ReqBodyType: dara.String("formData"),
6915 BodyType: dara.String("json"),
6916 }
6917 _result = &DeleteWafRuleResponse{}
6918 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6919 if _err != nil {
6920 return _result, _err
6921 }
6922 _err = dara.Convert(_body, &_result)
6923 return _result, _err
6924 }
6925
6926 // Summary:
6927 //
6928 // # Delete WAF Ruleset
6929 //
6930 // @param request - DeleteWafRulesetRequest
6931 //
6932 // @param runtime - runtime options for this request RuntimeOptions
6933 //
6934 // @return DeleteWafRulesetResponse
6935 func DeleteWafRulesetWithContext(ctx context.Context, client *Client, request *DeleteWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *DeleteWafRulesetResponse, _err error) {
6936 if dara.BoolValue(client.EnableValidate) == true {
6937 _err = request.Validate()
6938 if _err != nil {
6939 return _result, _err
6940 }
6941 }
6942 query := map[string]interface{}{}
6943 if !dara.IsNil(request.SiteId) {
6944 query["SiteId"] = request.SiteId
6945 }
6946
6947 if !dara.IsNil(request.SiteVersion) {
6948 query["SiteVersion"] = request.SiteVersion
6949 }
6950
6951 body := map[string]interface{}{}
6952 if !dara.IsNil(request.Id) {
6953 body["Id"] = request.Id
6954 }
6955
6956 req := &openapiutil.OpenApiRequest{
6957 Query: openapiutil.Query(query),
6958 Body: openapiutil.ParseToMap(body),
6959 }
6960 params := &openapiutil.Params{
6961 Action: dara.String("DeleteWafRuleset"),
6962 Version: dara.String("2024-09-10"),
6963 Protocol: dara.String("HTTPS"),
6964 Pathname: dara.String("/"),
6965 Method: dara.String("POST"),
6966 AuthType: dara.String("AK"),
6967 Style: dara.String("RPC"),
6968 ReqBodyType: dara.String("formData"),
6969 BodyType: dara.String("json"),
6970 }
6971 _result = &DeleteWafRulesetResponse{}
6972 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
6973 if _err != nil {
6974 return _result, _err
6975 }
6976 _err = dara.Convert(_body, &_result)
6977 return _result, _err
6978 }
6979
6980 // Summary:
6981 //
6982 // Deletes a waiting room.
6983 //
6984 // @param request - DeleteWaitingRoomRequest
6985 //
6986 // @param runtime - runtime options for this request RuntimeOptions
6987 //
6988 // @return DeleteWaitingRoomResponse
6989 func DeleteWaitingRoomWithContext(ctx context.Context, client *Client, request *DeleteWaitingRoomRequest, runtime *dara.RuntimeOptions) (_result *DeleteWaitingRoomResponse, _err error) {
6990 if dara.BoolValue(client.EnableValidate) == true {
6991 _err = request.Validate()
6992 if _err != nil {
6993 return _result, _err
6994 }
6995 }
6996 query := map[string]interface{}{}
6997 if !dara.IsNil(request.SiteId) {
6998 query["SiteId"] = request.SiteId
6999 }
7000
7001 if !dara.IsNil(request.WaitingRoomId) {
7002 query["WaitingRoomId"] = request.WaitingRoomId
7003 }
7004
7005 req := &openapiutil.OpenApiRequest{
7006 Query: openapiutil.Query(query),
7007 }
7008 params := &openapiutil.Params{
7009 Action: dara.String("DeleteWaitingRoom"),
7010 Version: dara.String("2024-09-10"),
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 = &DeleteWaitingRoomResponse{}
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 // Deletes a waiting room event.
7031 //
7032 // @param request - DeleteWaitingRoomEventRequest
7033 //
7034 // @param runtime - runtime options for this request RuntimeOptions
7035 //
7036 // @return DeleteWaitingRoomEventResponse
7037 func DeleteWaitingRoomEventWithContext(ctx context.Context, client *Client, request *DeleteWaitingRoomEventRequest, runtime *dara.RuntimeOptions) (_result *DeleteWaitingRoomEventResponse, _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.SiteId) {
7046 query["SiteId"] = request.SiteId
7047 }
7048
7049 if !dara.IsNil(request.WaitingRoomEventId) {
7050 query["WaitingRoomEventId"] = request.WaitingRoomEventId
7051 }
7052
7053 req := &openapiutil.OpenApiRequest{
7054 Query: openapiutil.Query(query),
7055 }
7056 params := &openapiutil.Params{
7057 Action: dara.String("DeleteWaitingRoomEvent"),
7058 Version: dara.String("2024-09-10"),
7059 Protocol: dara.String("HTTPS"),
7060 Pathname: dara.String("/"),
7061 Method: dara.String("POST"),
7062 AuthType: dara.String("AK"),
7063 Style: dara.String("RPC"),
7064 ReqBodyType: dara.String("formData"),
7065 BodyType: dara.String("json"),
7066 }
7067 _result = &DeleteWaitingRoomEventResponse{}
7068 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7069 if _err != nil {
7070 return _result, _err
7071 }
7072 _err = dara.Convert(_body, &_result)
7073 return _result, _err
7074 }
7075
7076 // Summary:
7077 //
7078 // Deletes a waiting room bypass rule.
7079 //
7080 // @param request - DeleteWaitingRoomRuleRequest
7081 //
7082 // @param runtime - runtime options for this request RuntimeOptions
7083 //
7084 // @return DeleteWaitingRoomRuleResponse
7085 func DeleteWaitingRoomRuleWithContext(ctx context.Context, client *Client, request *DeleteWaitingRoomRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteWaitingRoomRuleResponse, _err error) {
7086 if dara.BoolValue(client.EnableValidate) == true {
7087 _err = request.Validate()
7088 if _err != nil {
7089 return _result, _err
7090 }
7091 }
7092 query := map[string]interface{}{}
7093 if !dara.IsNil(request.SiteId) {
7094 query["SiteId"] = request.SiteId
7095 }
7096
7097 if !dara.IsNil(request.WaitingRoomRuleId) {
7098 query["WaitingRoomRuleId"] = request.WaitingRoomRuleId
7099 }
7100
7101 req := &openapiutil.OpenApiRequest{
7102 Query: openapiutil.Query(query),
7103 }
7104 params := &openapiutil.Params{
7105 Action: dara.String("DeleteWaitingRoomRule"),
7106 Version: dara.String("2024-09-10"),
7107 Protocol: dara.String("HTTPS"),
7108 Pathname: dara.String("/"),
7109 Method: dara.String("POST"),
7110 AuthType: dara.String("AK"),
7111 Style: dara.String("RPC"),
7112 ReqBodyType: dara.String("formData"),
7113 BodyType: dara.String("json"),
7114 }
7115 _result = &DeleteWaitingRoomRuleResponse{}
7116 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7117 if _err != nil {
7118 return _result, _err
7119 }
7120 _err = dara.Convert(_body, &_result)
7121 return _result, _err
7122 }
7123
7124 // Summary:
7125 //
7126 // Queries the configurations of a scenario-specific policy.
7127 //
7128 // @param request - DescribeCustomScenePoliciesRequest
7129 //
7130 // @param runtime - runtime options for this request RuntimeOptions
7131 //
7132 // @return DescribeCustomScenePoliciesResponse
7133 func DescribeCustomScenePoliciesWithContext(ctx context.Context, client *Client, request *DescribeCustomScenePoliciesRequest, runtime *dara.RuntimeOptions) (_result *DescribeCustomScenePoliciesResponse, _err error) {
7134 if dara.BoolValue(client.EnableValidate) == true {
7135 _err = request.Validate()
7136 if _err != nil {
7137 return _result, _err
7138 }
7139 }
7140 query := map[string]interface{}{}
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 if !dara.IsNil(request.PolicyId) {
7150 query["PolicyId"] = request.PolicyId
7151 }
7152
7153 req := &openapiutil.OpenApiRequest{
7154 Query: openapiutil.Query(query),
7155 }
7156 params := &openapiutil.Params{
7157 Action: dara.String("DescribeCustomScenePolicies"),
7158 Version: dara.String("2024-09-10"),
7159 Protocol: dara.String("HTTPS"),
7160 Pathname: dara.String("/"),
7161 Method: dara.String("POST"),
7162 AuthType: dara.String("AK"),
7163 Style: dara.String("RPC"),
7164 ReqBodyType: dara.String("formData"),
7165 BodyType: dara.String("json"),
7166 }
7167 _result = &DescribeCustomScenePoliciesResponse{}
7168 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7169 if _err != nil {
7170 return _result, _err
7171 }
7172 _err = dara.Convert(_body, &_result)
7173 return _result, _err
7174 }
7175
7176 // Summary:
7177 //
7178 // Queries DDoS attack events.
7179 //
7180 // @param request - DescribeDDoSAllEventListRequest
7181 //
7182 // @param runtime - runtime options for this request RuntimeOptions
7183 //
7184 // @return DescribeDDoSAllEventListResponse
7185 func DescribeDDoSAllEventListWithContext(ctx context.Context, client *Client, request *DescribeDDoSAllEventListRequest, runtime *dara.RuntimeOptions) (_result *DescribeDDoSAllEventListResponse, _err error) {
7186 if dara.BoolValue(client.EnableValidate) == true {
7187 _err = request.Validate()
7188 if _err != nil {
7189 return _result, _err
7190 }
7191 }
7192 query := map[string]interface{}{}
7193 if !dara.IsNil(request.EndTime) {
7194 query["EndTime"] = request.EndTime
7195 }
7196
7197 if !dara.IsNil(request.EventType) {
7198 query["EventType"] = request.EventType
7199 }
7200
7201 if !dara.IsNil(request.PageNumber) {
7202 query["PageNumber"] = request.PageNumber
7203 }
7204
7205 if !dara.IsNil(request.PageSize) {
7206 query["PageSize"] = request.PageSize
7207 }
7208
7209 if !dara.IsNil(request.SiteId) {
7210 query["SiteId"] = request.SiteId
7211 }
7212
7213 if !dara.IsNil(request.StartTime) {
7214 query["StartTime"] = request.StartTime
7215 }
7216
7217 req := &openapiutil.OpenApiRequest{
7218 Query: openapiutil.Query(query),
7219 }
7220 params := &openapiutil.Params{
7221 Action: dara.String("DescribeDDoSAllEventList"),
7222 Version: dara.String("2024-09-10"),
7223 Protocol: dara.String("HTTPS"),
7224 Pathname: dara.String("/"),
7225 Method: dara.String("POST"),
7226 AuthType: dara.String("AK"),
7227 Style: dara.String("RPC"),
7228 ReqBodyType: dara.String("formData"),
7229 BodyType: dara.String("json"),
7230 }
7231 _result = &DescribeDDoSAllEventListResponse{}
7232 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7233 if _err != nil {
7234 return _result, _err
7235 }
7236 _err = dara.Convert(_body, &_result)
7237 return _result, _err
7238 }
7239
7240 // Summary:
7241 //
7242 // # Query DCDN DDoS user bps and pps data
7243 //
7244 // @param request - DescribeDDoSBpsListRequest
7245 //
7246 // @param runtime - runtime options for this request RuntimeOptions
7247 //
7248 // @return DescribeDDoSBpsListResponse
7249 func DescribeDDoSBpsListWithContext(ctx context.Context, client *Client, request *DescribeDDoSBpsListRequest, runtime *dara.RuntimeOptions) (_result *DescribeDDoSBpsListResponse, _err error) {
7250 if dara.BoolValue(client.EnableValidate) == true {
7251 _err = request.Validate()
7252 if _err != nil {
7253 return _result, _err
7254 }
7255 }
7256 query := openapiutil.Query(dara.ToMap(request))
7257 req := &openapiutil.OpenApiRequest{
7258 Query: openapiutil.Query(query),
7259 }
7260 params := &openapiutil.Params{
7261 Action: dara.String("DescribeDDoSBpsList"),
7262 Version: dara.String("2024-09-10"),
7263 Protocol: dara.String("HTTPS"),
7264 Pathname: dara.String("/"),
7265 Method: dara.String("GET"),
7266 AuthType: dara.String("AK"),
7267 Style: dara.String("RPC"),
7268 ReqBodyType: dara.String("formData"),
7269 BodyType: dara.String("json"),
7270 }
7271 _result = &DescribeDDoSBpsListResponse{}
7272 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7273 if _err != nil {
7274 return _result, _err
7275 }
7276 _err = dara.Convert(_body, &_result)
7277 return _result, _err
7278 }
7279
7280 // Summary:
7281 //
7282 // # DDoS Analysis Layer 7 QPS Trend Chart API
7283 //
7284 // @param request - DescribeDDoSL7QpsListRequest
7285 //
7286 // @param runtime - runtime options for this request RuntimeOptions
7287 //
7288 // @return DescribeDDoSL7QpsListResponse
7289 func DescribeDDoSL7QpsListWithContext(ctx context.Context, client *Client, request *DescribeDDoSL7QpsListRequest, runtime *dara.RuntimeOptions) (_result *DescribeDDoSL7QpsListResponse, _err error) {
7290 if dara.BoolValue(client.EnableValidate) == true {
7291 _err = request.Validate()
7292 if _err != nil {
7293 return _result, _err
7294 }
7295 }
7296 query := map[string]interface{}{}
7297 if !dara.IsNil(request.EndTime) {
7298 query["EndTime"] = request.EndTime
7299 }
7300
7301 if !dara.IsNil(request.Interval) {
7302 query["Interval"] = request.Interval
7303 }
7304
7305 if !dara.IsNil(request.RecordId) {
7306 query["RecordId"] = request.RecordId
7307 }
7308
7309 if !dara.IsNil(request.SiteId) {
7310 query["SiteId"] = request.SiteId
7311 }
7312
7313 if !dara.IsNil(request.StartTime) {
7314 query["StartTime"] = request.StartTime
7315 }
7316
7317 req := &openapiutil.OpenApiRequest{
7318 Query: openapiutil.Query(query),
7319 }
7320 params := &openapiutil.Params{
7321 Action: dara.String("DescribeDDoSL7QpsList"),
7322 Version: dara.String("2024-09-10"),
7323 Protocol: dara.String("HTTPS"),
7324 Pathname: dara.String("/"),
7325 Method: dara.String("POST"),
7326 AuthType: dara.String("AK"),
7327 Style: dara.String("RPC"),
7328 ReqBodyType: dara.String("formData"),
7329 BodyType: dara.String("json"),
7330 }
7331 _result = &DescribeDDoSL7QpsListResponse{}
7332 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7333 if _err != nil {
7334 return _result, _err
7335 }
7336 _err = dara.Convert(_body, &_result)
7337 return _result, _err
7338 }
7339
7340 // Summary:
7341 //
7342 // Provides monitoring data for metrics of ESA edge containers.
7343 //
7344 // @param request - DescribeEdgeContainerAppStatsRequest
7345 //
7346 // @param runtime - runtime options for this request RuntimeOptions
7347 //
7348 // @return DescribeEdgeContainerAppStatsResponse
7349 func DescribeEdgeContainerAppStatsWithContext(ctx context.Context, client *Client, request *DescribeEdgeContainerAppStatsRequest, runtime *dara.RuntimeOptions) (_result *DescribeEdgeContainerAppStatsResponse, _err error) {
7350 if dara.BoolValue(client.EnableValidate) == true {
7351 _err = request.Validate()
7352 if _err != nil {
7353 return _result, _err
7354 }
7355 }
7356 query := openapiutil.Query(dara.ToMap(request))
7357 req := &openapiutil.OpenApiRequest{
7358 Query: openapiutil.Query(query),
7359 }
7360 params := &openapiutil.Params{
7361 Action: dara.String("DescribeEdgeContainerAppStats"),
7362 Version: dara.String("2024-09-10"),
7363 Protocol: dara.String("HTTPS"),
7364 Pathname: dara.String("/"),
7365 Method: dara.String("GET"),
7366 AuthType: dara.String("AK"),
7367 Style: dara.String("RPC"),
7368 ReqBodyType: dara.String("formData"),
7369 BodyType: dara.String("json"),
7370 }
7371 _result = &DescribeEdgeContainerAppStatsResponse{}
7372 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7373 if _err != nil {
7374 return _result, _err
7375 }
7376 _err = dara.Convert(_body, &_result)
7377 return _result, _err
7378 }
7379
7380 // Summary:
7381 //
7382 // Queries the configuration of smart HTTP DDoS protection for a website.
7383 //
7384 // @param request - DescribeHttpDDoSAttackIntelligentProtectionRequest
7385 //
7386 // @param runtime - runtime options for this request RuntimeOptions
7387 //
7388 // @return DescribeHttpDDoSAttackIntelligentProtectionResponse
7389 func DescribeHttpDDoSAttackIntelligentProtectionWithContext(ctx context.Context, client *Client, request *DescribeHttpDDoSAttackIntelligentProtectionRequest, runtime *dara.RuntimeOptions) (_result *DescribeHttpDDoSAttackIntelligentProtectionResponse, _err error) {
7390 if dara.BoolValue(client.EnableValidate) == true {
7391 _err = request.Validate()
7392 if _err != nil {
7393 return _result, _err
7394 }
7395 }
7396 query := map[string]interface{}{}
7397 if !dara.IsNil(request.SiteId) {
7398 query["SiteId"] = request.SiteId
7399 }
7400
7401 req := &openapiutil.OpenApiRequest{
7402 Query: openapiutil.Query(query),
7403 }
7404 params := &openapiutil.Params{
7405 Action: dara.String("DescribeHttpDDoSAttackIntelligentProtection"),
7406 Version: dara.String("2024-09-10"),
7407 Protocol: dara.String("HTTPS"),
7408 Pathname: dara.String("/"),
7409 Method: dara.String("POST"),
7410 AuthType: dara.String("AK"),
7411 Style: dara.String("RPC"),
7412 ReqBodyType: dara.String("formData"),
7413 BodyType: dara.String("json"),
7414 }
7415 _result = &DescribeHttpDDoSAttackIntelligentProtectionResponse{}
7416 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7417 if _err != nil {
7418 return _result, _err
7419 }
7420 _err = dara.Convert(_body, &_result)
7421 return _result, _err
7422 }
7423
7424 // Summary:
7425 //
7426 // Queries the configurations of HTTP DDoS attack protection.
7427 //
7428 // @param request - DescribeHttpDDoSAttackProtectionRequest
7429 //
7430 // @param runtime - runtime options for this request RuntimeOptions
7431 //
7432 // @return DescribeHttpDDoSAttackProtectionResponse
7433 func DescribeHttpDDoSAttackProtectionWithContext(ctx context.Context, client *Client, request *DescribeHttpDDoSAttackProtectionRequest, runtime *dara.RuntimeOptions) (_result *DescribeHttpDDoSAttackProtectionResponse, _err error) {
7434 if dara.BoolValue(client.EnableValidate) == true {
7435 _err = request.Validate()
7436 if _err != nil {
7437 return _result, _err
7438 }
7439 }
7440 query := map[string]interface{}{}
7441 if !dara.IsNil(request.SiteId) {
7442 query["SiteId"] = request.SiteId
7443 }
7444
7445 req := &openapiutil.OpenApiRequest{
7446 Query: openapiutil.Query(query),
7447 }
7448 params := &openapiutil.Params{
7449 Action: dara.String("DescribeHttpDDoSAttackProtection"),
7450 Version: dara.String("2024-09-10"),
7451 Protocol: dara.String("HTTPS"),
7452 Pathname: dara.String("/"),
7453 Method: dara.String("POST"),
7454 AuthType: dara.String("AK"),
7455 Style: dara.String("RPC"),
7456 ReqBodyType: dara.String("formData"),
7457 BodyType: dara.String("json"),
7458 }
7459 _result = &DescribeHttpDDoSAttackProtectionResponse{}
7460 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7461 if _err != nil {
7462 return _result, _err
7463 }
7464 _err = dara.Convert(_body, &_result)
7465 return _result, _err
7466 }
7467
7468 // Summary:
7469 //
7470 // Queries the details of prefetch tasks by time, task status, or prefetch URL.
7471 //
7472 // @param request - DescribePreloadTasksRequest
7473 //
7474 // @param runtime - runtime options for this request RuntimeOptions
7475 //
7476 // @return DescribePreloadTasksResponse
7477 func DescribePreloadTasksWithContext(ctx context.Context, client *Client, request *DescribePreloadTasksRequest, runtime *dara.RuntimeOptions) (_result *DescribePreloadTasksResponse, _err error) {
7478 if dara.BoolValue(client.EnableValidate) == true {
7479 _err = request.Validate()
7480 if _err != nil {
7481 return _result, _err
7482 }
7483 }
7484 query := openapiutil.Query(dara.ToMap(request))
7485 req := &openapiutil.OpenApiRequest{
7486 Query: openapiutil.Query(query),
7487 }
7488 params := &openapiutil.Params{
7489 Action: dara.String("DescribePreloadTasks"),
7490 Version: dara.String("2024-09-10"),
7491 Protocol: dara.String("HTTPS"),
7492 Pathname: dara.String("/"),
7493 Method: dara.String("GET"),
7494 AuthType: dara.String("AK"),
7495 Style: dara.String("RPC"),
7496 ReqBodyType: dara.String("formData"),
7497 BodyType: dara.String("json"),
7498 }
7499 _result = &DescribePreloadTasksResponse{}
7500 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7501 if _err != nil {
7502 return _result, _err
7503 }
7504 _err = dara.Convert(_body, &_result)
7505 return _result, _err
7506 }
7507
7508 // Summary:
7509 //
7510 // Queries the details of purge tasks.
7511 //
7512 // @param request - DescribePurgeTasksRequest
7513 //
7514 // @param runtime - runtime options for this request RuntimeOptions
7515 //
7516 // @return DescribePurgeTasksResponse
7517 func DescribePurgeTasksWithContext(ctx context.Context, client *Client, request *DescribePurgeTasksRequest, runtime *dara.RuntimeOptions) (_result *DescribePurgeTasksResponse, _err error) {
7518 if dara.BoolValue(client.EnableValidate) == true {
7519 _err = request.Validate()
7520 if _err != nil {
7521 return _result, _err
7522 }
7523 }
7524 query := openapiutil.Query(dara.ToMap(request))
7525 req := &openapiutil.OpenApiRequest{
7526 Query: openapiutil.Query(query),
7527 }
7528 params := &openapiutil.Params{
7529 Action: dara.String("DescribePurgeTasks"),
7530 Version: dara.String("2024-09-10"),
7531 Protocol: dara.String("HTTPS"),
7532 Pathname: dara.String("/"),
7533 Method: dara.String("GET"),
7534 AuthType: dara.String("AK"),
7535 Style: dara.String("RPC"),
7536 ReqBodyType: dara.String("formData"),
7537 BodyType: dara.String("json"),
7538 }
7539 _result = &DescribePurgeTasksResponse{}
7540 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7541 if _err != nil {
7542 return _result, _err
7543 }
7544 _err = dara.Convert(_body, &_result)
7545 return _result, _err
7546 }
7547
7548 // Summary:
7549 //
7550 // Queries the status of an instance that uses a plan.
7551 //
7552 // Description:
7553 //
7554 // You can query the status of an instance after you purchase a plan for the instance.
7555 //
7556 // @param request - DescribeRatePlanInstanceStatusRequest
7557 //
7558 // @param runtime - runtime options for this request RuntimeOptions
7559 //
7560 // @return DescribeRatePlanInstanceStatusResponse
7561 func DescribeRatePlanInstanceStatusWithContext(ctx context.Context, client *Client, request *DescribeRatePlanInstanceStatusRequest, runtime *dara.RuntimeOptions) (_result *DescribeRatePlanInstanceStatusResponse, _err error) {
7562 if dara.BoolValue(client.EnableValidate) == true {
7563 _err = request.Validate()
7564 if _err != nil {
7565 return _result, _err
7566 }
7567 }
7568 query := map[string]interface{}{}
7569 if !dara.IsNil(request.InstanceId) {
7570 query["InstanceId"] = request.InstanceId
7571 }
7572
7573 req := &openapiutil.OpenApiRequest{
7574 Query: openapiutil.Query(query),
7575 }
7576 params := &openapiutil.Params{
7577 Action: dara.String("DescribeRatePlanInstanceStatus"),
7578 Version: dara.String("2024-09-10"),
7579 Protocol: dara.String("HTTPS"),
7580 Pathname: dara.String("/"),
7581 Method: dara.String("POST"),
7582 AuthType: dara.String("AK"),
7583 Style: dara.String("RPC"),
7584 ReqBodyType: dara.String("formData"),
7585 BodyType: dara.String("json"),
7586 }
7587 _result = &DescribeRatePlanInstanceStatusResponse{}
7588 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7589 if _err != nil {
7590 return _result, _err
7591 }
7592 _err = dara.Convert(_body, &_result)
7593 return _result, _err
7594 }
7595
7596 // Summary:
7597 //
7598 // Queries the URLs from which you can download the raw access logs of a website.
7599 //
7600 // Description:
7601 //
7602 // If you do not specify StartTime or EndTime, the log data generated in the last 24 hours is queried. If you specify StartTime and EndTime, the log data generated within the specified time range is queried.
7603 //
7604 // - The log data is collected every hour.
7605 //
7606 // - You can call this operation up to 50 times per second per account.
7607 //
7608 // - You can query only logs in the last month. The time range cannot exceed 31 days.
7609 //
7610 // @param request - DescribeSiteLogsRequest
7611 //
7612 // @param runtime - runtime options for this request RuntimeOptions
7613 //
7614 // @return DescribeSiteLogsResponse
7615 func DescribeSiteLogsWithContext(ctx context.Context, client *Client, request *DescribeSiteLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribeSiteLogsResponse, _err error) {
7616 if dara.BoolValue(client.EnableValidate) == true {
7617 _err = request.Validate()
7618 if _err != nil {
7619 return _result, _err
7620 }
7621 }
7622 query := map[string]interface{}{}
7623 if !dara.IsNil(request.EndTime) {
7624 query["EndTime"] = request.EndTime
7625 }
7626
7627 if !dara.IsNil(request.PageNumber) {
7628 query["PageNumber"] = request.PageNumber
7629 }
7630
7631 if !dara.IsNil(request.PageSize) {
7632 query["PageSize"] = request.PageSize
7633 }
7634
7635 if !dara.IsNil(request.SiteId) {
7636 query["SiteId"] = request.SiteId
7637 }
7638
7639 if !dara.IsNil(request.StartTime) {
7640 query["StartTime"] = request.StartTime
7641 }
7642
7643 req := &openapiutil.OpenApiRequest{
7644 Query: openapiutil.Query(query),
7645 }
7646 params := &openapiutil.Params{
7647 Action: dara.String("DescribeSiteLogs"),
7648 Version: dara.String("2024-09-10"),
7649 Protocol: dara.String("HTTPS"),
7650 Pathname: dara.String("/"),
7651 Method: dara.String("POST"),
7652 AuthType: dara.String("AK"),
7653 Style: dara.String("RPC"),
7654 ReqBodyType: dara.String("formData"),
7655 BodyType: dara.String("json"),
7656 }
7657 _result = &DescribeSiteLogsResponse{}
7658 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7659 if _err != nil {
7660 return _result, _err
7661 }
7662 _err = dara.Convert(_body, &_result)
7663 return _result, _err
7664 }
7665
7666 // Summary:
7667 //
7668 // # Query traffic analysis time series data
7669 //
7670 // Description:
7671 //
7672 // - If you do not specify `StartTime` and `EndTime`, the API returns data for the past 24 hours; if you specify `StartTime` and `EndTime`, the API returns data for the specified time period.
7673 //
7674 // - The API returns different time granularities based on the span between `StartTime` and `EndTime`.
7675 //
7676 // - For a span of 3 hours or less, it returns 1-minute granularity data.
7677 //
7678 // - For a span greater than 3 hours but no more than 12 hours, it returns 5-minute granularity data.
7679 //
7680 // - For a span greater than 12 hours but no more than 1 day, it returns 15-minute granularity data.
7681 //
7682 // - For a span greater than 1 day but no more than 10 days, it returns hourly granularity data.
7683 //
7684 // - For a span greater than 10 days but no more than 31 days, it returns daily granularity data.
7685 //
7686 // - Due to the high number of accesses during the query period, the data analysis may be sampled.
7687 //
7688 // @param tmpReq - DescribeSiteTimeSeriesDataRequest
7689 //
7690 // @param runtime - runtime options for this request RuntimeOptions
7691 //
7692 // @return DescribeSiteTimeSeriesDataResponse
7693 func DescribeSiteTimeSeriesDataWithContext(ctx context.Context, client *Client, tmpReq *DescribeSiteTimeSeriesDataRequest, runtime *dara.RuntimeOptions) (_result *DescribeSiteTimeSeriesDataResponse, _err error) {
7694 if dara.BoolValue(client.EnableValidate) == true {
7695 _err = tmpReq.Validate()
7696 if _err != nil {
7697 return _result, _err
7698 }
7699 }
7700 request := &DescribeSiteTimeSeriesDataShrinkRequest{}
7701 openapiutil.Convert(tmpReq, request)
7702 if !dara.IsNil(tmpReq.Fields) {
7703 request.FieldsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Fields, dara.String("Fields"), dara.String("json"))
7704 }
7705
7706 query := map[string]interface{}{}
7707 if !dara.IsNil(request.EndTime) {
7708 query["EndTime"] = request.EndTime
7709 }
7710
7711 if !dara.IsNil(request.FieldsShrink) {
7712 query["Fields"] = request.FieldsShrink
7713 }
7714
7715 if !dara.IsNil(request.Interval) {
7716 query["Interval"] = request.Interval
7717 }
7718
7719 if !dara.IsNil(request.SiteId) {
7720 query["SiteId"] = request.SiteId
7721 }
7722
7723 if !dara.IsNil(request.StartTime) {
7724 query["StartTime"] = request.StartTime
7725 }
7726
7727 req := &openapiutil.OpenApiRequest{
7728 Query: openapiutil.Query(query),
7729 }
7730 params := &openapiutil.Params{
7731 Action: dara.String("DescribeSiteTimeSeriesData"),
7732 Version: dara.String("2024-09-10"),
7733 Protocol: dara.String("HTTPS"),
7734 Pathname: dara.String("/"),
7735 Method: dara.String("POST"),
7736 AuthType: dara.String("AK"),
7737 Style: dara.String("RPC"),
7738 ReqBodyType: dara.String("formData"),
7739 BodyType: dara.String("json"),
7740 }
7741 _result = &DescribeSiteTimeSeriesDataResponse{}
7742 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7743 if _err != nil {
7744 return _result, _err
7745 }
7746 _err = dara.Convert(_body, &_result)
7747 return _result, _err
7748 }
7749
7750 // Summary:
7751 //
7752 // Queries the top-ranking records in a traffic analytics report by website or Alibaba Cloud account.
7753 //
7754 // Description:
7755 //
7756 // If you do not specify the StartTime or EndTime parameter, the request returns the data collected in the previous 24 hours. If you specify both parameters, the request returns the data collected within the specified time range.
7757 //
7758 // @param tmpReq - DescribeSiteTopDataRequest
7759 //
7760 // @param runtime - runtime options for this request RuntimeOptions
7761 //
7762 // @return DescribeSiteTopDataResponse
7763 func DescribeSiteTopDataWithContext(ctx context.Context, client *Client, tmpReq *DescribeSiteTopDataRequest, runtime *dara.RuntimeOptions) (_result *DescribeSiteTopDataResponse, _err error) {
7764 if dara.BoolValue(client.EnableValidate) == true {
7765 _err = tmpReq.Validate()
7766 if _err != nil {
7767 return _result, _err
7768 }
7769 }
7770 request := &DescribeSiteTopDataShrinkRequest{}
7771 openapiutil.Convert(tmpReq, request)
7772 if !dara.IsNil(tmpReq.Fields) {
7773 request.FieldsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Fields, dara.String("Fields"), dara.String("json"))
7774 }
7775
7776 query := map[string]interface{}{}
7777 if !dara.IsNil(request.EndTime) {
7778 query["EndTime"] = request.EndTime
7779 }
7780
7781 if !dara.IsNil(request.FieldsShrink) {
7782 query["Fields"] = request.FieldsShrink
7783 }
7784
7785 if !dara.IsNil(request.Interval) {
7786 query["Interval"] = request.Interval
7787 }
7788
7789 if !dara.IsNil(request.Limit) {
7790 query["Limit"] = request.Limit
7791 }
7792
7793 if !dara.IsNil(request.SiteId) {
7794 query["SiteId"] = request.SiteId
7795 }
7796
7797 if !dara.IsNil(request.StartTime) {
7798 query["StartTime"] = request.StartTime
7799 }
7800
7801 req := &openapiutil.OpenApiRequest{
7802 Query: openapiutil.Query(query),
7803 }
7804 params := &openapiutil.Params{
7805 Action: dara.String("DescribeSiteTopData"),
7806 Version: dara.String("2024-09-10"),
7807 Protocol: dara.String("HTTPS"),
7808 Pathname: dara.String("/"),
7809 Method: dara.String("POST"),
7810 AuthType: dara.String("AK"),
7811 Style: dara.String("RPC"),
7812 ReqBodyType: dara.String("formData"),
7813 BodyType: dara.String("json"),
7814 }
7815 _result = &DescribeSiteTopDataResponse{}
7816 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7817 if _err != nil {
7818 return _result, _err
7819 }
7820 _err = dara.Convert(_body, &_result)
7821 return _result, _err
7822 }
7823
7824 // Summary:
7825 //
7826 // Queries the page monitoring data.
7827 //
7828 // Description:
7829 //
7830 // If you do not specify the StartTime or EndTime parameter, this operation returns the data collected within the last 24 hours. If you specify both parameters, this operation returns the data collected within the specified time range.
7831 //
7832 // @param request - DescribeUrlObservationDataRequest
7833 //
7834 // @param runtime - runtime options for this request RuntimeOptions
7835 //
7836 // @return DescribeUrlObservationDataResponse
7837 func DescribeUrlObservationDataWithContext(ctx context.Context, client *Client, request *DescribeUrlObservationDataRequest, runtime *dara.RuntimeOptions) (_result *DescribeUrlObservationDataResponse, _err error) {
7838 if dara.BoolValue(client.EnableValidate) == true {
7839 _err = request.Validate()
7840 if _err != nil {
7841 return _result, _err
7842 }
7843 }
7844 query := map[string]interface{}{}
7845 if !dara.IsNil(request.ClientPlatform) {
7846 query["ClientPlatform"] = request.ClientPlatform
7847 }
7848
7849 if !dara.IsNil(request.EndTime) {
7850 query["EndTime"] = request.EndTime
7851 }
7852
7853 if !dara.IsNil(request.Metric) {
7854 query["Metric"] = request.Metric
7855 }
7856
7857 if !dara.IsNil(request.SiteId) {
7858 query["SiteId"] = request.SiteId
7859 }
7860
7861 if !dara.IsNil(request.StartTime) {
7862 query["StartTime"] = request.StartTime
7863 }
7864
7865 if !dara.IsNil(request.Url) {
7866 query["Url"] = request.Url
7867 }
7868
7869 req := &openapiutil.OpenApiRequest{
7870 Query: openapiutil.Query(query),
7871 }
7872 params := &openapiutil.Params{
7873 Action: dara.String("DescribeUrlObservationData"),
7874 Version: dara.String("2024-09-10"),
7875 Protocol: dara.String("HTTPS"),
7876 Pathname: dara.String("/"),
7877 Method: dara.String("POST"),
7878 AuthType: dara.String("AK"),
7879 Style: dara.String("RPC"),
7880 ReqBodyType: dara.String("formData"),
7881 BodyType: dara.String("json"),
7882 }
7883 _result = &DescribeUrlObservationDataResponse{}
7884 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7885 if _err != nil {
7886 return _result, _err
7887 }
7888 _err = dara.Convert(_body, &_result)
7889 return _result, _err
7890 }
7891
7892 // Summary:
7893 //
7894 // Disables a scenario-specific policy.
7895 //
7896 // @param request - DisableCustomScenePolicyRequest
7897 //
7898 // @param runtime - runtime options for this request RuntimeOptions
7899 //
7900 // @return DisableCustomScenePolicyResponse
7901 func DisableCustomScenePolicyWithContext(ctx context.Context, client *Client, request *DisableCustomScenePolicyRequest, runtime *dara.RuntimeOptions) (_result *DisableCustomScenePolicyResponse, _err error) {
7902 if dara.BoolValue(client.EnableValidate) == true {
7903 _err = request.Validate()
7904 if _err != nil {
7905 return _result, _err
7906 }
7907 }
7908 query := map[string]interface{}{}
7909 if !dara.IsNil(request.PolicyId) {
7910 query["PolicyId"] = request.PolicyId
7911 }
7912
7913 req := &openapiutil.OpenApiRequest{
7914 Query: openapiutil.Query(query),
7915 }
7916 params := &openapiutil.Params{
7917 Action: dara.String("DisableCustomScenePolicy"),
7918 Version: dara.String("2024-09-10"),
7919 Protocol: dara.String("HTTPS"),
7920 Pathname: dara.String("/"),
7921 Method: dara.String("POST"),
7922 AuthType: dara.String("AK"),
7923 Style: dara.String("RPC"),
7924 ReqBodyType: dara.String("formData"),
7925 BodyType: dara.String("json"),
7926 }
7927 _result = &DisableCustomScenePolicyResponse{}
7928 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7929 if _err != nil {
7930 return _result, _err
7931 }
7932 _err = dara.Convert(_body, &_result)
7933 return _result, _err
7934 }
7935
7936 // Summary:
7937 //
7938 // # Edit WAF Configuration for a Site
7939 //
7940 // @param tmpReq - EditSiteWafSettingsRequest
7941 //
7942 // @param runtime - runtime options for this request RuntimeOptions
7943 //
7944 // @return EditSiteWafSettingsResponse
7945 func EditSiteWafSettingsWithContext(ctx context.Context, client *Client, tmpReq *EditSiteWafSettingsRequest, runtime *dara.RuntimeOptions) (_result *EditSiteWafSettingsResponse, _err error) {
7946 if dara.BoolValue(client.EnableValidate) == true {
7947 _err = tmpReq.Validate()
7948 if _err != nil {
7949 return _result, _err
7950 }
7951 }
7952 request := &EditSiteWafSettingsShrinkRequest{}
7953 openapiutil.Convert(tmpReq, request)
7954 if !dara.IsNil(tmpReq.Settings) {
7955 request.SettingsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Settings, dara.String("Settings"), dara.String("json"))
7956 }
7957
7958 query := map[string]interface{}{}
7959 if !dara.IsNil(request.SiteId) {
7960 query["SiteId"] = request.SiteId
7961 }
7962
7963 if !dara.IsNil(request.SiteVersion) {
7964 query["SiteVersion"] = request.SiteVersion
7965 }
7966
7967 body := map[string]interface{}{}
7968 if !dara.IsNil(request.SettingsShrink) {
7969 body["Settings"] = request.SettingsShrink
7970 }
7971
7972 req := &openapiutil.OpenApiRequest{
7973 Query: openapiutil.Query(query),
7974 Body: openapiutil.ParseToMap(body),
7975 }
7976 params := &openapiutil.Params{
7977 Action: dara.String("EditSiteWafSettings"),
7978 Version: dara.String("2024-09-10"),
7979 Protocol: dara.String("HTTPS"),
7980 Pathname: dara.String("/"),
7981 Method: dara.String("POST"),
7982 AuthType: dara.String("AK"),
7983 Style: dara.String("RPC"),
7984 ReqBodyType: dara.String("formData"),
7985 BodyType: dara.String("json"),
7986 }
7987 _result = &EditSiteWafSettingsResponse{}
7988 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
7989 if _err != nil {
7990 return _result, _err
7991 }
7992 _err = dara.Convert(_body, &_result)
7993 return _result, _err
7994 }
7995
7996 // Summary:
7997 //
7998 // Enables a scenario-specific policy.
7999 //
8000 // @param request - EnableCustomScenePolicyRequest
8001 //
8002 // @param runtime - runtime options for this request RuntimeOptions
8003 //
8004 // @return EnableCustomScenePolicyResponse
8005 func EnableCustomScenePolicyWithContext(ctx context.Context, client *Client, request *EnableCustomScenePolicyRequest, runtime *dara.RuntimeOptions) (_result *EnableCustomScenePolicyResponse, _err error) {
8006 if dara.BoolValue(client.EnableValidate) == true {
8007 _err = request.Validate()
8008 if _err != nil {
8009 return _result, _err
8010 }
8011 }
8012 query := map[string]interface{}{}
8013 if !dara.IsNil(request.PolicyId) {
8014 query["PolicyId"] = request.PolicyId
8015 }
8016
8017 req := &openapiutil.OpenApiRequest{
8018 Query: openapiutil.Query(query),
8019 }
8020 params := &openapiutil.Params{
8021 Action: dara.String("EnableCustomScenePolicy"),
8022 Version: dara.String("2024-09-10"),
8023 Protocol: dara.String("HTTPS"),
8024 Pathname: dara.String("/"),
8025 Method: dara.String("POST"),
8026 AuthType: dara.String("AK"),
8027 Style: dara.String("RPC"),
8028 ReqBodyType: dara.String("formData"),
8029 BodyType: dara.String("json"),
8030 }
8031 _result = &EnableCustomScenePolicyResponse{}
8032 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8033 if _err != nil {
8034 return _result, _err
8035 }
8036 _err = dara.Convert(_body, &_result)
8037 return _result, _err
8038 }
8039
8040 // Summary:
8041 //
8042 // Exports all DNS records of a website domain as a TXT file.
8043 //
8044 // @param request - ExportRecordsRequest
8045 //
8046 // @param runtime - runtime options for this request RuntimeOptions
8047 //
8048 // @return ExportRecordsResponse
8049 func ExportRecordsWithContext(ctx context.Context, client *Client, request *ExportRecordsRequest, runtime *dara.RuntimeOptions) (_result *ExportRecordsResponse, _err error) {
8050 if dara.BoolValue(client.EnableValidate) == true {
8051 _err = request.Validate()
8052 if _err != nil {
8053 return _result, _err
8054 }
8055 }
8056 query := openapiutil.Query(dara.ToMap(request))
8057 req := &openapiutil.OpenApiRequest{
8058 Query: openapiutil.Query(query),
8059 }
8060 params := &openapiutil.Params{
8061 Action: dara.String("ExportRecords"),
8062 Version: dara.String("2024-09-10"),
8063 Protocol: dara.String("HTTPS"),
8064 Pathname: dara.String("/"),
8065 Method: dara.String("GET"),
8066 AuthType: dara.String("AK"),
8067 Style: dara.String("RPC"),
8068 ReqBodyType: dara.String("formData"),
8069 BodyType: dara.String("json"),
8070 }
8071 _result = &ExportRecordsResponse{}
8072 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8073 if _err != nil {
8074 return _result, _err
8075 }
8076 _err = dara.Convert(_body, &_result)
8077 return _result, _err
8078 }
8079
8080 // Summary:
8081 //
8082 // Queries the usage of the upload file quota for API security schema verification.
8083 //
8084 // @param request - GetApiSchemaUsageRequest
8085 //
8086 // @param runtime - runtime options for this request RuntimeOptions
8087 //
8088 // @return GetApiSchemaUsageResponse
8089 func GetApiSchemaUsageWithContext(ctx context.Context, client *Client, request *GetApiSchemaUsageRequest, runtime *dara.RuntimeOptions) (_result *GetApiSchemaUsageResponse, _err error) {
8090 if dara.BoolValue(client.EnableValidate) == true {
8091 _err = request.Validate()
8092 if _err != nil {
8093 return _result, _err
8094 }
8095 }
8096 query := map[string]interface{}{}
8097 if !dara.IsNil(request.SiteId) {
8098 query["SiteId"] = request.SiteId
8099 }
8100
8101 if !dara.IsNil(request.SiteVersion) {
8102 query["SiteVersion"] = request.SiteVersion
8103 }
8104
8105 req := &openapiutil.OpenApiRequest{
8106 Query: openapiutil.Query(query),
8107 }
8108 params := &openapiutil.Params{
8109 Action: dara.String("GetApiSchemaUsage"),
8110 Version: dara.String("2024-09-10"),
8111 Protocol: dara.String("HTTPS"),
8112 Pathname: dara.String("/"),
8113 Method: dara.String("POST"),
8114 AuthType: dara.String("AK"),
8115 Style: dara.String("RPC"),
8116 ReqBodyType: dara.String("formData"),
8117 BodyType: dara.String("json"),
8118 }
8119 _result = &GetApiSchemaUsageResponse{}
8120 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8121 if _err != nil {
8122 return _result, _err
8123 }
8124 _err = dara.Convert(_body, &_result)
8125 return _result, _err
8126 }
8127
8128 // Summary:
8129 //
8130 // # Query a single cache configuration
8131 //
8132 // @param request - GetCacheRuleRequest
8133 //
8134 // @param runtime - runtime options for this request RuntimeOptions
8135 //
8136 // @return GetCacheRuleResponse
8137 func GetCacheRuleWithContext(ctx context.Context, client *Client, request *GetCacheRuleRequest, runtime *dara.RuntimeOptions) (_result *GetCacheRuleResponse, _err error) {
8138 if dara.BoolValue(client.EnableValidate) == true {
8139 _err = request.Validate()
8140 if _err != nil {
8141 return _result, _err
8142 }
8143 }
8144 query := openapiutil.Query(dara.ToMap(request))
8145 req := &openapiutil.OpenApiRequest{
8146 Query: openapiutil.Query(query),
8147 }
8148 params := &openapiutil.Params{
8149 Action: dara.String("GetCacheRule"),
8150 Version: dara.String("2024-09-10"),
8151 Protocol: dara.String("HTTPS"),
8152 Pathname: dara.String("/"),
8153 Method: dara.String("GET"),
8154 AuthType: dara.String("AK"),
8155 Style: dara.String("RPC"),
8156 ReqBodyType: dara.String("formData"),
8157 BodyType: dara.String("json"),
8158 }
8159 _result = &GetCacheRuleResponse{}
8160 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8161 if _err != nil {
8162 return _result, _err
8163 }
8164 _err = dara.Convert(_body, &_result)
8165 return _result, _err
8166 }
8167
8168 // Summary:
8169 //
8170 // # Query Site Cache Tag Configuration
8171 //
8172 // @param request - GetCacheTagRequest
8173 //
8174 // @param runtime - runtime options for this request RuntimeOptions
8175 //
8176 // @return GetCacheTagResponse
8177 func GetCacheTagWithContext(ctx context.Context, client *Client, request *GetCacheTagRequest, runtime *dara.RuntimeOptions) (_result *GetCacheTagResponse, _err error) {
8178 if dara.BoolValue(client.EnableValidate) == true {
8179 _err = request.Validate()
8180 if _err != nil {
8181 return _result, _err
8182 }
8183 }
8184 query := openapiutil.Query(dara.ToMap(request))
8185 req := &openapiutil.OpenApiRequest{
8186 Query: openapiutil.Query(query),
8187 }
8188 params := &openapiutil.Params{
8189 Action: dara.String("GetCacheTag"),
8190 Version: dara.String("2024-09-10"),
8191 Protocol: dara.String("HTTPS"),
8192 Pathname: dara.String("/"),
8193 Method: dara.String("GET"),
8194 AuthType: dara.String("AK"),
8195 Style: dara.String("RPC"),
8196 ReqBodyType: dara.String("formData"),
8197 BodyType: dara.String("json"),
8198 }
8199 _result = &GetCacheTagResponse{}
8200 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8201 if _err != nil {
8202 return _result, _err
8203 }
8204 _err = dara.Convert(_body, &_result)
8205 return _result, _err
8206 }
8207
8208 // Summary:
8209 //
8210 // # Retrieve the certificate, private key, and certificate information
8211 //
8212 // @param request - GetCertificateRequest
8213 //
8214 // @param runtime - runtime options for this request RuntimeOptions
8215 //
8216 // @return GetCertificateResponse
8217 func GetCertificateWithContext(ctx context.Context, client *Client, request *GetCertificateRequest, runtime *dara.RuntimeOptions) (_result *GetCertificateResponse, _err error) {
8218 if dara.BoolValue(client.EnableValidate) == true {
8219 _err = request.Validate()
8220 if _err != nil {
8221 return _result, _err
8222 }
8223 }
8224 query := openapiutil.Query(dara.ToMap(request))
8225 req := &openapiutil.OpenApiRequest{
8226 Query: openapiutil.Query(query),
8227 }
8228 params := &openapiutil.Params{
8229 Action: dara.String("GetCertificate"),
8230 Version: dara.String("2024-09-10"),
8231 Protocol: dara.String("HTTPS"),
8232 Pathname: dara.String("/"),
8233 Method: dara.String("GET"),
8234 AuthType: dara.String("AK"),
8235 Style: dara.String("RPC"),
8236 ReqBodyType: dara.String("formData"),
8237 BodyType: dara.String("json"),
8238 }
8239 _result = &GetCertificateResponse{}
8240 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8241 if _err != nil {
8242 return _result, _err
8243 }
8244 _err = dara.Convert(_body, &_result)
8245 return _result, _err
8246 }
8247
8248 // Summary:
8249 //
8250 // # Query certificate quota and usage
8251 //
8252 // @param request - GetCertificateQuotaRequest
8253 //
8254 // @param runtime - runtime options for this request RuntimeOptions
8255 //
8256 // @return GetCertificateQuotaResponse
8257 func GetCertificateQuotaWithContext(ctx context.Context, client *Client, request *GetCertificateQuotaRequest, runtime *dara.RuntimeOptions) (_result *GetCertificateQuotaResponse, _err error) {
8258 if dara.BoolValue(client.EnableValidate) == true {
8259 _err = request.Validate()
8260 if _err != nil {
8261 return _result, _err
8262 }
8263 }
8264 query := openapiutil.Query(dara.ToMap(request))
8265 req := &openapiutil.OpenApiRequest{
8266 Query: openapiutil.Query(query),
8267 }
8268 params := &openapiutil.Params{
8269 Action: dara.String("GetCertificateQuota"),
8270 Version: dara.String("2024-09-10"),
8271 Protocol: dara.String("HTTPS"),
8272 Pathname: dara.String("/"),
8273 Method: dara.String("GET"),
8274 AuthType: dara.String("AK"),
8275 Style: dara.String("RPC"),
8276 ReqBodyType: dara.String("formData"),
8277 BodyType: dara.String("json"),
8278 }
8279 _result = &GetCertificateQuotaResponse{}
8280 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8281 if _err != nil {
8282 return _result, _err
8283 }
8284 _err = dara.Convert(_body, &_result)
8285 return _result, _err
8286 }
8287
8288 // Summary:
8289 //
8290 // Queries a client CA certificate.
8291 //
8292 // @param request - GetClientCaCertificateRequest
8293 //
8294 // @param runtime - runtime options for this request RuntimeOptions
8295 //
8296 // @return GetClientCaCertificateResponse
8297 func GetClientCaCertificateWithContext(ctx context.Context, client *Client, request *GetClientCaCertificateRequest, runtime *dara.RuntimeOptions) (_result *GetClientCaCertificateResponse, _err error) {
8298 if dara.BoolValue(client.EnableValidate) == true {
8299 _err = request.Validate()
8300 if _err != nil {
8301 return _result, _err
8302 }
8303 }
8304 query := openapiutil.Query(dara.ToMap(request))
8305 req := &openapiutil.OpenApiRequest{
8306 Query: openapiutil.Query(query),
8307 }
8308 params := &openapiutil.Params{
8309 Action: dara.String("GetClientCaCertificate"),
8310 Version: dara.String("2024-09-10"),
8311 Protocol: dara.String("HTTPS"),
8312 Pathname: dara.String("/"),
8313 Method: dara.String("GET"),
8314 AuthType: dara.String("AK"),
8315 Style: dara.String("RPC"),
8316 ReqBodyType: dara.String("formData"),
8317 BodyType: dara.String("json"),
8318 }
8319 _result = &GetClientCaCertificateResponse{}
8320 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8321 if _err != nil {
8322 return _result, _err
8323 }
8324 _err = dara.Convert(_body, &_result)
8325 return _result, _err
8326 }
8327
8328 // Summary:
8329 //
8330 // Queries information about a client certificate.
8331 //
8332 // @param request - GetClientCertificateRequest
8333 //
8334 // @param runtime - runtime options for this request RuntimeOptions
8335 //
8336 // @return GetClientCertificateResponse
8337 func GetClientCertificateWithContext(ctx context.Context, client *Client, request *GetClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *GetClientCertificateResponse, _err error) {
8338 if dara.BoolValue(client.EnableValidate) == true {
8339 _err = request.Validate()
8340 if _err != nil {
8341 return _result, _err
8342 }
8343 }
8344 query := openapiutil.Query(dara.ToMap(request))
8345 req := &openapiutil.OpenApiRequest{
8346 Query: openapiutil.Query(query),
8347 }
8348 params := &openapiutil.Params{
8349 Action: dara.String("GetClientCertificate"),
8350 Version: dara.String("2024-09-10"),
8351 Protocol: dara.String("HTTPS"),
8352 Pathname: dara.String("/"),
8353 Method: dara.String("GET"),
8354 AuthType: dara.String("AK"),
8355 Style: dara.String("RPC"),
8356 ReqBodyType: dara.String("formData"),
8357 BodyType: dara.String("json"),
8358 }
8359 _result = &GetClientCertificateResponse{}
8360 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8361 if _err != nil {
8362 return _result, _err
8363 }
8364 _err = dara.Convert(_body, &_result)
8365 return _result, _err
8366 }
8367
8368 // Summary:
8369 //
8370 // Queries domain names associated with a client CA certificate. If no certificate is specified, domain names associated with an Edge Security Acceleration(ESA)-managed CA certificate are returned.
8371 //
8372 // @param request - GetClientCertificateHostnamesRequest
8373 //
8374 // @param runtime - runtime options for this request RuntimeOptions
8375 //
8376 // @return GetClientCertificateHostnamesResponse
8377 func GetClientCertificateHostnamesWithContext(ctx context.Context, client *Client, request *GetClientCertificateHostnamesRequest, runtime *dara.RuntimeOptions) (_result *GetClientCertificateHostnamesResponse, _err error) {
8378 if dara.BoolValue(client.EnableValidate) == true {
8379 _err = request.Validate()
8380 if _err != nil {
8381 return _result, _err
8382 }
8383 }
8384 query := openapiutil.Query(dara.ToMap(request))
8385 req := &openapiutil.OpenApiRequest{
8386 Query: openapiutil.Query(query),
8387 }
8388 params := &openapiutil.Params{
8389 Action: dara.String("GetClientCertificateHostnames"),
8390 Version: dara.String("2024-09-10"),
8391 Protocol: dara.String("HTTPS"),
8392 Pathname: dara.String("/"),
8393 Method: dara.String("GET"),
8394 AuthType: dara.String("AK"),
8395 Style: dara.String("RPC"),
8396 ReqBodyType: dara.String("formData"),
8397 BodyType: dara.String("json"),
8398 }
8399 _result = &GetClientCertificateHostnamesResponse{}
8400 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8401 if _err != nil {
8402 return _result, _err
8403 }
8404 _err = dara.Convert(_body, &_result)
8405 return _result, _err
8406 }
8407
8408 // Summary:
8409 //
8410 // # Queries the CNAME flattening configuration of a website
8411 //
8412 // @param request - GetCnameFlatteningRequest
8413 //
8414 // @param runtime - runtime options for this request RuntimeOptions
8415 //
8416 // @return GetCnameFlatteningResponse
8417 func GetCnameFlatteningWithContext(ctx context.Context, client *Client, request *GetCnameFlatteningRequest, runtime *dara.RuntimeOptions) (_result *GetCnameFlatteningResponse, _err error) {
8418 if dara.BoolValue(client.EnableValidate) == true {
8419 _err = request.Validate()
8420 if _err != nil {
8421 return _result, _err
8422 }
8423 }
8424 query := openapiutil.Query(dara.ToMap(request))
8425 req := &openapiutil.OpenApiRequest{
8426 Query: openapiutil.Query(query),
8427 }
8428 params := &openapiutil.Params{
8429 Action: dara.String("GetCnameFlattening"),
8430 Version: dara.String("2024-09-10"),
8431 Protocol: dara.String("HTTPS"),
8432 Pathname: dara.String("/"),
8433 Method: dara.String("GET"),
8434 AuthType: dara.String("AK"),
8435 Style: dara.String("RPC"),
8436 ReqBodyType: dara.String("formData"),
8437 BodyType: dara.String("json"),
8438 }
8439 _result = &GetCnameFlatteningResponse{}
8440 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8441 if _err != nil {
8442 return _result, _err
8443 }
8444 _err = dara.Convert(_body, &_result)
8445 return _result, _err
8446 }
8447
8448 // Summary:
8449 //
8450 // # Query Compression Rule Details
8451 //
8452 // @param request - GetCompressionRuleRequest
8453 //
8454 // @param runtime - runtime options for this request RuntimeOptions
8455 //
8456 // @return GetCompressionRuleResponse
8457 func GetCompressionRuleWithContext(ctx context.Context, client *Client, request *GetCompressionRuleRequest, runtime *dara.RuntimeOptions) (_result *GetCompressionRuleResponse, _err error) {
8458 if dara.BoolValue(client.EnableValidate) == true {
8459 _err = request.Validate()
8460 if _err != nil {
8461 return _result, _err
8462 }
8463 }
8464 query := openapiutil.Query(dara.ToMap(request))
8465 req := &openapiutil.OpenApiRequest{
8466 Query: openapiutil.Query(query),
8467 }
8468 params := &openapiutil.Params{
8469 Action: dara.String("GetCompressionRule"),
8470 Version: dara.String("2024-09-10"),
8471 Protocol: dara.String("HTTPS"),
8472 Pathname: dara.String("/"),
8473 Method: dara.String("GET"),
8474 AuthType: dara.String("AK"),
8475 Style: dara.String("RPC"),
8476 ReqBodyType: dara.String("formData"),
8477 BodyType: dara.String("json"),
8478 }
8479 _result = &GetCompressionRuleResponse{}
8480 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8481 if _err != nil {
8482 return _result, _err
8483 }
8484 _err = dara.Convert(_body, &_result)
8485 return _result, _err
8486 }
8487
8488 // Summary:
8489 //
8490 // Queries the configuration of Chinese mainland access optimization.
8491 //
8492 // @param request - GetCrossBorderOptimizationRequest
8493 //
8494 // @param runtime - runtime options for this request RuntimeOptions
8495 //
8496 // @return GetCrossBorderOptimizationResponse
8497 func GetCrossBorderOptimizationWithContext(ctx context.Context, client *Client, request *GetCrossBorderOptimizationRequest, runtime *dara.RuntimeOptions) (_result *GetCrossBorderOptimizationResponse, _err error) {
8498 if dara.BoolValue(client.EnableValidate) == true {
8499 _err = request.Validate()
8500 if _err != nil {
8501 return _result, _err
8502 }
8503 }
8504 query := openapiutil.Query(dara.ToMap(request))
8505 req := &openapiutil.OpenApiRequest{
8506 Query: openapiutil.Query(query),
8507 }
8508 params := &openapiutil.Params{
8509 Action: dara.String("GetCrossBorderOptimization"),
8510 Version: dara.String("2024-09-10"),
8511 Protocol: dara.String("HTTPS"),
8512 Pathname: dara.String("/"),
8513 Method: dara.String("GET"),
8514 AuthType: dara.String("AK"),
8515 Style: dara.String("RPC"),
8516 ReqBodyType: dara.String("formData"),
8517 BodyType: dara.String("json"),
8518 }
8519 _result = &GetCrossBorderOptimizationResponse{}
8520 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8521 if _err != nil {
8522 return _result, _err
8523 }
8524 _err = dara.Convert(_body, &_result)
8525 return _result, _err
8526 }
8527
8528 // Summary:
8529 //
8530 // # Query Site Developer Mode Configuration
8531 //
8532 // @param request - GetDevelopmentModeRequest
8533 //
8534 // @param runtime - runtime options for this request RuntimeOptions
8535 //
8536 // @return GetDevelopmentModeResponse
8537 func GetDevelopmentModeWithContext(ctx context.Context, client *Client, request *GetDevelopmentModeRequest, runtime *dara.RuntimeOptions) (_result *GetDevelopmentModeResponse, _err error) {
8538 if dara.BoolValue(client.EnableValidate) == true {
8539 _err = request.Validate()
8540 if _err != nil {
8541 return _result, _err
8542 }
8543 }
8544 query := openapiutil.Query(dara.ToMap(request))
8545 req := &openapiutil.OpenApiRequest{
8546 Query: openapiutil.Query(query),
8547 }
8548 params := &openapiutil.Params{
8549 Action: dara.String("GetDevelopmentMode"),
8550 Version: dara.String("2024-09-10"),
8551 Protocol: dara.String("HTTPS"),
8552 Pathname: dara.String("/"),
8553 Method: dara.String("GET"),
8554 AuthType: dara.String("AK"),
8555 Style: dara.String("RPC"),
8556 ReqBodyType: dara.String("formData"),
8557 BodyType: dara.String("json"),
8558 }
8559 _result = &GetDevelopmentModeResponse{}
8560 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8561 if _err != nil {
8562 return _result, _err
8563 }
8564 _err = dara.Convert(_body, &_result)
8565 return _result, _err
8566 }
8567
8568 // Summary:
8569 //
8570 // Queries the information about a containerized application, including basic application configurations and health check configurations.
8571 //
8572 // @param request - GetEdgeContainerAppRequest
8573 //
8574 // @param runtime - runtime options for this request RuntimeOptions
8575 //
8576 // @return GetEdgeContainerAppResponse
8577 func GetEdgeContainerAppWithContext(ctx context.Context, client *Client, request *GetEdgeContainerAppRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppResponse, _err error) {
8578 if dara.BoolValue(client.EnableValidate) == true {
8579 _err = request.Validate()
8580 if _err != nil {
8581 return _result, _err
8582 }
8583 }
8584 query := map[string]interface{}{}
8585 if !dara.IsNil(request.AppId) {
8586 query["AppId"] = request.AppId
8587 }
8588
8589 req := &openapiutil.OpenApiRequest{
8590 Query: openapiutil.Query(query),
8591 }
8592 params := &openapiutil.Params{
8593 Action: dara.String("GetEdgeContainerApp"),
8594 Version: dara.String("2024-09-10"),
8595 Protocol: dara.String("HTTPS"),
8596 Pathname: dara.String("/"),
8597 Method: dara.String("POST"),
8598 AuthType: dara.String("AK"),
8599 Style: dara.String("RPC"),
8600 ReqBodyType: dara.String("formData"),
8601 BodyType: dara.String("json"),
8602 }
8603 _result = &GetEdgeContainerAppResponse{}
8604 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8605 if _err != nil {
8606 return _result, _err
8607 }
8608 _err = dara.Convert(_body, &_result)
8609 return _result, _err
8610 }
8611
8612 // Summary:
8613 //
8614 // Queries the log collection configuration of a containerized application.
8615 //
8616 // @param request - GetEdgeContainerAppLogRiverRequest
8617 //
8618 // @param runtime - runtime options for this request RuntimeOptions
8619 //
8620 // @return GetEdgeContainerAppLogRiverResponse
8621 func GetEdgeContainerAppLogRiverWithContext(ctx context.Context, client *Client, request *GetEdgeContainerAppLogRiverRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppLogRiverResponse, _err error) {
8622 if dara.BoolValue(client.EnableValidate) == true {
8623 _err = request.Validate()
8624 if _err != nil {
8625 return _result, _err
8626 }
8627 }
8628 query := openapiutil.Query(dara.ToMap(request))
8629 req := &openapiutil.OpenApiRequest{
8630 Query: openapiutil.Query(query),
8631 }
8632 params := &openapiutil.Params{
8633 Action: dara.String("GetEdgeContainerAppLogRiver"),
8634 Version: dara.String("2024-09-10"),
8635 Protocol: dara.String("HTTPS"),
8636 Pathname: dara.String("/"),
8637 Method: dara.String("GET"),
8638 AuthType: dara.String("AK"),
8639 Style: dara.String("RPC"),
8640 ReqBodyType: dara.String("formData"),
8641 BodyType: dara.String("json"),
8642 }
8643 _result = &GetEdgeContainerAppLogRiverResponse{}
8644 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8645 if _err != nil {
8646 return _result, _err
8647 }
8648 _err = dara.Convert(_body, &_result)
8649 return _result, _err
8650 }
8651
8652 // Summary:
8653 //
8654 // 获取边缘容器应用的资源容量
8655 //
8656 // @param request - GetEdgeContainerAppResourceCapacityRequest
8657 //
8658 // @param runtime - runtime options for this request RuntimeOptions
8659 //
8660 // @return GetEdgeContainerAppResourceCapacityResponse
8661 func GetEdgeContainerAppResourceCapacityWithContext(ctx context.Context, client *Client, request *GetEdgeContainerAppResourceCapacityRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppResourceCapacityResponse, _err error) {
8662 if dara.BoolValue(client.EnableValidate) == true {
8663 _err = request.Validate()
8664 if _err != nil {
8665 return _result, _err
8666 }
8667 }
8668 query := map[string]interface{}{}
8669 if !dara.IsNil(request.AppId) {
8670 query["AppId"] = request.AppId
8671 }
8672
8673 req := &openapiutil.OpenApiRequest{
8674 Query: openapiutil.Query(query),
8675 }
8676 params := &openapiutil.Params{
8677 Action: dara.String("GetEdgeContainerAppResourceCapacity"),
8678 Version: dara.String("2024-09-10"),
8679 Protocol: dara.String("HTTPS"),
8680 Pathname: dara.String("/"),
8681 Method: dara.String("POST"),
8682 AuthType: dara.String("AK"),
8683 Style: dara.String("RPC"),
8684 ReqBodyType: dara.String("formData"),
8685 BodyType: dara.String("json"),
8686 }
8687 _result = &GetEdgeContainerAppResourceCapacityResponse{}
8688 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8689 if _err != nil {
8690 return _result, _err
8691 }
8692 _err = dara.Convert(_body, &_result)
8693 return _result, _err
8694 }
8695
8696 // Summary:
8697 //
8698 // Obtain the resource reservation configuration of the edge container.
8699 //
8700 // @param request - GetEdgeContainerAppResourceReserveRequest
8701 //
8702 // @param runtime - runtime options for this request RuntimeOptions
8703 //
8704 // @return GetEdgeContainerAppResourceReserveResponse
8705 func GetEdgeContainerAppResourceReserveWithContext(ctx context.Context, client *Client, request *GetEdgeContainerAppResourceReserveRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppResourceReserveResponse, _err error) {
8706 if dara.BoolValue(client.EnableValidate) == true {
8707 _err = request.Validate()
8708 if _err != nil {
8709 return _result, _err
8710 }
8711 }
8712 query := map[string]interface{}{}
8713 if !dara.IsNil(request.AppId) {
8714 query["AppId"] = request.AppId
8715 }
8716
8717 req := &openapiutil.OpenApiRequest{
8718 Query: openapiutil.Query(query),
8719 }
8720 params := &openapiutil.Params{
8721 Action: dara.String("GetEdgeContainerAppResourceReserve"),
8722 Version: dara.String("2024-09-10"),
8723 Protocol: dara.String("HTTPS"),
8724 Pathname: dara.String("/"),
8725 Method: dara.String("POST"),
8726 AuthType: dara.String("AK"),
8727 Style: dara.String("RPC"),
8728 ReqBodyType: dara.String("formData"),
8729 BodyType: dara.String("json"),
8730 }
8731 _result = &GetEdgeContainerAppResourceReserveResponse{}
8732 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8733 if _err != nil {
8734 return _result, _err
8735 }
8736 _err = dara.Convert(_body, &_result)
8737 return _result, _err
8738 }
8739
8740 // Summary:
8741 //
8742 // Obtains the distribution of edge container application resources.
8743 //
8744 // @param request - GetEdgeContainerAppResourceStatusRequest
8745 //
8746 // @param runtime - runtime options for this request RuntimeOptions
8747 //
8748 // @return GetEdgeContainerAppResourceStatusResponse
8749 func GetEdgeContainerAppResourceStatusWithContext(ctx context.Context, client *Client, request *GetEdgeContainerAppResourceStatusRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppResourceStatusResponse, _err error) {
8750 if dara.BoolValue(client.EnableValidate) == true {
8751 _err = request.Validate()
8752 if _err != nil {
8753 return _result, _err
8754 }
8755 }
8756 query := map[string]interface{}{}
8757 if !dara.IsNil(request.AppId) {
8758 query["AppId"] = request.AppId
8759 }
8760
8761 req := &openapiutil.OpenApiRequest{
8762 Query: openapiutil.Query(query),
8763 }
8764 params := &openapiutil.Params{
8765 Action: dara.String("GetEdgeContainerAppResourceStatus"),
8766 Version: dara.String("2024-09-10"),
8767 Protocol: dara.String("HTTPS"),
8768 Pathname: dara.String("/"),
8769 Method: dara.String("POST"),
8770 AuthType: dara.String("AK"),
8771 Style: dara.String("RPC"),
8772 ReqBodyType: dara.String("formData"),
8773 BodyType: dara.String("json"),
8774 }
8775 _result = &GetEdgeContainerAppResourceStatusResponse{}
8776 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8777 if _err != nil {
8778 return _result, _err
8779 }
8780 _err = dara.Convert(_body, &_result)
8781 return _result, _err
8782 }
8783
8784 // Summary:
8785 //
8786 // Queries the status information about a containerized application, including the deployment, release, and rollback of the application.
8787 //
8788 // @param request - GetEdgeContainerAppStatusRequest
8789 //
8790 // @param runtime - runtime options for this request RuntimeOptions
8791 //
8792 // @return GetEdgeContainerAppStatusResponse
8793 func GetEdgeContainerAppStatusWithContext(ctx context.Context, client *Client, request *GetEdgeContainerAppStatusRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppStatusResponse, _err error) {
8794 if dara.BoolValue(client.EnableValidate) == true {
8795 _err = request.Validate()
8796 if _err != nil {
8797 return _result, _err
8798 }
8799 }
8800 query := map[string]interface{}{}
8801 if !dara.IsNil(request.AppId) {
8802 query["AppId"] = request.AppId
8803 }
8804
8805 if !dara.IsNil(request.PublishEnv) {
8806 query["PublishEnv"] = request.PublishEnv
8807 }
8808
8809 req := &openapiutil.OpenApiRequest{
8810 Query: openapiutil.Query(query),
8811 }
8812 params := &openapiutil.Params{
8813 Action: dara.String("GetEdgeContainerAppStatus"),
8814 Version: dara.String("2024-09-10"),
8815 Protocol: dara.String("HTTPS"),
8816 Pathname: dara.String("/"),
8817 Method: dara.String("POST"),
8818 AuthType: dara.String("AK"),
8819 Style: dara.String("RPC"),
8820 ReqBodyType: dara.String("formData"),
8821 BodyType: dara.String("json"),
8822 }
8823 _result = &GetEdgeContainerAppStatusResponse{}
8824 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8825 if _err != nil {
8826 return _result, _err
8827 }
8828 _err = dara.Convert(_body, &_result)
8829 return _result, _err
8830 }
8831
8832 // Summary:
8833 //
8834 // Queries the information about a version of a containerized application. You can select an application version to release based on the version information.
8835 //
8836 // @param request - GetEdgeContainerAppVersionRequest
8837 //
8838 // @param runtime - runtime options for this request RuntimeOptions
8839 //
8840 // @return GetEdgeContainerAppVersionResponse
8841 func GetEdgeContainerAppVersionWithContext(ctx context.Context, client *Client, request *GetEdgeContainerAppVersionRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppVersionResponse, _err error) {
8842 if dara.BoolValue(client.EnableValidate) == true {
8843 _err = request.Validate()
8844 if _err != nil {
8845 return _result, _err
8846 }
8847 }
8848 query := openapiutil.Query(dara.ToMap(request))
8849 req := &openapiutil.OpenApiRequest{
8850 Query: openapiutil.Query(query),
8851 }
8852 params := &openapiutil.Params{
8853 Action: dara.String("GetEdgeContainerAppVersion"),
8854 Version: dara.String("2024-09-10"),
8855 Protocol: dara.String("HTTPS"),
8856 Pathname: dara.String("/"),
8857 Method: dara.String("GET"),
8858 AuthType: dara.String("AK"),
8859 Style: dara.String("RPC"),
8860 ReqBodyType: dara.String("formData"),
8861 BodyType: dara.String("json"),
8862 }
8863 _result = &GetEdgeContainerAppVersionResponse{}
8864 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8865 if _err != nil {
8866 return _result, _err
8867 }
8868 _err = dara.Convert(_body, &_result)
8869 return _result, _err
8870 }
8871
8872 // Summary:
8873 //
8874 // Queries regions where a containerized application is deployed based on the application ID.
8875 //
8876 // @param request - GetEdgeContainerDeployRegionsRequest
8877 //
8878 // @param runtime - runtime options for this request RuntimeOptions
8879 //
8880 // @return GetEdgeContainerDeployRegionsResponse
8881 func GetEdgeContainerDeployRegionsWithContext(ctx context.Context, client *Client, request *GetEdgeContainerDeployRegionsRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerDeployRegionsResponse, _err error) {
8882 if dara.BoolValue(client.EnableValidate) == true {
8883 _err = request.Validate()
8884 if _err != nil {
8885 return _result, _err
8886 }
8887 }
8888 query := openapiutil.Query(dara.ToMap(request))
8889 req := &openapiutil.OpenApiRequest{
8890 Query: openapiutil.Query(query),
8891 }
8892 params := &openapiutil.Params{
8893 Action: dara.String("GetEdgeContainerDeployRegions"),
8894 Version: dara.String("2024-09-10"),
8895 Protocol: dara.String("HTTPS"),
8896 Pathname: dara.String("/"),
8897 Method: dara.String("GET"),
8898 AuthType: dara.String("AK"),
8899 Style: dara.String("RPC"),
8900 ReqBodyType: dara.String("formData"),
8901 BodyType: dara.String("json"),
8902 }
8903 _result = &GetEdgeContainerDeployRegionsResponse{}
8904 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8905 if _err != nil {
8906 return _result, _err
8907 }
8908 _err = dara.Convert(_body, &_result)
8909 return _result, _err
8910 }
8911
8912 // Summary:
8913 //
8914 // Queries Edge Container logs.
8915 //
8916 // @param request - GetEdgeContainerLogsRequest
8917 //
8918 // @param runtime - runtime options for this request RuntimeOptions
8919 //
8920 // @return GetEdgeContainerLogsResponse
8921 func GetEdgeContainerLogsWithContext(ctx context.Context, client *Client, request *GetEdgeContainerLogsRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerLogsResponse, _err error) {
8922 if dara.BoolValue(client.EnableValidate) == true {
8923 _err = request.Validate()
8924 if _err != nil {
8925 return _result, _err
8926 }
8927 }
8928 query := openapiutil.Query(dara.ToMap(request))
8929 req := &openapiutil.OpenApiRequest{
8930 Query: openapiutil.Query(query),
8931 }
8932 params := &openapiutil.Params{
8933 Action: dara.String("GetEdgeContainerLogs"),
8934 Version: dara.String("2024-09-10"),
8935 Protocol: dara.String("HTTPS"),
8936 Pathname: dara.String("/"),
8937 Method: dara.String("GET"),
8938 AuthType: dara.String("AK"),
8939 Style: dara.String("RPC"),
8940 ReqBodyType: dara.String("formData"),
8941 BodyType: dara.String("json"),
8942 }
8943 _result = &GetEdgeContainerLogsResponse{}
8944 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8945 if _err != nil {
8946 return _result, _err
8947 }
8948 _err = dara.Convert(_body, &_result)
8949 return _result, _err
8950 }
8951
8952 // Summary:
8953 //
8954 // Queries the deployment status of an application in the staging environment by using the application ID.
8955 //
8956 // @param request - GetEdgeContainerStagingDeployStatusRequest
8957 //
8958 // @param runtime - runtime options for this request RuntimeOptions
8959 //
8960 // @return GetEdgeContainerStagingDeployStatusResponse
8961 func GetEdgeContainerStagingDeployStatusWithContext(ctx context.Context, client *Client, request *GetEdgeContainerStagingDeployStatusRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerStagingDeployStatusResponse, _err error) {
8962 if dara.BoolValue(client.EnableValidate) == true {
8963 _err = request.Validate()
8964 if _err != nil {
8965 return _result, _err
8966 }
8967 }
8968 query := openapiutil.Query(dara.ToMap(request))
8969 req := &openapiutil.OpenApiRequest{
8970 Query: openapiutil.Query(query),
8971 }
8972 params := &openapiutil.Params{
8973 Action: dara.String("GetEdgeContainerStagingDeployStatus"),
8974 Version: dara.String("2024-09-10"),
8975 Protocol: dara.String("HTTPS"),
8976 Pathname: dara.String("/"),
8977 Method: dara.String("GET"),
8978 AuthType: dara.String("AK"),
8979 Style: dara.String("RPC"),
8980 ReqBodyType: dara.String("formData"),
8981 BodyType: dara.String("json"),
8982 }
8983 _result = &GetEdgeContainerStagingDeployStatusResponse{}
8984 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
8985 if _err != nil {
8986 return _result, _err
8987 }
8988 _err = dara.Convert(_body, &_result)
8989 return _result, _err
8990 }
8991
8992 // Summary:
8993 //
8994 // Queries the terminal information of a containerized application.
8995 //
8996 // @param request - GetEdgeContainerTerminalRequest
8997 //
8998 // @param runtime - runtime options for this request RuntimeOptions
8999 //
9000 // @return GetEdgeContainerTerminalResponse
9001 func GetEdgeContainerTerminalWithContext(ctx context.Context, client *Client, request *GetEdgeContainerTerminalRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerTerminalResponse, _err error) {
9002 if dara.BoolValue(client.EnableValidate) == true {
9003 _err = request.Validate()
9004 if _err != nil {
9005 return _result, _err
9006 }
9007 }
9008 query := map[string]interface{}{}
9009 if !dara.IsNil(request.AppId) {
9010 query["AppId"] = request.AppId
9011 }
9012
9013 req := &openapiutil.OpenApiRequest{
9014 Query: openapiutil.Query(query),
9015 }
9016 params := &openapiutil.Params{
9017 Action: dara.String("GetEdgeContainerTerminal"),
9018 Version: dara.String("2024-09-10"),
9019 Protocol: dara.String("HTTPS"),
9020 Pathname: dara.String("/"),
9021 Method: dara.String("POST"),
9022 AuthType: dara.String("AK"),
9023 Style: dara.String("RPC"),
9024 ReqBodyType: dara.String("formData"),
9025 BodyType: dara.String("json"),
9026 }
9027 _result = &GetEdgeContainerTerminalResponse{}
9028 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9029 if _err != nil {
9030 return _result, _err
9031 }
9032 _err = dara.Convert(_body, &_result)
9033 return _result, _err
9034 }
9035
9036 // Summary:
9037 //
9038 // Checks the status of Edge Routine.
9039 //
9040 // @param request - GetErServiceRequest
9041 //
9042 // @param runtime - runtime options for this request RuntimeOptions
9043 //
9044 // @return GetErServiceResponse
9045 func GetErServiceWithContext(ctx context.Context, client *Client, request *GetErServiceRequest, runtime *dara.RuntimeOptions) (_result *GetErServiceResponse, _err error) {
9046 if dara.BoolValue(client.EnableValidate) == true {
9047 _err = request.Validate()
9048 if _err != nil {
9049 return _result, _err
9050 }
9051 }
9052 query := openapiutil.Query(dara.ToMap(request))
9053 req := &openapiutil.OpenApiRequest{
9054 Query: openapiutil.Query(query),
9055 }
9056 params := &openapiutil.Params{
9057 Action: dara.String("GetErService"),
9058 Version: dara.String("2024-09-10"),
9059 Protocol: dara.String("HTTPS"),
9060 Pathname: dara.String("/"),
9061 Method: dara.String("GET"),
9062 AuthType: dara.String("AK"),
9063 Style: dara.String("RPC"),
9064 ReqBodyType: dara.String("formData"),
9065 BodyType: dara.String("json"),
9066 }
9067 _result = &GetErServiceResponse{}
9068 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9069 if _err != nil {
9070 return _result, _err
9071 }
9072 _err = dara.Convert(_body, &_result)
9073 return _result, _err
9074 }
9075
9076 // Summary:
9077 //
9078 // Queries the configuration details of an HTTP request header modification rule for a website.
9079 //
9080 // @param request - GetHttpIncomingRequestHeaderModificationRuleRequest
9081 //
9082 // @param runtime - runtime options for this request RuntimeOptions
9083 //
9084 // @return GetHttpIncomingRequestHeaderModificationRuleResponse
9085 func GetHttpIncomingRequestHeaderModificationRuleWithContext(ctx context.Context, client *Client, request *GetHttpIncomingRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *GetHttpIncomingRequestHeaderModificationRuleResponse, _err error) {
9086 if dara.BoolValue(client.EnableValidate) == true {
9087 _err = request.Validate()
9088 if _err != nil {
9089 return _result, _err
9090 }
9091 }
9092 query := openapiutil.Query(dara.ToMap(request))
9093 req := &openapiutil.OpenApiRequest{
9094 Query: openapiutil.Query(query),
9095 }
9096 params := &openapiutil.Params{
9097 Action: dara.String("GetHttpIncomingRequestHeaderModificationRule"),
9098 Version: dara.String("2024-09-10"),
9099 Protocol: dara.String("HTTPS"),
9100 Pathname: dara.String("/"),
9101 Method: dara.String("GET"),
9102 AuthType: dara.String("AK"),
9103 Style: dara.String("RPC"),
9104 ReqBodyType: dara.String("formData"),
9105 BodyType: dara.String("json"),
9106 }
9107 _result = &GetHttpIncomingRequestHeaderModificationRuleResponse{}
9108 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9109 if _err != nil {
9110 return _result, _err
9111 }
9112 _err = dara.Convert(_body, &_result)
9113 return _result, _err
9114 }
9115
9116 // Summary:
9117 //
9118 // Queries the configuration details of an incoming HTTP response header modification rule for a website.
9119 //
9120 // @param request - GetHttpIncomingResponseHeaderModificationRuleRequest
9121 //
9122 // @param runtime - runtime options for this request RuntimeOptions
9123 //
9124 // @return GetHttpIncomingResponseHeaderModificationRuleResponse
9125 func GetHttpIncomingResponseHeaderModificationRuleWithContext(ctx context.Context, client *Client, request *GetHttpIncomingResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *GetHttpIncomingResponseHeaderModificationRuleResponse, _err error) {
9126 if dara.BoolValue(client.EnableValidate) == true {
9127 _err = request.Validate()
9128 if _err != nil {
9129 return _result, _err
9130 }
9131 }
9132 query := openapiutil.Query(dara.ToMap(request))
9133 req := &openapiutil.OpenApiRequest{
9134 Query: openapiutil.Query(query),
9135 }
9136 params := &openapiutil.Params{
9137 Action: dara.String("GetHttpIncomingResponseHeaderModificationRule"),
9138 Version: dara.String("2024-09-10"),
9139 Protocol: dara.String("HTTPS"),
9140 Pathname: dara.String("/"),
9141 Method: dara.String("GET"),
9142 AuthType: dara.String("AK"),
9143 Style: dara.String("RPC"),
9144 ReqBodyType: dara.String("formData"),
9145 BodyType: dara.String("json"),
9146 }
9147 _result = &GetHttpIncomingResponseHeaderModificationRuleResponse{}
9148 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9149 if _err != nil {
9150 return _result, _err
9151 }
9152 _err = dara.Convert(_body, &_result)
9153 return _result, _err
9154 }
9155
9156 // Summary:
9157 //
9158 // # Query HTTP Request Header Rule Details
9159 //
9160 // @param request - GetHttpRequestHeaderModificationRuleRequest
9161 //
9162 // @param runtime - runtime options for this request RuntimeOptions
9163 //
9164 // @return GetHttpRequestHeaderModificationRuleResponse
9165 func GetHttpRequestHeaderModificationRuleWithContext(ctx context.Context, client *Client, request *GetHttpRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *GetHttpRequestHeaderModificationRuleResponse, _err error) {
9166 if dara.BoolValue(client.EnableValidate) == true {
9167 _err = request.Validate()
9168 if _err != nil {
9169 return _result, _err
9170 }
9171 }
9172 query := openapiutil.Query(dara.ToMap(request))
9173 req := &openapiutil.OpenApiRequest{
9174 Query: openapiutil.Query(query),
9175 }
9176 params := &openapiutil.Params{
9177 Action: dara.String("GetHttpRequestHeaderModificationRule"),
9178 Version: dara.String("2024-09-10"),
9179 Protocol: dara.String("HTTPS"),
9180 Pathname: dara.String("/"),
9181 Method: dara.String("GET"),
9182 AuthType: dara.String("AK"),
9183 Style: dara.String("RPC"),
9184 ReqBodyType: dara.String("formData"),
9185 BodyType: dara.String("json"),
9186 }
9187 _result = &GetHttpRequestHeaderModificationRuleResponse{}
9188 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9189 if _err != nil {
9190 return _result, _err
9191 }
9192 _err = dara.Convert(_body, &_result)
9193 return _result, _err
9194 }
9195
9196 // Summary:
9197 //
9198 // # Query HTTP Response Header Rules
9199 //
9200 // @param request - GetHttpResponseHeaderModificationRuleRequest
9201 //
9202 // @param runtime - runtime options for this request RuntimeOptions
9203 //
9204 // @return GetHttpResponseHeaderModificationRuleResponse
9205 func GetHttpResponseHeaderModificationRuleWithContext(ctx context.Context, client *Client, request *GetHttpResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *GetHttpResponseHeaderModificationRuleResponse, _err error) {
9206 if dara.BoolValue(client.EnableValidate) == true {
9207 _err = request.Validate()
9208 if _err != nil {
9209 return _result, _err
9210 }
9211 }
9212 query := openapiutil.Query(dara.ToMap(request))
9213 req := &openapiutil.OpenApiRequest{
9214 Query: openapiutil.Query(query),
9215 }
9216 params := &openapiutil.Params{
9217 Action: dara.String("GetHttpResponseHeaderModificationRule"),
9218 Version: dara.String("2024-09-10"),
9219 Protocol: dara.String("HTTPS"),
9220 Pathname: dara.String("/"),
9221 Method: dara.String("GET"),
9222 AuthType: dara.String("AK"),
9223 Style: dara.String("RPC"),
9224 ReqBodyType: dara.String("formData"),
9225 BodyType: dara.String("json"),
9226 }
9227 _result = &GetHttpResponseHeaderModificationRuleResponse{}
9228 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9229 if _err != nil {
9230 return _result, _err
9231 }
9232 _err = dara.Convert(_body, &_result)
9233 return _result, _err
9234 }
9235
9236 // Summary:
9237 //
9238 // # Query a Single HTTPS Application Configuration
9239 //
9240 // @param request - GetHttpsApplicationConfigurationRequest
9241 //
9242 // @param runtime - runtime options for this request RuntimeOptions
9243 //
9244 // @return GetHttpsApplicationConfigurationResponse
9245 func GetHttpsApplicationConfigurationWithContext(ctx context.Context, client *Client, request *GetHttpsApplicationConfigurationRequest, runtime *dara.RuntimeOptions) (_result *GetHttpsApplicationConfigurationResponse, _err error) {
9246 if dara.BoolValue(client.EnableValidate) == true {
9247 _err = request.Validate()
9248 if _err != nil {
9249 return _result, _err
9250 }
9251 }
9252 query := openapiutil.Query(dara.ToMap(request))
9253 req := &openapiutil.OpenApiRequest{
9254 Query: openapiutil.Query(query),
9255 }
9256 params := &openapiutil.Params{
9257 Action: dara.String("GetHttpsApplicationConfiguration"),
9258 Version: dara.String("2024-09-10"),
9259 Protocol: dara.String("HTTPS"),
9260 Pathname: dara.String("/"),
9261 Method: dara.String("GET"),
9262 AuthType: dara.String("AK"),
9263 Style: dara.String("RPC"),
9264 ReqBodyType: dara.String("formData"),
9265 BodyType: dara.String("json"),
9266 }
9267 _result = &GetHttpsApplicationConfigurationResponse{}
9268 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9269 if _err != nil {
9270 return _result, _err
9271 }
9272 _err = dara.Convert(_body, &_result)
9273 return _result, _err
9274 }
9275
9276 // Summary:
9277 //
9278 // # Query a Single HTTPS Basic Configuration
9279 //
9280 // @param request - GetHttpsBasicConfigurationRequest
9281 //
9282 // @param runtime - runtime options for this request RuntimeOptions
9283 //
9284 // @return GetHttpsBasicConfigurationResponse
9285 func GetHttpsBasicConfigurationWithContext(ctx context.Context, client *Client, request *GetHttpsBasicConfigurationRequest, runtime *dara.RuntimeOptions) (_result *GetHttpsBasicConfigurationResponse, _err error) {
9286 if dara.BoolValue(client.EnableValidate) == true {
9287 _err = request.Validate()
9288 if _err != nil {
9289 return _result, _err
9290 }
9291 }
9292 query := openapiutil.Query(dara.ToMap(request))
9293 req := &openapiutil.OpenApiRequest{
9294 Query: openapiutil.Query(query),
9295 }
9296 params := &openapiutil.Params{
9297 Action: dara.String("GetHttpsBasicConfiguration"),
9298 Version: dara.String("2024-09-10"),
9299 Protocol: dara.String("HTTPS"),
9300 Pathname: dara.String("/"),
9301 Method: dara.String("GET"),
9302 AuthType: dara.String("AK"),
9303 Style: dara.String("RPC"),
9304 ReqBodyType: dara.String("formData"),
9305 BodyType: dara.String("json"),
9306 }
9307 _result = &GetHttpsBasicConfigurationResponse{}
9308 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9309 if _err != nil {
9310 return _result, _err
9311 }
9312 _err = dara.Convert(_body, &_result)
9313 return _result, _err
9314 }
9315
9316 // Summary:
9317 //
9318 // Queries the IPv6 configuration of a website.
9319 //
9320 // @param request - GetIPv6Request
9321 //
9322 // @param runtime - runtime options for this request RuntimeOptions
9323 //
9324 // @return GetIPv6Response
9325 func GetIPv6WithContext(ctx context.Context, client *Client, request *GetIPv6Request, runtime *dara.RuntimeOptions) (_result *GetIPv6Response, _err error) {
9326 if dara.BoolValue(client.EnableValidate) == true {
9327 _err = request.Validate()
9328 if _err != nil {
9329 return _result, _err
9330 }
9331 }
9332 query := openapiutil.Query(dara.ToMap(request))
9333 req := &openapiutil.OpenApiRequest{
9334 Query: openapiutil.Query(query),
9335 }
9336 params := &openapiutil.Params{
9337 Action: dara.String("GetIPv6"),
9338 Version: dara.String("2024-09-10"),
9339 Protocol: dara.String("HTTPS"),
9340 Pathname: dara.String("/"),
9341 Method: dara.String("GET"),
9342 AuthType: dara.String("AK"),
9343 Style: dara.String("RPC"),
9344 ReqBodyType: dara.String("formData"),
9345 BodyType: dara.String("json"),
9346 }
9347 _result = &GetIPv6Response{}
9348 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9349 if _err != nil {
9350 return _result, _err
9351 }
9352 _err = dara.Convert(_body, &_result)
9353 return _result, _err
9354 }
9355
9356 // Summary:
9357 //
9358 // # Query Single Site Image Transformation Configuration
9359 //
9360 // @param request - GetImageTransformRequest
9361 //
9362 // @param runtime - runtime options for this request RuntimeOptions
9363 //
9364 // @return GetImageTransformResponse
9365 func GetImageTransformWithContext(ctx context.Context, client *Client, request *GetImageTransformRequest, runtime *dara.RuntimeOptions) (_result *GetImageTransformResponse, _err error) {
9366 if dara.BoolValue(client.EnableValidate) == true {
9367 _err = request.Validate()
9368 if _err != nil {
9369 return _result, _err
9370 }
9371 }
9372 query := openapiutil.Query(dara.ToMap(request))
9373 req := &openapiutil.OpenApiRequest{
9374 Query: openapiutil.Query(query),
9375 }
9376 params := &openapiutil.Params{
9377 Action: dara.String("GetImageTransform"),
9378 Version: dara.String("2024-09-10"),
9379 Protocol: dara.String("HTTPS"),
9380 Pathname: dara.String("/"),
9381 Method: dara.String("GET"),
9382 AuthType: dara.String("AK"),
9383 Style: dara.String("RPC"),
9384 ReqBodyType: dara.String("formData"),
9385 BodyType: dara.String("json"),
9386 }
9387 _result = &GetImageTransformResponse{}
9388 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9389 if _err != nil {
9390 return _result, _err
9391 }
9392 _err = dara.Convert(_body, &_result)
9393 return _result, _err
9394 }
9395
9396 // Summary:
9397 //
9398 // Queries the value of a key in a key-value pair.
9399 //
9400 // @param request - GetKvRequest
9401 //
9402 // @param runtime - runtime options for this request RuntimeOptions
9403 //
9404 // @return GetKvResponse
9405 func GetKvWithContext(ctx context.Context, client *Client, request *GetKvRequest, runtime *dara.RuntimeOptions) (_result *GetKvResponse, _err error) {
9406 if dara.BoolValue(client.EnableValidate) == true {
9407 _err = request.Validate()
9408 if _err != nil {
9409 return _result, _err
9410 }
9411 }
9412 query := openapiutil.Query(dara.ToMap(request))
9413 req := &openapiutil.OpenApiRequest{
9414 Query: openapiutil.Query(query),
9415 }
9416 params := &openapiutil.Params{
9417 Action: dara.String("GetKv"),
9418 Version: dara.String("2024-09-10"),
9419 Protocol: dara.String("HTTPS"),
9420 Pathname: dara.String("/"),
9421 Method: dara.String("GET"),
9422 AuthType: dara.String("AK"),
9423 Style: dara.String("RPC"),
9424 ReqBodyType: dara.String("formData"),
9425 BodyType: dara.String("json"),
9426 }
9427 _result = &GetKvResponse{}
9428 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9429 if _err != nil {
9430 return _result, _err
9431 }
9432 _err = dara.Convert(_body, &_result)
9433 return _result, _err
9434 }
9435
9436 // Summary:
9437 //
9438 // 查询Key-Value对的某个Key的详情
9439 //
9440 // @param request - GetKvDetailRequest
9441 //
9442 // @param runtime - runtime options for this request RuntimeOptions
9443 //
9444 // @return GetKvDetailResponse
9445 func GetKvDetailWithContext(ctx context.Context, client *Client, request *GetKvDetailRequest, runtime *dara.RuntimeOptions) (_result *GetKvDetailResponse, _err error) {
9446 if dara.BoolValue(client.EnableValidate) == true {
9447 _err = request.Validate()
9448 if _err != nil {
9449 return _result, _err
9450 }
9451 }
9452 query := map[string]interface{}{}
9453 if !dara.IsNil(request.Key) {
9454 query["Key"] = request.Key
9455 }
9456
9457 if !dara.IsNil(request.Namespace) {
9458 query["Namespace"] = request.Namespace
9459 }
9460
9461 req := &openapiutil.OpenApiRequest{
9462 Query: openapiutil.Query(query),
9463 }
9464 params := &openapiutil.Params{
9465 Action: dara.String("GetKvDetail"),
9466 Version: dara.String("2024-09-10"),
9467 Protocol: dara.String("HTTPS"),
9468 Pathname: dara.String("/"),
9469 Method: dara.String("POST"),
9470 AuthType: dara.String("AK"),
9471 Style: dara.String("RPC"),
9472 ReqBodyType: dara.String("formData"),
9473 BodyType: dara.String("json"),
9474 }
9475 _result = &GetKvDetailResponse{}
9476 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9477 if _err != nil {
9478 return _result, _err
9479 }
9480 _err = dara.Convert(_body, &_result)
9481 return _result, _err
9482 }
9483
9484 // Summary:
9485 //
9486 // Queries the information about a namespace in your Alibaba Cloud account.
9487 //
9488 // @param request - GetKvNamespaceRequest
9489 //
9490 // @param runtime - runtime options for this request RuntimeOptions
9491 //
9492 // @return GetKvNamespaceResponse
9493 func GetKvNamespaceWithContext(ctx context.Context, client *Client, request *GetKvNamespaceRequest, runtime *dara.RuntimeOptions) (_result *GetKvNamespaceResponse, _err error) {
9494 if dara.BoolValue(client.EnableValidate) == true {
9495 _err = request.Validate()
9496 if _err != nil {
9497 return _result, _err
9498 }
9499 }
9500 query := openapiutil.Query(dara.ToMap(request))
9501 req := &openapiutil.OpenApiRequest{
9502 Query: openapiutil.Query(query),
9503 }
9504 params := &openapiutil.Params{
9505 Action: dara.String("GetKvNamespace"),
9506 Version: dara.String("2024-09-10"),
9507 Protocol: dara.String("HTTPS"),
9508 Pathname: dara.String("/"),
9509 Method: dara.String("GET"),
9510 AuthType: dara.String("AK"),
9511 Style: dara.String("RPC"),
9512 ReqBodyType: dara.String("formData"),
9513 BodyType: dara.String("json"),
9514 }
9515 _result = &GetKvNamespaceResponse{}
9516 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9517 if _err != nil {
9518 return _result, _err
9519 }
9520 _err = dara.Convert(_body, &_result)
9521 return _result, _err
9522 }
9523
9524 // Summary:
9525 //
9526 // Queries the details of a custom list, such as the name, description, type, and content.
9527 //
9528 // @param request - GetListRequest
9529 //
9530 // @param runtime - runtime options for this request RuntimeOptions
9531 //
9532 // @return GetListResponse
9533 func GetListWithContext(ctx context.Context, client *Client, request *GetListRequest, runtime *dara.RuntimeOptions) (_result *GetListResponse, _err error) {
9534 if dara.BoolValue(client.EnableValidate) == true {
9535 _err = request.Validate()
9536 if _err != nil {
9537 return _result, _err
9538 }
9539 }
9540 query := map[string]interface{}{}
9541 if !dara.IsNil(request.Id) {
9542 query["Id"] = request.Id
9543 }
9544
9545 req := &openapiutil.OpenApiRequest{
9546 Query: openapiutil.Query(query),
9547 }
9548 params := &openapiutil.Params{
9549 Action: dara.String("GetList"),
9550 Version: dara.String("2024-09-10"),
9551 Protocol: dara.String("HTTPS"),
9552 Pathname: dara.String("/"),
9553 Method: dara.String("POST"),
9554 AuthType: dara.String("AK"),
9555 Style: dara.String("RPC"),
9556 ReqBodyType: dara.String("formData"),
9557 BodyType: dara.String("json"),
9558 }
9559 _result = &GetListResponse{}
9560 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9561 if _err != nil {
9562 return _result, _err
9563 }
9564 _err = dara.Convert(_body, &_result)
9565 return _result, _err
9566 }
9567
9568 // Summary:
9569 //
9570 // # Query a Specific Load Balancer
9571 //
9572 // Description:
9573 //
9574 // This API allows users to query the configuration details of a specific load balancer by providing necessary authentication information and resource identifiers, including but not limited to name, session persistence strategy, routing policy, etc.
9575 //
9576 // @param request - GetLoadBalancerRequest
9577 //
9578 // @param runtime - runtime options for this request RuntimeOptions
9579 //
9580 // @return GetLoadBalancerResponse
9581 func GetLoadBalancerWithContext(ctx context.Context, client *Client, request *GetLoadBalancerRequest, runtime *dara.RuntimeOptions) (_result *GetLoadBalancerResponse, _err error) {
9582 if dara.BoolValue(client.EnableValidate) == true {
9583 _err = request.Validate()
9584 if _err != nil {
9585 return _result, _err
9586 }
9587 }
9588 query := openapiutil.Query(dara.ToMap(request))
9589 req := &openapiutil.OpenApiRequest{
9590 Query: openapiutil.Query(query),
9591 }
9592 params := &openapiutil.Params{
9593 Action: dara.String("GetLoadBalancer"),
9594 Version: dara.String("2024-09-10"),
9595 Protocol: dara.String("HTTPS"),
9596 Pathname: dara.String("/"),
9597 Method: dara.String("GET"),
9598 AuthType: dara.String("AK"),
9599 Style: dara.String("RPC"),
9600 ReqBodyType: dara.String("formData"),
9601 BodyType: dara.String("json"),
9602 }
9603 _result = &GetLoadBalancerResponse{}
9604 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9605 if _err != nil {
9606 return _result, _err
9607 }
9608 _err = dara.Convert(_body, &_result)
9609 return _result, _err
9610 }
9611
9612 // Summary:
9613 //
9614 // # Query Managed Transform Configuration
9615 //
9616 // @param request - GetManagedTransformRequest
9617 //
9618 // @param runtime - runtime options for this request RuntimeOptions
9619 //
9620 // @return GetManagedTransformResponse
9621 func GetManagedTransformWithContext(ctx context.Context, client *Client, request *GetManagedTransformRequest, runtime *dara.RuntimeOptions) (_result *GetManagedTransformResponse, _err error) {
9622 if dara.BoolValue(client.EnableValidate) == true {
9623 _err = request.Validate()
9624 if _err != nil {
9625 return _result, _err
9626 }
9627 }
9628 query := openapiutil.Query(dara.ToMap(request))
9629 req := &openapiutil.OpenApiRequest{
9630 Query: openapiutil.Query(query),
9631 }
9632 params := &openapiutil.Params{
9633 Action: dara.String("GetManagedTransform"),
9634 Version: dara.String("2024-09-10"),
9635 Protocol: dara.String("HTTPS"),
9636 Pathname: dara.String("/"),
9637 Method: dara.String("GET"),
9638 AuthType: dara.String("AK"),
9639 Style: dara.String("RPC"),
9640 ReqBodyType: dara.String("formData"),
9641 BodyType: dara.String("json"),
9642 }
9643 _result = &GetManagedTransformResponse{}
9644 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9645 if _err != nil {
9646 return _result, _err
9647 }
9648 _err = dara.Convert(_body, &_result)
9649 return _result, _err
9650 }
9651
9652 // Summary:
9653 //
9654 // # Query a single network optimization configuration
9655 //
9656 // @param request - GetNetworkOptimizationRequest
9657 //
9658 // @param runtime - runtime options for this request RuntimeOptions
9659 //
9660 // @return GetNetworkOptimizationResponse
9661 func GetNetworkOptimizationWithContext(ctx context.Context, client *Client, request *GetNetworkOptimizationRequest, runtime *dara.RuntimeOptions) (_result *GetNetworkOptimizationResponse, _err error) {
9662 if dara.BoolValue(client.EnableValidate) == true {
9663 _err = request.Validate()
9664 if _err != nil {
9665 return _result, _err
9666 }
9667 }
9668 query := openapiutil.Query(dara.ToMap(request))
9669 req := &openapiutil.OpenApiRequest{
9670 Query: openapiutil.Query(query),
9671 }
9672 params := &openapiutil.Params{
9673 Action: dara.String("GetNetworkOptimization"),
9674 Version: dara.String("2024-09-10"),
9675 Protocol: dara.String("HTTPS"),
9676 Pathname: dara.String("/"),
9677 Method: dara.String("GET"),
9678 AuthType: dara.String("AK"),
9679 Style: dara.String("RPC"),
9680 ReqBodyType: dara.String("formData"),
9681 BodyType: dara.String("json"),
9682 }
9683 _result = &GetNetworkOptimizationResponse{}
9684 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9685 if _err != nil {
9686 return _result, _err
9687 }
9688 _err = dara.Convert(_body, &_result)
9689 return _result, _err
9690 }
9691
9692 // Summary:
9693 //
9694 // 获取源服务器CA证书信息
9695 //
9696 // @param request - GetOriginCaCertificateRequest
9697 //
9698 // @param runtime - runtime options for this request RuntimeOptions
9699 //
9700 // @return GetOriginCaCertificateResponse
9701 func GetOriginCaCertificateWithContext(ctx context.Context, client *Client, request *GetOriginCaCertificateRequest, runtime *dara.RuntimeOptions) (_result *GetOriginCaCertificateResponse, _err error) {
9702 if dara.BoolValue(client.EnableValidate) == true {
9703 _err = request.Validate()
9704 if _err != nil {
9705 return _result, _err
9706 }
9707 }
9708 query := openapiutil.Query(dara.ToMap(request))
9709 req := &openapiutil.OpenApiRequest{
9710 Query: openapiutil.Query(query),
9711 }
9712 params := &openapiutil.Params{
9713 Action: dara.String("GetOriginCaCertificate"),
9714 Version: dara.String("2024-09-10"),
9715 Protocol: dara.String("HTTPS"),
9716 Pathname: dara.String("/"),
9717 Method: dara.String("GET"),
9718 AuthType: dara.String("AK"),
9719 Style: dara.String("RPC"),
9720 ReqBodyType: dara.String("formData"),
9721 BodyType: dara.String("json"),
9722 }
9723 _result = &GetOriginCaCertificateResponse{}
9724 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9725 if _err != nil {
9726 return _result, _err
9727 }
9728 _err = dara.Convert(_body, &_result)
9729 return _result, _err
9730 }
9731
9732 // Summary:
9733 //
9734 // 获取域名回源客户端证书信息
9735 //
9736 // @param request - GetOriginClientCertificateRequest
9737 //
9738 // @param runtime - runtime options for this request RuntimeOptions
9739 //
9740 // @return GetOriginClientCertificateResponse
9741 func GetOriginClientCertificateWithContext(ctx context.Context, client *Client, request *GetOriginClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *GetOriginClientCertificateResponse, _err error) {
9742 if dara.BoolValue(client.EnableValidate) == true {
9743 _err = request.Validate()
9744 if _err != nil {
9745 return _result, _err
9746 }
9747 }
9748 query := openapiutil.Query(dara.ToMap(request))
9749 req := &openapiutil.OpenApiRequest{
9750 Query: openapiutil.Query(query),
9751 }
9752 params := &openapiutil.Params{
9753 Action: dara.String("GetOriginClientCertificate"),
9754 Version: dara.String("2024-09-10"),
9755 Protocol: dara.String("HTTPS"),
9756 Pathname: dara.String("/"),
9757 Method: dara.String("GET"),
9758 AuthType: dara.String("AK"),
9759 Style: dara.String("RPC"),
9760 ReqBodyType: dara.String("formData"),
9761 BodyType: dara.String("json"),
9762 }
9763 _result = &GetOriginClientCertificateResponse{}
9764 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9765 if _err != nil {
9766 return _result, _err
9767 }
9768 _err = dara.Convert(_body, &_result)
9769 return _result, _err
9770 }
9771
9772 // Summary:
9773 //
9774 // 获取域名回源客户端证书绑定的域名列表
9775 //
9776 // @param request - GetOriginClientCertificateHostnamesRequest
9777 //
9778 // @param runtime - runtime options for this request RuntimeOptions
9779 //
9780 // @return GetOriginClientCertificateHostnamesResponse
9781 func GetOriginClientCertificateHostnamesWithContext(ctx context.Context, client *Client, request *GetOriginClientCertificateHostnamesRequest, runtime *dara.RuntimeOptions) (_result *GetOriginClientCertificateHostnamesResponse, _err error) {
9782 if dara.BoolValue(client.EnableValidate) == true {
9783 _err = request.Validate()
9784 if _err != nil {
9785 return _result, _err
9786 }
9787 }
9788 query := openapiutil.Query(dara.ToMap(request))
9789 req := &openapiutil.OpenApiRequest{
9790 Query: openapiutil.Query(query),
9791 }
9792 params := &openapiutil.Params{
9793 Action: dara.String("GetOriginClientCertificateHostnames"),
9794 Version: dara.String("2024-09-10"),
9795 Protocol: dara.String("HTTPS"),
9796 Pathname: dara.String("/"),
9797 Method: dara.String("GET"),
9798 AuthType: dara.String("AK"),
9799 Style: dara.String("RPC"),
9800 ReqBodyType: dara.String("formData"),
9801 BodyType: dara.String("json"),
9802 }
9803 _result = &GetOriginClientCertificateHostnamesResponse{}
9804 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9805 if _err != nil {
9806 return _result, _err
9807 }
9808 _err = dara.Convert(_body, &_result)
9809 return _result, _err
9810 }
9811
9812 // Summary:
9813 //
9814 // # Query a specific origin pool
9815 //
9816 // @param request - GetOriginPoolRequest
9817 //
9818 // @param runtime - runtime options for this request RuntimeOptions
9819 //
9820 // @return GetOriginPoolResponse
9821 func GetOriginPoolWithContext(ctx context.Context, client *Client, request *GetOriginPoolRequest, runtime *dara.RuntimeOptions) (_result *GetOriginPoolResponse, _err error) {
9822 if dara.BoolValue(client.EnableValidate) == true {
9823 _err = request.Validate()
9824 if _err != nil {
9825 return _result, _err
9826 }
9827 }
9828 query := openapiutil.Query(dara.ToMap(request))
9829 req := &openapiutil.OpenApiRequest{
9830 Query: openapiutil.Query(query),
9831 }
9832 params := &openapiutil.Params{
9833 Action: dara.String("GetOriginPool"),
9834 Version: dara.String("2024-09-10"),
9835 Protocol: dara.String("HTTPS"),
9836 Pathname: dara.String("/"),
9837 Method: dara.String("GET"),
9838 AuthType: dara.String("AK"),
9839 Style: dara.String("RPC"),
9840 ReqBodyType: dara.String("formData"),
9841 BodyType: dara.String("json"),
9842 }
9843 _result = &GetOriginPoolResponse{}
9844 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9845 if _err != nil {
9846 return _result, _err
9847 }
9848 _err = dara.Convert(_body, &_result)
9849 return _result, _err
9850 }
9851
9852 // Summary:
9853 //
9854 // Queries the origin protection configurations of a website, including the origin protection, IP convergence, and the status and details of the IP whitelist for origin protection. The details includes the IP whitelist used by the website, the latest IP whitelist, and the differences between them.
9855 //
9856 // @param request - GetOriginProtectionRequest
9857 //
9858 // @param runtime - runtime options for this request RuntimeOptions
9859 //
9860 // @return GetOriginProtectionResponse
9861 func GetOriginProtectionWithContext(ctx context.Context, client *Client, request *GetOriginProtectionRequest, runtime *dara.RuntimeOptions) (_result *GetOriginProtectionResponse, _err error) {
9862 if dara.BoolValue(client.EnableValidate) == true {
9863 _err = request.Validate()
9864 if _err != nil {
9865 return _result, _err
9866 }
9867 }
9868 query := openapiutil.Query(dara.ToMap(request))
9869 req := &openapiutil.OpenApiRequest{
9870 Query: openapiutil.Query(query),
9871 }
9872 params := &openapiutil.Params{
9873 Action: dara.String("GetOriginProtection"),
9874 Version: dara.String("2024-09-10"),
9875 Protocol: dara.String("HTTPS"),
9876 Pathname: dara.String("/"),
9877 Method: dara.String("GET"),
9878 AuthType: dara.String("AK"),
9879 Style: dara.String("RPC"),
9880 ReqBodyType: dara.String("formData"),
9881 BodyType: dara.String("json"),
9882 }
9883 _result = &GetOriginProtectionResponse{}
9884 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9885 if _err != nil {
9886 return _result, _err
9887 }
9888 _err = dara.Convert(_body, &_result)
9889 return _result, _err
9890 }
9891
9892 // Summary:
9893 //
9894 // Queries the configurations of a single origin rule.
9895 //
9896 // @param request - GetOriginRuleRequest
9897 //
9898 // @param runtime - runtime options for this request RuntimeOptions
9899 //
9900 // @return GetOriginRuleResponse
9901 func GetOriginRuleWithContext(ctx context.Context, client *Client, request *GetOriginRuleRequest, runtime *dara.RuntimeOptions) (_result *GetOriginRuleResponse, _err error) {
9902 if dara.BoolValue(client.EnableValidate) == true {
9903 _err = request.Validate()
9904 if _err != nil {
9905 return _result, _err
9906 }
9907 }
9908 query := openapiutil.Query(dara.ToMap(request))
9909 req := &openapiutil.OpenApiRequest{
9910 Query: openapiutil.Query(query),
9911 }
9912 params := &openapiutil.Params{
9913 Action: dara.String("GetOriginRule"),
9914 Version: dara.String("2024-09-10"),
9915 Protocol: dara.String("HTTPS"),
9916 Pathname: dara.String("/"),
9917 Method: dara.String("GET"),
9918 AuthType: dara.String("AK"),
9919 Style: dara.String("RPC"),
9920 ReqBodyType: dara.String("formData"),
9921 BodyType: dara.String("json"),
9922 }
9923 _result = &GetOriginRuleResponse{}
9924 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9925 if _err != nil {
9926 return _result, _err
9927 }
9928 _err = dara.Convert(_body, &_result)
9929 return _result, _err
9930 }
9931
9932 // Summary:
9933 //
9934 // Queries the details of a custom error page based on the error page ID.
9935 //
9936 // @param request - GetPageRequest
9937 //
9938 // @param runtime - runtime options for this request RuntimeOptions
9939 //
9940 // @return GetPageResponse
9941 func GetPageWithContext(ctx context.Context, client *Client, request *GetPageRequest, runtime *dara.RuntimeOptions) (_result *GetPageResponse, _err error) {
9942 if dara.BoolValue(client.EnableValidate) == true {
9943 _err = request.Validate()
9944 if _err != nil {
9945 return _result, _err
9946 }
9947 }
9948 query := map[string]interface{}{}
9949 if !dara.IsNil(request.Id) {
9950 query["Id"] = request.Id
9951 }
9952
9953 req := &openapiutil.OpenApiRequest{
9954 Query: openapiutil.Query(query),
9955 }
9956 params := &openapiutil.Params{
9957 Action: dara.String("GetPage"),
9958 Version: dara.String("2024-09-10"),
9959 Protocol: dara.String("HTTPS"),
9960 Pathname: dara.String("/"),
9961 Method: dara.String("POST"),
9962 AuthType: dara.String("AK"),
9963 Style: dara.String("RPC"),
9964 ReqBodyType: dara.String("formData"),
9965 BodyType: dara.String("json"),
9966 }
9967 _result = &GetPageResponse{}
9968 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
9969 if _err != nil {
9970 return _result, _err
9971 }
9972 _err = dara.Convert(_body, &_result)
9973 return _result, _err
9974 }
9975
9976 // Summary:
9977 //
9978 // Queries the quotas and quota usage for different cache purge options.
9979 //
9980 // @param request - GetPurgeQuotaRequest
9981 //
9982 // @param runtime - runtime options for this request RuntimeOptions
9983 //
9984 // @return GetPurgeQuotaResponse
9985 func GetPurgeQuotaWithContext(ctx context.Context, client *Client, request *GetPurgeQuotaRequest, runtime *dara.RuntimeOptions) (_result *GetPurgeQuotaResponse, _err error) {
9986 if dara.BoolValue(client.EnableValidate) == true {
9987 _err = request.Validate()
9988 if _err != nil {
9989 return _result, _err
9990 }
9991 }
9992 query := openapiutil.Query(dara.ToMap(request))
9993 req := &openapiutil.OpenApiRequest{
9994 Query: openapiutil.Query(query),
9995 }
9996 params := &openapiutil.Params{
9997 Action: dara.String("GetPurgeQuota"),
9998 Version: dara.String("2024-09-10"),
9999 Protocol: dara.String("HTTPS"),
10000 Pathname: dara.String("/"),
10001 Method: dara.String("GET"),
10002 AuthType: dara.String("AK"),
10003 Style: dara.String("RPC"),
10004 ReqBodyType: dara.String("formData"),
10005 BodyType: dara.String("json"),
10006 }
10007 _result = &GetPurgeQuotaResponse{}
10008 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10009 if _err != nil {
10010 return _result, _err
10011 }
10012 _err = dara.Convert(_body, &_result)
10013 return _result, _err
10014 }
10015
10016 // Summary:
10017 //
10018 // Queries the fields in real-time logs based on the log category.
10019 //
10020 // @param request - GetRealtimeDeliveryFieldRequest
10021 //
10022 // @param runtime - runtime options for this request RuntimeOptions
10023 //
10024 // @return GetRealtimeDeliveryFieldResponse
10025 func GetRealtimeDeliveryFieldWithContext(ctx context.Context, client *Client, request *GetRealtimeDeliveryFieldRequest, runtime *dara.RuntimeOptions) (_result *GetRealtimeDeliveryFieldResponse, _err error) {
10026 if dara.BoolValue(client.EnableValidate) == true {
10027 _err = request.Validate()
10028 if _err != nil {
10029 return _result, _err
10030 }
10031 }
10032 query := openapiutil.Query(dara.ToMap(request))
10033 req := &openapiutil.OpenApiRequest{
10034 Query: openapiutil.Query(query),
10035 }
10036 params := &openapiutil.Params{
10037 Action: dara.String("GetRealtimeDeliveryField"),
10038 Version: dara.String("2024-09-10"),
10039 Protocol: dara.String("HTTPS"),
10040 Pathname: dara.String("/"),
10041 Method: dara.String("GET"),
10042 AuthType: dara.String("AK"),
10043 Style: dara.String("RPC"),
10044 ReqBodyType: dara.String("formData"),
10045 BodyType: dara.String("json"),
10046 }
10047 _result = &GetRealtimeDeliveryFieldResponse{}
10048 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10049 if _err != nil {
10050 return _result, _err
10051 }
10052 _err = dara.Convert(_body, &_result)
10053 return _result, _err
10054 }
10055
10056 // Summary:
10057 //
10058 // Queries the configuration of a single DNS record, such as the record value, priority, and origin authentication setting (exclusive to CNAME records).
10059 //
10060 // @param request - GetRecordRequest
10061 //
10062 // @param runtime - runtime options for this request RuntimeOptions
10063 //
10064 // @return GetRecordResponse
10065 func GetRecordWithContext(ctx context.Context, client *Client, request *GetRecordRequest, runtime *dara.RuntimeOptions) (_result *GetRecordResponse, _err error) {
10066 if dara.BoolValue(client.EnableValidate) == true {
10067 _err = request.Validate()
10068 if _err != nil {
10069 return _result, _err
10070 }
10071 }
10072 query := openapiutil.Query(dara.ToMap(request))
10073 req := &openapiutil.OpenApiRequest{
10074 Query: openapiutil.Query(query),
10075 }
10076 params := &openapiutil.Params{
10077 Action: dara.String("GetRecord"),
10078 Version: dara.String("2024-09-10"),
10079 Protocol: dara.String("HTTPS"),
10080 Pathname: dara.String("/"),
10081 Method: dara.String("GET"),
10082 AuthType: dara.String("AK"),
10083 Style: dara.String("RPC"),
10084 ReqBodyType: dara.String("formData"),
10085 BodyType: dara.String("json"),
10086 }
10087 _result = &GetRecordResponse{}
10088 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10089 if _err != nil {
10090 return _result, _err
10091 }
10092 _err = dara.Convert(_body, &_result)
10093 return _result, _err
10094 }
10095
10096 // Summary:
10097 //
10098 // # Query Redirect Rule Details
10099 //
10100 // @param request - GetRedirectRuleRequest
10101 //
10102 // @param runtime - runtime options for this request RuntimeOptions
10103 //
10104 // @return GetRedirectRuleResponse
10105 func GetRedirectRuleWithContext(ctx context.Context, client *Client, request *GetRedirectRuleRequest, runtime *dara.RuntimeOptions) (_result *GetRedirectRuleResponse, _err error) {
10106 if dara.BoolValue(client.EnableValidate) == true {
10107 _err = request.Validate()
10108 if _err != nil {
10109 return _result, _err
10110 }
10111 }
10112 query := openapiutil.Query(dara.ToMap(request))
10113 req := &openapiutil.OpenApiRequest{
10114 Query: openapiutil.Query(query),
10115 }
10116 params := &openapiutil.Params{
10117 Action: dara.String("GetRedirectRule"),
10118 Version: dara.String("2024-09-10"),
10119 Protocol: dara.String("HTTPS"),
10120 Pathname: dara.String("/"),
10121 Method: dara.String("GET"),
10122 AuthType: dara.String("AK"),
10123 Style: dara.String("RPC"),
10124 ReqBodyType: dara.String("formData"),
10125 BodyType: dara.String("json"),
10126 }
10127 _result = &GetRedirectRuleResponse{}
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 // # Query details of the rewrite URL rule
10139 //
10140 // @param request - GetRewriteUrlRuleRequest
10141 //
10142 // @param runtime - runtime options for this request RuntimeOptions
10143 //
10144 // @return GetRewriteUrlRuleResponse
10145 func GetRewriteUrlRuleWithContext(ctx context.Context, client *Client, request *GetRewriteUrlRuleRequest, runtime *dara.RuntimeOptions) (_result *GetRewriteUrlRuleResponse, _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 := openapiutil.Query(dara.ToMap(request))
10153 req := &openapiutil.OpenApiRequest{
10154 Query: openapiutil.Query(query),
10155 }
10156 params := &openapiutil.Params{
10157 Action: dara.String("GetRewriteUrlRule"),
10158 Version: dara.String("2024-09-10"),
10159 Protocol: dara.String("HTTPS"),
10160 Pathname: dara.String("/"),
10161 Method: dara.String("GET"),
10162 AuthType: dara.String("AK"),
10163 Style: dara.String("RPC"),
10164 ReqBodyType: dara.String("formData"),
10165 BodyType: dara.String("json"),
10166 }
10167 _result = &GetRewriteUrlRuleResponse{}
10168 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10169 if _err != nil {
10170 return _result, _err
10171 }
10172 _err = dara.Convert(_body, &_result)
10173 return _result, _err
10174 }
10175
10176 // Summary:
10177 //
10178 // Queries the configurations of a routine, including the code versions and the configurations of the environments, associated domain names, and associated routes.
10179 //
10180 // @param request - GetRoutineRequest
10181 //
10182 // @param runtime - runtime options for this request RuntimeOptions
10183 //
10184 // @return GetRoutineResponse
10185 func GetRoutineWithContext(ctx context.Context, client *Client, request *GetRoutineRequest, runtime *dara.RuntimeOptions) (_result *GetRoutineResponse, _err error) {
10186 if dara.BoolValue(client.EnableValidate) == true {
10187 _err = request.Validate()
10188 if _err != nil {
10189 return _result, _err
10190 }
10191 }
10192 body := map[string]interface{}{}
10193 if !dara.IsNil(request.Name) {
10194 body["Name"] = request.Name
10195 }
10196
10197 req := &openapiutil.OpenApiRequest{
10198 Body: openapiutil.ParseToMap(body),
10199 }
10200 params := &openapiutil.Params{
10201 Action: dara.String("GetRoutine"),
10202 Version: dara.String("2024-09-10"),
10203 Protocol: dara.String("HTTPS"),
10204 Pathname: dara.String("/"),
10205 Method: dara.String("POST"),
10206 AuthType: dara.String("AK"),
10207 Style: dara.String("RPC"),
10208 ReqBodyType: dara.String("formData"),
10209 BodyType: dara.String("json"),
10210 }
10211 _result = &GetRoutineResponse{}
10212 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10213 if _err != nil {
10214 return _result, _err
10215 }
10216 _err = dara.Convert(_body, &_result)
10217 return _result, _err
10218 }
10219
10220 // Summary:
10221 //
10222 // 查询Routine默认访问记录访问鉴权token
10223 //
10224 // @param request - GetRoutineAccessTokenRequest
10225 //
10226 // @param runtime - runtime options for this request RuntimeOptions
10227 //
10228 // @return GetRoutineAccessTokenResponse
10229 func GetRoutineAccessTokenWithContext(ctx context.Context, client *Client, request *GetRoutineAccessTokenRequest, runtime *dara.RuntimeOptions) (_result *GetRoutineAccessTokenResponse, _err error) {
10230 if dara.BoolValue(client.EnableValidate) == true {
10231 _err = request.Validate()
10232 if _err != nil {
10233 return _result, _err
10234 }
10235 }
10236 body := map[string]interface{}{}
10237 if !dara.IsNil(request.Name) {
10238 body["Name"] = request.Name
10239 }
10240
10241 req := &openapiutil.OpenApiRequest{
10242 Body: openapiutil.ParseToMap(body),
10243 }
10244 params := &openapiutil.Params{
10245 Action: dara.String("GetRoutineAccessToken"),
10246 Version: dara.String("2024-09-10"),
10247 Protocol: dara.String("HTTPS"),
10248 Pathname: dara.String("/"),
10249 Method: dara.String("POST"),
10250 AuthType: dara.String("AK"),
10251 Style: dara.String("RPC"),
10252 ReqBodyType: dara.String("formData"),
10253 BodyType: dara.String("json"),
10254 }
10255 _result = &GetRoutineAccessTokenResponse{}
10256 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10257 if _err != nil {
10258 return _result, _err
10259 }
10260 _err = dara.Convert(_body, &_result)
10261 return _result, _err
10262 }
10263
10264 // Summary:
10265 //
10266 // Queries information about a code version of a routine.
10267 //
10268 // @param request - GetRoutineCodeVersionRequest
10269 //
10270 // @param runtime - runtime options for this request RuntimeOptions
10271 //
10272 // @return GetRoutineCodeVersionResponse
10273 func GetRoutineCodeVersionWithContext(ctx context.Context, client *Client, request *GetRoutineCodeVersionRequest, runtime *dara.RuntimeOptions) (_result *GetRoutineCodeVersionResponse, _err error) {
10274 if dara.BoolValue(client.EnableValidate) == true {
10275 _err = request.Validate()
10276 if _err != nil {
10277 return _result, _err
10278 }
10279 }
10280 body := map[string]interface{}{}
10281 if !dara.IsNil(request.CodeVersion) {
10282 body["CodeVersion"] = request.CodeVersion
10283 }
10284
10285 if !dara.IsNil(request.Name) {
10286 body["Name"] = request.Name
10287 }
10288
10289 req := &openapiutil.OpenApiRequest{
10290 Body: openapiutil.ParseToMap(body),
10291 }
10292 params := &openapiutil.Params{
10293 Action: dara.String("GetRoutineCodeVersion"),
10294 Version: dara.String("2024-09-10"),
10295 Protocol: dara.String("HTTPS"),
10296 Pathname: dara.String("/"),
10297 Method: dara.String("POST"),
10298 AuthType: dara.String("AK"),
10299 Style: dara.String("RPC"),
10300 ReqBodyType: dara.String("formData"),
10301 BodyType: dara.String("json"),
10302 }
10303 _result = &GetRoutineCodeVersionResponse{}
10304 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10305 if _err != nil {
10306 return _result, _err
10307 }
10308 _err = dara.Convert(_body, &_result)
10309 return _result, _err
10310 }
10311
10312 // Summary:
10313 //
10314 // Queries the route configurations of a single edge function.
10315 //
10316 // @param request - GetRoutineRouteRequest
10317 //
10318 // @param runtime - runtime options for this request RuntimeOptions
10319 //
10320 // @return GetRoutineRouteResponse
10321 func GetRoutineRouteWithContext(ctx context.Context, client *Client, request *GetRoutineRouteRequest, runtime *dara.RuntimeOptions) (_result *GetRoutineRouteResponse, _err error) {
10322 if dara.BoolValue(client.EnableValidate) == true {
10323 _err = request.Validate()
10324 if _err != nil {
10325 return _result, _err
10326 }
10327 }
10328 query := map[string]interface{}{}
10329 if !dara.IsNil(request.ConfigId) {
10330 query["ConfigId"] = request.ConfigId
10331 }
10332
10333 if !dara.IsNil(request.SiteId) {
10334 query["SiteId"] = request.SiteId
10335 }
10336
10337 req := &openapiutil.OpenApiRequest{
10338 Query: openapiutil.Query(query),
10339 }
10340 params := &openapiutil.Params{
10341 Action: dara.String("GetRoutineRoute"),
10342 Version: dara.String("2024-09-10"),
10343 Protocol: dara.String("HTTPS"),
10344 Pathname: dara.String("/"),
10345 Method: dara.String("POST"),
10346 AuthType: dara.String("AK"),
10347 Style: dara.String("RPC"),
10348 ReqBodyType: dara.String("formData"),
10349 BodyType: dara.String("json"),
10350 }
10351 _result = &GetRoutineRouteResponse{}
10352 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10353 if _err != nil {
10354 return _result, _err
10355 }
10356 _err = dara.Convert(_body, &_result)
10357 return _result, _err
10358 }
10359
10360 // Summary:
10361 //
10362 // Obtains the release information about the routine code that is released to the staging environment. This information can be used to upload the test code to Object Storage Service (OSS).
10363 //
10364 // Description:
10365 //
10366 // Every time the code of a routine is released to the staging environment, a version number is generated. Such code is for tests only.
10367 //
10368 // - A routine can retain a maximum of 10 code versions. If the number of versions reaches the limit, you must call the DeleteRoutineCodeRevision operation to delete unwanted versions.
10369 //
10370 // @param request - GetRoutineStagingCodeUploadInfoRequest
10371 //
10372 // @param runtime - runtime options for this request RuntimeOptions
10373 //
10374 // @return GetRoutineStagingCodeUploadInfoResponse
10375 func GetRoutineStagingCodeUploadInfoWithContext(ctx context.Context, client *Client, request *GetRoutineStagingCodeUploadInfoRequest, runtime *dara.RuntimeOptions) (_result *GetRoutineStagingCodeUploadInfoResponse, _err error) {
10376 if dara.BoolValue(client.EnableValidate) == true {
10377 _err = request.Validate()
10378 if _err != nil {
10379 return _result, _err
10380 }
10381 }
10382 body := map[string]interface{}{}
10383 if !dara.IsNil(request.CodeDescription) {
10384 body["CodeDescription"] = request.CodeDescription
10385 }
10386
10387 if !dara.IsNil(request.Name) {
10388 body["Name"] = request.Name
10389 }
10390
10391 req := &openapiutil.OpenApiRequest{
10392 Body: openapiutil.ParseToMap(body),
10393 }
10394 params := &openapiutil.Params{
10395 Action: dara.String("GetRoutineStagingCodeUploadInfo"),
10396 Version: dara.String("2024-09-10"),
10397 Protocol: dara.String("HTTPS"),
10398 Pathname: dara.String("/"),
10399 Method: dara.String("POST"),
10400 AuthType: dara.String("AK"),
10401 Style: dara.String("RPC"),
10402 ReqBodyType: dara.String("formData"),
10403 BodyType: dara.String("json"),
10404 }
10405 _result = &GetRoutineStagingCodeUploadInfoResponse{}
10406 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10407 if _err != nil {
10408 return _result, _err
10409 }
10410 _err = dara.Convert(_body, &_result)
10411 return _result, _err
10412 }
10413
10414 // Summary:
10415 //
10416 // Queries a specified scheduled prefetch task based on the task ID.
10417 //
10418 // @param request - GetScheduledPreloadJobRequest
10419 //
10420 // @param runtime - runtime options for this request RuntimeOptions
10421 //
10422 // @return GetScheduledPreloadJobResponse
10423 func GetScheduledPreloadJobWithContext(ctx context.Context, client *Client, request *GetScheduledPreloadJobRequest, runtime *dara.RuntimeOptions) (_result *GetScheduledPreloadJobResponse, _err error) {
10424 if dara.BoolValue(client.EnableValidate) == true {
10425 _err = request.Validate()
10426 if _err != nil {
10427 return _result, _err
10428 }
10429 }
10430 query := openapiutil.Query(dara.ToMap(request))
10431 req := &openapiutil.OpenApiRequest{
10432 Query: openapiutil.Query(query),
10433 }
10434 params := &openapiutil.Params{
10435 Action: dara.String("GetScheduledPreloadJob"),
10436 Version: dara.String("2024-09-10"),
10437 Protocol: dara.String("HTTPS"),
10438 Pathname: dara.String("/"),
10439 Method: dara.String("GET"),
10440 AuthType: dara.String("AK"),
10441 Style: dara.String("RPC"),
10442 ReqBodyType: dara.String("formData"),
10443 BodyType: dara.String("json"),
10444 }
10445 _result = &GetScheduledPreloadJobResponse{}
10446 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10447 if _err != nil {
10448 return _result, _err
10449 }
10450 _err = dara.Convert(_body, &_result)
10451 return _result, _err
10452 }
10453
10454 // Summary:
10455 //
10456 // Queries the configuration for search engine crawler of a website.
10457 //
10458 // @param request - GetSeoBypassRequest
10459 //
10460 // @param runtime - runtime options for this request RuntimeOptions
10461 //
10462 // @return GetSeoBypassResponse
10463 func GetSeoBypassWithContext(ctx context.Context, client *Client, request *GetSeoBypassRequest, runtime *dara.RuntimeOptions) (_result *GetSeoBypassResponse, _err error) {
10464 if dara.BoolValue(client.EnableValidate) == true {
10465 _err = request.Validate()
10466 if _err != nil {
10467 return _result, _err
10468 }
10469 }
10470 query := openapiutil.Query(dara.ToMap(request))
10471 req := &openapiutil.OpenApiRequest{
10472 Query: openapiutil.Query(query),
10473 }
10474 params := &openapiutil.Params{
10475 Action: dara.String("GetSeoBypass"),
10476 Version: dara.String("2024-09-10"),
10477 Protocol: dara.String("HTTPS"),
10478 Pathname: dara.String("/"),
10479 Method: dara.String("GET"),
10480 AuthType: dara.String("AK"),
10481 Style: dara.String("RPC"),
10482 ReqBodyType: dara.String("formData"),
10483 BodyType: dara.String("json"),
10484 }
10485 _result = &GetSeoBypassResponse{}
10486 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10487 if _err != nil {
10488 return _result, _err
10489 }
10490 _err = dara.Convert(_body, &_result)
10491 return _result, _err
10492 }
10493
10494 // Summary:
10495 //
10496 // Queries information about a website based on the website ID.
10497 //
10498 // @param request - GetSiteRequest
10499 //
10500 // @param runtime - runtime options for this request RuntimeOptions
10501 //
10502 // @return GetSiteResponse
10503 func GetSiteWithContext(ctx context.Context, client *Client, request *GetSiteRequest, runtime *dara.RuntimeOptions) (_result *GetSiteResponse, _err error) {
10504 if dara.BoolValue(client.EnableValidate) == true {
10505 _err = request.Validate()
10506 if _err != nil {
10507 return _result, _err
10508 }
10509 }
10510 query := openapiutil.Query(dara.ToMap(request))
10511 req := &openapiutil.OpenApiRequest{
10512 Query: openapiutil.Query(query),
10513 }
10514 params := &openapiutil.Params{
10515 Action: dara.String("GetSite"),
10516 Version: dara.String("2024-09-10"),
10517 Protocol: dara.String("HTTPS"),
10518 Pathname: dara.String("/"),
10519 Method: dara.String("GET"),
10520 AuthType: dara.String("AK"),
10521 Style: dara.String("RPC"),
10522 ReqBodyType: dara.String("formData"),
10523 BodyType: dara.String("json"),
10524 }
10525 _result = &GetSiteResponse{}
10526 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10527 if _err != nil {
10528 return _result, _err
10529 }
10530 _err = dara.Convert(_body, &_result)
10531 return _result, _err
10532 }
10533
10534 // Summary:
10535 //
10536 // Queries the nameservers configured for a website.
10537 //
10538 // @param request - GetSiteCurrentNSRequest
10539 //
10540 // @param runtime - runtime options for this request RuntimeOptions
10541 //
10542 // @return GetSiteCurrentNSResponse
10543 func GetSiteCurrentNSWithContext(ctx context.Context, client *Client, request *GetSiteCurrentNSRequest, runtime *dara.RuntimeOptions) (_result *GetSiteCurrentNSResponse, _err error) {
10544 if dara.BoolValue(client.EnableValidate) == true {
10545 _err = request.Validate()
10546 if _err != nil {
10547 return _result, _err
10548 }
10549 }
10550 query := openapiutil.Query(dara.ToMap(request))
10551 req := &openapiutil.OpenApiRequest{
10552 Query: openapiutil.Query(query),
10553 }
10554 params := &openapiutil.Params{
10555 Action: dara.String("GetSiteCurrentNS"),
10556 Version: dara.String("2024-09-10"),
10557 Protocol: dara.String("HTTPS"),
10558 Pathname: dara.String("/"),
10559 Method: dara.String("GET"),
10560 AuthType: dara.String("AK"),
10561 Style: dara.String("RPC"),
10562 ReqBodyType: dara.String("formData"),
10563 BodyType: dara.String("json"),
10564 }
10565 _result = &GetSiteCurrentNSResponse{}
10566 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10567 if _err != nil {
10568 return _result, _err
10569 }
10570 _err = dara.Convert(_body, &_result)
10571 return _result, _err
10572 }
10573
10574 // Summary:
10575 //
10576 // Queries the configuration of custom log fields for a website.
10577 //
10578 // Description:
10579 //
10580 // **Description**: You can call this operation to query the configuration of custom log fields for a website, including custom fields in request headers, response headers, and cookies.
10581 //
10582 // - **Scenarios**: You can call this operation in scenarios where you need to obtain specific HTTP headers or cookie information for log analysis.
10583 //
10584 // - ****
10585 //
10586 // @param request - GetSiteCustomLogRequest
10587 //
10588 // @param runtime - runtime options for this request RuntimeOptions
10589 //
10590 // @return GetSiteCustomLogResponse
10591 func GetSiteCustomLogWithContext(ctx context.Context, client *Client, request *GetSiteCustomLogRequest, runtime *dara.RuntimeOptions) (_result *GetSiteCustomLogResponse, _err error) {
10592 if dara.BoolValue(client.EnableValidate) == true {
10593 _err = request.Validate()
10594 if _err != nil {
10595 return _result, _err
10596 }
10597 }
10598 query := openapiutil.Query(dara.ToMap(request))
10599 req := &openapiutil.OpenApiRequest{
10600 Query: openapiutil.Query(query),
10601 }
10602 params := &openapiutil.Params{
10603 Action: dara.String("GetSiteCustomLog"),
10604 Version: dara.String("2024-09-10"),
10605 Protocol: dara.String("HTTPS"),
10606 Pathname: dara.String("/"),
10607 Method: dara.String("GET"),
10608 AuthType: dara.String("AK"),
10609 Style: dara.String("RPC"),
10610 ReqBodyType: dara.String("formData"),
10611 BodyType: dara.String("json"),
10612 }
10613 _result = &GetSiteCustomLogResponse{}
10614 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10615 if _err != nil {
10616 return _result, _err
10617 }
10618 _err = dara.Convert(_body, &_result)
10619 return _result, _err
10620 }
10621
10622 // Summary:
10623 //
10624 // Queries a real-time log delivery task.
10625 //
10626 // @param request - GetSiteDeliveryTaskRequest
10627 //
10628 // @param runtime - runtime options for this request RuntimeOptions
10629 //
10630 // @return GetSiteDeliveryTaskResponse
10631 func GetSiteDeliveryTaskWithContext(ctx context.Context, client *Client, request *GetSiteDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *GetSiteDeliveryTaskResponse, _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 := openapiutil.Query(dara.ToMap(request))
10639 req := &openapiutil.OpenApiRequest{
10640 Query: openapiutil.Query(query),
10641 }
10642 params := &openapiutil.Params{
10643 Action: dara.String("GetSiteDeliveryTask"),
10644 Version: dara.String("2024-09-10"),
10645 Protocol: dara.String("HTTPS"),
10646 Pathname: dara.String("/"),
10647 Method: dara.String("GET"),
10648 AuthType: dara.String("AK"),
10649 Style: dara.String("RPC"),
10650 ReqBodyType: dara.String("formData"),
10651 BodyType: dara.String("json"),
10652 }
10653 _result = &GetSiteDeliveryTaskResponse{}
10654 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10655 if _err != nil {
10656 return _result, _err
10657 }
10658 _err = dara.Convert(_body, &_result)
10659 return _result, _err
10660 }
10661
10662 // Summary:
10663 //
10664 // Queries the remaining quota for delivering a specific category of real-time logs in a website.
10665 //
10666 // Description:
10667 //
10668 // You can call this operation to query the remaining quota for delivering a specific category of real-time logs in a website within an Alibaba Cloud account. This is essential for monitoring and managing your log delivery capacity to ensure that logs can be delivered to the destination and prevent data loss or latency caused by insufficient quota.
10669 //
10670 // **Take note of the following parameters:**
10671 //
10672 // - “
10673 //
10674 // - `BusinessType` is required. You must specify a log category to obtain the corresponding quota information.
10675 //
10676 // - `SiteId` specifies the ID of a website, which must be a valid integer that corresponds to a website that you configured on Alibaba Cloud.
10677 //
10678 // **Response:**
10679 //
10680 // - If a request is successful, the system returns the remaining log delivery quota (`FreeQuota`), request ID (`RequestId`), website ID (`SiteId`), and log category (`BusinessType`). You can confirm and record the returned data.
10681 //
10682 // @param request - GetSiteLogDeliveryQuotaRequest
10683 //
10684 // @param runtime - runtime options for this request RuntimeOptions
10685 //
10686 // @return GetSiteLogDeliveryQuotaResponse
10687 func GetSiteLogDeliveryQuotaWithContext(ctx context.Context, client *Client, request *GetSiteLogDeliveryQuotaRequest, runtime *dara.RuntimeOptions) (_result *GetSiteLogDeliveryQuotaResponse, _err error) {
10688 if dara.BoolValue(client.EnableValidate) == true {
10689 _err = request.Validate()
10690 if _err != nil {
10691 return _result, _err
10692 }
10693 }
10694 query := openapiutil.Query(dara.ToMap(request))
10695 req := &openapiutil.OpenApiRequest{
10696 Query: openapiutil.Query(query),
10697 }
10698 params := &openapiutil.Params{
10699 Action: dara.String("GetSiteLogDeliveryQuota"),
10700 Version: dara.String("2024-09-10"),
10701 Protocol: dara.String("HTTPS"),
10702 Pathname: dara.String("/"),
10703 Method: dara.String("GET"),
10704 AuthType: dara.String("AK"),
10705 Style: dara.String("RPC"),
10706 ReqBodyType: dara.String("formData"),
10707 BodyType: dara.String("json"),
10708 }
10709 _result = &GetSiteLogDeliveryQuotaResponse{}
10710 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10711 if _err != nil {
10712 return _result, _err
10713 }
10714 _err = dara.Convert(_body, &_result)
10715 return _result, _err
10716 }
10717
10718 // Summary:
10719 //
10720 // Queries the site hold configuration of a website. After you enable site hold, other accounts cannot add your website domain or its subdomains to ESA.
10721 //
10722 // @param request - GetSiteNameExclusiveRequest
10723 //
10724 // @param runtime - runtime options for this request RuntimeOptions
10725 //
10726 // @return GetSiteNameExclusiveResponse
10727 func GetSiteNameExclusiveWithContext(ctx context.Context, client *Client, request *GetSiteNameExclusiveRequest, runtime *dara.RuntimeOptions) (_result *GetSiteNameExclusiveResponse, _err error) {
10728 if dara.BoolValue(client.EnableValidate) == true {
10729 _err = request.Validate()
10730 if _err != nil {
10731 return _result, _err
10732 }
10733 }
10734 query := openapiutil.Query(dara.ToMap(request))
10735 req := &openapiutil.OpenApiRequest{
10736 Query: openapiutil.Query(query),
10737 }
10738 params := &openapiutil.Params{
10739 Action: dara.String("GetSiteNameExclusive"),
10740 Version: dara.String("2024-09-10"),
10741 Protocol: dara.String("HTTPS"),
10742 Pathname: dara.String("/"),
10743 Method: dara.String("GET"),
10744 AuthType: dara.String("AK"),
10745 Style: dara.String("RPC"),
10746 ReqBodyType: dara.String("formData"),
10747 BodyType: dara.String("json"),
10748 }
10749 _result = &GetSiteNameExclusiveResponse{}
10750 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10751 if _err != nil {
10752 return _result, _err
10753 }
10754 _err = dara.Convert(_body, &_result)
10755 return _result, _err
10756 }
10757
10758 // Summary:
10759 //
10760 // 获取站点回源客户端证书信息
10761 //
10762 // @param request - GetSiteOriginClientCertificateRequest
10763 //
10764 // @param runtime - runtime options for this request RuntimeOptions
10765 //
10766 // @return GetSiteOriginClientCertificateResponse
10767 func GetSiteOriginClientCertificateWithContext(ctx context.Context, client *Client, request *GetSiteOriginClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *GetSiteOriginClientCertificateResponse, _err error) {
10768 if dara.BoolValue(client.EnableValidate) == true {
10769 _err = request.Validate()
10770 if _err != nil {
10771 return _result, _err
10772 }
10773 }
10774 query := openapiutil.Query(dara.ToMap(request))
10775 req := &openapiutil.OpenApiRequest{
10776 Query: openapiutil.Query(query),
10777 }
10778 params := &openapiutil.Params{
10779 Action: dara.String("GetSiteOriginClientCertificate"),
10780 Version: dara.String("2024-09-10"),
10781 Protocol: dara.String("HTTPS"),
10782 Pathname: dara.String("/"),
10783 Method: dara.String("GET"),
10784 AuthType: dara.String("AK"),
10785 Style: dara.String("RPC"),
10786 ReqBodyType: dara.String("formData"),
10787 BodyType: dara.String("json"),
10788 }
10789 _result = &GetSiteOriginClientCertificateResponse{}
10790 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10791 if _err != nil {
10792 return _result, _err
10793 }
10794 _err = dara.Convert(_body, &_result)
10795 return _result, _err
10796 }
10797
10798 // Summary:
10799 //
10800 // Queries the ESA proxy configuration of a website.
10801 //
10802 // @param request - GetSitePauseRequest
10803 //
10804 // @param runtime - runtime options for this request RuntimeOptions
10805 //
10806 // @return GetSitePauseResponse
10807 func GetSitePauseWithContext(ctx context.Context, client *Client, request *GetSitePauseRequest, runtime *dara.RuntimeOptions) (_result *GetSitePauseResponse, _err error) {
10808 if dara.BoolValue(client.EnableValidate) == true {
10809 _err = request.Validate()
10810 if _err != nil {
10811 return _result, _err
10812 }
10813 }
10814 query := openapiutil.Query(dara.ToMap(request))
10815 req := &openapiutil.OpenApiRequest{
10816 Query: openapiutil.Query(query),
10817 }
10818 params := &openapiutil.Params{
10819 Action: dara.String("GetSitePause"),
10820 Version: dara.String("2024-09-10"),
10821 Protocol: dara.String("HTTPS"),
10822 Pathname: dara.String("/"),
10823 Method: dara.String("GET"),
10824 AuthType: dara.String("AK"),
10825 Style: dara.String("RPC"),
10826 ReqBodyType: dara.String("formData"),
10827 BodyType: dara.String("json"),
10828 }
10829 _result = &GetSitePauseResponse{}
10830 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10831 if _err != nil {
10832 return _result, _err
10833 }
10834 _err = dara.Convert(_body, &_result)
10835 return _result, _err
10836 }
10837
10838 // Summary:
10839 //
10840 // # Get WAF Configuration for a Site
10841 //
10842 // @param request - GetSiteWafSettingsRequest
10843 //
10844 // @param runtime - runtime options for this request RuntimeOptions
10845 //
10846 // @return GetSiteWafSettingsResponse
10847 func GetSiteWafSettingsWithContext(ctx context.Context, client *Client, request *GetSiteWafSettingsRequest, runtime *dara.RuntimeOptions) (_result *GetSiteWafSettingsResponse, _err error) {
10848 if dara.BoolValue(client.EnableValidate) == true {
10849 _err = request.Validate()
10850 if _err != nil {
10851 return _result, _err
10852 }
10853 }
10854 query := map[string]interface{}{}
10855 if !dara.IsNil(request.Path) {
10856 query["Path"] = request.Path
10857 }
10858
10859 if !dara.IsNil(request.SiteId) {
10860 query["SiteId"] = request.SiteId
10861 }
10862
10863 if !dara.IsNil(request.SiteVersion) {
10864 query["SiteVersion"] = request.SiteVersion
10865 }
10866
10867 req := &openapiutil.OpenApiRequest{
10868 Query: openapiutil.Query(query),
10869 }
10870 params := &openapiutil.Params{
10871 Action: dara.String("GetSiteWafSettings"),
10872 Version: dara.String("2024-09-10"),
10873 Protocol: dara.String("HTTPS"),
10874 Pathname: dara.String("/"),
10875 Method: dara.String("POST"),
10876 AuthType: dara.String("AK"),
10877 Style: dara.String("RPC"),
10878 ReqBodyType: dara.String("formData"),
10879 BodyType: dara.String("json"),
10880 }
10881 _result = &GetSiteWafSettingsResponse{}
10882 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10883 if _err != nil {
10884 return _result, _err
10885 }
10886 _err = dara.Convert(_body, &_result)
10887 return _result, _err
10888 }
10889
10890 // Summary:
10891 //
10892 // # Query Multi-level Cache Configuration for Site
10893 //
10894 // @param request - GetTieredCacheRequest
10895 //
10896 // @param runtime - runtime options for this request RuntimeOptions
10897 //
10898 // @return GetTieredCacheResponse
10899 func GetTieredCacheWithContext(ctx context.Context, client *Client, request *GetTieredCacheRequest, runtime *dara.RuntimeOptions) (_result *GetTieredCacheResponse, _err error) {
10900 if dara.BoolValue(client.EnableValidate) == true {
10901 _err = request.Validate()
10902 if _err != nil {
10903 return _result, _err
10904 }
10905 }
10906 query := openapiutil.Query(dara.ToMap(request))
10907 req := &openapiutil.OpenApiRequest{
10908 Query: openapiutil.Query(query),
10909 }
10910 params := &openapiutil.Params{
10911 Action: dara.String("GetTieredCache"),
10912 Version: dara.String("2024-09-10"),
10913 Protocol: dara.String("HTTPS"),
10914 Pathname: dara.String("/"),
10915 Method: dara.String("GET"),
10916 AuthType: dara.String("AK"),
10917 Style: dara.String("RPC"),
10918 ReqBodyType: dara.String("formData"),
10919 BodyType: dara.String("json"),
10920 }
10921 _result = &GetTieredCacheResponse{}
10922 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10923 if _err != nil {
10924 return _result, _err
10925 }
10926 _err = dara.Convert(_body, &_result)
10927 return _result, _err
10928 }
10929
10930 // Summary:
10931 //
10932 // # Query details of the transport layer application
10933 //
10934 // @param request - GetTransportLayerApplicationRequest
10935 //
10936 // @param runtime - runtime options for this request RuntimeOptions
10937 //
10938 // @return GetTransportLayerApplicationResponse
10939 func GetTransportLayerApplicationWithContext(ctx context.Context, client *Client, request *GetTransportLayerApplicationRequest, runtime *dara.RuntimeOptions) (_result *GetTransportLayerApplicationResponse, _err error) {
10940 if dara.BoolValue(client.EnableValidate) == true {
10941 _err = request.Validate()
10942 if _err != nil {
10943 return _result, _err
10944 }
10945 }
10946 query := openapiutil.Query(dara.ToMap(request))
10947 req := &openapiutil.OpenApiRequest{
10948 Query: openapiutil.Query(query),
10949 }
10950 params := &openapiutil.Params{
10951 Action: dara.String("GetTransportLayerApplication"),
10952 Version: dara.String("2024-09-10"),
10953 Protocol: dara.String("HTTPS"),
10954 Pathname: dara.String("/"),
10955 Method: dara.String("GET"),
10956 AuthType: dara.String("AK"),
10957 Style: dara.String("RPC"),
10958 ReqBodyType: dara.String("formData"),
10959 BodyType: dara.String("json"),
10960 }
10961 _result = &GetTransportLayerApplicationResponse{}
10962 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
10963 if _err != nil {
10964 return _result, _err
10965 }
10966 _err = dara.Convert(_body, &_result)
10967 return _result, _err
10968 }
10969
10970 // Summary:
10971 //
10972 // Queries the execution status and running information of a file upload task based on the task ID.
10973 //
10974 // @param request - GetUploadTaskRequest
10975 //
10976 // @param runtime - runtime options for this request RuntimeOptions
10977 //
10978 // @return GetUploadTaskResponse
10979 func GetUploadTaskWithContext(ctx context.Context, client *Client, request *GetUploadTaskRequest, runtime *dara.RuntimeOptions) (_result *GetUploadTaskResponse, _err error) {
10980 if dara.BoolValue(client.EnableValidate) == true {
10981 _err = request.Validate()
10982 if _err != nil {
10983 return _result, _err
10984 }
10985 }
10986 query := openapiutil.Query(dara.ToMap(request))
10987 req := &openapiutil.OpenApiRequest{
10988 Query: openapiutil.Query(query),
10989 }
10990 params := &openapiutil.Params{
10991 Action: dara.String("GetUploadTask"),
10992 Version: dara.String("2024-09-10"),
10993 Protocol: dara.String("HTTPS"),
10994 Pathname: dara.String("/"),
10995 Method: dara.String("GET"),
10996 AuthType: dara.String("AK"),
10997 Style: dara.String("RPC"),
10998 ReqBodyType: dara.String("formData"),
10999 BodyType: dara.String("json"),
11000 }
11001 _result = &GetUploadTaskResponse{}
11002 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11003 if _err != nil {
11004 return _result, _err
11005 }
11006 _err = dara.Convert(_body, &_result)
11007 return _result, _err
11008 }
11009
11010 // Summary:
11011 //
11012 // Queries the information about a log delivery task by account.
11013 //
11014 // Description:
11015 //
11016 // This API operation queries the details of a delivery task, including the task name, discard rate, region, log category, status, delivery destination, configuration, and filtering rules.****
11017 //
11018 // - You can call this operation to query detailed information about a log delivery task to analyze log processing efficiency or troubleshoot delivery problems.****
11019 //
11020 // - ****````
11021 //
11022 // @param request - GetUserDeliveryTaskRequest
11023 //
11024 // @param runtime - runtime options for this request RuntimeOptions
11025 //
11026 // @return GetUserDeliveryTaskResponse
11027 func GetUserDeliveryTaskWithContext(ctx context.Context, client *Client, request *GetUserDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *GetUserDeliveryTaskResponse, _err error) {
11028 if dara.BoolValue(client.EnableValidate) == true {
11029 _err = request.Validate()
11030 if _err != nil {
11031 return _result, _err
11032 }
11033 }
11034 query := openapiutil.Query(dara.ToMap(request))
11035 req := &openapiutil.OpenApiRequest{
11036 Query: openapiutil.Query(query),
11037 }
11038 params := &openapiutil.Params{
11039 Action: dara.String("GetUserDeliveryTask"),
11040 Version: dara.String("2024-09-10"),
11041 Protocol: dara.String("HTTPS"),
11042 Pathname: dara.String("/"),
11043 Method: dara.String("GET"),
11044 AuthType: dara.String("AK"),
11045 Style: dara.String("RPC"),
11046 ReqBodyType: dara.String("formData"),
11047 BodyType: dara.String("json"),
11048 }
11049 _result = &GetUserDeliveryTaskResponse{}
11050 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11051 if _err != nil {
11052 return _result, _err
11053 }
11054 _err = dara.Convert(_body, &_result)
11055 return _result, _err
11056 }
11057
11058 // Summary:
11059 //
11060 // Queries the remaining log delivery quota of each log category in your account.
11061 //
11062 // Description:
11063 //
11064 // This operation allows you to query the remaining real-time log delivery quota of each log category in your Alibaba Cloud account. You must provide your Alibaba Cloud account ID (aliUid) and log category (BusinessType). The system then returns the remaining quota of the log category to help you track the usage.
11065 //
11066 // @param request - GetUserLogDeliveryQuotaRequest
11067 //
11068 // @param runtime - runtime options for this request RuntimeOptions
11069 //
11070 // @return GetUserLogDeliveryQuotaResponse
11071 func GetUserLogDeliveryQuotaWithContext(ctx context.Context, client *Client, request *GetUserLogDeliveryQuotaRequest, runtime *dara.RuntimeOptions) (_result *GetUserLogDeliveryQuotaResponse, _err error) {
11072 if dara.BoolValue(client.EnableValidate) == true {
11073 _err = request.Validate()
11074 if _err != nil {
11075 return _result, _err
11076 }
11077 }
11078 query := openapiutil.Query(dara.ToMap(request))
11079 req := &openapiutil.OpenApiRequest{
11080 Query: openapiutil.Query(query),
11081 }
11082 params := &openapiutil.Params{
11083 Action: dara.String("GetUserLogDeliveryQuota"),
11084 Version: dara.String("2024-09-10"),
11085 Protocol: dara.String("HTTPS"),
11086 Pathname: dara.String("/"),
11087 Method: dara.String("GET"),
11088 AuthType: dara.String("AK"),
11089 Style: dara.String("RPC"),
11090 ReqBodyType: dara.String("formData"),
11091 BodyType: dara.String("json"),
11092 }
11093 _result = &GetUserLogDeliveryQuotaResponse{}
11094 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11095 if _err != nil {
11096 return _result, _err
11097 }
11098 _err = dara.Convert(_body, &_result)
11099 return _result, _err
11100 }
11101
11102 // Summary:
11103 //
11104 // 用于获取实例级别的Web应用防火墙规则集详情
11105 //
11106 // @param request - GetUserWafRulesetRequest
11107 //
11108 // @param runtime - runtime options for this request RuntimeOptions
11109 //
11110 // @return GetUserWafRulesetResponse
11111 func GetUserWafRulesetWithContext(ctx context.Context, client *Client, request *GetUserWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *GetUserWafRulesetResponse, _err error) {
11112 if dara.BoolValue(client.EnableValidate) == true {
11113 _err = request.Validate()
11114 if _err != nil {
11115 return _result, _err
11116 }
11117 }
11118 query := map[string]interface{}{}
11119 if !dara.IsNil(request.Id) {
11120 query["Id"] = request.Id
11121 }
11122
11123 if !dara.IsNil(request.InstanceId) {
11124 query["InstanceId"] = request.InstanceId
11125 }
11126
11127 req := &openapiutil.OpenApiRequest{
11128 Query: openapiutil.Query(query),
11129 }
11130 params := &openapiutil.Params{
11131 Action: dara.String("GetUserWafRuleset"),
11132 Version: dara.String("2024-09-10"),
11133 Protocol: dara.String("HTTPS"),
11134 Pathname: dara.String("/"),
11135 Method: dara.String("POST"),
11136 AuthType: dara.String("AK"),
11137 Style: dara.String("RPC"),
11138 ReqBodyType: dara.String("formData"),
11139 BodyType: dara.String("json"),
11140 }
11141 _result = &GetUserWafRulesetResponse{}
11142 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11143 if _err != nil {
11144 return _result, _err
11145 }
11146 _err = dara.Convert(_body, &_result)
11147 return _result, _err
11148 }
11149
11150 // Summary:
11151 //
11152 // Queries the video processing configuration details of a site.
11153 //
11154 // @param request - GetVideoProcessingRequest
11155 //
11156 // @param runtime - runtime options for this request RuntimeOptions
11157 //
11158 // @return GetVideoProcessingResponse
11159 func GetVideoProcessingWithContext(ctx context.Context, client *Client, request *GetVideoProcessingRequest, runtime *dara.RuntimeOptions) (_result *GetVideoProcessingResponse, _err error) {
11160 if dara.BoolValue(client.EnableValidate) == true {
11161 _err = request.Validate()
11162 if _err != nil {
11163 return _result, _err
11164 }
11165 }
11166 query := map[string]interface{}{}
11167 if !dara.IsNil(request.ConfigId) {
11168 query["ConfigId"] = request.ConfigId
11169 }
11170
11171 if !dara.IsNil(request.SiteId) {
11172 query["SiteId"] = request.SiteId
11173 }
11174
11175 req := &openapiutil.OpenApiRequest{
11176 Query: openapiutil.Query(query),
11177 }
11178 params := &openapiutil.Params{
11179 Action: dara.String("GetVideoProcessing"),
11180 Version: dara.String("2024-09-10"),
11181 Protocol: dara.String("HTTPS"),
11182 Pathname: dara.String("/"),
11183 Method: dara.String("POST"),
11184 AuthType: dara.String("AK"),
11185 Style: dara.String("RPC"),
11186 ReqBodyType: dara.String("formData"),
11187 BodyType: dara.String("json"),
11188 }
11189 _result = &GetVideoProcessingResponse{}
11190 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11191 if _err != nil {
11192 return _result, _err
11193 }
11194 _err = dara.Convert(_body, &_result)
11195 return _result, _err
11196 }
11197
11198 // Summary:
11199 //
11200 // Queries the conditions for matching incoming requests that are configured in a WAF rule category for a website. These conditions define how WAF detects and processes different types of requests.
11201 //
11202 // @param request - GetWafFilterRequest
11203 //
11204 // @param runtime - runtime options for this request RuntimeOptions
11205 //
11206 // @return GetWafFilterResponse
11207 func GetWafFilterWithContext(ctx context.Context, client *Client, request *GetWafFilterRequest, runtime *dara.RuntimeOptions) (_result *GetWafFilterResponse, _err error) {
11208 if dara.BoolValue(client.EnableValidate) == true {
11209 _err = request.Validate()
11210 if _err != nil {
11211 return _result, _err
11212 }
11213 }
11214 query := map[string]interface{}{}
11215 if !dara.IsNil(request.Phase) {
11216 query["Phase"] = request.Phase
11217 }
11218
11219 if !dara.IsNil(request.SiteId) {
11220 query["SiteId"] = request.SiteId
11221 }
11222
11223 if !dara.IsNil(request.Target) {
11224 query["Target"] = request.Target
11225 }
11226
11227 if !dara.IsNil(request.Type) {
11228 query["Type"] = request.Type
11229 }
11230
11231 req := &openapiutil.OpenApiRequest{
11232 Query: openapiutil.Query(query),
11233 }
11234 params := &openapiutil.Params{
11235 Action: dara.String("GetWafFilter"),
11236 Version: dara.String("2024-09-10"),
11237 Protocol: dara.String("HTTPS"),
11238 Pathname: dara.String("/"),
11239 Method: dara.String("POST"),
11240 AuthType: dara.String("AK"),
11241 Style: dara.String("RPC"),
11242 ReqBodyType: dara.String("formData"),
11243 BodyType: dara.String("json"),
11244 }
11245 _result = &GetWafFilterResponse{}
11246 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11247 if _err != nil {
11248 return _result, _err
11249 }
11250 _err = dara.Convert(_body, &_result)
11251 return _result, _err
11252 }
11253
11254 // Summary:
11255 //
11256 // # Get WAF Quota Details
11257 //
11258 // @param request - GetWafQuotaRequest
11259 //
11260 // @param runtime - runtime options for this request RuntimeOptions
11261 //
11262 // @return GetWafQuotaResponse
11263 func GetWafQuotaWithContext(ctx context.Context, client *Client, request *GetWafQuotaRequest, runtime *dara.RuntimeOptions) (_result *GetWafQuotaResponse, _err error) {
11264 if dara.BoolValue(client.EnableValidate) == true {
11265 _err = request.Validate()
11266 if _err != nil {
11267 return _result, _err
11268 }
11269 }
11270 query := map[string]interface{}{}
11271 if !dara.IsNil(request.Paths) {
11272 query["Paths"] = request.Paths
11273 }
11274
11275 req := &openapiutil.OpenApiRequest{
11276 Query: openapiutil.Query(query),
11277 }
11278 params := &openapiutil.Params{
11279 Action: dara.String("GetWafQuota"),
11280 Version: dara.String("2024-09-10"),
11281 Protocol: dara.String("HTTPS"),
11282 Pathname: dara.String("/"),
11283 Method: dara.String("POST"),
11284 AuthType: dara.String("AK"),
11285 Style: dara.String("RPC"),
11286 ReqBodyType: dara.String("formData"),
11287 BodyType: dara.String("json"),
11288 }
11289 _result = &GetWafQuotaResponse{}
11290 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11291 if _err != nil {
11292 return _result, _err
11293 }
11294 _err = dara.Convert(_body, &_result)
11295 return _result, _err
11296 }
11297
11298 // Summary:
11299 //
11300 // # Get Details of a Single WAF Rule
11301 //
11302 // @param request - GetWafRuleRequest
11303 //
11304 // @param runtime - runtime options for this request RuntimeOptions
11305 //
11306 // @return GetWafRuleResponse
11307 func GetWafRuleWithContext(ctx context.Context, client *Client, request *GetWafRuleRequest, runtime *dara.RuntimeOptions) (_result *GetWafRuleResponse, _err error) {
11308 if dara.BoolValue(client.EnableValidate) == true {
11309 _err = request.Validate()
11310 if _err != nil {
11311 return _result, _err
11312 }
11313 }
11314 query := map[string]interface{}{}
11315 if !dara.IsNil(request.Id) {
11316 query["Id"] = request.Id
11317 }
11318
11319 if !dara.IsNil(request.SiteId) {
11320 query["SiteId"] = request.SiteId
11321 }
11322
11323 req := &openapiutil.OpenApiRequest{
11324 Query: openapiutil.Query(query),
11325 }
11326 params := &openapiutil.Params{
11327 Action: dara.String("GetWafRule"),
11328 Version: dara.String("2024-09-10"),
11329 Protocol: dara.String("HTTPS"),
11330 Pathname: dara.String("/"),
11331 Method: dara.String("POST"),
11332 AuthType: dara.String("AK"),
11333 Style: dara.String("RPC"),
11334 ReqBodyType: dara.String("formData"),
11335 BodyType: dara.String("json"),
11336 }
11337 _result = &GetWafRuleResponse{}
11338 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11339 if _err != nil {
11340 return _result, _err
11341 }
11342 _err = dara.Convert(_body, &_result)
11343 return _result, _err
11344 }
11345
11346 // Summary:
11347 //
11348 // # Get WAF Ruleset Details
11349 //
11350 // @param request - GetWafRulesetRequest
11351 //
11352 // @param runtime - runtime options for this request RuntimeOptions
11353 //
11354 // @return GetWafRulesetResponse
11355 func GetWafRulesetWithContext(ctx context.Context, client *Client, request *GetWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *GetWafRulesetResponse, _err error) {
11356 if dara.BoolValue(client.EnableValidate) == true {
11357 _err = request.Validate()
11358 if _err != nil {
11359 return _result, _err
11360 }
11361 }
11362 query := map[string]interface{}{}
11363 if !dara.IsNil(request.Id) {
11364 query["Id"] = request.Id
11365 }
11366
11367 if !dara.IsNil(request.Phase) {
11368 query["Phase"] = request.Phase
11369 }
11370
11371 if !dara.IsNil(request.SiteId) {
11372 query["SiteId"] = request.SiteId
11373 }
11374
11375 req := &openapiutil.OpenApiRequest{
11376 Query: openapiutil.Query(query),
11377 }
11378 params := &openapiutil.Params{
11379 Action: dara.String("GetWafRuleset"),
11380 Version: dara.String("2024-09-10"),
11381 Protocol: dara.String("HTTPS"),
11382 Pathname: dara.String("/"),
11383 Method: dara.String("POST"),
11384 AuthType: dara.String("AK"),
11385 Style: dara.String("RPC"),
11386 ReqBodyType: dara.String("formData"),
11387 BodyType: dara.String("json"),
11388 }
11389 _result = &GetWafRulesetResponse{}
11390 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11391 if _err != nil {
11392 return _result, _err
11393 }
11394 _err = dara.Convert(_body, &_result)
11395 return _result, _err
11396 }
11397
11398 // Summary:
11399 //
11400 // # Query Cache Reserve Instance List
11401 //
11402 // @param request - ListCacheReserveInstancesRequest
11403 //
11404 // @param runtime - runtime options for this request RuntimeOptions
11405 //
11406 // @return ListCacheReserveInstancesResponse
11407 func ListCacheReserveInstancesWithContext(ctx context.Context, client *Client, request *ListCacheReserveInstancesRequest, runtime *dara.RuntimeOptions) (_result *ListCacheReserveInstancesResponse, _err error) {
11408 if dara.BoolValue(client.EnableValidate) == true {
11409 _err = request.Validate()
11410 if _err != nil {
11411 return _result, _err
11412 }
11413 }
11414 query := openapiutil.Query(dara.ToMap(request))
11415 req := &openapiutil.OpenApiRequest{
11416 Query: openapiutil.Query(query),
11417 }
11418 params := &openapiutil.Params{
11419 Action: dara.String("ListCacheReserveInstances"),
11420 Version: dara.String("2024-09-10"),
11421 Protocol: dara.String("HTTPS"),
11422 Pathname: dara.String("/"),
11423 Method: dara.String("GET"),
11424 AuthType: dara.String("AK"),
11425 Style: dara.String("RPC"),
11426 ReqBodyType: dara.String("formData"),
11427 BodyType: dara.String("json"),
11428 }
11429 _result = &ListCacheReserveInstancesResponse{}
11430 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11431 if _err != nil {
11432 return _result, _err
11433 }
11434 _err = dara.Convert(_body, &_result)
11435 return _result, _err
11436 }
11437
11438 // Summary:
11439 //
11440 // # Query multiple cache configurations
11441 //
11442 // @param request - ListCacheRulesRequest
11443 //
11444 // @param runtime - runtime options for this request RuntimeOptions
11445 //
11446 // @return ListCacheRulesResponse
11447 func ListCacheRulesWithContext(ctx context.Context, client *Client, request *ListCacheRulesRequest, runtime *dara.RuntimeOptions) (_result *ListCacheRulesResponse, _err error) {
11448 if dara.BoolValue(client.EnableValidate) == true {
11449 _err = request.Validate()
11450 if _err != nil {
11451 return _result, _err
11452 }
11453 }
11454 query := openapiutil.Query(dara.ToMap(request))
11455 req := &openapiutil.OpenApiRequest{
11456 Query: openapiutil.Query(query),
11457 }
11458 params := &openapiutil.Params{
11459 Action: dara.String("ListCacheRules"),
11460 Version: dara.String("2024-09-10"),
11461 Protocol: dara.String("HTTPS"),
11462 Pathname: dara.String("/"),
11463 Method: dara.String("GET"),
11464 AuthType: dara.String("AK"),
11465 Style: dara.String("RPC"),
11466 ReqBodyType: dara.String("formData"),
11467 BodyType: dara.String("json"),
11468 }
11469 _result = &ListCacheRulesResponse{}
11470 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11471 if _err != nil {
11472 return _result, _err
11473 }
11474 _err = dara.Convert(_body, &_result)
11475 return _result, _err
11476 }
11477
11478 // Summary:
11479 //
11480 // Lists certificates of a website.
11481 //
11482 // @param request - ListCertificatesRequest
11483 //
11484 // @param runtime - runtime options for this request RuntimeOptions
11485 //
11486 // @return ListCertificatesResponse
11487 func ListCertificatesWithContext(ctx context.Context, client *Client, request *ListCertificatesRequest, runtime *dara.RuntimeOptions) (_result *ListCertificatesResponse, _err error) {
11488 if dara.BoolValue(client.EnableValidate) == true {
11489 _err = request.Validate()
11490 if _err != nil {
11491 return _result, _err
11492 }
11493 }
11494 query := openapiutil.Query(dara.ToMap(request))
11495 req := &openapiutil.OpenApiRequest{
11496 Query: openapiutil.Query(query),
11497 }
11498 params := &openapiutil.Params{
11499 Action: dara.String("ListCertificates"),
11500 Version: dara.String("2024-09-10"),
11501 Protocol: dara.String("HTTPS"),
11502 Pathname: dara.String("/"),
11503 Method: dara.String("GET"),
11504 AuthType: dara.String("AK"),
11505 Style: dara.String("RPC"),
11506 ReqBodyType: dara.String("formData"),
11507 BodyType: dara.String("json"),
11508 }
11509 _result = &ListCertificatesResponse{}
11510 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11511 if _err != nil {
11512 return _result, _err
11513 }
11514 _err = dara.Convert(_body, &_result)
11515 return _result, _err
11516 }
11517
11518 // Summary:
11519 //
11520 // Lists certificates that match specified records for a website. You can specify multiple records at a time.
11521 //
11522 // @param request - ListCertificatesByRecordRequest
11523 //
11524 // @param runtime - runtime options for this request RuntimeOptions
11525 //
11526 // @return ListCertificatesByRecordResponse
11527 func ListCertificatesByRecordWithContext(ctx context.Context, client *Client, request *ListCertificatesByRecordRequest, runtime *dara.RuntimeOptions) (_result *ListCertificatesByRecordResponse, _err error) {
11528 if dara.BoolValue(client.EnableValidate) == true {
11529 _err = request.Validate()
11530 if _err != nil {
11531 return _result, _err
11532 }
11533 }
11534 query := openapiutil.Query(dara.ToMap(request))
11535 req := &openapiutil.OpenApiRequest{
11536 Query: openapiutil.Query(query),
11537 }
11538 params := &openapiutil.Params{
11539 Action: dara.String("ListCertificatesByRecord"),
11540 Version: dara.String("2024-09-10"),
11541 Protocol: dara.String("HTTPS"),
11542 Pathname: dara.String("/"),
11543 Method: dara.String("GET"),
11544 AuthType: dara.String("AK"),
11545 Style: dara.String("RPC"),
11546 ReqBodyType: dara.String("formData"),
11547 BodyType: dara.String("json"),
11548 }
11549 _result = &ListCertificatesByRecordResponse{}
11550 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11551 if _err != nil {
11552 return _result, _err
11553 }
11554 _err = dara.Convert(_body, &_result)
11555 return _result, _err
11556 }
11557
11558 // Summary:
11559 //
11560 // # Query TLS Cipher Suite List
11561 //
11562 // @param request - ListCiphersRequest
11563 //
11564 // @param runtime - runtime options for this request RuntimeOptions
11565 //
11566 // @return ListCiphersResponse
11567 func ListCiphersWithContext(ctx context.Context, client *Client, request *ListCiphersRequest, runtime *dara.RuntimeOptions) (_result *ListCiphersResponse, _err error) {
11568 if dara.BoolValue(client.EnableValidate) == true {
11569 _err = request.Validate()
11570 if _err != nil {
11571 return _result, _err
11572 }
11573 }
11574 query := openapiutil.Query(dara.ToMap(request))
11575 req := &openapiutil.OpenApiRequest{
11576 Query: openapiutil.Query(query),
11577 }
11578 params := &openapiutil.Params{
11579 Action: dara.String("ListCiphers"),
11580 Version: dara.String("2024-09-10"),
11581 Protocol: dara.String("HTTPS"),
11582 Pathname: dara.String("/"),
11583 Method: dara.String("GET"),
11584 AuthType: dara.String("AK"),
11585 Style: dara.String("RPC"),
11586 ReqBodyType: dara.String("formData"),
11587 BodyType: dara.String("json"),
11588 }
11589 _result = &ListCiphersResponse{}
11590 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11591 if _err != nil {
11592 return _result, _err
11593 }
11594 _err = dara.Convert(_body, &_result)
11595 return _result, _err
11596 }
11597
11598 // Summary:
11599 //
11600 // Queries a list of client certificate authority (CA) certificates for a website.
11601 //
11602 // @param request - ListClientCaCertificatesRequest
11603 //
11604 // @param runtime - runtime options for this request RuntimeOptions
11605 //
11606 // @return ListClientCaCertificatesResponse
11607 func ListClientCaCertificatesWithContext(ctx context.Context, client *Client, request *ListClientCaCertificatesRequest, runtime *dara.RuntimeOptions) (_result *ListClientCaCertificatesResponse, _err error) {
11608 if dara.BoolValue(client.EnableValidate) == true {
11609 _err = request.Validate()
11610 if _err != nil {
11611 return _result, _err
11612 }
11613 }
11614 query := openapiutil.Query(dara.ToMap(request))
11615 req := &openapiutil.OpenApiRequest{
11616 Query: openapiutil.Query(query),
11617 }
11618 params := &openapiutil.Params{
11619 Action: dara.String("ListClientCaCertificates"),
11620 Version: dara.String("2024-09-10"),
11621 Protocol: dara.String("HTTPS"),
11622 Pathname: dara.String("/"),
11623 Method: dara.String("GET"),
11624 AuthType: dara.String("AK"),
11625 Style: dara.String("RPC"),
11626 ReqBodyType: dara.String("formData"),
11627 BodyType: dara.String("json"),
11628 }
11629 _result = &ListClientCaCertificatesResponse{}
11630 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11631 if _err != nil {
11632 return _result, _err
11633 }
11634 _err = dara.Convert(_body, &_result)
11635 return _result, _err
11636 }
11637
11638 // Summary:
11639 //
11640 // Queries client certificates configured for a website.
11641 //
11642 // @param request - ListClientCertificatesRequest
11643 //
11644 // @param runtime - runtime options for this request RuntimeOptions
11645 //
11646 // @return ListClientCertificatesResponse
11647 func ListClientCertificatesWithContext(ctx context.Context, client *Client, request *ListClientCertificatesRequest, runtime *dara.RuntimeOptions) (_result *ListClientCertificatesResponse, _err error) {
11648 if dara.BoolValue(client.EnableValidate) == true {
11649 _err = request.Validate()
11650 if _err != nil {
11651 return _result, _err
11652 }
11653 }
11654 query := openapiutil.Query(dara.ToMap(request))
11655 req := &openapiutil.OpenApiRequest{
11656 Query: openapiutil.Query(query),
11657 }
11658 params := &openapiutil.Params{
11659 Action: dara.String("ListClientCertificates"),
11660 Version: dara.String("2024-09-10"),
11661 Protocol: dara.String("HTTPS"),
11662 Pathname: dara.String("/"),
11663 Method: dara.String("GET"),
11664 AuthType: dara.String("AK"),
11665 Style: dara.String("RPC"),
11666 ReqBodyType: dara.String("formData"),
11667 BodyType: dara.String("json"),
11668 }
11669 _result = &ListClientCertificatesResponse{}
11670 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11671 if _err != nil {
11672 return _result, _err
11673 }
11674 _err = dara.Convert(_body, &_result)
11675 return _result, _err
11676 }
11677
11678 // Summary:
11679 //
11680 // # Query the list of compression rules
11681 //
11682 // @param request - ListCompressionRulesRequest
11683 //
11684 // @param runtime - runtime options for this request RuntimeOptions
11685 //
11686 // @return ListCompressionRulesResponse
11687 func ListCompressionRulesWithContext(ctx context.Context, client *Client, request *ListCompressionRulesRequest, runtime *dara.RuntimeOptions) (_result *ListCompressionRulesResponse, _err error) {
11688 if dara.BoolValue(client.EnableValidate) == true {
11689 _err = request.Validate()
11690 if _err != nil {
11691 return _result, _err
11692 }
11693 }
11694 query := openapiutil.Query(dara.ToMap(request))
11695 req := &openapiutil.OpenApiRequest{
11696 Query: openapiutil.Query(query),
11697 }
11698 params := &openapiutil.Params{
11699 Action: dara.String("ListCompressionRules"),
11700 Version: dara.String("2024-09-10"),
11701 Protocol: dara.String("HTTPS"),
11702 Pathname: dara.String("/"),
11703 Method: dara.String("GET"),
11704 AuthType: dara.String("AK"),
11705 Style: dara.String("RPC"),
11706 ReqBodyType: dara.String("formData"),
11707 BodyType: dara.String("json"),
11708 }
11709 _result = &ListCompressionRulesResponse{}
11710 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11711 if _err != nil {
11712 return _result, _err
11713 }
11714 _err = dara.Convert(_body, &_result)
11715 return _result, _err
11716 }
11717
11718 // Summary:
11719 //
11720 // Batch query whether the IP address is included in the ESA resolution result.
11721 //
11722 // Description:
11723 //
11724 // This interface is used to check whether the vs_addr parameter in the vipInfo collection is vip.
11725 //
11726 // @param request - ListESAIPInfoRequest
11727 //
11728 // @param runtime - runtime options for this request RuntimeOptions
11729 //
11730 // @return ListESAIPInfoResponse
11731 func ListESAIPInfoWithContext(ctx context.Context, client *Client, request *ListESAIPInfoRequest, runtime *dara.RuntimeOptions) (_result *ListESAIPInfoResponse, _err error) {
11732 if dara.BoolValue(client.EnableValidate) == true {
11733 _err = request.Validate()
11734 if _err != nil {
11735 return _result, _err
11736 }
11737 }
11738 query := openapiutil.Query(dara.ToMap(request))
11739 req := &openapiutil.OpenApiRequest{
11740 Query: openapiutil.Query(query),
11741 }
11742 params := &openapiutil.Params{
11743 Action: dara.String("ListESAIPInfo"),
11744 Version: dara.String("2024-09-10"),
11745 Protocol: dara.String("HTTPS"),
11746 Pathname: dara.String("/"),
11747 Method: dara.String("GET"),
11748 AuthType: dara.String("AK"),
11749 Style: dara.String("RPC"),
11750 ReqBodyType: dara.String("formData"),
11751 BodyType: dara.String("json"),
11752 }
11753 _result = &ListESAIPInfoResponse{}
11754 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11755 if _err != nil {
11756 return _result, _err
11757 }
11758 _err = dara.Convert(_body, &_result)
11759 return _result, _err
11760 }
11761
11762 // Summary:
11763 //
11764 // 获取边缘容器应用的镜像秘钥列表
11765 //
11766 // @param request - ListEdgeContainerAppImageSecretsRequest
11767 //
11768 // @param runtime - runtime options for this request RuntimeOptions
11769 //
11770 // @return ListEdgeContainerAppImageSecretsResponse
11771 func ListEdgeContainerAppImageSecretsWithContext(ctx context.Context, client *Client, request *ListEdgeContainerAppImageSecretsRequest, runtime *dara.RuntimeOptions) (_result *ListEdgeContainerAppImageSecretsResponse, _err error) {
11772 if dara.BoolValue(client.EnableValidate) == true {
11773 _err = request.Validate()
11774 if _err != nil {
11775 return _result, _err
11776 }
11777 }
11778 query := map[string]interface{}{}
11779 if !dara.IsNil(request.AppId) {
11780 query["AppId"] = request.AppId
11781 }
11782
11783 req := &openapiutil.OpenApiRequest{
11784 Query: openapiutil.Query(query),
11785 }
11786 params := &openapiutil.Params{
11787 Action: dara.String("ListEdgeContainerAppImageSecrets"),
11788 Version: dara.String("2024-09-10"),
11789 Protocol: dara.String("HTTPS"),
11790 Pathname: dara.String("/"),
11791 Method: dara.String("POST"),
11792 AuthType: dara.String("AK"),
11793 Style: dara.String("RPC"),
11794 ReqBodyType: dara.String("formData"),
11795 BodyType: dara.String("json"),
11796 }
11797 _result = &ListEdgeContainerAppImageSecretsResponse{}
11798 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11799 if _err != nil {
11800 return _result, _err
11801 }
11802 _err = dara.Convert(_body, &_result)
11803 return _result, _err
11804 }
11805
11806 // Summary:
11807 //
11808 // Lists domain names that are associated with a containerized application.
11809 //
11810 // @param request - ListEdgeContainerAppRecordsRequest
11811 //
11812 // @param runtime - runtime options for this request RuntimeOptions
11813 //
11814 // @return ListEdgeContainerAppRecordsResponse
11815 func ListEdgeContainerAppRecordsWithContext(ctx context.Context, client *Client, request *ListEdgeContainerAppRecordsRequest, runtime *dara.RuntimeOptions) (_result *ListEdgeContainerAppRecordsResponse, _err error) {
11816 if dara.BoolValue(client.EnableValidate) == true {
11817 _err = request.Validate()
11818 if _err != nil {
11819 return _result, _err
11820 }
11821 }
11822 query := openapiutil.Query(dara.ToMap(request))
11823 req := &openapiutil.OpenApiRequest{
11824 Query: openapiutil.Query(query),
11825 }
11826 params := &openapiutil.Params{
11827 Action: dara.String("ListEdgeContainerAppRecords"),
11828 Version: dara.String("2024-09-10"),
11829 Protocol: dara.String("HTTPS"),
11830 Pathname: dara.String("/"),
11831 Method: dara.String("GET"),
11832 AuthType: dara.String("AK"),
11833 Style: dara.String("RPC"),
11834 ReqBodyType: dara.String("formData"),
11835 BodyType: dara.String("json"),
11836 }
11837 _result = &ListEdgeContainerAppRecordsResponse{}
11838 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11839 if _err != nil {
11840 return _result, _err
11841 }
11842 _err = dara.Convert(_body, &_result)
11843 return _result, _err
11844 }
11845
11846 // Summary:
11847 //
11848 // Lists versions of all containerized applications.
11849 //
11850 // @param request - ListEdgeContainerAppVersionsRequest
11851 //
11852 // @param runtime - runtime options for this request RuntimeOptions
11853 //
11854 // @return ListEdgeContainerAppVersionsResponse
11855 func ListEdgeContainerAppVersionsWithContext(ctx context.Context, client *Client, request *ListEdgeContainerAppVersionsRequest, runtime *dara.RuntimeOptions) (_result *ListEdgeContainerAppVersionsResponse, _err error) {
11856 if dara.BoolValue(client.EnableValidate) == true {
11857 _err = request.Validate()
11858 if _err != nil {
11859 return _result, _err
11860 }
11861 }
11862 query := openapiutil.Query(dara.ToMap(request))
11863 req := &openapiutil.OpenApiRequest{
11864 Query: openapiutil.Query(query),
11865 }
11866 params := &openapiutil.Params{
11867 Action: dara.String("ListEdgeContainerAppVersions"),
11868 Version: dara.String("2024-09-10"),
11869 Protocol: dara.String("HTTPS"),
11870 Pathname: dara.String("/"),
11871 Method: dara.String("GET"),
11872 AuthType: dara.String("AK"),
11873 Style: dara.String("RPC"),
11874 ReqBodyType: dara.String("formData"),
11875 BodyType: dara.String("json"),
11876 }
11877 _result = &ListEdgeContainerAppVersionsResponse{}
11878 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11879 if _err != nil {
11880 return _result, _err
11881 }
11882 _err = dara.Convert(_body, &_result)
11883 return _result, _err
11884 }
11885
11886 // Summary:
11887 //
11888 // Queries all containerized applications in your Alibaba Cloud account.
11889 //
11890 // @param request - ListEdgeContainerAppsRequest
11891 //
11892 // @param runtime - runtime options for this request RuntimeOptions
11893 //
11894 // @return ListEdgeContainerAppsResponse
11895 func ListEdgeContainerAppsWithContext(ctx context.Context, client *Client, request *ListEdgeContainerAppsRequest, runtime *dara.RuntimeOptions) (_result *ListEdgeContainerAppsResponse, _err error) {
11896 if dara.BoolValue(client.EnableValidate) == true {
11897 _err = request.Validate()
11898 if _err != nil {
11899 return _result, _err
11900 }
11901 }
11902 query := map[string]interface{}{}
11903 if !dara.IsNil(request.OrderKey) {
11904 query["OrderKey"] = request.OrderKey
11905 }
11906
11907 if !dara.IsNil(request.OrderType) {
11908 query["OrderType"] = request.OrderType
11909 }
11910
11911 if !dara.IsNil(request.PageNumber) {
11912 query["PageNumber"] = request.PageNumber
11913 }
11914
11915 if !dara.IsNil(request.PageSize) {
11916 query["PageSize"] = request.PageSize
11917 }
11918
11919 if !dara.IsNil(request.SearchKey) {
11920 query["SearchKey"] = request.SearchKey
11921 }
11922
11923 if !dara.IsNil(request.SearchType) {
11924 query["SearchType"] = request.SearchType
11925 }
11926
11927 req := &openapiutil.OpenApiRequest{
11928 Query: openapiutil.Query(query),
11929 }
11930 params := &openapiutil.Params{
11931 Action: dara.String("ListEdgeContainerApps"),
11932 Version: dara.String("2024-09-10"),
11933 Protocol: dara.String("HTTPS"),
11934 Pathname: dara.String("/"),
11935 Method: dara.String("POST"),
11936 AuthType: dara.String("AK"),
11937 Style: dara.String("RPC"),
11938 ReqBodyType: dara.String("formData"),
11939 BodyType: dara.String("json"),
11940 }
11941 _result = &ListEdgeContainerAppsResponse{}
11942 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11943 if _err != nil {
11944 return _result, _err
11945 }
11946 _err = dara.Convert(_body, &_result)
11947 return _result, _err
11948 }
11949
11950 // Summary:
11951 //
11952 // Queries the records that are associated with Edge Container for a website.
11953 //
11954 // @param request - ListEdgeContainerRecordsRequest
11955 //
11956 // @param runtime - runtime options for this request RuntimeOptions
11957 //
11958 // @return ListEdgeContainerRecordsResponse
11959 func ListEdgeContainerRecordsWithContext(ctx context.Context, client *Client, request *ListEdgeContainerRecordsRequest, runtime *dara.RuntimeOptions) (_result *ListEdgeContainerRecordsResponse, _err error) {
11960 if dara.BoolValue(client.EnableValidate) == true {
11961 _err = request.Validate()
11962 if _err != nil {
11963 return _result, _err
11964 }
11965 }
11966 query := openapiutil.Query(dara.ToMap(request))
11967 req := &openapiutil.OpenApiRequest{
11968 Query: openapiutil.Query(query),
11969 }
11970 params := &openapiutil.Params{
11971 Action: dara.String("ListEdgeContainerRecords"),
11972 Version: dara.String("2024-09-10"),
11973 Protocol: dara.String("HTTPS"),
11974 Pathname: dara.String("/"),
11975 Method: dara.String("GET"),
11976 AuthType: dara.String("AK"),
11977 Style: dara.String("RPC"),
11978 ReqBodyType: dara.String("formData"),
11979 BodyType: dara.String("json"),
11980 }
11981 _result = &ListEdgeContainerRecordsResponse{}
11982 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
11983 if _err != nil {
11984 return _result, _err
11985 }
11986 _err = dara.Convert(_body, &_result)
11987 return _result, _err
11988 }
11989
11990 // Summary:
11991 //
11992 // Queries the records that are associated with Edge Routine routes for a website.
11993 //
11994 // Description:
11995 //
11996 // > You can call this operation 100 times per second.
11997 //
11998 // @param request - ListEdgeRoutineRecordsRequest
11999 //
12000 // @param runtime - runtime options for this request RuntimeOptions
12001 //
12002 // @return ListEdgeRoutineRecordsResponse
12003 func ListEdgeRoutineRecordsWithContext(ctx context.Context, client *Client, request *ListEdgeRoutineRecordsRequest, runtime *dara.RuntimeOptions) (_result *ListEdgeRoutineRecordsResponse, _err error) {
12004 if dara.BoolValue(client.EnableValidate) == true {
12005 _err = request.Validate()
12006 if _err != nil {
12007 return _result, _err
12008 }
12009 }
12010 query := openapiutil.Query(dara.ToMap(request))
12011 req := &openapiutil.OpenApiRequest{
12012 Query: openapiutil.Query(query),
12013 }
12014 params := &openapiutil.Params{
12015 Action: dara.String("ListEdgeRoutineRecords"),
12016 Version: dara.String("2024-09-10"),
12017 Protocol: dara.String("HTTPS"),
12018 Pathname: dara.String("/"),
12019 Method: dara.String("GET"),
12020 AuthType: dara.String("AK"),
12021 Style: dara.String("RPC"),
12022 ReqBodyType: dara.String("formData"),
12023 BodyType: dara.String("json"),
12024 }
12025 _result = &ListEdgeRoutineRecordsResponse{}
12026 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12027 if _err != nil {
12028 return _result, _err
12029 }
12030 _err = dara.Convert(_body, &_result)
12031 return _result, _err
12032 }
12033
12034 // Summary:
12035 //
12036 // Queries the configuration details of an incoming HTTP request header modification rule for a website.
12037 //
12038 // @param request - ListHttpIncomingRequestHeaderModificationRulesRequest
12039 //
12040 // @param runtime - runtime options for this request RuntimeOptions
12041 //
12042 // @return ListHttpIncomingRequestHeaderModificationRulesResponse
12043 func ListHttpIncomingRequestHeaderModificationRulesWithContext(ctx context.Context, client *Client, request *ListHttpIncomingRequestHeaderModificationRulesRequest, runtime *dara.RuntimeOptions) (_result *ListHttpIncomingRequestHeaderModificationRulesResponse, _err error) {
12044 if dara.BoolValue(client.EnableValidate) == true {
12045 _err = request.Validate()
12046 if _err != nil {
12047 return _result, _err
12048 }
12049 }
12050 query := openapiutil.Query(dara.ToMap(request))
12051 req := &openapiutil.OpenApiRequest{
12052 Query: openapiutil.Query(query),
12053 }
12054 params := &openapiutil.Params{
12055 Action: dara.String("ListHttpIncomingRequestHeaderModificationRules"),
12056 Version: dara.String("2024-09-10"),
12057 Protocol: dara.String("HTTPS"),
12058 Pathname: dara.String("/"),
12059 Method: dara.String("GET"),
12060 AuthType: dara.String("AK"),
12061 Style: dara.String("RPC"),
12062 ReqBodyType: dara.String("formData"),
12063 BodyType: dara.String("json"),
12064 }
12065 _result = &ListHttpIncomingRequestHeaderModificationRulesResponse{}
12066 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12067 if _err != nil {
12068 return _result, _err
12069 }
12070 _err = dara.Convert(_body, &_result)
12071 return _result, _err
12072 }
12073
12074 // Summary:
12075 //
12076 // Queries the configurations of an incoming HTTP response header modification rule for a website.
12077 //
12078 // @param request - ListHttpIncomingResponseHeaderModificationRulesRequest
12079 //
12080 // @param runtime - runtime options for this request RuntimeOptions
12081 //
12082 // @return ListHttpIncomingResponseHeaderModificationRulesResponse
12083 func ListHttpIncomingResponseHeaderModificationRulesWithContext(ctx context.Context, client *Client, request *ListHttpIncomingResponseHeaderModificationRulesRequest, runtime *dara.RuntimeOptions) (_result *ListHttpIncomingResponseHeaderModificationRulesResponse, _err error) {
12084 if dara.BoolValue(client.EnableValidate) == true {
12085 _err = request.Validate()
12086 if _err != nil {
12087 return _result, _err
12088 }
12089 }
12090 query := openapiutil.Query(dara.ToMap(request))
12091 req := &openapiutil.OpenApiRequest{
12092 Query: openapiutil.Query(query),
12093 }
12094 params := &openapiutil.Params{
12095 Action: dara.String("ListHttpIncomingResponseHeaderModificationRules"),
12096 Version: dara.String("2024-09-10"),
12097 Protocol: dara.String("HTTPS"),
12098 Pathname: dara.String("/"),
12099 Method: dara.String("GET"),
12100 AuthType: dara.String("AK"),
12101 Style: dara.String("RPC"),
12102 ReqBodyType: dara.String("formData"),
12103 BodyType: dara.String("json"),
12104 }
12105 _result = &ListHttpIncomingResponseHeaderModificationRulesResponse{}
12106 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12107 if _err != nil {
12108 return _result, _err
12109 }
12110 _err = dara.Convert(_body, &_result)
12111 return _result, _err
12112 }
12113
12114 // Summary:
12115 //
12116 // # List of HTTP Request Header Rules
12117 //
12118 // @param request - ListHttpRequestHeaderModificationRulesRequest
12119 //
12120 // @param runtime - runtime options for this request RuntimeOptions
12121 //
12122 // @return ListHttpRequestHeaderModificationRulesResponse
12123 func ListHttpRequestHeaderModificationRulesWithContext(ctx context.Context, client *Client, request *ListHttpRequestHeaderModificationRulesRequest, runtime *dara.RuntimeOptions) (_result *ListHttpRequestHeaderModificationRulesResponse, _err error) {
12124 if dara.BoolValue(client.EnableValidate) == true {
12125 _err = request.Validate()
12126 if _err != nil {
12127 return _result, _err
12128 }
12129 }
12130 query := openapiutil.Query(dara.ToMap(request))
12131 req := &openapiutil.OpenApiRequest{
12132 Query: openapiutil.Query(query),
12133 }
12134 params := &openapiutil.Params{
12135 Action: dara.String("ListHttpRequestHeaderModificationRules"),
12136 Version: dara.String("2024-09-10"),
12137 Protocol: dara.String("HTTPS"),
12138 Pathname: dara.String("/"),
12139 Method: dara.String("GET"),
12140 AuthType: dara.String("AK"),
12141 Style: dara.String("RPC"),
12142 ReqBodyType: dara.String("formData"),
12143 BodyType: dara.String("json"),
12144 }
12145 _result = &ListHttpRequestHeaderModificationRulesResponse{}
12146 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12147 if _err != nil {
12148 return _result, _err
12149 }
12150 _err = dara.Convert(_body, &_result)
12151 return _result, _err
12152 }
12153
12154 // Summary:
12155 //
12156 // # List of HTTP Response Header Rules
12157 //
12158 // @param request - ListHttpResponseHeaderModificationRulesRequest
12159 //
12160 // @param runtime - runtime options for this request RuntimeOptions
12161 //
12162 // @return ListHttpResponseHeaderModificationRulesResponse
12163 func ListHttpResponseHeaderModificationRulesWithContext(ctx context.Context, client *Client, request *ListHttpResponseHeaderModificationRulesRequest, runtime *dara.RuntimeOptions) (_result *ListHttpResponseHeaderModificationRulesResponse, _err error) {
12164 if dara.BoolValue(client.EnableValidate) == true {
12165 _err = request.Validate()
12166 if _err != nil {
12167 return _result, _err
12168 }
12169 }
12170 query := openapiutil.Query(dara.ToMap(request))
12171 req := &openapiutil.OpenApiRequest{
12172 Query: openapiutil.Query(query),
12173 }
12174 params := &openapiutil.Params{
12175 Action: dara.String("ListHttpResponseHeaderModificationRules"),
12176 Version: dara.String("2024-09-10"),
12177 Protocol: dara.String("HTTPS"),
12178 Pathname: dara.String("/"),
12179 Method: dara.String("GET"),
12180 AuthType: dara.String("AK"),
12181 Style: dara.String("RPC"),
12182 ReqBodyType: dara.String("formData"),
12183 BodyType: dara.String("json"),
12184 }
12185 _result = &ListHttpResponseHeaderModificationRulesResponse{}
12186 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12187 if _err != nil {
12188 return _result, _err
12189 }
12190 _err = dara.Convert(_body, &_result)
12191 return _result, _err
12192 }
12193
12194 // Summary:
12195 //
12196 // # Query multiple HTTPS application configurations
12197 //
12198 // @param request - ListHttpsApplicationConfigurationsRequest
12199 //
12200 // @param runtime - runtime options for this request RuntimeOptions
12201 //
12202 // @return ListHttpsApplicationConfigurationsResponse
12203 func ListHttpsApplicationConfigurationsWithContext(ctx context.Context, client *Client, request *ListHttpsApplicationConfigurationsRequest, runtime *dara.RuntimeOptions) (_result *ListHttpsApplicationConfigurationsResponse, _err error) {
12204 if dara.BoolValue(client.EnableValidate) == true {
12205 _err = request.Validate()
12206 if _err != nil {
12207 return _result, _err
12208 }
12209 }
12210 query := openapiutil.Query(dara.ToMap(request))
12211 req := &openapiutil.OpenApiRequest{
12212 Query: openapiutil.Query(query),
12213 }
12214 params := &openapiutil.Params{
12215 Action: dara.String("ListHttpsApplicationConfigurations"),
12216 Version: dara.String("2024-09-10"),
12217 Protocol: dara.String("HTTPS"),
12218 Pathname: dara.String("/"),
12219 Method: dara.String("GET"),
12220 AuthType: dara.String("AK"),
12221 Style: dara.String("RPC"),
12222 ReqBodyType: dara.String("formData"),
12223 BodyType: dara.String("json"),
12224 }
12225 _result = &ListHttpsApplicationConfigurationsResponse{}
12226 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12227 if _err != nil {
12228 return _result, _err
12229 }
12230 _err = dara.Convert(_body, &_result)
12231 return _result, _err
12232 }
12233
12234 // Summary:
12235 //
12236 // # Query multiple HTTPS basic configurations
12237 //
12238 // @param request - ListHttpsBasicConfigurationsRequest
12239 //
12240 // @param runtime - runtime options for this request RuntimeOptions
12241 //
12242 // @return ListHttpsBasicConfigurationsResponse
12243 func ListHttpsBasicConfigurationsWithContext(ctx context.Context, client *Client, request *ListHttpsBasicConfigurationsRequest, runtime *dara.RuntimeOptions) (_result *ListHttpsBasicConfigurationsResponse, _err error) {
12244 if dara.BoolValue(client.EnableValidate) == true {
12245 _err = request.Validate()
12246 if _err != nil {
12247 return _result, _err
12248 }
12249 }
12250 query := openapiutil.Query(dara.ToMap(request))
12251 req := &openapiutil.OpenApiRequest{
12252 Query: openapiutil.Query(query),
12253 }
12254 params := &openapiutil.Params{
12255 Action: dara.String("ListHttpsBasicConfigurations"),
12256 Version: dara.String("2024-09-10"),
12257 Protocol: dara.String("HTTPS"),
12258 Pathname: dara.String("/"),
12259 Method: dara.String("GET"),
12260 AuthType: dara.String("AK"),
12261 Style: dara.String("RPC"),
12262 ReqBodyType: dara.String("formData"),
12263 BodyType: dara.String("json"),
12264 }
12265 _result = &ListHttpsBasicConfigurationsResponse{}
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 // # Query Multiple Site Image Transformation Configurations
12277 //
12278 // @param request - ListImageTransformsRequest
12279 //
12280 // @param runtime - runtime options for this request RuntimeOptions
12281 //
12282 // @return ListImageTransformsResponse
12283 func ListImageTransformsWithContext(ctx context.Context, client *Client, request *ListImageTransformsRequest, runtime *dara.RuntimeOptions) (_result *ListImageTransformsResponse, _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 := openapiutil.Query(dara.ToMap(request))
12291 req := &openapiutil.OpenApiRequest{
12292 Query: openapiutil.Query(query),
12293 }
12294 params := &openapiutil.Params{
12295 Action: dara.String("ListImageTransforms"),
12296 Version: dara.String("2024-09-10"),
12297 Protocol: dara.String("HTTPS"),
12298 Pathname: dara.String("/"),
12299 Method: dara.String("GET"),
12300 AuthType: dara.String("AK"),
12301 Style: dara.String("RPC"),
12302 ReqBodyType: dara.String("formData"),
12303 BodyType: dara.String("json"),
12304 }
12305 _result = &ListImageTransformsResponse{}
12306 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12307 if _err != nil {
12308 return _result, _err
12309 }
12310 _err = dara.Convert(_body, &_result)
12311 return _result, _err
12312 }
12313
12314 // Summary:
12315 //
12316 // Queries the quota details in a subscription plan.
12317 //
12318 // @param request - ListInstanceQuotasRequest
12319 //
12320 // @param runtime - runtime options for this request RuntimeOptions
12321 //
12322 // @return ListInstanceQuotasResponse
12323 func ListInstanceQuotasWithContext(ctx context.Context, client *Client, request *ListInstanceQuotasRequest, runtime *dara.RuntimeOptions) (_result *ListInstanceQuotasResponse, _err error) {
12324 if dara.BoolValue(client.EnableValidate) == true {
12325 _err = request.Validate()
12326 if _err != nil {
12327 return _result, _err
12328 }
12329 }
12330 query := openapiutil.Query(dara.ToMap(request))
12331 req := &openapiutil.OpenApiRequest{
12332 Query: openapiutil.Query(query),
12333 }
12334 params := &openapiutil.Params{
12335 Action: dara.String("ListInstanceQuotas"),
12336 Version: dara.String("2024-09-10"),
12337 Protocol: dara.String("HTTPS"),
12338 Pathname: dara.String("/"),
12339 Method: dara.String("GET"),
12340 AuthType: dara.String("AK"),
12341 Style: dara.String("RPC"),
12342 ReqBodyType: dara.String("formData"),
12343 BodyType: dara.String("json"),
12344 }
12345 _result = &ListInstanceQuotasResponse{}
12346 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12347 if _err != nil {
12348 return _result, _err
12349 }
12350 _err = dara.Convert(_body, &_result)
12351 return _result, _err
12352 }
12353
12354 // Summary:
12355 //
12356 // Queries quotas and the actual usage in a plan based on the website or plan ID.
12357 //
12358 // @param request - ListInstanceQuotasWithUsageRequest
12359 //
12360 // @param runtime - runtime options for this request RuntimeOptions
12361 //
12362 // @return ListInstanceQuotasWithUsageResponse
12363 func ListInstanceQuotasWithUsageWithContext(ctx context.Context, client *Client, request *ListInstanceQuotasWithUsageRequest, runtime *dara.RuntimeOptions) (_result *ListInstanceQuotasWithUsageResponse, _err error) {
12364 if dara.BoolValue(client.EnableValidate) == true {
12365 _err = request.Validate()
12366 if _err != nil {
12367 return _result, _err
12368 }
12369 }
12370 query := openapiutil.Query(dara.ToMap(request))
12371 req := &openapiutil.OpenApiRequest{
12372 Query: openapiutil.Query(query),
12373 }
12374 params := &openapiutil.Params{
12375 Action: dara.String("ListInstanceQuotasWithUsage"),
12376 Version: dara.String("2024-09-10"),
12377 Protocol: dara.String("HTTPS"),
12378 Pathname: dara.String("/"),
12379 Method: dara.String("GET"),
12380 AuthType: dara.String("AK"),
12381 Style: dara.String("RPC"),
12382 ReqBodyType: dara.String("formData"),
12383 BodyType: dara.String("json"),
12384 }
12385 _result = &ListInstanceQuotasWithUsageResponse{}
12386 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12387 if _err != nil {
12388 return _result, _err
12389 }
12390 _err = dara.Convert(_body, &_result)
12391 return _result, _err
12392 }
12393
12394 // Summary:
12395 //
12396 // Lists all key-value pairs in a namespace in your Alibaba Cloud account.
12397 //
12398 // @param request - ListKvsRequest
12399 //
12400 // @param runtime - runtime options for this request RuntimeOptions
12401 //
12402 // @return ListKvsResponse
12403 func ListKvsWithContext(ctx context.Context, client *Client, request *ListKvsRequest, runtime *dara.RuntimeOptions) (_result *ListKvsResponse, _err error) {
12404 if dara.BoolValue(client.EnableValidate) == true {
12405 _err = request.Validate()
12406 if _err != nil {
12407 return _result, _err
12408 }
12409 }
12410 query := openapiutil.Query(dara.ToMap(request))
12411 req := &openapiutil.OpenApiRequest{
12412 Query: openapiutil.Query(query),
12413 }
12414 params := &openapiutil.Params{
12415 Action: dara.String("ListKvs"),
12416 Version: dara.String("2024-09-10"),
12417 Protocol: dara.String("HTTPS"),
12418 Pathname: dara.String("/"),
12419 Method: dara.String("GET"),
12420 AuthType: dara.String("AK"),
12421 Style: dara.String("RPC"),
12422 ReqBodyType: dara.String("formData"),
12423 BodyType: dara.String("json"),
12424 }
12425 _result = &ListKvsResponse{}
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 // Queries all custom lists and their details in an Alibaba Cloud account. You can specify query arguments to filter the results and display the returned lists by page.
12437 //
12438 // @param tmpReq - ListListsRequest
12439 //
12440 // @param runtime - runtime options for this request RuntimeOptions
12441 //
12442 // @return ListListsResponse
12443 func ListListsWithContext(ctx context.Context, client *Client, tmpReq *ListListsRequest, runtime *dara.RuntimeOptions) (_result *ListListsResponse, _err error) {
12444 if dara.BoolValue(client.EnableValidate) == true {
12445 _err = tmpReq.Validate()
12446 if _err != nil {
12447 return _result, _err
12448 }
12449 }
12450 request := &ListListsShrinkRequest{}
12451 openapiutil.Convert(tmpReq, request)
12452 if !dara.IsNil(tmpReq.QueryArgs) {
12453 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
12454 }
12455
12456 query := map[string]interface{}{}
12457 if !dara.IsNil(request.PageNumber) {
12458 query["PageNumber"] = request.PageNumber
12459 }
12460
12461 if !dara.IsNil(request.PageSize) {
12462 query["PageSize"] = request.PageSize
12463 }
12464
12465 if !dara.IsNil(request.QueryArgsShrink) {
12466 query["QueryArgs"] = request.QueryArgsShrink
12467 }
12468
12469 req := &openapiutil.OpenApiRequest{
12470 Query: openapiutil.Query(query),
12471 }
12472 params := &openapiutil.Params{
12473 Action: dara.String("ListLists"),
12474 Version: dara.String("2024-09-10"),
12475 Protocol: dara.String("HTTPS"),
12476 Pathname: dara.String("/"),
12477 Method: dara.String("POST"),
12478 AuthType: dara.String("AK"),
12479 Style: dara.String("RPC"),
12480 ReqBodyType: dara.String("formData"),
12481 BodyType: dara.String("json"),
12482 }
12483 _result = &ListListsResponse{}
12484 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12485 if _err != nil {
12486 return _result, _err
12487 }
12488 _err = dara.Convert(_body, &_result)
12489 return _result, _err
12490 }
12491
12492 // Summary:
12493 //
12494 // # Query the status of origins in load balancers
12495 //
12496 // Description:
12497 //
12498 // Query the status of origins under load balancers. You can pass multiple load balancer IDs at once, separated by commas. This is for load balancers that have monitors configured. It will probe the origins in the source address pools used by the load balancers and record the current status of each origin.
12499 //
12500 // - Healthy(healthy): The probe result is available.
12501 //
12502 // - Unhealthy(unhealthy): The probe result is unavailable.
12503 //
12504 // - Unknown(unknown): Unknown, the monitor has not yet probed.
12505 //
12506 // - Undetected(undetected): The load balancer to which the origin belongs is not bound to a monitor.
12507 //
12508 // @param request - ListLoadBalancerOriginStatusRequest
12509 //
12510 // @param runtime - runtime options for this request RuntimeOptions
12511 //
12512 // @return ListLoadBalancerOriginStatusResponse
12513 func ListLoadBalancerOriginStatusWithContext(ctx context.Context, client *Client, request *ListLoadBalancerOriginStatusRequest, runtime *dara.RuntimeOptions) (_result *ListLoadBalancerOriginStatusResponse, _err error) {
12514 if dara.BoolValue(client.EnableValidate) == true {
12515 _err = request.Validate()
12516 if _err != nil {
12517 return _result, _err
12518 }
12519 }
12520 query := openapiutil.Query(dara.ToMap(request))
12521 req := &openapiutil.OpenApiRequest{
12522 Query: openapiutil.Query(query),
12523 }
12524 params := &openapiutil.Params{
12525 Action: dara.String("ListLoadBalancerOriginStatus"),
12526 Version: dara.String("2024-09-10"),
12527 Protocol: dara.String("HTTPS"),
12528 Pathname: dara.String("/"),
12529 Method: dara.String("GET"),
12530 AuthType: dara.String("AK"),
12531 Style: dara.String("RPC"),
12532 ReqBodyType: dara.String("formData"),
12533 BodyType: dara.String("json"),
12534 }
12535 _result = &ListLoadBalancerOriginStatusResponse{}
12536 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12537 if _err != nil {
12538 return _result, _err
12539 }
12540 _err = dara.Convert(_body, &_result)
12541 return _result, _err
12542 }
12543
12544 // Summary:
12545 //
12546 // # Query Load Balancer Region List
12547 //
12548 // Description:
12549 //
12550 // When creating a load balancer \\"based on country/region scheduling\\" strategy through OpenAPI, use the code of primary or secondary regions to represent traffic from this geographical area.
12551 //
12552 // @param request - ListLoadBalancerRegionsRequest
12553 //
12554 // @param runtime - runtime options for this request RuntimeOptions
12555 //
12556 // @return ListLoadBalancerRegionsResponse
12557 func ListLoadBalancerRegionsWithContext(ctx context.Context, client *Client, request *ListLoadBalancerRegionsRequest, runtime *dara.RuntimeOptions) (_result *ListLoadBalancerRegionsResponse, _err error) {
12558 if dara.BoolValue(client.EnableValidate) == true {
12559 _err = request.Validate()
12560 if _err != nil {
12561 return _result, _err
12562 }
12563 }
12564 query := openapiutil.Query(dara.ToMap(request))
12565 req := &openapiutil.OpenApiRequest{
12566 Query: openapiutil.Query(query),
12567 }
12568 params := &openapiutil.Params{
12569 Action: dara.String("ListLoadBalancerRegions"),
12570 Version: dara.String("2024-09-10"),
12571 Protocol: dara.String("HTTPS"),
12572 Pathname: dara.String("/"),
12573 Method: dara.String("GET"),
12574 AuthType: dara.String("AK"),
12575 Style: dara.String("RPC"),
12576 ReqBodyType: dara.String("formData"),
12577 BodyType: dara.String("json"),
12578 }
12579 _result = &ListLoadBalancerRegionsResponse{}
12580 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12581 if _err != nil {
12582 return _result, _err
12583 }
12584 _err = dara.Convert(_body, &_result)
12585 return _result, _err
12586 }
12587
12588 // Summary:
12589 //
12590 // # Query the list of load balancers
12591 //
12592 // @param request - ListLoadBalancersRequest
12593 //
12594 // @param runtime - runtime options for this request RuntimeOptions
12595 //
12596 // @return ListLoadBalancersResponse
12597 func ListLoadBalancersWithContext(ctx context.Context, client *Client, request *ListLoadBalancersRequest, runtime *dara.RuntimeOptions) (_result *ListLoadBalancersResponse, _err error) {
12598 if dara.BoolValue(client.EnableValidate) == true {
12599 _err = request.Validate()
12600 if _err != nil {
12601 return _result, _err
12602 }
12603 }
12604 query := openapiutil.Query(dara.ToMap(request))
12605 req := &openapiutil.OpenApiRequest{
12606 Query: openapiutil.Query(query),
12607 }
12608 params := &openapiutil.Params{
12609 Action: dara.String("ListLoadBalancers"),
12610 Version: dara.String("2024-09-10"),
12611 Protocol: dara.String("HTTPS"),
12612 Pathname: dara.String("/"),
12613 Method: dara.String("GET"),
12614 AuthType: dara.String("AK"),
12615 Style: dara.String("RPC"),
12616 ReqBodyType: dara.String("formData"),
12617 BodyType: dara.String("json"),
12618 }
12619 _result = &ListLoadBalancersResponse{}
12620 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12621 if _err != nil {
12622 return _result, _err
12623 }
12624 _err = dara.Convert(_body, &_result)
12625 return _result, _err
12626 }
12627
12628 // Summary:
12629 //
12630 // # List Custom Managed Rule Groups
12631 //
12632 // @param request - ListManagedRulesGroupsRequest
12633 //
12634 // @param runtime - runtime options for this request RuntimeOptions
12635 //
12636 // @return ListManagedRulesGroupsResponse
12637 func ListManagedRulesGroupsWithContext(ctx context.Context, client *Client, request *ListManagedRulesGroupsRequest, runtime *dara.RuntimeOptions) (_result *ListManagedRulesGroupsResponse, _err error) {
12638 if dara.BoolValue(client.EnableValidate) == true {
12639 _err = request.Validate()
12640 if _err != nil {
12641 return _result, _err
12642 }
12643 }
12644 query := map[string]interface{}{}
12645 if !dara.IsNil(request.PageNumber) {
12646 query["PageNumber"] = request.PageNumber
12647 }
12648
12649 if !dara.IsNil(request.PageSize) {
12650 query["PageSize"] = request.PageSize
12651 }
12652
12653 req := &openapiutil.OpenApiRequest{
12654 Query: openapiutil.Query(query),
12655 }
12656 params := &openapiutil.Params{
12657 Action: dara.String("ListManagedRulesGroups"),
12658 Version: dara.String("2024-09-10"),
12659 Protocol: dara.String("HTTPS"),
12660 Pathname: dara.String("/"),
12661 Method: dara.String("POST"),
12662 AuthType: dara.String("AK"),
12663 Style: dara.String("RPC"),
12664 ReqBodyType: dara.String("formData"),
12665 BodyType: dara.String("json"),
12666 }
12667 _result = &ListManagedRulesGroupsResponse{}
12668 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12669 if _err != nil {
12670 return _result, _err
12671 }
12672 _err = dara.Convert(_body, &_result)
12673 return _result, _err
12674 }
12675
12676 // Summary:
12677 //
12678 // # Query multiple network optimization configurations
12679 //
12680 // @param request - ListNetworkOptimizationsRequest
12681 //
12682 // @param runtime - runtime options for this request RuntimeOptions
12683 //
12684 // @return ListNetworkOptimizationsResponse
12685 func ListNetworkOptimizationsWithContext(ctx context.Context, client *Client, request *ListNetworkOptimizationsRequest, runtime *dara.RuntimeOptions) (_result *ListNetworkOptimizationsResponse, _err error) {
12686 if dara.BoolValue(client.EnableValidate) == true {
12687 _err = request.Validate()
12688 if _err != nil {
12689 return _result, _err
12690 }
12691 }
12692 query := openapiutil.Query(dara.ToMap(request))
12693 req := &openapiutil.OpenApiRequest{
12694 Query: openapiutil.Query(query),
12695 }
12696 params := &openapiutil.Params{
12697 Action: dara.String("ListNetworkOptimizations"),
12698 Version: dara.String("2024-09-10"),
12699 Protocol: dara.String("HTTPS"),
12700 Pathname: dara.String("/"),
12701 Method: dara.String("GET"),
12702 AuthType: dara.String("AK"),
12703 Style: dara.String("RPC"),
12704 ReqBodyType: dara.String("formData"),
12705 BodyType: dara.String("json"),
12706 }
12707 _result = &ListNetworkOptimizationsResponse{}
12708 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12709 if _err != nil {
12710 return _result, _err
12711 }
12712 _err = dara.Convert(_body, &_result)
12713 return _result, _err
12714 }
12715
12716 // Summary:
12717 //
12718 // 查询源服务器CA证书列表
12719 //
12720 // @param request - ListOriginCaCertificatesRequest
12721 //
12722 // @param runtime - runtime options for this request RuntimeOptions
12723 //
12724 // @return ListOriginCaCertificatesResponse
12725 func ListOriginCaCertificatesWithContext(ctx context.Context, client *Client, request *ListOriginCaCertificatesRequest, runtime *dara.RuntimeOptions) (_result *ListOriginCaCertificatesResponse, _err error) {
12726 if dara.BoolValue(client.EnableValidate) == true {
12727 _err = request.Validate()
12728 if _err != nil {
12729 return _result, _err
12730 }
12731 }
12732 query := openapiutil.Query(dara.ToMap(request))
12733 req := &openapiutil.OpenApiRequest{
12734 Query: openapiutil.Query(query),
12735 }
12736 params := &openapiutil.Params{
12737 Action: dara.String("ListOriginCaCertificates"),
12738 Version: dara.String("2024-09-10"),
12739 Protocol: dara.String("HTTPS"),
12740 Pathname: dara.String("/"),
12741 Method: dara.String("GET"),
12742 AuthType: dara.String("AK"),
12743 Style: dara.String("RPC"),
12744 ReqBodyType: dara.String("formData"),
12745 BodyType: dara.String("json"),
12746 }
12747 _result = &ListOriginCaCertificatesResponse{}
12748 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12749 if _err != nil {
12750 return _result, _err
12751 }
12752 _err = dara.Convert(_body, &_result)
12753 return _result, _err
12754 }
12755
12756 // Summary:
12757 //
12758 // 查询域名回源客户端证书列表
12759 //
12760 // @param request - ListOriginClientCertificatesRequest
12761 //
12762 // @param runtime - runtime options for this request RuntimeOptions
12763 //
12764 // @return ListOriginClientCertificatesResponse
12765 func ListOriginClientCertificatesWithContext(ctx context.Context, client *Client, request *ListOriginClientCertificatesRequest, runtime *dara.RuntimeOptions) (_result *ListOriginClientCertificatesResponse, _err error) {
12766 if dara.BoolValue(client.EnableValidate) == true {
12767 _err = request.Validate()
12768 if _err != nil {
12769 return _result, _err
12770 }
12771 }
12772 query := openapiutil.Query(dara.ToMap(request))
12773 req := &openapiutil.OpenApiRequest{
12774 Query: openapiutil.Query(query),
12775 }
12776 params := &openapiutil.Params{
12777 Action: dara.String("ListOriginClientCertificates"),
12778 Version: dara.String("2024-09-10"),
12779 Protocol: dara.String("HTTPS"),
12780 Pathname: dara.String("/"),
12781 Method: dara.String("GET"),
12782 AuthType: dara.String("AK"),
12783 Style: dara.String("RPC"),
12784 ReqBodyType: dara.String("formData"),
12785 BodyType: dara.String("json"),
12786 }
12787 _result = &ListOriginClientCertificatesResponse{}
12788 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12789 if _err != nil {
12790 return _result, _err
12791 }
12792 _err = dara.Convert(_body, &_result)
12793 return _result, _err
12794 }
12795
12796 // Summary:
12797 //
12798 // # List Origin Pools
12799 //
12800 // @param request - ListOriginPoolsRequest
12801 //
12802 // @param runtime - runtime options for this request RuntimeOptions
12803 //
12804 // @return ListOriginPoolsResponse
12805 func ListOriginPoolsWithContext(ctx context.Context, client *Client, request *ListOriginPoolsRequest, runtime *dara.RuntimeOptions) (_result *ListOriginPoolsResponse, _err error) {
12806 if dara.BoolValue(client.EnableValidate) == true {
12807 _err = request.Validate()
12808 if _err != nil {
12809 return _result, _err
12810 }
12811 }
12812 query := openapiutil.Query(dara.ToMap(request))
12813 req := &openapiutil.OpenApiRequest{
12814 Query: openapiutil.Query(query),
12815 }
12816 params := &openapiutil.Params{
12817 Action: dara.String("ListOriginPools"),
12818 Version: dara.String("2024-09-10"),
12819 Protocol: dara.String("HTTPS"),
12820 Pathname: dara.String("/"),
12821 Method: dara.String("GET"),
12822 AuthType: dara.String("AK"),
12823 Style: dara.String("RPC"),
12824 ReqBodyType: dara.String("formData"),
12825 BodyType: dara.String("json"),
12826 }
12827 _result = &ListOriginPoolsResponse{}
12828 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12829 if _err != nil {
12830 return _result, _err
12831 }
12832 _err = dara.Convert(_body, &_result)
12833 return _result, _err
12834 }
12835
12836 // Summary:
12837 //
12838 // # Query multiple origin rule configurations
12839 //
12840 // @param request - ListOriginRulesRequest
12841 //
12842 // @param runtime - runtime options for this request RuntimeOptions
12843 //
12844 // @return ListOriginRulesResponse
12845 func ListOriginRulesWithContext(ctx context.Context, client *Client, request *ListOriginRulesRequest, runtime *dara.RuntimeOptions) (_result *ListOriginRulesResponse, _err error) {
12846 if dara.BoolValue(client.EnableValidate) == true {
12847 _err = request.Validate()
12848 if _err != nil {
12849 return _result, _err
12850 }
12851 }
12852 query := openapiutil.Query(dara.ToMap(request))
12853 req := &openapiutil.OpenApiRequest{
12854 Query: openapiutil.Query(query),
12855 }
12856 params := &openapiutil.Params{
12857 Action: dara.String("ListOriginRules"),
12858 Version: dara.String("2024-09-10"),
12859 Protocol: dara.String("HTTPS"),
12860 Pathname: dara.String("/"),
12861 Method: dara.String("GET"),
12862 AuthType: dara.String("AK"),
12863 Style: dara.String("RPC"),
12864 ReqBodyType: dara.String("formData"),
12865 BodyType: dara.String("json"),
12866 }
12867 _result = &ListOriginRulesResponse{}
12868 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12869 if _err != nil {
12870 return _result, _err
12871 }
12872 _err = dara.Convert(_body, &_result)
12873 return _result, _err
12874 }
12875
12876 // Summary:
12877 //
12878 // Lists all custom error pages that you created. You can define the page number and the number of entries per page to display the response.
12879 //
12880 // @param tmpReq - ListPagesRequest
12881 //
12882 // @param runtime - runtime options for this request RuntimeOptions
12883 //
12884 // @return ListPagesResponse
12885 func ListPagesWithContext(ctx context.Context, client *Client, tmpReq *ListPagesRequest, runtime *dara.RuntimeOptions) (_result *ListPagesResponse, _err error) {
12886 if dara.BoolValue(client.EnableValidate) == true {
12887 _err = tmpReq.Validate()
12888 if _err != nil {
12889 return _result, _err
12890 }
12891 }
12892 request := &ListPagesShrinkRequest{}
12893 openapiutil.Convert(tmpReq, request)
12894 if !dara.IsNil(tmpReq.QueryArgs) {
12895 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
12896 }
12897
12898 query := map[string]interface{}{}
12899 if !dara.IsNil(request.PageNumber) {
12900 query["PageNumber"] = request.PageNumber
12901 }
12902
12903 if !dara.IsNil(request.PageSize) {
12904 query["PageSize"] = request.PageSize
12905 }
12906
12907 if !dara.IsNil(request.QueryArgsShrink) {
12908 query["QueryArgs"] = request.QueryArgsShrink
12909 }
12910
12911 req := &openapiutil.OpenApiRequest{
12912 Query: openapiutil.Query(query),
12913 }
12914 params := &openapiutil.Params{
12915 Action: dara.String("ListPages"),
12916 Version: dara.String("2024-09-10"),
12917 Protocol: dara.String("HTTPS"),
12918 Pathname: dara.String("/"),
12919 Method: dara.String("POST"),
12920 AuthType: dara.String("AK"),
12921 Style: dara.String("RPC"),
12922 ReqBodyType: dara.String("formData"),
12923 BodyType: dara.String("json"),
12924 }
12925 _result = &ListPagesResponse{}
12926 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12927 if _err != nil {
12928 return _result, _err
12929 }
12930 _err = dara.Convert(_body, &_result)
12931 return _result, _err
12932 }
12933
12934 // Summary:
12935 //
12936 // Queries a list of Domain Name System (DNS) records of a website, including the record value, priority, and authentication configurations. Supports filtering by specifying parameters such as RecordName and RecordMatchType.
12937 //
12938 // Description:
12939 //
12940 // The DNS records related to Edge Container, Edge Routine, and TCP/UDP proxy are not returned in this operation.
12941 //
12942 // @param request - ListRecordsRequest
12943 //
12944 // @param runtime - runtime options for this request RuntimeOptions
12945 //
12946 // @return ListRecordsResponse
12947 func ListRecordsWithContext(ctx context.Context, client *Client, request *ListRecordsRequest, runtime *dara.RuntimeOptions) (_result *ListRecordsResponse, _err error) {
12948 if dara.BoolValue(client.EnableValidate) == true {
12949 _err = request.Validate()
12950 if _err != nil {
12951 return _result, _err
12952 }
12953 }
12954 query := openapiutil.Query(dara.ToMap(request))
12955 req := &openapiutil.OpenApiRequest{
12956 Query: openapiutil.Query(query),
12957 }
12958 params := &openapiutil.Params{
12959 Action: dara.String("ListRecords"),
12960 Version: dara.String("2024-09-10"),
12961 Protocol: dara.String("HTTPS"),
12962 Pathname: dara.String("/"),
12963 Method: dara.String("GET"),
12964 AuthType: dara.String("AK"),
12965 Style: dara.String("RPC"),
12966 ReqBodyType: dara.String("formData"),
12967 BodyType: dara.String("json"),
12968 }
12969 _result = &ListRecordsResponse{}
12970 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
12971 if _err != nil {
12972 return _result, _err
12973 }
12974 _err = dara.Convert(_body, &_result)
12975 return _result, _err
12976 }
12977
12978 // Summary:
12979 //
12980 // # Query Redirect Rule List
12981 //
12982 // @param request - ListRedirectRulesRequest
12983 //
12984 // @param runtime - runtime options for this request RuntimeOptions
12985 //
12986 // @return ListRedirectRulesResponse
12987 func ListRedirectRulesWithContext(ctx context.Context, client *Client, request *ListRedirectRulesRequest, runtime *dara.RuntimeOptions) (_result *ListRedirectRulesResponse, _err error) {
12988 if dara.BoolValue(client.EnableValidate) == true {
12989 _err = request.Validate()
12990 if _err != nil {
12991 return _result, _err
12992 }
12993 }
12994 query := openapiutil.Query(dara.ToMap(request))
12995 req := &openapiutil.OpenApiRequest{
12996 Query: openapiutil.Query(query),
12997 }
12998 params := &openapiutil.Params{
12999 Action: dara.String("ListRedirectRules"),
13000 Version: dara.String("2024-09-10"),
13001 Protocol: dara.String("HTTPS"),
13002 Pathname: dara.String("/"),
13003 Method: dara.String("GET"),
13004 AuthType: dara.String("AK"),
13005 Style: dara.String("RPC"),
13006 ReqBodyType: dara.String("formData"),
13007 BodyType: dara.String("json"),
13008 }
13009 _result = &ListRedirectRulesResponse{}
13010 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13011 if _err != nil {
13012 return _result, _err
13013 }
13014 _err = dara.Convert(_body, &_result)
13015 return _result, _err
13016 }
13017
13018 // Summary:
13019 //
13020 // # List of Rewrite URL Rules
13021 //
13022 // @param request - ListRewriteUrlRulesRequest
13023 //
13024 // @param runtime - runtime options for this request RuntimeOptions
13025 //
13026 // @return ListRewriteUrlRulesResponse
13027 func ListRewriteUrlRulesWithContext(ctx context.Context, client *Client, request *ListRewriteUrlRulesRequest, runtime *dara.RuntimeOptions) (_result *ListRewriteUrlRulesResponse, _err error) {
13028 if dara.BoolValue(client.EnableValidate) == true {
13029 _err = request.Validate()
13030 if _err != nil {
13031 return _result, _err
13032 }
13033 }
13034 query := openapiutil.Query(dara.ToMap(request))
13035 req := &openapiutil.OpenApiRequest{
13036 Query: openapiutil.Query(query),
13037 }
13038 params := &openapiutil.Params{
13039 Action: dara.String("ListRewriteUrlRules"),
13040 Version: dara.String("2024-09-10"),
13041 Protocol: dara.String("HTTPS"),
13042 Pathname: dara.String("/"),
13043 Method: dara.String("GET"),
13044 AuthType: dara.String("AK"),
13045 Style: dara.String("RPC"),
13046 ReqBodyType: dara.String("formData"),
13047 BodyType: dara.String("json"),
13048 }
13049 _result = &ListRewriteUrlRulesResponse{}
13050 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13051 if _err != nil {
13052 return _result, _err
13053 }
13054 _err = dara.Convert(_body, &_result)
13055 return _result, _err
13056 }
13057
13058 // Summary:
13059 //
13060 // Queries the code versions of a function (routine) by page.
13061 //
13062 // Description:
13063 //
13064 // Call this operation to query the code versions of a specific function. Paged query and fuzzy search are supported. You can configure `Name` to specify the name of a function.
13065 //
13066 // Specify `PageNumber` and `PageSize` to control the number of entries returned in a request, and use `SearchKeyWord` to specify a keyword for fuzzy search.
13067 //
13068 // The response includes the number, description, and creation time of each code version.
13069 //
13070 // @param request - ListRoutineCodeVersionsRequest
13071 //
13072 // @param runtime - runtime options for this request RuntimeOptions
13073 //
13074 // @return ListRoutineCodeVersionsResponse
13075 func ListRoutineCodeVersionsWithContext(ctx context.Context, client *Client, request *ListRoutineCodeVersionsRequest, runtime *dara.RuntimeOptions) (_result *ListRoutineCodeVersionsResponse, _err error) {
13076 if dara.BoolValue(client.EnableValidate) == true {
13077 _err = request.Validate()
13078 if _err != nil {
13079 return _result, _err
13080 }
13081 }
13082 body := map[string]interface{}{}
13083 if !dara.IsNil(request.Name) {
13084 body["Name"] = request.Name
13085 }
13086
13087 if !dara.IsNil(request.PageNumber) {
13088 body["PageNumber"] = request.PageNumber
13089 }
13090
13091 if !dara.IsNil(request.PageSize) {
13092 body["PageSize"] = request.PageSize
13093 }
13094
13095 if !dara.IsNil(request.SearchKeyWord) {
13096 body["SearchKeyWord"] = request.SearchKeyWord
13097 }
13098
13099 req := &openapiutil.OpenApiRequest{
13100 Body: openapiutil.ParseToMap(body),
13101 }
13102 params := &openapiutil.Params{
13103 Action: dara.String("ListRoutineCodeVersions"),
13104 Version: dara.String("2024-09-10"),
13105 Protocol: dara.String("HTTPS"),
13106 Pathname: dara.String("/"),
13107 Method: dara.String("POST"),
13108 AuthType: dara.String("AK"),
13109 Style: dara.String("RPC"),
13110 ReqBodyType: dara.String("formData"),
13111 BodyType: dara.String("json"),
13112 }
13113 _result = &ListRoutineCodeVersionsResponse{}
13114 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13115 if _err != nil {
13116 return _result, _err
13117 }
13118 _err = dara.Convert(_body, &_result)
13119 return _result, _err
13120 }
13121
13122 // Summary:
13123 //
13124 // The records associated with the function.
13125 //
13126 // Description:
13127 //
13128 // You can call this operation to query the routes associated with a function. You can specify paged query parameters to obtain the specified number of routes or specify a keyword for fuzzy search to filter specific routes.
13129 //
13130 // @param request - ListRoutineRelatedRecordsRequest
13131 //
13132 // @param runtime - runtime options for this request RuntimeOptions
13133 //
13134 // @return ListRoutineRelatedRecordsResponse
13135 func ListRoutineRelatedRecordsWithContext(ctx context.Context, client *Client, request *ListRoutineRelatedRecordsRequest, runtime *dara.RuntimeOptions) (_result *ListRoutineRelatedRecordsResponse, _err error) {
13136 if dara.BoolValue(client.EnableValidate) == true {
13137 _err = request.Validate()
13138 if _err != nil {
13139 return _result, _err
13140 }
13141 }
13142 body := map[string]interface{}{}
13143 if !dara.IsNil(request.Name) {
13144 body["Name"] = request.Name
13145 }
13146
13147 if !dara.IsNil(request.PageNumber) {
13148 body["PageNumber"] = request.PageNumber
13149 }
13150
13151 if !dara.IsNil(request.PageSize) {
13152 body["PageSize"] = request.PageSize
13153 }
13154
13155 if !dara.IsNil(request.SearchKeyWord) {
13156 body["SearchKeyWord"] = request.SearchKeyWord
13157 }
13158
13159 req := &openapiutil.OpenApiRequest{
13160 Body: openapiutil.ParseToMap(body),
13161 }
13162 params := &openapiutil.Params{
13163 Action: dara.String("ListRoutineRelatedRecords"),
13164 Version: dara.String("2024-09-10"),
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 = &ListRoutineRelatedRecordsResponse{}
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 // Queries the routes of an edge function.
13185 //
13186 // @param request - ListRoutineRoutesRequest
13187 //
13188 // @param runtime - runtime options for this request RuntimeOptions
13189 //
13190 // @return ListRoutineRoutesResponse
13191 func ListRoutineRoutesWithContext(ctx context.Context, client *Client, request *ListRoutineRoutesRequest, runtime *dara.RuntimeOptions) (_result *ListRoutineRoutesResponse, _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.PageNumber) {
13200 query["PageNumber"] = request.PageNumber
13201 }
13202
13203 if !dara.IsNil(request.PageSize) {
13204 query["PageSize"] = request.PageSize
13205 }
13206
13207 if !dara.IsNil(request.RoutineName) {
13208 query["RoutineName"] = request.RoutineName
13209 }
13210
13211 req := &openapiutil.OpenApiRequest{
13212 Query: openapiutil.Query(query),
13213 }
13214 params := &openapiutil.Params{
13215 Action: dara.String("ListRoutineRoutes"),
13216 Version: dara.String("2024-09-10"),
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 = &ListRoutineRoutesResponse{}
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 // Lists the plans in a scheduled prefetch task by task ID.
13237 //
13238 // @param request - ListScheduledPreloadExecutionsRequest
13239 //
13240 // @param runtime - runtime options for this request RuntimeOptions
13241 //
13242 // @return ListScheduledPreloadExecutionsResponse
13243 func ListScheduledPreloadExecutionsWithContext(ctx context.Context, client *Client, request *ListScheduledPreloadExecutionsRequest, runtime *dara.RuntimeOptions) (_result *ListScheduledPreloadExecutionsResponse, _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 := openapiutil.Query(dara.ToMap(request))
13251 req := &openapiutil.OpenApiRequest{
13252 Query: openapiutil.Query(query),
13253 }
13254 params := &openapiutil.Params{
13255 Action: dara.String("ListScheduledPreloadExecutions"),
13256 Version: dara.String("2024-09-10"),
13257 Protocol: dara.String("HTTPS"),
13258 Pathname: dara.String("/"),
13259 Method: dara.String("GET"),
13260 AuthType: dara.String("AK"),
13261 Style: dara.String("RPC"),
13262 ReqBodyType: dara.String("formData"),
13263 BodyType: dara.String("json"),
13264 }
13265 _result = &ListScheduledPreloadExecutionsResponse{}
13266 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13267 if _err != nil {
13268 return _result, _err
13269 }
13270 _err = dara.Convert(_body, &_result)
13271 return _result, _err
13272 }
13273
13274 // Summary:
13275 //
13276 // Queries the scheduled prefetch tasks for a website.
13277 //
13278 // @param request - ListScheduledPreloadJobsRequest
13279 //
13280 // @param runtime - runtime options for this request RuntimeOptions
13281 //
13282 // @return ListScheduledPreloadJobsResponse
13283 func ListScheduledPreloadJobsWithContext(ctx context.Context, client *Client, request *ListScheduledPreloadJobsRequest, runtime *dara.RuntimeOptions) (_result *ListScheduledPreloadJobsResponse, _err error) {
13284 if dara.BoolValue(client.EnableValidate) == true {
13285 _err = request.Validate()
13286 if _err != nil {
13287 return _result, _err
13288 }
13289 }
13290 query := openapiutil.Query(dara.ToMap(request))
13291 req := &openapiutil.OpenApiRequest{
13292 Query: openapiutil.Query(query),
13293 }
13294 params := &openapiutil.Params{
13295 Action: dara.String("ListScheduledPreloadJobs"),
13296 Version: dara.String("2024-09-10"),
13297 Protocol: dara.String("HTTPS"),
13298 Pathname: dara.String("/"),
13299 Method: dara.String("GET"),
13300 AuthType: dara.String("AK"),
13301 Style: dara.String("RPC"),
13302 ReqBodyType: dara.String("formData"),
13303 BodyType: dara.String("json"),
13304 }
13305 _result = &ListScheduledPreloadJobsResponse{}
13306 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13307 if _err != nil {
13308 return _result, _err
13309 }
13310 _err = dara.Convert(_body, &_result)
13311 return _result, _err
13312 }
13313
13314 // Summary:
13315 //
13316 // Lists all log delivery tasks that are in progress.
13317 //
13318 // @param request - ListSiteDeliveryTasksRequest
13319 //
13320 // @param runtime - runtime options for this request RuntimeOptions
13321 //
13322 // @return ListSiteDeliveryTasksResponse
13323 func ListSiteDeliveryTasksWithContext(ctx context.Context, client *Client, request *ListSiteDeliveryTasksRequest, runtime *dara.RuntimeOptions) (_result *ListSiteDeliveryTasksResponse, _err error) {
13324 if dara.BoolValue(client.EnableValidate) == true {
13325 _err = request.Validate()
13326 if _err != nil {
13327 return _result, _err
13328 }
13329 }
13330 query := openapiutil.Query(dara.ToMap(request))
13331 req := &openapiutil.OpenApiRequest{
13332 Query: openapiutil.Query(query),
13333 }
13334 params := &openapiutil.Params{
13335 Action: dara.String("ListSiteDeliveryTasks"),
13336 Version: dara.String("2024-09-10"),
13337 Protocol: dara.String("HTTPS"),
13338 Pathname: dara.String("/"),
13339 Method: dara.String("GET"),
13340 AuthType: dara.String("AK"),
13341 Style: dara.String("RPC"),
13342 ReqBodyType: dara.String("formData"),
13343 BodyType: dara.String("json"),
13344 }
13345 _result = &ListSiteDeliveryTasksResponse{}
13346 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13347 if _err != nil {
13348 return _result, _err
13349 }
13350 _err = dara.Convert(_body, &_result)
13351 return _result, _err
13352 }
13353
13354 // Summary:
13355 //
13356 // Queries the edge function routes for a website.
13357 //
13358 // @param request - ListSiteRoutesRequest
13359 //
13360 // @param runtime - runtime options for this request RuntimeOptions
13361 //
13362 // @return ListSiteRoutesResponse
13363 func ListSiteRoutesWithContext(ctx context.Context, client *Client, request *ListSiteRoutesRequest, runtime *dara.RuntimeOptions) (_result *ListSiteRoutesResponse, _err error) {
13364 if dara.BoolValue(client.EnableValidate) == true {
13365 _err = request.Validate()
13366 if _err != nil {
13367 return _result, _err
13368 }
13369 }
13370 query := map[string]interface{}{}
13371 if !dara.IsNil(request.ConfigId) {
13372 query["ConfigId"] = request.ConfigId
13373 }
13374
13375 if !dara.IsNil(request.ConfigType) {
13376 query["ConfigType"] = request.ConfigType
13377 }
13378
13379 if !dara.IsNil(request.PageNumber) {
13380 query["PageNumber"] = request.PageNumber
13381 }
13382
13383 if !dara.IsNil(request.PageSize) {
13384 query["PageSize"] = request.PageSize
13385 }
13386
13387 if !dara.IsNil(request.RouteName) {
13388 query["RouteName"] = request.RouteName
13389 }
13390
13391 if !dara.IsNil(request.SiteId) {
13392 query["SiteId"] = request.SiteId
13393 }
13394
13395 req := &openapiutil.OpenApiRequest{
13396 Query: openapiutil.Query(query),
13397 }
13398 params := &openapiutil.Params{
13399 Action: dara.String("ListSiteRoutes"),
13400 Version: dara.String("2024-09-10"),
13401 Protocol: dara.String("HTTPS"),
13402 Pathname: dara.String("/"),
13403 Method: dara.String("POST"),
13404 AuthType: dara.String("AK"),
13405 Style: dara.String("RPC"),
13406 ReqBodyType: dara.String("formData"),
13407 BodyType: dara.String("json"),
13408 }
13409 _result = &ListSiteRoutesResponse{}
13410 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13411 if _err != nil {
13412 return _result, _err
13413 }
13414 _err = dara.Convert(_body, &_result)
13415 return _result, _err
13416 }
13417
13418 // Summary:
13419 //
13420 // Queries the information about websites in your account, such as the name, status, and configuration of each website.
13421 //
13422 // @param tmpReq - ListSitesRequest
13423 //
13424 // @param runtime - runtime options for this request RuntimeOptions
13425 //
13426 // @return ListSitesResponse
13427 func ListSitesWithContext(ctx context.Context, client *Client, tmpReq *ListSitesRequest, runtime *dara.RuntimeOptions) (_result *ListSitesResponse, _err error) {
13428 if dara.BoolValue(client.EnableValidate) == true {
13429 _err = tmpReq.Validate()
13430 if _err != nil {
13431 return _result, _err
13432 }
13433 }
13434 request := &ListSitesShrinkRequest{}
13435 openapiutil.Convert(tmpReq, request)
13436 if !dara.IsNil(tmpReq.TagFilter) {
13437 request.TagFilterShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.TagFilter, dara.String("TagFilter"), dara.String("json"))
13438 }
13439
13440 query := openapiutil.Query(dara.ToMap(request))
13441 req := &openapiutil.OpenApiRequest{
13442 Query: openapiutil.Query(query),
13443 }
13444 params := &openapiutil.Params{
13445 Action: dara.String("ListSites"),
13446 Version: dara.String("2024-09-10"),
13447 Protocol: dara.String("HTTPS"),
13448 Pathname: dara.String("/"),
13449 Method: dara.String("GET"),
13450 AuthType: dara.String("AK"),
13451 Style: dara.String("RPC"),
13452 ReqBodyType: dara.String("formData"),
13453 BodyType: dara.String("json"),
13454 }
13455 _result = &ListSitesResponse{}
13456 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13457 if _err != nil {
13458 return _result, _err
13459 }
13460 _err = dara.Convert(_body, &_result)
13461 return _result, _err
13462 }
13463
13464 // Summary:
13465 //
13466 // Queries tags based on the region ID and resource type.
13467 //
13468 // @param request - ListTagResourcesRequest
13469 //
13470 // @param runtime - runtime options for this request RuntimeOptions
13471 //
13472 // @return ListTagResourcesResponse
13473 func ListTagResourcesWithContext(ctx context.Context, client *Client, request *ListTagResourcesRequest, runtime *dara.RuntimeOptions) (_result *ListTagResourcesResponse, _err error) {
13474 if dara.BoolValue(client.EnableValidate) == true {
13475 _err = request.Validate()
13476 if _err != nil {
13477 return _result, _err
13478 }
13479 }
13480 query := map[string]interface{}{}
13481 if !dara.IsNil(request.MaxItem) {
13482 query["MaxItem"] = request.MaxItem
13483 }
13484
13485 if !dara.IsNil(request.NextToken) {
13486 query["NextToken"] = request.NextToken
13487 }
13488
13489 if !dara.IsNil(request.OwnerId) {
13490 query["OwnerId"] = request.OwnerId
13491 }
13492
13493 if !dara.IsNil(request.RegionId) {
13494 query["RegionId"] = request.RegionId
13495 }
13496
13497 if !dara.IsNil(request.ResourceId) {
13498 query["ResourceId"] = request.ResourceId
13499 }
13500
13501 if !dara.IsNil(request.ResourceType) {
13502 query["ResourceType"] = request.ResourceType
13503 }
13504
13505 if !dara.IsNil(request.SecurityToken) {
13506 query["SecurityToken"] = request.SecurityToken
13507 }
13508
13509 if !dara.IsNil(request.Tag) {
13510 query["Tag"] = request.Tag
13511 }
13512
13513 req := &openapiutil.OpenApiRequest{
13514 Query: openapiutil.Query(query),
13515 }
13516 params := &openapiutil.Params{
13517 Action: dara.String("ListTagResources"),
13518 Version: dara.String("2024-09-10"),
13519 Protocol: dara.String("HTTPS"),
13520 Pathname: dara.String("/"),
13521 Method: dara.String("POST"),
13522 AuthType: dara.String("AK"),
13523 Style: dara.String("RPC"),
13524 ReqBodyType: dara.String("formData"),
13525 BodyType: dara.String("json"),
13526 }
13527 _result = &ListTagResourcesResponse{}
13528 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13529 if _err != nil {
13530 return _result, _err
13531 }
13532 _err = dara.Convert(_body, &_result)
13533 return _result, _err
13534 }
13535
13536 // Summary:
13537 //
13538 // # List of Transport Layer Applications
13539 //
13540 // @param request - ListTransportLayerApplicationsRequest
13541 //
13542 // @param runtime - runtime options for this request RuntimeOptions
13543 //
13544 // @return ListTransportLayerApplicationsResponse
13545 func ListTransportLayerApplicationsWithContext(ctx context.Context, client *Client, request *ListTransportLayerApplicationsRequest, runtime *dara.RuntimeOptions) (_result *ListTransportLayerApplicationsResponse, _err error) {
13546 if dara.BoolValue(client.EnableValidate) == true {
13547 _err = request.Validate()
13548 if _err != nil {
13549 return _result, _err
13550 }
13551 }
13552 query := openapiutil.Query(dara.ToMap(request))
13553 req := &openapiutil.OpenApiRequest{
13554 Query: openapiutil.Query(query),
13555 }
13556 params := &openapiutil.Params{
13557 Action: dara.String("ListTransportLayerApplications"),
13558 Version: dara.String("2024-09-10"),
13559 Protocol: dara.String("HTTPS"),
13560 Pathname: dara.String("/"),
13561 Method: dara.String("GET"),
13562 AuthType: dara.String("AK"),
13563 Style: dara.String("RPC"),
13564 ReqBodyType: dara.String("formData"),
13565 BodyType: dara.String("json"),
13566 }
13567 _result = &ListTransportLayerApplicationsResponse{}
13568 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13569 if _err != nil {
13570 return _result, _err
13571 }
13572 _err = dara.Convert(_body, &_result)
13573 return _result, _err
13574 }
13575
13576 // Summary:
13577 //
13578 // Queries the execution status and running information of file upload tasks based on the task time and type.
13579 //
13580 // @param request - ListUploadTasksRequest
13581 //
13582 // @param runtime - runtime options for this request RuntimeOptions
13583 //
13584 // @return ListUploadTasksResponse
13585 func ListUploadTasksWithContext(ctx context.Context, client *Client, request *ListUploadTasksRequest, runtime *dara.RuntimeOptions) (_result *ListUploadTasksResponse, _err error) {
13586 if dara.BoolValue(client.EnableValidate) == true {
13587 _err = request.Validate()
13588 if _err != nil {
13589 return _result, _err
13590 }
13591 }
13592 query := openapiutil.Query(dara.ToMap(request))
13593 req := &openapiutil.OpenApiRequest{
13594 Query: openapiutil.Query(query),
13595 }
13596 params := &openapiutil.Params{
13597 Action: dara.String("ListUploadTasks"),
13598 Version: dara.String("2024-09-10"),
13599 Protocol: dara.String("HTTPS"),
13600 Pathname: dara.String("/"),
13601 Method: dara.String("GET"),
13602 AuthType: dara.String("AK"),
13603 Style: dara.String("RPC"),
13604 ReqBodyType: dara.String("formData"),
13605 BodyType: dara.String("json"),
13606 }
13607 _result = &ListUploadTasksResponse{}
13608 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13609 if _err != nil {
13610 return _result, _err
13611 }
13612 _err = dara.Convert(_body, &_result)
13613 return _result, _err
13614 }
13615
13616 // Summary:
13617 //
13618 // Queries the list of page monitoring configurations.
13619 //
13620 // @param request - ListUrlObservationsRequest
13621 //
13622 // @param runtime - runtime options for this request RuntimeOptions
13623 //
13624 // @return ListUrlObservationsResponse
13625 func ListUrlObservationsWithContext(ctx context.Context, client *Client, request *ListUrlObservationsRequest, runtime *dara.RuntimeOptions) (_result *ListUrlObservationsResponse, _err error) {
13626 if dara.BoolValue(client.EnableValidate) == true {
13627 _err = request.Validate()
13628 if _err != nil {
13629 return _result, _err
13630 }
13631 }
13632 query := map[string]interface{}{}
13633 if !dara.IsNil(request.ConfigId) {
13634 query["ConfigId"] = request.ConfigId
13635 }
13636
13637 if !dara.IsNil(request.PageNumber) {
13638 query["PageNumber"] = request.PageNumber
13639 }
13640
13641 if !dara.IsNil(request.PageSize) {
13642 query["PageSize"] = request.PageSize
13643 }
13644
13645 if !dara.IsNil(request.SiteId) {
13646 query["SiteId"] = request.SiteId
13647 }
13648
13649 req := &openapiutil.OpenApiRequest{
13650 Query: openapiutil.Query(query),
13651 }
13652 params := &openapiutil.Params{
13653 Action: dara.String("ListUrlObservations"),
13654 Version: dara.String("2024-09-10"),
13655 Protocol: dara.String("HTTPS"),
13656 Pathname: dara.String("/"),
13657 Method: dara.String("POST"),
13658 AuthType: dara.String("AK"),
13659 Style: dara.String("RPC"),
13660 ReqBodyType: dara.String("formData"),
13661 BodyType: dara.String("json"),
13662 }
13663 _result = &ListUrlObservationsResponse{}
13664 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13665 if _err != nil {
13666 return _result, _err
13667 }
13668 _err = dara.Convert(_body, &_result)
13669 return _result, _err
13670 }
13671
13672 // Summary:
13673 //
13674 // Queries all delivery tasks in your Alibaba Cloud account by page. You can filter the delivery tasks by the category of the delivered real-time logs.
13675 //
13676 // @param request - ListUserDeliveryTasksRequest
13677 //
13678 // @param runtime - runtime options for this request RuntimeOptions
13679 //
13680 // @return ListUserDeliveryTasksResponse
13681 func ListUserDeliveryTasksWithContext(ctx context.Context, client *Client, request *ListUserDeliveryTasksRequest, runtime *dara.RuntimeOptions) (_result *ListUserDeliveryTasksResponse, _err error) {
13682 if dara.BoolValue(client.EnableValidate) == true {
13683 _err = request.Validate()
13684 if _err != nil {
13685 return _result, _err
13686 }
13687 }
13688 query := openapiutil.Query(dara.ToMap(request))
13689 req := &openapiutil.OpenApiRequest{
13690 Query: openapiutil.Query(query),
13691 }
13692 params := &openapiutil.Params{
13693 Action: dara.String("ListUserDeliveryTasks"),
13694 Version: dara.String("2024-09-10"),
13695 Protocol: dara.String("HTTPS"),
13696 Pathname: dara.String("/"),
13697 Method: dara.String("GET"),
13698 AuthType: dara.String("AK"),
13699 Style: dara.String("RPC"),
13700 ReqBodyType: dara.String("formData"),
13701 BodyType: dara.String("json"),
13702 }
13703 _result = &ListUserDeliveryTasksResponse{}
13704 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13705 if _err != nil {
13706 return _result, _err
13707 }
13708 _err = dara.Convert(_body, &_result)
13709 return _result, _err
13710 }
13711
13712 // Summary:
13713 //
13714 // Queries the plans that you purchased and the details of the plans.
13715 //
13716 // @param request - ListUserRatePlanInstancesRequest
13717 //
13718 // @param runtime - runtime options for this request RuntimeOptions
13719 //
13720 // @return ListUserRatePlanInstancesResponse
13721 func ListUserRatePlanInstancesWithContext(ctx context.Context, client *Client, request *ListUserRatePlanInstancesRequest, runtime *dara.RuntimeOptions) (_result *ListUserRatePlanInstancesResponse, _err error) {
13722 if dara.BoolValue(client.EnableValidate) == true {
13723 _err = request.Validate()
13724 if _err != nil {
13725 return _result, _err
13726 }
13727 }
13728 query := openapiutil.Query(dara.ToMap(request))
13729 req := &openapiutil.OpenApiRequest{
13730 Query: openapiutil.Query(query),
13731 }
13732 params := &openapiutil.Params{
13733 Action: dara.String("ListUserRatePlanInstances"),
13734 Version: dara.String("2024-09-10"),
13735 Protocol: dara.String("HTTPS"),
13736 Pathname: dara.String("/"),
13737 Method: dara.String("GET"),
13738 AuthType: dara.String("AK"),
13739 Style: dara.String("RPC"),
13740 ReqBodyType: dara.String("formData"),
13741 BodyType: dara.String("json"),
13742 }
13743 _result = &ListUserRatePlanInstancesResponse{}
13744 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13745 if _err != nil {
13746 return _result, _err
13747 }
13748 _err = dara.Convert(_body, &_result)
13749 return _result, _err
13750 }
13751
13752 // Summary:
13753 //
13754 // Queries the functions created in your account and the maximum number of functions supported by your plan. You can call this operation to perform a paged query.
13755 //
13756 // Description:
13757 //
13758 // You can call this operation to perform a paged query to query all functions created in your account, the maximum number of functions supported by the billing plan that you use, and the number of functions already created. You can specify `PageNumber` and `PageSize` to control the number of entries to be returned in the response and specify `SearchKeyWord` to perform a fuzzy search to filter specific routine names.
13759 //
13760 // @param request - ListUserRoutinesRequest
13761 //
13762 // @param runtime - runtime options for this request RuntimeOptions
13763 //
13764 // @return ListUserRoutinesResponse
13765 func ListUserRoutinesWithContext(ctx context.Context, client *Client, request *ListUserRoutinesRequest, runtime *dara.RuntimeOptions) (_result *ListUserRoutinesResponse, _err error) {
13766 if dara.BoolValue(client.EnableValidate) == true {
13767 _err = request.Validate()
13768 if _err != nil {
13769 return _result, _err
13770 }
13771 }
13772 query := map[string]interface{}{}
13773 if !dara.IsNil(request.PageNumber) {
13774 query["PageNumber"] = request.PageNumber
13775 }
13776
13777 if !dara.IsNil(request.PageSize) {
13778 query["PageSize"] = request.PageSize
13779 }
13780
13781 if !dara.IsNil(request.SearchKeyWord) {
13782 query["SearchKeyWord"] = request.SearchKeyWord
13783 }
13784
13785 req := &openapiutil.OpenApiRequest{
13786 Query: openapiutil.Query(query),
13787 }
13788 params := &openapiutil.Params{
13789 Action: dara.String("ListUserRoutines"),
13790 Version: dara.String("2024-09-10"),
13791 Protocol: dara.String("HTTPS"),
13792 Pathname: dara.String("/"),
13793 Method: dara.String("POST"),
13794 AuthType: dara.String("AK"),
13795 Style: dara.String("RPC"),
13796 ReqBodyType: dara.String("formData"),
13797 BodyType: dara.String("json"),
13798 }
13799 _result = &ListUserRoutinesResponse{}
13800 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13801 if _err != nil {
13802 return _result, _err
13803 }
13804 _err = dara.Convert(_body, &_result)
13805 return _result, _err
13806 }
13807
13808 // Summary:
13809 //
13810 // 用于列举实例级别的Web应用防火墙规则集。
13811 //
13812 // @param tmpReq - ListUserWafRulesetsRequest
13813 //
13814 // @param runtime - runtime options for this request RuntimeOptions
13815 //
13816 // @return ListUserWafRulesetsResponse
13817 func ListUserWafRulesetsWithContext(ctx context.Context, client *Client, tmpReq *ListUserWafRulesetsRequest, runtime *dara.RuntimeOptions) (_result *ListUserWafRulesetsResponse, _err error) {
13818 if dara.BoolValue(client.EnableValidate) == true {
13819 _err = tmpReq.Validate()
13820 if _err != nil {
13821 return _result, _err
13822 }
13823 }
13824 request := &ListUserWafRulesetsShrinkRequest{}
13825 openapiutil.Convert(tmpReq, request)
13826 if !dara.IsNil(tmpReq.QueryArgs) {
13827 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
13828 }
13829
13830 query := map[string]interface{}{}
13831 if !dara.IsNil(request.InstanceId) {
13832 query["InstanceId"] = request.InstanceId
13833 }
13834
13835 if !dara.IsNil(request.PageNumber) {
13836 query["PageNumber"] = request.PageNumber
13837 }
13838
13839 if !dara.IsNil(request.PageSize) {
13840 query["PageSize"] = request.PageSize
13841 }
13842
13843 if !dara.IsNil(request.Phase) {
13844 query["Phase"] = request.Phase
13845 }
13846
13847 if !dara.IsNil(request.QueryArgsShrink) {
13848 query["QueryArgs"] = request.QueryArgsShrink
13849 }
13850
13851 req := &openapiutil.OpenApiRequest{
13852 Query: openapiutil.Query(query),
13853 }
13854 params := &openapiutil.Params{
13855 Action: dara.String("ListUserWafRulesets"),
13856 Version: dara.String("2024-09-10"),
13857 Protocol: dara.String("HTTPS"),
13858 Pathname: dara.String("/"),
13859 Method: dara.String("POST"),
13860 AuthType: dara.String("AK"),
13861 Style: dara.String("RPC"),
13862 ReqBodyType: dara.String("formData"),
13863 BodyType: dara.String("json"),
13864 }
13865 _result = &ListUserWafRulesetsResponse{}
13866 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13867 if _err != nil {
13868 return _result, _err
13869 }
13870 _err = dara.Convert(_body, &_result)
13871 return _result, _err
13872 }
13873
13874 // Summary:
13875 //
13876 // Queries the video processing configurations of a site.
13877 //
13878 // @param request - ListVideoProcessingsRequest
13879 //
13880 // @param runtime - runtime options for this request RuntimeOptions
13881 //
13882 // @return ListVideoProcessingsResponse
13883 func ListVideoProcessingsWithContext(ctx context.Context, client *Client, request *ListVideoProcessingsRequest, runtime *dara.RuntimeOptions) (_result *ListVideoProcessingsResponse, _err error) {
13884 if dara.BoolValue(client.EnableValidate) == true {
13885 _err = request.Validate()
13886 if _err != nil {
13887 return _result, _err
13888 }
13889 }
13890 query := map[string]interface{}{}
13891 if !dara.IsNil(request.ConfigId) {
13892 query["ConfigId"] = request.ConfigId
13893 }
13894
13895 if !dara.IsNil(request.ConfigType) {
13896 query["ConfigType"] = request.ConfigType
13897 }
13898
13899 if !dara.IsNil(request.PageNumber) {
13900 query["PageNumber"] = request.PageNumber
13901 }
13902
13903 if !dara.IsNil(request.PageSize) {
13904 query["PageSize"] = request.PageSize
13905 }
13906
13907 if !dara.IsNil(request.RuleName) {
13908 query["RuleName"] = request.RuleName
13909 }
13910
13911 if !dara.IsNil(request.SiteId) {
13912 query["SiteId"] = request.SiteId
13913 }
13914
13915 if !dara.IsNil(request.SiteVersion) {
13916 query["SiteVersion"] = request.SiteVersion
13917 }
13918
13919 req := &openapiutil.OpenApiRequest{
13920 Query: openapiutil.Query(query),
13921 }
13922 params := &openapiutil.Params{
13923 Action: dara.String("ListVideoProcessings"),
13924 Version: dara.String("2024-09-10"),
13925 Protocol: dara.String("HTTPS"),
13926 Pathname: dara.String("/"),
13927 Method: dara.String("POST"),
13928 AuthType: dara.String("AK"),
13929 Style: dara.String("RPC"),
13930 ReqBodyType: dara.String("formData"),
13931 BodyType: dara.String("json"),
13932 }
13933 _result = &ListVideoProcessingsResponse{}
13934 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
13935 if _err != nil {
13936 return _result, _err
13937 }
13938 _err = dara.Convert(_body, &_result)
13939 return _result, _err
13940 }
13941
13942 // Summary:
13943 //
13944 // # List WAF Managed Rules
13945 //
13946 // @param tmpReq - ListWafManagedRulesRequest
13947 //
13948 // @param runtime - runtime options for this request RuntimeOptions
13949 //
13950 // @return ListWafManagedRulesResponse
13951 func ListWafManagedRulesWithContext(ctx context.Context, client *Client, tmpReq *ListWafManagedRulesRequest, runtime *dara.RuntimeOptions) (_result *ListWafManagedRulesResponse, _err error) {
13952 if dara.BoolValue(client.EnableValidate) == true {
13953 _err = tmpReq.Validate()
13954 if _err != nil {
13955 return _result, _err
13956 }
13957 }
13958 request := &ListWafManagedRulesShrinkRequest{}
13959 openapiutil.Convert(tmpReq, request)
13960 if !dara.IsNil(tmpReq.ManagedRuleset) {
13961 request.ManagedRulesetShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ManagedRuleset, dara.String("ManagedRuleset"), dara.String("json"))
13962 }
13963
13964 if !dara.IsNil(tmpReq.QueryArgs) {
13965 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
13966 }
13967
13968 query := map[string]interface{}{}
13969 if !dara.IsNil(request.AttackType) {
13970 query["AttackType"] = request.AttackType
13971 }
13972
13973 if !dara.IsNil(request.Id) {
13974 query["Id"] = request.Id
13975 }
13976
13977 if !dara.IsNil(request.InstanceId) {
13978 query["InstanceId"] = request.InstanceId
13979 }
13980
13981 if !dara.IsNil(request.Language) {
13982 query["Language"] = request.Language
13983 }
13984
13985 if !dara.IsNil(request.ManagedRulesetShrink) {
13986 query["ManagedRuleset"] = request.ManagedRulesetShrink
13987 }
13988
13989 if !dara.IsNil(request.PageNumber) {
13990 query["PageNumber"] = request.PageNumber
13991 }
13992
13993 if !dara.IsNil(request.PageSize) {
13994 query["PageSize"] = request.PageSize
13995 }
13996
13997 if !dara.IsNil(request.ProtectionLevel) {
13998 query["ProtectionLevel"] = request.ProtectionLevel
13999 }
14000
14001 if !dara.IsNil(request.QueryArgsShrink) {
14002 query["QueryArgs"] = request.QueryArgsShrink
14003 }
14004
14005 if !dara.IsNil(request.SiteId) {
14006 query["SiteId"] = request.SiteId
14007 }
14008
14009 req := &openapiutil.OpenApiRequest{
14010 Query: openapiutil.Query(query),
14011 }
14012 params := &openapiutil.Params{
14013 Action: dara.String("ListWafManagedRules"),
14014 Version: dara.String("2024-09-10"),
14015 Protocol: dara.String("HTTPS"),
14016 Pathname: dara.String("/"),
14017 Method: dara.String("POST"),
14018 AuthType: dara.String("AK"),
14019 Style: dara.String("RPC"),
14020 ReqBodyType: dara.String("formData"),
14021 BodyType: dara.String("json"),
14022 }
14023 _result = &ListWafManagedRulesResponse{}
14024 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14025 if _err != nil {
14026 return _result, _err
14027 }
14028 _err = dara.Convert(_body, &_result)
14029 return _result, _err
14030 }
14031
14032 // Summary:
14033 //
14034 // # List WAF Phases
14035 //
14036 // @param request - ListWafPhasesRequest
14037 //
14038 // @param runtime - runtime options for this request RuntimeOptions
14039 //
14040 // @return ListWafPhasesResponse
14041 func ListWafPhasesWithContext(ctx context.Context, client *Client, request *ListWafPhasesRequest, runtime *dara.RuntimeOptions) (_result *ListWafPhasesResponse, _err error) {
14042 if dara.BoolValue(client.EnableValidate) == true {
14043 _err = request.Validate()
14044 if _err != nil {
14045 return _result, _err
14046 }
14047 }
14048 query := map[string]interface{}{}
14049 if !dara.IsNil(request.SiteId) {
14050 query["SiteId"] = request.SiteId
14051 }
14052
14053 if !dara.IsNil(request.SiteVersion) {
14054 query["SiteVersion"] = request.SiteVersion
14055 }
14056
14057 req := &openapiutil.OpenApiRequest{
14058 Query: openapiutil.Query(query),
14059 }
14060 params := &openapiutil.Params{
14061 Action: dara.String("ListWafPhases"),
14062 Version: dara.String("2024-09-10"),
14063 Protocol: dara.String("HTTPS"),
14064 Pathname: dara.String("/"),
14065 Method: dara.String("POST"),
14066 AuthType: dara.String("AK"),
14067 Style: dara.String("RPC"),
14068 ReqBodyType: dara.String("formData"),
14069 BodyType: dara.String("json"),
14070 }
14071 _result = &ListWafPhasesResponse{}
14072 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14073 if _err != nil {
14074 return _result, _err
14075 }
14076 _err = dara.Convert(_body, &_result)
14077 return _result, _err
14078 }
14079
14080 // Summary:
14081 //
14082 // # List WAF Rules
14083 //
14084 // @param tmpReq - ListWafRulesRequest
14085 //
14086 // @param runtime - runtime options for this request RuntimeOptions
14087 //
14088 // @return ListWafRulesResponse
14089 func ListWafRulesWithContext(ctx context.Context, client *Client, tmpReq *ListWafRulesRequest, runtime *dara.RuntimeOptions) (_result *ListWafRulesResponse, _err error) {
14090 if dara.BoolValue(client.EnableValidate) == true {
14091 _err = tmpReq.Validate()
14092 if _err != nil {
14093 return _result, _err
14094 }
14095 }
14096 request := &ListWafRulesShrinkRequest{}
14097 openapiutil.Convert(tmpReq, request)
14098 if !dara.IsNil(tmpReq.QueryArgs) {
14099 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
14100 }
14101
14102 query := map[string]interface{}{}
14103 if !dara.IsNil(request.PageNumber) {
14104 query["PageNumber"] = request.PageNumber
14105 }
14106
14107 if !dara.IsNil(request.PageSize) {
14108 query["PageSize"] = request.PageSize
14109 }
14110
14111 if !dara.IsNil(request.Phase) {
14112 query["Phase"] = request.Phase
14113 }
14114
14115 if !dara.IsNil(request.QueryArgsShrink) {
14116 query["QueryArgs"] = request.QueryArgsShrink
14117 }
14118
14119 if !dara.IsNil(request.RulesetId) {
14120 query["RulesetId"] = request.RulesetId
14121 }
14122
14123 if !dara.IsNil(request.SiteId) {
14124 query["SiteId"] = request.SiteId
14125 }
14126
14127 if !dara.IsNil(request.SiteVersion) {
14128 query["SiteVersion"] = request.SiteVersion
14129 }
14130
14131 req := &openapiutil.OpenApiRequest{
14132 Query: openapiutil.Query(query),
14133 }
14134 params := &openapiutil.Params{
14135 Action: dara.String("ListWafRules"),
14136 Version: dara.String("2024-09-10"),
14137 Protocol: dara.String("HTTPS"),
14138 Pathname: dara.String("/"),
14139 Method: dara.String("POST"),
14140 AuthType: dara.String("AK"),
14141 Style: dara.String("RPC"),
14142 ReqBodyType: dara.String("formData"),
14143 BodyType: dara.String("json"),
14144 }
14145 _result = &ListWafRulesResponse{}
14146 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14147 if _err != nil {
14148 return _result, _err
14149 }
14150 _err = dara.Convert(_body, &_result)
14151 return _result, _err
14152 }
14153
14154 // Summary:
14155 //
14156 // # List WAF Rule Sets
14157 //
14158 // @param tmpReq - ListWafRulesetsRequest
14159 //
14160 // @param runtime - runtime options for this request RuntimeOptions
14161 //
14162 // @return ListWafRulesetsResponse
14163 func ListWafRulesetsWithContext(ctx context.Context, client *Client, tmpReq *ListWafRulesetsRequest, runtime *dara.RuntimeOptions) (_result *ListWafRulesetsResponse, _err error) {
14164 if dara.BoolValue(client.EnableValidate) == true {
14165 _err = tmpReq.Validate()
14166 if _err != nil {
14167 return _result, _err
14168 }
14169 }
14170 request := &ListWafRulesetsShrinkRequest{}
14171 openapiutil.Convert(tmpReq, request)
14172 if !dara.IsNil(tmpReq.QueryArgs) {
14173 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
14174 }
14175
14176 query := map[string]interface{}{}
14177 if !dara.IsNil(request.PageNumber) {
14178 query["PageNumber"] = request.PageNumber
14179 }
14180
14181 if !dara.IsNil(request.PageSize) {
14182 query["PageSize"] = request.PageSize
14183 }
14184
14185 if !dara.IsNil(request.Phase) {
14186 query["Phase"] = request.Phase
14187 }
14188
14189 if !dara.IsNil(request.QueryArgsShrink) {
14190 query["QueryArgs"] = request.QueryArgsShrink
14191 }
14192
14193 if !dara.IsNil(request.SiteId) {
14194 query["SiteId"] = request.SiteId
14195 }
14196
14197 if !dara.IsNil(request.SiteVersion) {
14198 query["SiteVersion"] = request.SiteVersion
14199 }
14200
14201 req := &openapiutil.OpenApiRequest{
14202 Query: openapiutil.Query(query),
14203 }
14204 params := &openapiutil.Params{
14205 Action: dara.String("ListWafRulesets"),
14206 Version: dara.String("2024-09-10"),
14207 Protocol: dara.String("HTTPS"),
14208 Pathname: dara.String("/"),
14209 Method: dara.String("POST"),
14210 AuthType: dara.String("AK"),
14211 Style: dara.String("RPC"),
14212 ReqBodyType: dara.String("formData"),
14213 BodyType: dara.String("json"),
14214 }
14215 _result = &ListWafRulesetsResponse{}
14216 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14217 if _err != nil {
14218 return _result, _err
14219 }
14220 _err = dara.Convert(_body, &_result)
14221 return _result, _err
14222 }
14223
14224 // Summary:
14225 //
14226 // # List WAF Template Rules
14227 //
14228 // @param tmpReq - ListWafTemplateRulesRequest
14229 //
14230 // @param runtime - runtime options for this request RuntimeOptions
14231 //
14232 // @return ListWafTemplateRulesResponse
14233 func ListWafTemplateRulesWithContext(ctx context.Context, client *Client, tmpReq *ListWafTemplateRulesRequest, runtime *dara.RuntimeOptions) (_result *ListWafTemplateRulesResponse, _err error) {
14234 if dara.BoolValue(client.EnableValidate) == true {
14235 _err = tmpReq.Validate()
14236 if _err != nil {
14237 return _result, _err
14238 }
14239 }
14240 request := &ListWafTemplateRulesShrinkRequest{}
14241 openapiutil.Convert(tmpReq, request)
14242 if !dara.IsNil(tmpReq.QueryArgs) {
14243 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
14244 }
14245
14246 query := map[string]interface{}{}
14247 if !dara.IsNil(request.InstanceId) {
14248 query["InstanceId"] = request.InstanceId
14249 }
14250
14251 if !dara.IsNil(request.Phase) {
14252 query["Phase"] = request.Phase
14253 }
14254
14255 if !dara.IsNil(request.QueryArgsShrink) {
14256 query["QueryArgs"] = request.QueryArgsShrink
14257 }
14258
14259 if !dara.IsNil(request.SiteId) {
14260 query["SiteId"] = request.SiteId
14261 }
14262
14263 req := &openapiutil.OpenApiRequest{
14264 Query: openapiutil.Query(query),
14265 }
14266 params := &openapiutil.Params{
14267 Action: dara.String("ListWafTemplateRules"),
14268 Version: dara.String("2024-09-10"),
14269 Protocol: dara.String("HTTPS"),
14270 Pathname: dara.String("/"),
14271 Method: dara.String("POST"),
14272 AuthType: dara.String("AK"),
14273 Style: dara.String("RPC"),
14274 ReqBodyType: dara.String("formData"),
14275 BodyType: dara.String("json"),
14276 }
14277 _result = &ListWafTemplateRulesResponse{}
14278 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14279 if _err != nil {
14280 return _result, _err
14281 }
14282 _err = dara.Convert(_body, &_result)
14283 return _result, _err
14284 }
14285
14286 // Summary:
14287 //
14288 // # List WAF Rule Usage
14289 //
14290 // @param request - ListWafUsageOfRulesRequest
14291 //
14292 // @param runtime - runtime options for this request RuntimeOptions
14293 //
14294 // @return ListWafUsageOfRulesResponse
14295 func ListWafUsageOfRulesWithContext(ctx context.Context, client *Client, request *ListWafUsageOfRulesRequest, runtime *dara.RuntimeOptions) (_result *ListWafUsageOfRulesResponse, _err error) {
14296 if dara.BoolValue(client.EnableValidate) == true {
14297 _err = request.Validate()
14298 if _err != nil {
14299 return _result, _err
14300 }
14301 }
14302 query := map[string]interface{}{}
14303 if !dara.IsNil(request.InstanceId) {
14304 query["InstanceId"] = request.InstanceId
14305 }
14306
14307 if !dara.IsNil(request.Phase) {
14308 query["Phase"] = request.Phase
14309 }
14310
14311 if !dara.IsNil(request.SiteId) {
14312 query["SiteId"] = request.SiteId
14313 }
14314
14315 req := &openapiutil.OpenApiRequest{
14316 Query: openapiutil.Query(query),
14317 }
14318 params := &openapiutil.Params{
14319 Action: dara.String("ListWafUsageOfRules"),
14320 Version: dara.String("2024-09-10"),
14321 Protocol: dara.String("HTTPS"),
14322 Pathname: dara.String("/"),
14323 Method: dara.String("POST"),
14324 AuthType: dara.String("AK"),
14325 Style: dara.String("RPC"),
14326 ReqBodyType: dara.String("formData"),
14327 BodyType: dara.String("json"),
14328 }
14329 _result = &ListWafUsageOfRulesResponse{}
14330 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14331 if _err != nil {
14332 return _result, _err
14333 }
14334 _err = dara.Convert(_body, &_result)
14335 return _result, _err
14336 }
14337
14338 // Summary:
14339 //
14340 // Queries the information about waiting room events for a waiting room.
14341 //
14342 // Description:
14343 //
14344 // You can call this operation to query details of all waiting room events related to a waiting room in a website.
14345 //
14346 // @param request - ListWaitingRoomEventsRequest
14347 //
14348 // @param runtime - runtime options for this request RuntimeOptions
14349 //
14350 // @return ListWaitingRoomEventsResponse
14351 func ListWaitingRoomEventsWithContext(ctx context.Context, client *Client, request *ListWaitingRoomEventsRequest, runtime *dara.RuntimeOptions) (_result *ListWaitingRoomEventsResponse, _err error) {
14352 if dara.BoolValue(client.EnableValidate) == true {
14353 _err = request.Validate()
14354 if _err != nil {
14355 return _result, _err
14356 }
14357 }
14358 query := openapiutil.Query(dara.ToMap(request))
14359 req := &openapiutil.OpenApiRequest{
14360 Query: openapiutil.Query(query),
14361 }
14362 params := &openapiutil.Params{
14363 Action: dara.String("ListWaitingRoomEvents"),
14364 Version: dara.String("2024-09-10"),
14365 Protocol: dara.String("HTTPS"),
14366 Pathname: dara.String("/"),
14367 Method: dara.String("GET"),
14368 AuthType: dara.String("AK"),
14369 Style: dara.String("RPC"),
14370 ReqBodyType: dara.String("formData"),
14371 BodyType: dara.String("json"),
14372 }
14373 _result = &ListWaitingRoomEventsResponse{}
14374 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14375 if _err != nil {
14376 return _result, _err
14377 }
14378 _err = dara.Convert(_body, &_result)
14379 return _result, _err
14380 }
14381
14382 // Summary:
14383 //
14384 // # Query Waiting Room Bypass Rules
14385 //
14386 // Description:
14387 //
14388 // This API allows users to query the list of waiting room bypass rules associated with a specific site.
14389 //
14390 // @param request - ListWaitingRoomRulesRequest
14391 //
14392 // @param runtime - runtime options for this request RuntimeOptions
14393 //
14394 // @return ListWaitingRoomRulesResponse
14395 func ListWaitingRoomRulesWithContext(ctx context.Context, client *Client, request *ListWaitingRoomRulesRequest, runtime *dara.RuntimeOptions) (_result *ListWaitingRoomRulesResponse, _err error) {
14396 if dara.BoolValue(client.EnableValidate) == true {
14397 _err = request.Validate()
14398 if _err != nil {
14399 return _result, _err
14400 }
14401 }
14402 query := openapiutil.Query(dara.ToMap(request))
14403 req := &openapiutil.OpenApiRequest{
14404 Query: openapiutil.Query(query),
14405 }
14406 params := &openapiutil.Params{
14407 Action: dara.String("ListWaitingRoomRules"),
14408 Version: dara.String("2024-09-10"),
14409 Protocol: dara.String("HTTPS"),
14410 Pathname: dara.String("/"),
14411 Method: dara.String("GET"),
14412 AuthType: dara.String("AK"),
14413 Style: dara.String("RPC"),
14414 ReqBodyType: dara.String("formData"),
14415 BodyType: dara.String("json"),
14416 }
14417 _result = &ListWaitingRoomRulesResponse{}
14418 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14419 if _err != nil {
14420 return _result, _err
14421 }
14422 _err = dara.Convert(_body, &_result)
14423 return _result, _err
14424 }
14425
14426 // Summary:
14427 //
14428 // Queries the information about all waiting rooms in a website.
14429 //
14430 // Description:
14431 //
14432 // You can call this operation to query detailed configurations about all waiting rooms in a website, including the status, name, and queuing rules of each waiting room.
14433 //
14434 // @param request - ListWaitingRoomsRequest
14435 //
14436 // @param runtime - runtime options for this request RuntimeOptions
14437 //
14438 // @return ListWaitingRoomsResponse
14439 func ListWaitingRoomsWithContext(ctx context.Context, client *Client, request *ListWaitingRoomsRequest, runtime *dara.RuntimeOptions) (_result *ListWaitingRoomsResponse, _err error) {
14440 if dara.BoolValue(client.EnableValidate) == true {
14441 _err = request.Validate()
14442 if _err != nil {
14443 return _result, _err
14444 }
14445 }
14446 query := openapiutil.Query(dara.ToMap(request))
14447 req := &openapiutil.OpenApiRequest{
14448 Query: openapiutil.Query(query),
14449 }
14450 params := &openapiutil.Params{
14451 Action: dara.String("ListWaitingRooms"),
14452 Version: dara.String("2024-09-10"),
14453 Protocol: dara.String("HTTPS"),
14454 Pathname: dara.String("/"),
14455 Method: dara.String("GET"),
14456 AuthType: dara.String("AK"),
14457 Style: dara.String("RPC"),
14458 ReqBodyType: dara.String("formData"),
14459 BodyType: dara.String("json"),
14460 }
14461 _result = &ListWaitingRoomsResponse{}
14462 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14463 if _err != nil {
14464 return _result, _err
14465 }
14466 _err = dara.Convert(_body, &_result)
14467 return _result, _err
14468 }
14469
14470 // Summary:
14471 //
14472 // # OpenErService
14473 //
14474 // @param request - OpenErServiceRequest
14475 //
14476 // @param runtime - runtime options for this request RuntimeOptions
14477 //
14478 // @return OpenErServiceResponse
14479 func OpenErServiceWithContext(ctx context.Context, client *Client, request *OpenErServiceRequest, runtime *dara.RuntimeOptions) (_result *OpenErServiceResponse, _err error) {
14480 if dara.BoolValue(client.EnableValidate) == true {
14481 _err = request.Validate()
14482 if _err != nil {
14483 return _result, _err
14484 }
14485 }
14486 query := map[string]interface{}{}
14487 if !dara.IsNil(request.OwnerId) {
14488 query["OwnerId"] = request.OwnerId
14489 }
14490
14491 if !dara.IsNil(request.SecurityToken) {
14492 query["SecurityToken"] = request.SecurityToken
14493 }
14494
14495 req := &openapiutil.OpenApiRequest{
14496 Query: openapiutil.Query(query),
14497 }
14498 params := &openapiutil.Params{
14499 Action: dara.String("OpenErService"),
14500 Version: dara.String("2024-09-10"),
14501 Protocol: dara.String("HTTPS"),
14502 Pathname: dara.String("/"),
14503 Method: dara.String("POST"),
14504 AuthType: dara.String("AK"),
14505 Style: dara.String("RPC"),
14506 ReqBodyType: dara.String("formData"),
14507 BodyType: dara.String("json"),
14508 }
14509 _result = &OpenErServiceResponse{}
14510 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14511 if _err != nil {
14512 return _result, _err
14513 }
14514 _err = dara.Convert(_body, &_result)
14515 return _result, _err
14516 }
14517
14518 // Summary:
14519 //
14520 // Prefetches cache.
14521 //
14522 // @param tmpReq - PreloadCachesRequest
14523 //
14524 // @param runtime - runtime options for this request RuntimeOptions
14525 //
14526 // @return PreloadCachesResponse
14527 func PreloadCachesWithContext(ctx context.Context, client *Client, tmpReq *PreloadCachesRequest, runtime *dara.RuntimeOptions) (_result *PreloadCachesResponse, _err error) {
14528 if dara.BoolValue(client.EnableValidate) == true {
14529 _err = tmpReq.Validate()
14530 if _err != nil {
14531 return _result, _err
14532 }
14533 }
14534 request := &PreloadCachesShrinkRequest{}
14535 openapiutil.Convert(tmpReq, request)
14536 if !dara.IsNil(tmpReq.Content) {
14537 request.ContentShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Content, dara.String("Content"), dara.String("json"))
14538 }
14539
14540 if !dara.IsNil(tmpReq.Headers) {
14541 request.HeadersShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Headers, dara.String("Headers"), dara.String("json"))
14542 }
14543
14544 query := map[string]interface{}{}
14545 if !dara.IsNil(request.ContentShrink) {
14546 query["Content"] = request.ContentShrink
14547 }
14548
14549 if !dara.IsNil(request.HeadersShrink) {
14550 query["Headers"] = request.HeadersShrink
14551 }
14552
14553 if !dara.IsNil(request.SiteId) {
14554 query["SiteId"] = request.SiteId
14555 }
14556
14557 req := &openapiutil.OpenApiRequest{
14558 Query: openapiutil.Query(query),
14559 }
14560 params := &openapiutil.Params{
14561 Action: dara.String("PreloadCaches"),
14562 Version: dara.String("2024-09-10"),
14563 Protocol: dara.String("HTTPS"),
14564 Pathname: dara.String("/"),
14565 Method: dara.String("POST"),
14566 AuthType: dara.String("AK"),
14567 Style: dara.String("RPC"),
14568 ReqBodyType: dara.String("formData"),
14569 BodyType: dara.String("json"),
14570 }
14571 _result = &PreloadCachesResponse{}
14572 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14573 if _err != nil {
14574 return _result, _err
14575 }
14576 _err = dara.Convert(_body, &_result)
14577 return _result, _err
14578 }
14579
14580 // Summary:
14581 //
14582 // Releases a specific version of a containerized application. You can call this operation to iterate an application.
14583 //
14584 // @param tmpReq - PublishEdgeContainerAppVersionRequest
14585 //
14586 // @param runtime - runtime options for this request RuntimeOptions
14587 //
14588 // @return PublishEdgeContainerAppVersionResponse
14589 func PublishEdgeContainerAppVersionWithContext(ctx context.Context, client *Client, tmpReq *PublishEdgeContainerAppVersionRequest, runtime *dara.RuntimeOptions) (_result *PublishEdgeContainerAppVersionResponse, _err error) {
14590 if dara.BoolValue(client.EnableValidate) == true {
14591 _err = tmpReq.Validate()
14592 if _err != nil {
14593 return _result, _err
14594 }
14595 }
14596 request := &PublishEdgeContainerAppVersionShrinkRequest{}
14597 openapiutil.Convert(tmpReq, request)
14598 if !dara.IsNil(tmpReq.Regions) {
14599 request.RegionsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Regions, dara.String("Regions"), dara.String("json"))
14600 }
14601
14602 query := map[string]interface{}{}
14603 if !dara.IsNil(request.FullRelease) {
14604 query["FullRelease"] = request.FullRelease
14605 }
14606
14607 if !dara.IsNil(request.PublishType) {
14608 query["PublishType"] = request.PublishType
14609 }
14610
14611 if !dara.IsNil(request.RegionsShrink) {
14612 query["Regions"] = request.RegionsShrink
14613 }
14614
14615 if !dara.IsNil(request.VersionId) {
14616 query["VersionId"] = request.VersionId
14617 }
14618
14619 body := map[string]interface{}{}
14620 if !dara.IsNil(request.AppId) {
14621 body["AppId"] = request.AppId
14622 }
14623
14624 if !dara.IsNil(request.Percentage) {
14625 body["Percentage"] = request.Percentage
14626 }
14627
14628 if !dara.IsNil(request.PublishEnv) {
14629 body["PublishEnv"] = request.PublishEnv
14630 }
14631
14632 if !dara.IsNil(request.Remarks) {
14633 body["Remarks"] = request.Remarks
14634 }
14635
14636 if !dara.IsNil(request.StartTime) {
14637 body["StartTime"] = request.StartTime
14638 }
14639
14640 req := &openapiutil.OpenApiRequest{
14641 Query: openapiutil.Query(query),
14642 Body: openapiutil.ParseToMap(body),
14643 }
14644 params := &openapiutil.Params{
14645 Action: dara.String("PublishEdgeContainerAppVersion"),
14646 Version: dara.String("2024-09-10"),
14647 Protocol: dara.String("HTTPS"),
14648 Pathname: dara.String("/"),
14649 Method: dara.String("POST"),
14650 AuthType: dara.String("AK"),
14651 Style: dara.String("RPC"),
14652 ReqBodyType: dara.String("formData"),
14653 BodyType: dara.String("json"),
14654 }
14655 _result = &PublishEdgeContainerAppVersionResponse{}
14656 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14657 if _err != nil {
14658 return _result, _err
14659 }
14660 _err = dara.Convert(_body, &_result)
14661 return _result, _err
14662 }
14663
14664 // Summary:
14665 //
14666 // Releases a code version of a routine to the staging, canary, or production environment. You can specify the regions where the canary environment is deployed to release your code.
14667 //
14668 // @param request - PublishRoutineCodeVersionRequest
14669 //
14670 // @param runtime - runtime options for this request RuntimeOptions
14671 //
14672 // @return PublishRoutineCodeVersionResponse
14673 func PublishRoutineCodeVersionWithContext(ctx context.Context, client *Client, request *PublishRoutineCodeVersionRequest, runtime *dara.RuntimeOptions) (_result *PublishRoutineCodeVersionResponse, _err error) {
14674 if dara.BoolValue(client.EnableValidate) == true {
14675 _err = request.Validate()
14676 if _err != nil {
14677 return _result, _err
14678 }
14679 }
14680 body := map[string]interface{}{}
14681 if !dara.IsNil(request.CodeVersion) {
14682 body["CodeVersion"] = request.CodeVersion
14683 }
14684
14685 if !dara.IsNil(request.Env) {
14686 body["Env"] = request.Env
14687 }
14688
14689 if !dara.IsNil(request.Name) {
14690 body["Name"] = request.Name
14691 }
14692
14693 req := &openapiutil.OpenApiRequest{
14694 Body: openapiutil.ParseToMap(body),
14695 }
14696 params := &openapiutil.Params{
14697 Action: dara.String("PublishRoutineCodeVersion"),
14698 Version: dara.String("2024-09-10"),
14699 Protocol: dara.String("HTTPS"),
14700 Pathname: dara.String("/"),
14701 Method: dara.String("POST"),
14702 AuthType: dara.String("AK"),
14703 Style: dara.String("RPC"),
14704 ReqBodyType: dara.String("formData"),
14705 BodyType: dara.String("json"),
14706 }
14707 _result = &PublishRoutineCodeVersionResponse{}
14708 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14709 if _err != nil {
14710 return _result, _err
14711 }
14712 _err = dara.Convert(_body, &_result)
14713 return _result, _err
14714 }
14715
14716 // Summary:
14717 //
14718 // # New Purchase of Cache Retention
14719 //
14720 // @param request - PurchaseCacheReserveRequest
14721 //
14722 // @param runtime - runtime options for this request RuntimeOptions
14723 //
14724 // @return PurchaseCacheReserveResponse
14725 func PurchaseCacheReserveWithContext(ctx context.Context, client *Client, request *PurchaseCacheReserveRequest, runtime *dara.RuntimeOptions) (_result *PurchaseCacheReserveResponse, _err error) {
14726 if dara.BoolValue(client.EnableValidate) == true {
14727 _err = request.Validate()
14728 if _err != nil {
14729 return _result, _err
14730 }
14731 }
14732 query := map[string]interface{}{}
14733 if !dara.IsNil(request.AutoPay) {
14734 query["AutoPay"] = request.AutoPay
14735 }
14736
14737 if !dara.IsNil(request.AutoRenew) {
14738 query["AutoRenew"] = request.AutoRenew
14739 }
14740
14741 if !dara.IsNil(request.ChargeType) {
14742 query["ChargeType"] = request.ChargeType
14743 }
14744
14745 if !dara.IsNil(request.CrRegion) {
14746 query["CrRegion"] = request.CrRegion
14747 }
14748
14749 if !dara.IsNil(request.Period) {
14750 query["Period"] = request.Period
14751 }
14752
14753 if !dara.IsNil(request.QuotaGb) {
14754 query["QuotaGb"] = request.QuotaGb
14755 }
14756
14757 req := &openapiutil.OpenApiRequest{
14758 Query: openapiutil.Query(query),
14759 }
14760 params := &openapiutil.Params{
14761 Action: dara.String("PurchaseCacheReserve"),
14762 Version: dara.String("2024-09-10"),
14763 Protocol: dara.String("HTTPS"),
14764 Pathname: dara.String("/"),
14765 Method: dara.String("POST"),
14766 AuthType: dara.String("AK"),
14767 Style: dara.String("RPC"),
14768 ReqBodyType: dara.String("formData"),
14769 BodyType: dara.String("json"),
14770 }
14771 _result = &PurchaseCacheReserveResponse{}
14772 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14773 if _err != nil {
14774 return _result, _err
14775 }
14776 _err = dara.Convert(_body, &_result)
14777 return _result, _err
14778 }
14779
14780 // Summary:
14781 //
14782 // # Purchase New Package
14783 //
14784 // Description:
14785 //
14786 // 1. The package name and code can be obtained from the DescribeRatePlanPrice interface.
14787 //
14788 // 2. If the acceleration area is not overseas, the site must have successfully completed the filing process.
14789 //
14790 // @param request - PurchaseRatePlanRequest
14791 //
14792 // @param runtime - runtime options for this request RuntimeOptions
14793 //
14794 // @return PurchaseRatePlanResponse
14795 func PurchaseRatePlanWithContext(ctx context.Context, client *Client, request *PurchaseRatePlanRequest, runtime *dara.RuntimeOptions) (_result *PurchaseRatePlanResponse, _err error) {
14796 if dara.BoolValue(client.EnableValidate) == true {
14797 _err = request.Validate()
14798 if _err != nil {
14799 return _result, _err
14800 }
14801 }
14802 query := map[string]interface{}{}
14803 if !dara.IsNil(request.Amount) {
14804 query["Amount"] = request.Amount
14805 }
14806
14807 if !dara.IsNil(request.AutoPay) {
14808 query["AutoPay"] = request.AutoPay
14809 }
14810
14811 if !dara.IsNil(request.AutoRenew) {
14812 query["AutoRenew"] = request.AutoRenew
14813 }
14814
14815 if !dara.IsNil(request.Channel) {
14816 query["Channel"] = request.Channel
14817 }
14818
14819 if !dara.IsNil(request.ChargeType) {
14820 query["ChargeType"] = request.ChargeType
14821 }
14822
14823 if !dara.IsNil(request.Coverage) {
14824 query["Coverage"] = request.Coverage
14825 }
14826
14827 if !dara.IsNil(request.Period) {
14828 query["Period"] = request.Period
14829 }
14830
14831 if !dara.IsNil(request.PlanCode) {
14832 query["PlanCode"] = request.PlanCode
14833 }
14834
14835 if !dara.IsNil(request.PlanName) {
14836 query["PlanName"] = request.PlanName
14837 }
14838
14839 if !dara.IsNil(request.SiteName) {
14840 query["SiteName"] = request.SiteName
14841 }
14842
14843 if !dara.IsNil(request.Type) {
14844 query["Type"] = request.Type
14845 }
14846
14847 req := &openapiutil.OpenApiRequest{
14848 Query: openapiutil.Query(query),
14849 }
14850 params := &openapiutil.Params{
14851 Action: dara.String("PurchaseRatePlan"),
14852 Version: dara.String("2024-09-10"),
14853 Protocol: dara.String("HTTPS"),
14854 Pathname: dara.String("/"),
14855 Method: dara.String("POST"),
14856 AuthType: dara.String("AK"),
14857 Style: dara.String("RPC"),
14858 ReqBodyType: dara.String("formData"),
14859 BodyType: dara.String("json"),
14860 }
14861 _result = &PurchaseRatePlanResponse{}
14862 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14863 if _err != nil {
14864 return _result, _err
14865 }
14866 _err = dara.Convert(_body, &_result)
14867 return _result, _err
14868 }
14869
14870 // Summary:
14871 //
14872 // # Cache Refresh
14873 //
14874 // @param tmpReq - PurgeCachesRequest
14875 //
14876 // @param runtime - runtime options for this request RuntimeOptions
14877 //
14878 // @return PurgeCachesResponse
14879 func PurgeCachesWithContext(ctx context.Context, client *Client, tmpReq *PurgeCachesRequest, runtime *dara.RuntimeOptions) (_result *PurgeCachesResponse, _err error) {
14880 if dara.BoolValue(client.EnableValidate) == true {
14881 _err = tmpReq.Validate()
14882 if _err != nil {
14883 return _result, _err
14884 }
14885 }
14886 request := &PurgeCachesShrinkRequest{}
14887 openapiutil.Convert(tmpReq, request)
14888 if !dara.IsNil(tmpReq.Content) {
14889 request.ContentShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Content, dara.String("Content"), dara.String("json"))
14890 }
14891
14892 query := map[string]interface{}{}
14893 if !dara.IsNil(request.ContentShrink) {
14894 query["Content"] = request.ContentShrink
14895 }
14896
14897 if !dara.IsNil(request.EdgeComputePurge) {
14898 query["EdgeComputePurge"] = request.EdgeComputePurge
14899 }
14900
14901 if !dara.IsNil(request.Force) {
14902 query["Force"] = request.Force
14903 }
14904
14905 if !dara.IsNil(request.SiteId) {
14906 query["SiteId"] = request.SiteId
14907 }
14908
14909 if !dara.IsNil(request.Type) {
14910 query["Type"] = request.Type
14911 }
14912
14913 req := &openapiutil.OpenApiRequest{
14914 Query: openapiutil.Query(query),
14915 }
14916 params := &openapiutil.Params{
14917 Action: dara.String("PurgeCaches"),
14918 Version: dara.String("2024-09-10"),
14919 Protocol: dara.String("HTTPS"),
14920 Pathname: dara.String("/"),
14921 Method: dara.String("POST"),
14922 AuthType: dara.String("AK"),
14923 Style: dara.String("RPC"),
14924 ReqBodyType: dara.String("formData"),
14925 BodyType: dara.String("json"),
14926 }
14927 _result = &PurgeCachesResponse{}
14928 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14929 if _err != nil {
14930 return _result, _err
14931 }
14932 _err = dara.Convert(_body, &_result)
14933 return _result, _err
14934 }
14935
14936 // Summary:
14937 //
14938 // Configures a key-value pair for a namespace. The request body can be up to 2 MB.
14939 //
14940 // @param request - PutKvRequest
14941 //
14942 // @param runtime - runtime options for this request RuntimeOptions
14943 //
14944 // @return PutKvResponse
14945 func PutKvWithContext(ctx context.Context, client *Client, request *PutKvRequest, runtime *dara.RuntimeOptions) (_result *PutKvResponse, _err error) {
14946 if dara.BoolValue(client.EnableValidate) == true {
14947 _err = request.Validate()
14948 if _err != nil {
14949 return _result, _err
14950 }
14951 }
14952 query := map[string]interface{}{}
14953 if !dara.IsNil(request.Base64) {
14954 query["Base64"] = request.Base64
14955 }
14956
14957 if !dara.IsNil(request.Expiration) {
14958 query["Expiration"] = request.Expiration
14959 }
14960
14961 if !dara.IsNil(request.ExpirationTtl) {
14962 query["ExpirationTtl"] = request.ExpirationTtl
14963 }
14964
14965 if !dara.IsNil(request.Key) {
14966 query["Key"] = request.Key
14967 }
14968
14969 if !dara.IsNil(request.Namespace) {
14970 query["Namespace"] = request.Namespace
14971 }
14972
14973 body := map[string]interface{}{}
14974 if !dara.IsNil(request.Value) {
14975 body["Value"] = request.Value
14976 }
14977
14978 req := &openapiutil.OpenApiRequest{
14979 Query: openapiutil.Query(query),
14980 Body: openapiutil.ParseToMap(body),
14981 }
14982 params := &openapiutil.Params{
14983 Action: dara.String("PutKv"),
14984 Version: dara.String("2024-09-10"),
14985 Protocol: dara.String("HTTPS"),
14986 Pathname: dara.String("/"),
14987 Method: dara.String("POST"),
14988 AuthType: dara.String("AK"),
14989 Style: dara.String("RPC"),
14990 ReqBodyType: dara.String("formData"),
14991 BodyType: dara.String("json"),
14992 }
14993 _result = &PutKvResponse{}
14994 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
14995 if _err != nil {
14996 return _result, _err
14997 }
14998 _err = dara.Convert(_body, &_result)
14999 return _result, _err
15000 }
15001
15002 // Summary:
15003 //
15004 // Configures a large key-value pair for a namespace. The request body can be up to 25 MB.
15005 //
15006 // Description:
15007 //
15008 // This operation allows you to upload a larger request body than by using [PutKv](~~PutKv~~). For small request bodies, we recommend that you use [PutKv](~~PutKv~~) to minimize the server processing time. This operation must be called by using SDKs. The following sample code uses the Golang SDK and PutKvWithHighCapacityAdvance to call the operation.
15009 //
15010 // func TestPutKvWithHighCapacity() {
15011 //
15012 // // Initialize the configurations.
15013 //
15014 // cfg := new(openapi.Config)
15015 //
15016 // cfg.SetAccessKeyId("xxxxxxxxx")
15017 //
15018 // cfg.SetAccessKeySecret("xxxxxxxxxx")
15019 //
15020 // cli, err := NewClient(cfg)
15021 //
15022 // if err != nil {
15023 //
15024 // return err
15025 //
15026 // }
15027 //
15028 // runtime := &util.RuntimeOptions{}
15029 //
15030 // // Construct a request for uploading key-value pairs.
15031 //
15032 // namespace := "test-put-kv"
15033 //
15034 // key := "test_PutKvWithHighCapacity_0"
15035 //
15036 // value := strings.Repeat("t", 10*1024*1024)
15037 //
15038 // rawReq := &PutKvRequest{
15039 //
15040 // Namespace: &namespace,
15041 //
15042 // Key: &key,
15043 //
15044 // Value: &value,
15045 //
15046 // }
15047 //
15048 // payload, err := json.Marshal(rawReq)
15049 //
15050 // if err != nil {
15051 //
15052 // return err
15053 //
15054 // }
15055 //
15056 // // If the payload is greater than 2 MB, call the PutKvWithHighCapacity operation for upload.
15057 //
15058 // reqHighCapacity := &PutKvWithHighCapacityAdvanceRequest{
15059 //
15060 // Namespace: &namespace,
15061 //
15062 // Key: &key,
15063 //
15064 // UrlObject: bytes.NewReader([]byte(payload)),
15065 //
15066 // }
15067 //
15068 // resp, err := cli.PutKvWithHighCapacityAdvance(reqHighCapacity, runtime)
15069 //
15070 // if err != nil {
15071 //
15072 // return err
15073 //
15074 // }
15075 //
15076 // return nil
15077 //
15078 // }
15079 //
15080 // @param request - PutKvWithHighCapacityRequest
15081 //
15082 // @param runtime - runtime options for this request RuntimeOptions
15083 //
15084 // @return PutKvWithHighCapacityResponse
15085 func PutKvWithHighCapacityWithContext(ctx context.Context, client *Client, request *PutKvWithHighCapacityRequest, runtime *dara.RuntimeOptions) (_result *PutKvWithHighCapacityResponse, _err error) {
15086 if dara.BoolValue(client.EnableValidate) == true {
15087 _err = request.Validate()
15088 if _err != nil {
15089 return _result, _err
15090 }
15091 }
15092 query := map[string]interface{}{}
15093 if !dara.IsNil(request.Key) {
15094 query["Key"] = request.Key
15095 }
15096
15097 if !dara.IsNil(request.Namespace) {
15098 query["Namespace"] = request.Namespace
15099 }
15100
15101 if !dara.IsNil(request.Url) {
15102 query["Url"] = request.Url
15103 }
15104
15105 req := &openapiutil.OpenApiRequest{
15106 Query: openapiutil.Query(query),
15107 }
15108 params := &openapiutil.Params{
15109 Action: dara.String("PutKvWithHighCapacity"),
15110 Version: dara.String("2024-09-10"),
15111 Protocol: dara.String("HTTPS"),
15112 Pathname: dara.String("/"),
15113 Method: dara.String("POST"),
15114 AuthType: dara.String("AK"),
15115 Style: dara.String("RPC"),
15116 ReqBodyType: dara.String("formData"),
15117 BodyType: dara.String("json"),
15118 }
15119 _result = &PutKvWithHighCapacityResponse{}
15120 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15121 if _err != nil {
15122 return _result, _err
15123 }
15124 _err = dara.Convert(_body, &_result)
15125 return _result, _err
15126 }
15127
15128 // Summary:
15129 //
15130 // Rebuilds the staging environment for containerized applications.
15131 //
15132 // @param request - RebuildEdgeContainerAppStagingEnvRequest
15133 //
15134 // @param runtime - runtime options for this request RuntimeOptions
15135 //
15136 // @return RebuildEdgeContainerAppStagingEnvResponse
15137 func RebuildEdgeContainerAppStagingEnvWithContext(ctx context.Context, client *Client, request *RebuildEdgeContainerAppStagingEnvRequest, runtime *dara.RuntimeOptions) (_result *RebuildEdgeContainerAppStagingEnvResponse, _err error) {
15138 if dara.BoolValue(client.EnableValidate) == true {
15139 _err = request.Validate()
15140 if _err != nil {
15141 return _result, _err
15142 }
15143 }
15144 query := map[string]interface{}{}
15145 if !dara.IsNil(request.AppId) {
15146 query["AppId"] = request.AppId
15147 }
15148
15149 req := &openapiutil.OpenApiRequest{
15150 Query: openapiutil.Query(query),
15151 }
15152 params := &openapiutil.Params{
15153 Action: dara.String("RebuildEdgeContainerAppStagingEnv"),
15154 Version: dara.String("2024-09-10"),
15155 Protocol: dara.String("HTTPS"),
15156 Pathname: dara.String("/"),
15157 Method: dara.String("POST"),
15158 AuthType: dara.String("AK"),
15159 Style: dara.String("RPC"),
15160 ReqBodyType: dara.String("formData"),
15161 BodyType: dara.String("json"),
15162 }
15163 _result = &RebuildEdgeContainerAppStagingEnvResponse{}
15164 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15165 if _err != nil {
15166 return _result, _err
15167 }
15168 _err = dara.Convert(_body, &_result)
15169 return _result, _err
15170 }
15171
15172 // Summary:
15173 //
15174 // Resets the progress of a scheduled prefetch task and starts the prefetch from the beginning.
15175 //
15176 // @param request - ResetScheduledPreloadJobRequest
15177 //
15178 // @param runtime - runtime options for this request RuntimeOptions
15179 //
15180 // @return ResetScheduledPreloadJobResponse
15181 func ResetScheduledPreloadJobWithContext(ctx context.Context, client *Client, request *ResetScheduledPreloadJobRequest, runtime *dara.RuntimeOptions) (_result *ResetScheduledPreloadJobResponse, _err error) {
15182 if dara.BoolValue(client.EnableValidate) == true {
15183 _err = request.Validate()
15184 if _err != nil {
15185 return _result, _err
15186 }
15187 }
15188 query := map[string]interface{}{}
15189 if !dara.IsNil(request.Id) {
15190 query["Id"] = request.Id
15191 }
15192
15193 req := &openapiutil.OpenApiRequest{
15194 Query: openapiutil.Query(query),
15195 }
15196 params := &openapiutil.Params{
15197 Action: dara.String("ResetScheduledPreloadJob"),
15198 Version: dara.String("2024-09-10"),
15199 Protocol: dara.String("HTTPS"),
15200 Pathname: dara.String("/"),
15201 Method: dara.String("POST"),
15202 AuthType: dara.String("AK"),
15203 Style: dara.String("RPC"),
15204 ReqBodyType: dara.String("formData"),
15205 BodyType: dara.String("json"),
15206 }
15207 _result = &ResetScheduledPreloadJobResponse{}
15208 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15209 if _err != nil {
15210 return _result, _err
15211 }
15212 _err = dara.Convert(_body, &_result)
15213 return _result, _err
15214 }
15215
15216 // Summary:
15217 //
15218 // Revokes an activated client certificate.
15219 //
15220 // @param request - RevokeClientCertificateRequest
15221 //
15222 // @param runtime - runtime options for this request RuntimeOptions
15223 //
15224 // @return RevokeClientCertificateResponse
15225 func RevokeClientCertificateWithContext(ctx context.Context, client *Client, request *RevokeClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *RevokeClientCertificateResponse, _err error) {
15226 if dara.BoolValue(client.EnableValidate) == true {
15227 _err = request.Validate()
15228 if _err != nil {
15229 return _result, _err
15230 }
15231 }
15232 query := openapiutil.Query(dara.ToMap(request))
15233 req := &openapiutil.OpenApiRequest{
15234 Query: openapiutil.Query(query),
15235 }
15236 params := &openapiutil.Params{
15237 Action: dara.String("RevokeClientCertificate"),
15238 Version: dara.String("2024-09-10"),
15239 Protocol: dara.String("HTTPS"),
15240 Pathname: dara.String("/"),
15241 Method: dara.String("GET"),
15242 AuthType: dara.String("AK"),
15243 Style: dara.String("RPC"),
15244 ReqBodyType: dara.String("formData"),
15245 BodyType: dara.String("json"),
15246 }
15247 _result = &RevokeClientCertificateResponse{}
15248 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15249 if _err != nil {
15250 return _result, _err
15251 }
15252 _err = dara.Convert(_body, &_result)
15253 return _result, _err
15254 }
15255
15256 // Summary:
15257 //
15258 // Rolls back a version of a containerized application.
15259 //
15260 // @param request - RollbackEdgeContainerAppVersionRequest
15261 //
15262 // @param runtime - runtime options for this request RuntimeOptions
15263 //
15264 // @return RollbackEdgeContainerAppVersionResponse
15265 func RollbackEdgeContainerAppVersionWithContext(ctx context.Context, client *Client, request *RollbackEdgeContainerAppVersionRequest, runtime *dara.RuntimeOptions) (_result *RollbackEdgeContainerAppVersionResponse, _err error) {
15266 if dara.BoolValue(client.EnableValidate) == true {
15267 _err = request.Validate()
15268 if _err != nil {
15269 return _result, _err
15270 }
15271 }
15272 query := map[string]interface{}{}
15273 if !dara.IsNil(request.Percentage) {
15274 query["Percentage"] = request.Percentage
15275 }
15276
15277 if !dara.IsNil(request.UsedPercent) {
15278 query["UsedPercent"] = request.UsedPercent
15279 }
15280
15281 if !dara.IsNil(request.VersionId) {
15282 query["VersionId"] = request.VersionId
15283 }
15284
15285 body := map[string]interface{}{}
15286 if !dara.IsNil(request.AppId) {
15287 body["AppId"] = request.AppId
15288 }
15289
15290 if !dara.IsNil(request.Remarks) {
15291 body["Remarks"] = request.Remarks
15292 }
15293
15294 req := &openapiutil.OpenApiRequest{
15295 Query: openapiutil.Query(query),
15296 Body: openapiutil.ParseToMap(body),
15297 }
15298 params := &openapiutil.Params{
15299 Action: dara.String("RollbackEdgeContainerAppVersion"),
15300 Version: dara.String("2024-09-10"),
15301 Protocol: dara.String("HTTPS"),
15302 Pathname: dara.String("/"),
15303 Method: dara.String("POST"),
15304 AuthType: dara.String("AK"),
15305 Style: dara.String("RPC"),
15306 ReqBodyType: dara.String("formData"),
15307 BodyType: dara.String("json"),
15308 }
15309 _result = &RollbackEdgeContainerAppVersionResponse{}
15310 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15311 if _err != nil {
15312 return _result, _err
15313 }
15314 _err = dara.Convert(_body, &_result)
15315 return _result, _err
15316 }
15317
15318 // Summary:
15319 //
15320 // Configures whether to enable certificates and update certificate information for a website.
15321 //
15322 // @param request - SetCertificateRequest
15323 //
15324 // @param runtime - runtime options for this request RuntimeOptions
15325 //
15326 // @return SetCertificateResponse
15327 func SetCertificateWithContext(ctx context.Context, client *Client, request *SetCertificateRequest, runtime *dara.RuntimeOptions) (_result *SetCertificateResponse, _err error) {
15328 if dara.BoolValue(client.EnableValidate) == true {
15329 _err = request.Validate()
15330 if _err != nil {
15331 return _result, _err
15332 }
15333 }
15334 query := map[string]interface{}{}
15335 if !dara.IsNil(request.OwnerId) {
15336 query["OwnerId"] = request.OwnerId
15337 }
15338
15339 if !dara.IsNil(request.SecurityToken) {
15340 query["SecurityToken"] = request.SecurityToken
15341 }
15342
15343 body := map[string]interface{}{}
15344 if !dara.IsNil(request.CasId) {
15345 body["CasId"] = request.CasId
15346 }
15347
15348 if !dara.IsNil(request.Certificate) {
15349 body["Certificate"] = request.Certificate
15350 }
15351
15352 if !dara.IsNil(request.Id) {
15353 body["Id"] = request.Id
15354 }
15355
15356 if !dara.IsNil(request.Name) {
15357 body["Name"] = request.Name
15358 }
15359
15360 if !dara.IsNil(request.PrivateKey) {
15361 body["PrivateKey"] = request.PrivateKey
15362 }
15363
15364 if !dara.IsNil(request.Region) {
15365 body["Region"] = request.Region
15366 }
15367
15368 if !dara.IsNil(request.SiteId) {
15369 body["SiteId"] = request.SiteId
15370 }
15371
15372 if !dara.IsNil(request.Type) {
15373 body["Type"] = request.Type
15374 }
15375
15376 req := &openapiutil.OpenApiRequest{
15377 Query: openapiutil.Query(query),
15378 Body: openapiutil.ParseToMap(body),
15379 }
15380 params := &openapiutil.Params{
15381 Action: dara.String("SetCertificate"),
15382 Version: dara.String("2024-09-10"),
15383 Protocol: dara.String("HTTPS"),
15384 Pathname: dara.String("/"),
15385 Method: dara.String("POST"),
15386 AuthType: dara.String("AK"),
15387 Style: dara.String("RPC"),
15388 ReqBodyType: dara.String("formData"),
15389 BodyType: dara.String("json"),
15390 }
15391 _result = &SetCertificateResponse{}
15392 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15393 if _err != nil {
15394 return _result, _err
15395 }
15396 _err = dara.Convert(_body, &_result)
15397 return _result, _err
15398 }
15399
15400 // Summary:
15401 //
15402 // Associates domain names with a client CA certificate. If no certificate is specified, domain names are associated with an Edge Security Acceleration (ESA)-managed CA certificate.
15403 //
15404 // @param tmpReq - SetClientCertificateHostnamesRequest
15405 //
15406 // @param runtime - runtime options for this request RuntimeOptions
15407 //
15408 // @return SetClientCertificateHostnamesResponse
15409 func SetClientCertificateHostnamesWithContext(ctx context.Context, client *Client, tmpReq *SetClientCertificateHostnamesRequest, runtime *dara.RuntimeOptions) (_result *SetClientCertificateHostnamesResponse, _err error) {
15410 if dara.BoolValue(client.EnableValidate) == true {
15411 _err = tmpReq.Validate()
15412 if _err != nil {
15413 return _result, _err
15414 }
15415 }
15416 request := &SetClientCertificateHostnamesShrinkRequest{}
15417 openapiutil.Convert(tmpReq, request)
15418 if !dara.IsNil(tmpReq.Hostnames) {
15419 request.HostnamesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Hostnames, dara.String("Hostnames"), dara.String("json"))
15420 }
15421
15422 query := map[string]interface{}{}
15423 if !dara.IsNil(request.SiteId) {
15424 query["SiteId"] = request.SiteId
15425 }
15426
15427 body := map[string]interface{}{}
15428 if !dara.IsNil(request.HostnamesShrink) {
15429 body["Hostnames"] = request.HostnamesShrink
15430 }
15431
15432 if !dara.IsNil(request.Id) {
15433 body["Id"] = request.Id
15434 }
15435
15436 req := &openapiutil.OpenApiRequest{
15437 Query: openapiutil.Query(query),
15438 Body: openapiutil.ParseToMap(body),
15439 }
15440 params := &openapiutil.Params{
15441 Action: dara.String("SetClientCertificateHostnames"),
15442 Version: dara.String("2024-09-10"),
15443 Protocol: dara.String("HTTPS"),
15444 Pathname: dara.String("/"),
15445 Method: dara.String("POST"),
15446 AuthType: dara.String("AK"),
15447 Style: dara.String("RPC"),
15448 ReqBodyType: dara.String("formData"),
15449 BodyType: dara.String("json"),
15450 }
15451 _result = &SetClientCertificateHostnamesResponse{}
15452 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15453 if _err != nil {
15454 return _result, _err
15455 }
15456 _err = dara.Convert(_body, &_result)
15457 return _result, _err
15458 }
15459
15460 // Summary:
15461 //
15462 // Configures smart HTTP DDoS protection.
15463 //
15464 // @param request - SetHttpDDoSAttackIntelligentProtectionRequest
15465 //
15466 // @param runtime - runtime options for this request RuntimeOptions
15467 //
15468 // @return SetHttpDDoSAttackIntelligentProtectionResponse
15469 func SetHttpDDoSAttackIntelligentProtectionWithContext(ctx context.Context, client *Client, request *SetHttpDDoSAttackIntelligentProtectionRequest, runtime *dara.RuntimeOptions) (_result *SetHttpDDoSAttackIntelligentProtectionResponse, _err error) {
15470 if dara.BoolValue(client.EnableValidate) == true {
15471 _err = request.Validate()
15472 if _err != nil {
15473 return _result, _err
15474 }
15475 }
15476 query := map[string]interface{}{}
15477 if !dara.IsNil(request.AiMode) {
15478 query["AiMode"] = request.AiMode
15479 }
15480
15481 if !dara.IsNil(request.AiTemplate) {
15482 query["AiTemplate"] = request.AiTemplate
15483 }
15484
15485 if !dara.IsNil(request.SiteId) {
15486 query["SiteId"] = request.SiteId
15487 }
15488
15489 req := &openapiutil.OpenApiRequest{
15490 Query: openapiutil.Query(query),
15491 }
15492 params := &openapiutil.Params{
15493 Action: dara.String("SetHttpDDoSAttackIntelligentProtection"),
15494 Version: dara.String("2024-09-10"),
15495 Protocol: dara.String("HTTPS"),
15496 Pathname: dara.String("/"),
15497 Method: dara.String("POST"),
15498 AuthType: dara.String("AK"),
15499 Style: dara.String("RPC"),
15500 ReqBodyType: dara.String("formData"),
15501 BodyType: dara.String("json"),
15502 }
15503 _result = &SetHttpDDoSAttackIntelligentProtectionResponse{}
15504 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15505 if _err != nil {
15506 return _result, _err
15507 }
15508 _err = dara.Convert(_body, &_result)
15509 return _result, _err
15510 }
15511
15512 // Summary:
15513 //
15514 // Configures HTTP DDoS attack protection for a website.
15515 //
15516 // @param request - SetHttpDDoSAttackProtectionRequest
15517 //
15518 // @param runtime - runtime options for this request RuntimeOptions
15519 //
15520 // @return SetHttpDDoSAttackProtectionResponse
15521 func SetHttpDDoSAttackProtectionWithContext(ctx context.Context, client *Client, request *SetHttpDDoSAttackProtectionRequest, runtime *dara.RuntimeOptions) (_result *SetHttpDDoSAttackProtectionResponse, _err error) {
15522 if dara.BoolValue(client.EnableValidate) == true {
15523 _err = request.Validate()
15524 if _err != nil {
15525 return _result, _err
15526 }
15527 }
15528 query := map[string]interface{}{}
15529 if !dara.IsNil(request.GlobalMode) {
15530 query["GlobalMode"] = request.GlobalMode
15531 }
15532
15533 if !dara.IsNil(request.SiteId) {
15534 query["SiteId"] = request.SiteId
15535 }
15536
15537 req := &openapiutil.OpenApiRequest{
15538 Query: openapiutil.Query(query),
15539 }
15540 params := &openapiutil.Params{
15541 Action: dara.String("SetHttpDDoSAttackProtection"),
15542 Version: dara.String("2024-09-10"),
15543 Protocol: dara.String("HTTPS"),
15544 Pathname: dara.String("/"),
15545 Method: dara.String("POST"),
15546 AuthType: dara.String("AK"),
15547 Style: dara.String("RPC"),
15548 ReqBodyType: dara.String("formData"),
15549 BodyType: dara.String("json"),
15550 }
15551 _result = &SetHttpDDoSAttackProtectionResponse{}
15552 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15553 if _err != nil {
15554 return _result, _err
15555 }
15556 _err = dara.Convert(_body, &_result)
15557 return _result, _err
15558 }
15559
15560 // Summary:
15561 //
15562 // 设置HTTP DDoS攻击防护指定规则防护动作
15563 //
15564 // @param request - SetHttpDDoSAttackRuleActionRequest
15565 //
15566 // @param runtime - runtime options for this request RuntimeOptions
15567 //
15568 // @return SetHttpDDoSAttackRuleActionResponse
15569 func SetHttpDDoSAttackRuleActionWithContext(ctx context.Context, client *Client, request *SetHttpDDoSAttackRuleActionRequest, runtime *dara.RuntimeOptions) (_result *SetHttpDDoSAttackRuleActionResponse, _err error) {
15570 if dara.BoolValue(client.EnableValidate) == true {
15571 _err = request.Validate()
15572 if _err != nil {
15573 return _result, _err
15574 }
15575 }
15576 query := map[string]interface{}{}
15577 if !dara.IsNil(request.RuleAction) {
15578 query["RuleAction"] = request.RuleAction
15579 }
15580
15581 if !dara.IsNil(request.RuleIds) {
15582 query["RuleIds"] = request.RuleIds
15583 }
15584
15585 if !dara.IsNil(request.SiteId) {
15586 query["SiteId"] = request.SiteId
15587 }
15588
15589 req := &openapiutil.OpenApiRequest{
15590 Query: openapiutil.Query(query),
15591 }
15592 params := &openapiutil.Params{
15593 Action: dara.String("SetHttpDDoSAttackRuleAction"),
15594 Version: dara.String("2024-09-10"),
15595 Protocol: dara.String("HTTPS"),
15596 Pathname: dara.String("/"),
15597 Method: dara.String("POST"),
15598 AuthType: dara.String("AK"),
15599 Style: dara.String("RPC"),
15600 ReqBodyType: dara.String("formData"),
15601 BodyType: dara.String("json"),
15602 }
15603 _result = &SetHttpDDoSAttackRuleActionResponse{}
15604 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15605 if _err != nil {
15606 return _result, _err
15607 }
15608 _err = dara.Convert(_body, &_result)
15609 return _result, _err
15610 }
15611
15612 // Summary:
15613 //
15614 // 设置HTTP DDoS攻击防护指定规则防护状态
15615 //
15616 // @param request - SetHttpDDoSAttackRuleStatusRequest
15617 //
15618 // @param runtime - runtime options for this request RuntimeOptions
15619 //
15620 // @return SetHttpDDoSAttackRuleStatusResponse
15621 func SetHttpDDoSAttackRuleStatusWithContext(ctx context.Context, client *Client, request *SetHttpDDoSAttackRuleStatusRequest, runtime *dara.RuntimeOptions) (_result *SetHttpDDoSAttackRuleStatusResponse, _err error) {
15622 if dara.BoolValue(client.EnableValidate) == true {
15623 _err = request.Validate()
15624 if _err != nil {
15625 return _result, _err
15626 }
15627 }
15628 query := map[string]interface{}{}
15629 if !dara.IsNil(request.RuleIds) {
15630 query["RuleIds"] = request.RuleIds
15631 }
15632
15633 if !dara.IsNil(request.SiteId) {
15634 query["SiteId"] = request.SiteId
15635 }
15636
15637 if !dara.IsNil(request.Status) {
15638 query["Status"] = request.Status
15639 }
15640
15641 req := &openapiutil.OpenApiRequest{
15642 Query: openapiutil.Query(query),
15643 }
15644 params := &openapiutil.Params{
15645 Action: dara.String("SetHttpDDoSAttackRuleStatus"),
15646 Version: dara.String("2024-09-10"),
15647 Protocol: dara.String("HTTPS"),
15648 Pathname: dara.String("/"),
15649 Method: dara.String("POST"),
15650 AuthType: dara.String("AK"),
15651 Style: dara.String("RPC"),
15652 ReqBodyType: dara.String("formData"),
15653 BodyType: dara.String("json"),
15654 }
15655 _result = &SetHttpDDoSAttackRuleStatusResponse{}
15656 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15657 if _err != nil {
15658 return _result, _err
15659 }
15660 _err = dara.Convert(_body, &_result)
15661 return _result, _err
15662 }
15663
15664 // Summary:
15665 //
15666 // 为域名回源客户端证书绑定域名
15667 //
15668 // @param tmpReq - SetOriginClientCertificateHostnamesRequest
15669 //
15670 // @param runtime - runtime options for this request RuntimeOptions
15671 //
15672 // @return SetOriginClientCertificateHostnamesResponse
15673 func SetOriginClientCertificateHostnamesWithContext(ctx context.Context, client *Client, tmpReq *SetOriginClientCertificateHostnamesRequest, runtime *dara.RuntimeOptions) (_result *SetOriginClientCertificateHostnamesResponse, _err error) {
15674 if dara.BoolValue(client.EnableValidate) == true {
15675 _err = tmpReq.Validate()
15676 if _err != nil {
15677 return _result, _err
15678 }
15679 }
15680 request := &SetOriginClientCertificateHostnamesShrinkRequest{}
15681 openapiutil.Convert(tmpReq, request)
15682 if !dara.IsNil(tmpReq.Hostnames) {
15683 request.HostnamesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Hostnames, dara.String("Hostnames"), dara.String("json"))
15684 }
15685
15686 body := map[string]interface{}{}
15687 if !dara.IsNil(request.HostnamesShrink) {
15688 body["Hostnames"] = request.HostnamesShrink
15689 }
15690
15691 if !dara.IsNil(request.Id) {
15692 body["Id"] = request.Id
15693 }
15694
15695 if !dara.IsNil(request.SiteId) {
15696 body["SiteId"] = request.SiteId
15697 }
15698
15699 req := &openapiutil.OpenApiRequest{
15700 Body: openapiutil.ParseToMap(body),
15701 }
15702 params := &openapiutil.Params{
15703 Action: dara.String("SetOriginClientCertificateHostnames"),
15704 Version: dara.String("2024-09-10"),
15705 Protocol: dara.String("HTTPS"),
15706 Pathname: dara.String("/"),
15707 Method: dara.String("POST"),
15708 AuthType: dara.String("AK"),
15709 Style: dara.String("RPC"),
15710 ReqBodyType: dara.String("formData"),
15711 BodyType: dara.String("json"),
15712 }
15713 _result = &SetOriginClientCertificateHostnamesResponse{}
15714 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15715 if _err != nil {
15716 return _result, _err
15717 }
15718 _err = dara.Convert(_body, &_result)
15719 return _result, _err
15720 }
15721
15722 // Summary:
15723 //
15724 // Starts a scheduled prefetch plan based on the plan ID.
15725 //
15726 // @param request - StartScheduledPreloadExecutionRequest
15727 //
15728 // @param runtime - runtime options for this request RuntimeOptions
15729 //
15730 // @return StartScheduledPreloadExecutionResponse
15731 func StartScheduledPreloadExecutionWithContext(ctx context.Context, client *Client, request *StartScheduledPreloadExecutionRequest, runtime *dara.RuntimeOptions) (_result *StartScheduledPreloadExecutionResponse, _err error) {
15732 if dara.BoolValue(client.EnableValidate) == true {
15733 _err = request.Validate()
15734 if _err != nil {
15735 return _result, _err
15736 }
15737 }
15738 query := map[string]interface{}{}
15739 if !dara.IsNil(request.Id) {
15740 query["Id"] = request.Id
15741 }
15742
15743 req := &openapiutil.OpenApiRequest{
15744 Query: openapiutil.Query(query),
15745 }
15746 params := &openapiutil.Params{
15747 Action: dara.String("StartScheduledPreloadExecution"),
15748 Version: dara.String("2024-09-10"),
15749 Protocol: dara.String("HTTPS"),
15750 Pathname: dara.String("/"),
15751 Method: dara.String("POST"),
15752 AuthType: dara.String("AK"),
15753 Style: dara.String("RPC"),
15754 ReqBodyType: dara.String("formData"),
15755 BodyType: dara.String("json"),
15756 }
15757 _result = &StartScheduledPreloadExecutionResponse{}
15758 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15759 if _err != nil {
15760 return _result, _err
15761 }
15762 _err = dara.Convert(_body, &_result)
15763 return _result, _err
15764 }
15765
15766 // Summary:
15767 //
15768 // Stops a scheduled prefetch plan based on the plan ID.
15769 //
15770 // @param request - StopScheduledPreloadExecutionRequest
15771 //
15772 // @param runtime - runtime options for this request RuntimeOptions
15773 //
15774 // @return StopScheduledPreloadExecutionResponse
15775 func StopScheduledPreloadExecutionWithContext(ctx context.Context, client *Client, request *StopScheduledPreloadExecutionRequest, runtime *dara.RuntimeOptions) (_result *StopScheduledPreloadExecutionResponse, _err error) {
15776 if dara.BoolValue(client.EnableValidate) == true {
15777 _err = request.Validate()
15778 if _err != nil {
15779 return _result, _err
15780 }
15781 }
15782 query := map[string]interface{}{}
15783 if !dara.IsNil(request.Id) {
15784 query["Id"] = request.Id
15785 }
15786
15787 req := &openapiutil.OpenApiRequest{
15788 Query: openapiutil.Query(query),
15789 }
15790 params := &openapiutil.Params{
15791 Action: dara.String("StopScheduledPreloadExecution"),
15792 Version: dara.String("2024-09-10"),
15793 Protocol: dara.String("HTTPS"),
15794 Pathname: dara.String("/"),
15795 Method: dara.String("POST"),
15796 AuthType: dara.String("AK"),
15797 Style: dara.String("RPC"),
15798 ReqBodyType: dara.String("formData"),
15799 BodyType: dara.String("json"),
15800 }
15801 _result = &StopScheduledPreloadExecutionResponse{}
15802 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15803 if _err != nil {
15804 return _result, _err
15805 }
15806 _err = dara.Convert(_body, &_result)
15807 return _result, _err
15808 }
15809
15810 // Summary:
15811 //
15812 // Adds one or more tags to resources.
15813 //
15814 // @param request - TagResourcesRequest
15815 //
15816 // @param runtime - runtime options for this request RuntimeOptions
15817 //
15818 // @return TagResourcesResponse
15819 func TagResourcesWithContext(ctx context.Context, client *Client, request *TagResourcesRequest, runtime *dara.RuntimeOptions) (_result *TagResourcesResponse, _err error) {
15820 if dara.BoolValue(client.EnableValidate) == true {
15821 _err = request.Validate()
15822 if _err != nil {
15823 return _result, _err
15824 }
15825 }
15826 query := map[string]interface{}{}
15827 if !dara.IsNil(request.OwnerId) {
15828 query["OwnerId"] = request.OwnerId
15829 }
15830
15831 if !dara.IsNil(request.RegionId) {
15832 query["RegionId"] = request.RegionId
15833 }
15834
15835 if !dara.IsNil(request.ResourceId) {
15836 query["ResourceId"] = request.ResourceId
15837 }
15838
15839 if !dara.IsNil(request.ResourceType) {
15840 query["ResourceType"] = request.ResourceType
15841 }
15842
15843 if !dara.IsNil(request.SecurityToken) {
15844 query["SecurityToken"] = request.SecurityToken
15845 }
15846
15847 if !dara.IsNil(request.Tag) {
15848 query["Tag"] = request.Tag
15849 }
15850
15851 req := &openapiutil.OpenApiRequest{
15852 Query: openapiutil.Query(query),
15853 }
15854 params := &openapiutil.Params{
15855 Action: dara.String("TagResources"),
15856 Version: dara.String("2024-09-10"),
15857 Protocol: dara.String("HTTPS"),
15858 Pathname: dara.String("/"),
15859 Method: dara.String("POST"),
15860 AuthType: dara.String("AK"),
15861 Style: dara.String("RPC"),
15862 ReqBodyType: dara.String("formData"),
15863 BodyType: dara.String("json"),
15864 }
15865 _result = &TagResourcesResponse{}
15866 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15867 if _err != nil {
15868 return _result, _err
15869 }
15870 _err = dara.Convert(_body, &_result)
15871 return _result, _err
15872 }
15873
15874 // Summary:
15875 //
15876 // Deletes a resource tag based on a specified resource ID.
15877 //
15878 // @param request - UntagResourcesRequest
15879 //
15880 // @param runtime - runtime options for this request RuntimeOptions
15881 //
15882 // @return UntagResourcesResponse
15883 func UntagResourcesWithContext(ctx context.Context, client *Client, request *UntagResourcesRequest, runtime *dara.RuntimeOptions) (_result *UntagResourcesResponse, _err error) {
15884 if dara.BoolValue(client.EnableValidate) == true {
15885 _err = request.Validate()
15886 if _err != nil {
15887 return _result, _err
15888 }
15889 }
15890 query := map[string]interface{}{}
15891 if !dara.IsNil(request.All) {
15892 query["All"] = request.All
15893 }
15894
15895 if !dara.IsNil(request.OwnerId) {
15896 query["OwnerId"] = request.OwnerId
15897 }
15898
15899 if !dara.IsNil(request.RegionId) {
15900 query["RegionId"] = request.RegionId
15901 }
15902
15903 if !dara.IsNil(request.ResourceId) {
15904 query["ResourceId"] = request.ResourceId
15905 }
15906
15907 if !dara.IsNil(request.ResourceType) {
15908 query["ResourceType"] = request.ResourceType
15909 }
15910
15911 if !dara.IsNil(request.SecurityToken) {
15912 query["SecurityToken"] = request.SecurityToken
15913 }
15914
15915 if !dara.IsNil(request.TagKey) {
15916 query["TagKey"] = request.TagKey
15917 }
15918
15919 req := &openapiutil.OpenApiRequest{
15920 Query: openapiutil.Query(query),
15921 }
15922 params := &openapiutil.Params{
15923 Action: dara.String("UntagResources"),
15924 Version: dara.String("2024-09-10"),
15925 Protocol: dara.String("HTTPS"),
15926 Pathname: dara.String("/"),
15927 Method: dara.String("POST"),
15928 AuthType: dara.String("AK"),
15929 Style: dara.String("RPC"),
15930 ReqBodyType: dara.String("formData"),
15931 BodyType: dara.String("json"),
15932 }
15933 _result = &UntagResourcesResponse{}
15934 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15935 if _err != nil {
15936 return _result, _err
15937 }
15938 _err = dara.Convert(_body, &_result)
15939 return _result, _err
15940 }
15941
15942 // Summary:
15943 //
15944 // # Cache Reserve Specification Change
15945 //
15946 // @param request - UpdateCacheReserveSpecRequest
15947 //
15948 // @param runtime - runtime options for this request RuntimeOptions
15949 //
15950 // @return UpdateCacheReserveSpecResponse
15951 func UpdateCacheReserveSpecWithContext(ctx context.Context, client *Client, request *UpdateCacheReserveSpecRequest, runtime *dara.RuntimeOptions) (_result *UpdateCacheReserveSpecResponse, _err error) {
15952 if dara.BoolValue(client.EnableValidate) == true {
15953 _err = request.Validate()
15954 if _err != nil {
15955 return _result, _err
15956 }
15957 }
15958 query := map[string]interface{}{}
15959 if !dara.IsNil(request.AutoPay) {
15960 query["AutoPay"] = request.AutoPay
15961 }
15962
15963 if !dara.IsNil(request.ChargeType) {
15964 query["ChargeType"] = request.ChargeType
15965 }
15966
15967 if !dara.IsNil(request.InstanceId) {
15968 query["InstanceId"] = request.InstanceId
15969 }
15970
15971 if !dara.IsNil(request.TargetQuotaGb) {
15972 query["TargetQuotaGb"] = request.TargetQuotaGb
15973 }
15974
15975 req := &openapiutil.OpenApiRequest{
15976 Query: openapiutil.Query(query),
15977 }
15978 params := &openapiutil.Params{
15979 Action: dara.String("UpdateCacheReserveSpec"),
15980 Version: dara.String("2024-09-10"),
15981 Protocol: dara.String("HTTPS"),
15982 Pathname: dara.String("/"),
15983 Method: dara.String("POST"),
15984 AuthType: dara.String("AK"),
15985 Style: dara.String("RPC"),
15986 ReqBodyType: dara.String("formData"),
15987 BodyType: dara.String("json"),
15988 }
15989 _result = &UpdateCacheReserveSpecResponse{}
15990 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
15991 if _err != nil {
15992 return _result, _err
15993 }
15994 _err = dara.Convert(_body, &_result)
15995 return _result, _err
15996 }
15997
15998 // Summary:
15999 //
16000 // # Modify cache configuration
16001 //
16002 // @param request - UpdateCacheRuleRequest
16003 //
16004 // @param runtime - runtime options for this request RuntimeOptions
16005 //
16006 // @return UpdateCacheRuleResponse
16007 func UpdateCacheRuleWithContext(ctx context.Context, client *Client, request *UpdateCacheRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateCacheRuleResponse, _err error) {
16008 if dara.BoolValue(client.EnableValidate) == true {
16009 _err = request.Validate()
16010 if _err != nil {
16011 return _result, _err
16012 }
16013 }
16014 query := map[string]interface{}{}
16015 if !dara.IsNil(request.AdditionalCacheablePorts) {
16016 query["AdditionalCacheablePorts"] = request.AdditionalCacheablePorts
16017 }
16018
16019 if !dara.IsNil(request.BrowserCacheMode) {
16020 query["BrowserCacheMode"] = request.BrowserCacheMode
16021 }
16022
16023 if !dara.IsNil(request.BrowserCacheTtl) {
16024 query["BrowserCacheTtl"] = request.BrowserCacheTtl
16025 }
16026
16027 if !dara.IsNil(request.BypassCache) {
16028 query["BypassCache"] = request.BypassCache
16029 }
16030
16031 if !dara.IsNil(request.CacheDeceptionArmor) {
16032 query["CacheDeceptionArmor"] = request.CacheDeceptionArmor
16033 }
16034
16035 if !dara.IsNil(request.CacheReserveEligibility) {
16036 query["CacheReserveEligibility"] = request.CacheReserveEligibility
16037 }
16038
16039 if !dara.IsNil(request.CheckPresenceCookie) {
16040 query["CheckPresenceCookie"] = request.CheckPresenceCookie
16041 }
16042
16043 if !dara.IsNil(request.CheckPresenceHeader) {
16044 query["CheckPresenceHeader"] = request.CheckPresenceHeader
16045 }
16046
16047 if !dara.IsNil(request.ConfigId) {
16048 query["ConfigId"] = request.ConfigId
16049 }
16050
16051 if !dara.IsNil(request.EdgeCacheMode) {
16052 query["EdgeCacheMode"] = request.EdgeCacheMode
16053 }
16054
16055 if !dara.IsNil(request.EdgeCacheTtl) {
16056 query["EdgeCacheTtl"] = request.EdgeCacheTtl
16057 }
16058
16059 if !dara.IsNil(request.EdgeStatusCodeCacheTtl) {
16060 query["EdgeStatusCodeCacheTtl"] = request.EdgeStatusCodeCacheTtl
16061 }
16062
16063 if !dara.IsNil(request.IncludeCookie) {
16064 query["IncludeCookie"] = request.IncludeCookie
16065 }
16066
16067 if !dara.IsNil(request.IncludeHeader) {
16068 query["IncludeHeader"] = request.IncludeHeader
16069 }
16070
16071 if !dara.IsNil(request.PostBodyCacheKey) {
16072 query["PostBodyCacheKey"] = request.PostBodyCacheKey
16073 }
16074
16075 if !dara.IsNil(request.PostBodySizeLimit) {
16076 query["PostBodySizeLimit"] = request.PostBodySizeLimit
16077 }
16078
16079 if !dara.IsNil(request.PostCache) {
16080 query["PostCache"] = request.PostCache
16081 }
16082
16083 if !dara.IsNil(request.QueryString) {
16084 query["QueryString"] = request.QueryString
16085 }
16086
16087 if !dara.IsNil(request.QueryStringMode) {
16088 query["QueryStringMode"] = request.QueryStringMode
16089 }
16090
16091 if !dara.IsNil(request.Rule) {
16092 query["Rule"] = request.Rule
16093 }
16094
16095 if !dara.IsNil(request.RuleEnable) {
16096 query["RuleEnable"] = request.RuleEnable
16097 }
16098
16099 if !dara.IsNil(request.RuleName) {
16100 query["RuleName"] = request.RuleName
16101 }
16102
16103 if !dara.IsNil(request.Sequence) {
16104 query["Sequence"] = request.Sequence
16105 }
16106
16107 if !dara.IsNil(request.ServeStale) {
16108 query["ServeStale"] = request.ServeStale
16109 }
16110
16111 if !dara.IsNil(request.SiteId) {
16112 query["SiteId"] = request.SiteId
16113 }
16114
16115 if !dara.IsNil(request.SortQueryStringForCache) {
16116 query["SortQueryStringForCache"] = request.SortQueryStringForCache
16117 }
16118
16119 if !dara.IsNil(request.UserDeviceType) {
16120 query["UserDeviceType"] = request.UserDeviceType
16121 }
16122
16123 if !dara.IsNil(request.UserGeo) {
16124 query["UserGeo"] = request.UserGeo
16125 }
16126
16127 if !dara.IsNil(request.UserLanguage) {
16128 query["UserLanguage"] = request.UserLanguage
16129 }
16130
16131 req := &openapiutil.OpenApiRequest{
16132 Query: openapiutil.Query(query),
16133 }
16134 params := &openapiutil.Params{
16135 Action: dara.String("UpdateCacheRule"),
16136 Version: dara.String("2024-09-10"),
16137 Protocol: dara.String("HTTPS"),
16138 Pathname: dara.String("/"),
16139 Method: dara.String("POST"),
16140 AuthType: dara.String("AK"),
16141 Style: dara.String("RPC"),
16142 ReqBodyType: dara.String("formData"),
16143 BodyType: dara.String("json"),
16144 }
16145 _result = &UpdateCacheRuleResponse{}
16146 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
16147 if _err != nil {
16148 return _result, _err
16149 }
16150 _err = dara.Convert(_body, &_result)
16151 return _result, _err
16152 }
16153
16154 // Summary:
16155 //
16156 // Modifies the cache tag configuration of your website. You can call this operation when you need to specify tags in the Cache-Tag response header to use the purge by cache tag feature.
16157 //
16158 // @param request - UpdateCacheTagRequest
16159 //
16160 // @param runtime - runtime options for this request RuntimeOptions
16161 //
16162 // @return UpdateCacheTagResponse
16163 func UpdateCacheTagWithContext(ctx context.Context, client *Client, request *UpdateCacheTagRequest, runtime *dara.RuntimeOptions) (_result *UpdateCacheTagResponse, _err error) {
16164 if dara.BoolValue(client.EnableValidate) == true {
16165 _err = request.Validate()
16166 if _err != nil {
16167 return _result, _err
16168 }
16169 }
16170 query := map[string]interface{}{}
16171 if !dara.IsNil(request.CaseInsensitive) {
16172 query["CaseInsensitive"] = request.CaseInsensitive
16173 }
16174
16175 if !dara.IsNil(request.SiteId) {
16176 query["SiteId"] = request.SiteId
16177 }
16178
16179 if !dara.IsNil(request.SiteVersion) {
16180 query["SiteVersion"] = request.SiteVersion
16181 }
16182
16183 if !dara.IsNil(request.TagName) {
16184 query["TagName"] = request.TagName
16185 }
16186
16187 req := &openapiutil.OpenApiRequest{
16188 Query: openapiutil.Query(query),
16189 }
16190 params := &openapiutil.Params{
16191 Action: dara.String("UpdateCacheTag"),
16192 Version: dara.String("2024-09-10"),
16193 Protocol: dara.String("HTTPS"),
16194 Pathname: dara.String("/"),
16195 Method: dara.String("POST"),
16196 AuthType: dara.String("AK"),
16197 Style: dara.String("RPC"),
16198 ReqBodyType: dara.String("formData"),
16199 BodyType: dara.String("json"),
16200 }
16201 _result = &UpdateCacheTagResponse{}
16202 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
16203 if _err != nil {
16204 return _result, _err
16205 }
16206 _err = dara.Convert(_body, &_result)
16207 return _result, _err
16208 }
16209
16210 // Summary:
16211 //
16212 // Modifies the CNAME flattening configuration of a website.
16213 //
16214 // @param request - UpdateCnameFlatteningRequest
16215 //
16216 // @param runtime - runtime options for this request RuntimeOptions
16217 //
16218 // @return UpdateCnameFlatteningResponse
16219 func UpdateCnameFlatteningWithContext(ctx context.Context, client *Client, request *UpdateCnameFlatteningRequest, runtime *dara.RuntimeOptions) (_result *UpdateCnameFlatteningResponse, _err error) {
16220 if dara.BoolValue(client.EnableValidate) == true {
16221 _err = request.Validate()
16222 if _err != nil {
16223 return _result, _err
16224 }
16225 }
16226 query := map[string]interface{}{}
16227 if !dara.IsNil(request.FlattenMode) {
16228 query["FlattenMode"] = request.FlattenMode
16229 }
16230
16231 if !dara.IsNil(request.SiteId) {
16232 query["SiteId"] = request.SiteId
16233 }
16234
16235 req := &openapiutil.OpenApiRequest{
16236 Query: openapiutil.Query(query),
16237 }
16238 params := &openapiutil.Params{
16239 Action: dara.String("UpdateCnameFlattening"),
16240 Version: dara.String("2024-09-10"),
16241 Protocol: dara.String("HTTPS"),
16242 Pathname: dara.String("/"),
16243 Method: dara.String("POST"),
16244 AuthType: dara.String("AK"),
16245 Style: dara.String("RPC"),
16246 ReqBodyType: dara.String("formData"),
16247 BodyType: dara.String("json"),
16248 }
16249 _result = &UpdateCnameFlatteningResponse{}
16250 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
16251 if _err != nil {
16252 return _result, _err
16253 }
16254 _err = dara.Convert(_body, &_result)
16255 return _result, _err
16256 }
16257
16258 // Summary:
16259 //
16260 // # Modify compression rule
16261 //
16262 // @param request - UpdateCompressionRuleRequest
16263 //
16264 // @param runtime - runtime options for this request RuntimeOptions
16265 //
16266 // @return UpdateCompressionRuleResponse
16267 func UpdateCompressionRuleWithContext(ctx context.Context, client *Client, request *UpdateCompressionRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateCompressionRuleResponse, _err error) {
16268 if dara.BoolValue(client.EnableValidate) == true {
16269 _err = request.Validate()
16270 if _err != nil {
16271 return _result, _err
16272 }
16273 }
16274 query := map[string]interface{}{}
16275 if !dara.IsNil(request.Brotli) {
16276 query["Brotli"] = request.Brotli
16277 }
16278
16279 if !dara.IsNil(request.ConfigId) {
16280 query["ConfigId"] = request.ConfigId
16281 }
16282
16283 if !dara.IsNil(request.Gzip) {
16284 query["Gzip"] = request.Gzip
16285 }
16286
16287 if !dara.IsNil(request.Rule) {
16288 query["Rule"] = request.Rule
16289 }
16290
16291 if !dara.IsNil(request.RuleEnable) {
16292 query["RuleEnable"] = request.RuleEnable
16293 }
16294
16295 if !dara.IsNil(request.RuleName) {
16296 query["RuleName"] = request.RuleName
16297 }
16298
16299 if !dara.IsNil(request.Sequence) {
16300 query["Sequence"] = request.Sequence
16301 }
16302
16303 if !dara.IsNil(request.SiteId) {
16304 query["SiteId"] = request.SiteId
16305 }
16306
16307 if !dara.IsNil(request.Zstd) {
16308 query["Zstd"] = request.Zstd
16309 }
16310
16311 req := &openapiutil.OpenApiRequest{
16312 Query: openapiutil.Query(query),
16313 }
16314 params := &openapiutil.Params{
16315 Action: dara.String("UpdateCompressionRule"),
16316 Version: dara.String("2024-09-10"),
16317 Protocol: dara.String("HTTPS"),
16318 Pathname: dara.String("/"),
16319 Method: dara.String("POST"),
16320 AuthType: dara.String("AK"),
16321 Style: dara.String("RPC"),
16322 ReqBodyType: dara.String("formData"),
16323 BodyType: dara.String("json"),
16324 }
16325 _result = &UpdateCompressionRuleResponse{}
16326 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
16327 if _err != nil {
16328 return _result, _err
16329 }
16330 _err = dara.Convert(_body, &_result)
16331 return _result, _err
16332 }
16333
16334 // Summary:
16335 //
16336 // Modifies the configuration of the Chinese mainland network access optimization.
16337 //
16338 // @param request - UpdateCrossBorderOptimizationRequest
16339 //
16340 // @param runtime - runtime options for this request RuntimeOptions
16341 //
16342 // @return UpdateCrossBorderOptimizationResponse
16343 func UpdateCrossBorderOptimizationWithContext(ctx context.Context, client *Client, request *UpdateCrossBorderOptimizationRequest, runtime *dara.RuntimeOptions) (_result *UpdateCrossBorderOptimizationResponse, _err error) {
16344 if dara.BoolValue(client.EnableValidate) == true {
16345 _err = request.Validate()
16346 if _err != nil {
16347 return _result, _err
16348 }
16349 }
16350 query := map[string]interface{}{}
16351 if !dara.IsNil(request.Enable) {
16352 query["Enable"] = request.Enable
16353 }
16354
16355 if !dara.IsNil(request.SiteId) {
16356 query["SiteId"] = request.SiteId
16357 }
16358
16359 req := &openapiutil.OpenApiRequest{
16360 Query: openapiutil.Query(query),
16361 }
16362 params := &openapiutil.Params{
16363 Action: dara.String("UpdateCrossBorderOptimization"),
16364 Version: dara.String("2024-09-10"),
16365 Protocol: dara.String("HTTPS"),
16366 Pathname: dara.String("/"),
16367 Method: dara.String("POST"),
16368 AuthType: dara.String("AK"),
16369 Style: dara.String("RPC"),
16370 ReqBodyType: dara.String("formData"),
16371 BodyType: dara.String("json"),
16372 }
16373 _result = &UpdateCrossBorderOptimizationResponse{}
16374 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
16375 if _err != nil {
16376 return _result, _err
16377 }
16378 _err = dara.Convert(_body, &_result)
16379 return _result, _err
16380 }
16381
16382 // Summary:
16383 //
16384 // Modifies the configurations of a custom scenario-specific policy.
16385 //
16386 // @param request - UpdateCustomScenePolicyRequest
16387 //
16388 // @param runtime - runtime options for this request RuntimeOptions
16389 //
16390 // @return UpdateCustomScenePolicyResponse
16391 func UpdateCustomScenePolicyWithContext(ctx context.Context, client *Client, request *UpdateCustomScenePolicyRequest, runtime *dara.RuntimeOptions) (_result *UpdateCustomScenePolicyResponse, _err error) {
16392 if dara.BoolValue(client.EnableValidate) == true {
16393 _err = request.Validate()
16394 if _err != nil {
16395 return _result, _err
16396 }
16397 }
16398 query := map[string]interface{}{}
16399 if !dara.IsNil(request.EndTime) {
16400 query["EndTime"] = request.EndTime
16401 }
16402
16403 if !dara.IsNil(request.Name) {
16404 query["Name"] = request.Name
16405 }
16406
16407 if !dara.IsNil(request.Objects) {
16408 query["Objects"] = request.Objects
16409 }
16410
16411 if !dara.IsNil(request.PolicyId) {
16412 query["PolicyId"] = request.PolicyId
16413 }
16414
16415 if !dara.IsNil(request.SiteIds) {
16416 query["SiteIds"] = request.SiteIds
16417 }
16418
16419 if !dara.IsNil(request.StartTime) {
16420 query["StartTime"] = request.StartTime
16421 }
16422
16423 if !dara.IsNil(request.Template) {
16424 query["Template"] = request.Template
16425 }
16426
16427 req := &openapiutil.OpenApiRequest{
16428 Query: openapiutil.Query(query),
16429 }
16430 params := &openapiutil.Params{
16431 Action: dara.String("UpdateCustomScenePolicy"),
16432 Version: dara.String("2024-09-10"),
16433 Protocol: dara.String("HTTPS"),
16434 Pathname: dara.String("/"),
16435 Method: dara.String("POST"),
16436 AuthType: dara.String("AK"),
16437 Style: dara.String("RPC"),
16438 ReqBodyType: dara.String("formData"),
16439 BodyType: dara.String("json"),
16440 }
16441 _result = &UpdateCustomScenePolicyResponse{}
16442 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
16443 if _err != nil {
16444 return _result, _err
16445 }
16446 _err = dara.Convert(_body, &_result)
16447 return _result, _err
16448 }
16449
16450 // Summary:
16451 //
16452 // Modifies the development mode configuration of your website. If you enable Development Mode, all requests bypass caching components on POPs and are redirected to the origin server. This allows clients to retrieve the most recent resources on the origin server.
16453 //
16454 // @param request - UpdateDevelopmentModeRequest
16455 //
16456 // @param runtime - runtime options for this request RuntimeOptions
16457 //
16458 // @return UpdateDevelopmentModeResponse
16459 func UpdateDevelopmentModeWithContext(ctx context.Context, client *Client, request *UpdateDevelopmentModeRequest, runtime *dara.RuntimeOptions) (_result *UpdateDevelopmentModeResponse, _err error) {
16460 if dara.BoolValue(client.EnableValidate) == true {
16461 _err = request.Validate()
16462 if _err != nil {
16463 return _result, _err
16464 }
16465 }
16466 query := map[string]interface{}{}
16467 if !dara.IsNil(request.Enable) {
16468 query["Enable"] = request.Enable
16469 }
16470
16471 if !dara.IsNil(request.SiteId) {
16472 query["SiteId"] = request.SiteId
16473 }
16474
16475 req := &openapiutil.OpenApiRequest{
16476 Query: openapiutil.Query(query),
16477 }
16478 params := &openapiutil.Params{
16479 Action: dara.String("UpdateDevelopmentMode"),
16480 Version: dara.String("2024-09-10"),
16481 Protocol: dara.String("HTTPS"),
16482 Pathname: dara.String("/"),
16483 Method: dara.String("POST"),
16484 AuthType: dara.String("AK"),
16485 Style: dara.String("RPC"),
16486 ReqBodyType: dara.String("formData"),
16487 BodyType: dara.String("json"),
16488 }
16489 _result = &UpdateDevelopmentModeResponse{}
16490 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
16491 if _err != nil {
16492 return _result, _err
16493 }
16494 _err = dara.Convert(_body, &_result)
16495 return _result, _err
16496 }
16497
16498 // Summary:
16499 //
16500 // Updates the log collection configuration of a containerized application.
16501 //
16502 // @param request - UpdateEdgeContainerAppLogRiverRequest
16503 //
16504 // @param runtime - runtime options for this request RuntimeOptions
16505 //
16506 // @return UpdateEdgeContainerAppLogRiverResponse
16507 func UpdateEdgeContainerAppLogRiverWithContext(ctx context.Context, client *Client, request *UpdateEdgeContainerAppLogRiverRequest, runtime *dara.RuntimeOptions) (_result *UpdateEdgeContainerAppLogRiverResponse, _err error) {
16508 if dara.BoolValue(client.EnableValidate) == true {
16509 _err = request.Validate()
16510 if _err != nil {
16511 return _result, _err
16512 }
16513 }
16514 query := map[string]interface{}{}
16515 if !dara.IsNil(request.AppId) {
16516 query["AppId"] = request.AppId
16517 }
16518
16519 if !dara.IsNil(request.Path) {
16520 query["Path"] = request.Path
16521 }
16522
16523 if !dara.IsNil(request.Stdout) {
16524 query["Stdout"] = request.Stdout
16525 }
16526
16527 req := &openapiutil.OpenApiRequest{
16528 Query: openapiutil.Query(query),
16529 }
16530 params := &openapiutil.Params{
16531 Action: dara.String("UpdateEdgeContainerAppLogRiver"),
16532 Version: dara.String("2024-09-10"),
16533 Protocol: dara.String("HTTPS"),
16534 Pathname: dara.String("/"),
16535 Method: dara.String("POST"),
16536 AuthType: dara.String("AK"),
16537 Style: dara.String("RPC"),
16538 ReqBodyType: dara.String("formData"),
16539 BodyType: dara.String("json"),
16540 }
16541 _result = &UpdateEdgeContainerAppLogRiverResponse{}
16542 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
16543 if _err != nil {
16544 return _result, _err
16545 }
16546 _err = dara.Convert(_body, &_result)
16547 return _result, _err
16548 }
16549
16550 // Summary:
16551 //
16552 // Updates the resource reservation configuration of an edge container.
16553 //
16554 // @param tmpReq - UpdateEdgeContainerAppResourceReserveRequest
16555 //
16556 // @param runtime - runtime options for this request RuntimeOptions
16557 //
16558 // @return UpdateEdgeContainerAppResourceReserveResponse
16559 func UpdateEdgeContainerAppResourceReserveWithContext(ctx context.Context, client *Client, tmpReq *UpdateEdgeContainerAppResourceReserveRequest, runtime *dara.RuntimeOptions) (_result *UpdateEdgeContainerAppResourceReserveResponse, _err error) {
16560 if dara.BoolValue(client.EnableValidate) == true {
16561 _err = tmpReq.Validate()
16562 if _err != nil {
16563 return _result, _err
16564 }
16565 }
16566 request := &UpdateEdgeContainerAppResourceReserveShrinkRequest{}
16567 openapiutil.Convert(tmpReq, request)
16568 if !dara.IsNil(tmpReq.ReserveSet) {
16569 request.ReserveSetShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ReserveSet, dara.String("ReserveSet"), dara.String("json"))
16570 }
16571
16572 query := map[string]interface{}{}
16573 if !dara.IsNil(request.AppId) {
16574 query["AppId"] = request.AppId
16575 }
16576
16577 if !dara.IsNil(request.DurationTime) {
16578 query["DurationTime"] = request.DurationTime
16579 }
16580
16581 if !dara.IsNil(request.Enable) {
16582 query["Enable"] = request.Enable
16583 }
16584
16585 if !dara.IsNil(request.Forever) {
16586 query["Forever"] = request.Forever
16587 }
16588
16589 if !dara.IsNil(request.ReserveSetShrink) {
16590 query["ReserveSet"] = request.ReserveSetShrink
16591 }
16592
16593 req := &openapiutil.OpenApiRequest{
16594 Query: openapiutil.Query(query),
16595 }
16596 params := &openapiutil.Params{
16597 Action: dara.String("UpdateEdgeContainerAppResourceReserve"),
16598 Version: dara.String("2024-09-10"),
16599 Protocol: dara.String("HTTPS"),
16600 Pathname: dara.String("/"),
16601 Method: dara.String("POST"),
16602 AuthType: dara.String("AK"),
16603 Style: dara.String("RPC"),
16604 ReqBodyType: dara.String("formData"),
16605 BodyType: dara.String("json"),
16606 }
16607 _result = &UpdateEdgeContainerAppResourceReserveResponse{}
16608 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
16609 if _err != nil {
16610 return _result, _err
16611 }
16612 _err = dara.Convert(_body, &_result)
16613 return _result, _err
16614 }
16615
16616 // Summary:
16617 //
16618 // Updates the HTTP incoming request header modification rule.
16619 //
16620 // @param tmpReq - UpdateHttpIncomingRequestHeaderModificationRuleRequest
16621 //
16622 // @param runtime - runtime options for this request RuntimeOptions
16623 //
16624 // @return UpdateHttpIncomingRequestHeaderModificationRuleResponse
16625 func UpdateHttpIncomingRequestHeaderModificationRuleWithContext(ctx context.Context, client *Client, tmpReq *UpdateHttpIncomingRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateHttpIncomingRequestHeaderModificationRuleResponse, _err error) {
16626 if dara.BoolValue(client.EnableValidate) == true {
16627 _err = tmpReq.Validate()
16628 if _err != nil {
16629 return _result, _err
16630 }
16631 }
16632 request := &UpdateHttpIncomingRequestHeaderModificationRuleShrinkRequest{}
16633 openapiutil.Convert(tmpReq, request)
16634 if !dara.IsNil(tmpReq.RequestHeaderModification) {
16635 request.RequestHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RequestHeaderModification, dara.String("RequestHeaderModification"), dara.String("json"))
16636 }
16637
16638 query := map[string]interface{}{}
16639 if !dara.IsNil(request.ConfigId) {
16640 query["ConfigId"] = request.ConfigId
16641 }
16642
16643 if !dara.IsNil(request.RequestHeaderModificationShrink) {
16644 query["RequestHeaderModification"] = request.RequestHeaderModificationShrink
16645 }
16646
16647 if !dara.IsNil(request.Rule) {
16648 query["Rule"] = request.Rule
16649 }
16650
16651 if !dara.IsNil(request.RuleEnable) {
16652 query["RuleEnable"] = request.RuleEnable
16653 }
16654
16655 if !dara.IsNil(request.RuleName) {
16656 query["RuleName"] = request.RuleName
16657 }
16658
16659 if !dara.IsNil(request.Sequence) {
16660 query["Sequence"] = request.Sequence
16661 }
16662
16663 if !dara.IsNil(request.SiteId) {
16664 query["SiteId"] = request.SiteId
16665 }
16666
16667 req := &openapiutil.OpenApiRequest{
16668 Query: openapiutil.Query(query),
16669 }
16670 params := &openapiutil.Params{
16671 Action: dara.String("UpdateHttpIncomingRequestHeaderModificationRule"),
16672 Version: dara.String("2024-09-10"),
16673 Protocol: dara.String("HTTPS"),
16674 Pathname: dara.String("/"),
16675 Method: dara.String("POST"),
16676 AuthType: dara.String("AK"),
16677 Style: dara.String("RPC"),
16678 ReqBodyType: dara.String("formData"),
16679 BodyType: dara.String("json"),
16680 }
16681 _result = &UpdateHttpIncomingRequestHeaderModificationRuleResponse{}
16682 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
16683 if _err != nil {
16684 return _result, _err
16685 }
16686 _err = dara.Convert(_body, &_result)
16687 return _result, _err
16688 }
16689
16690 // Summary:
16691 //
16692 // Updates the configuration of modifying HTTP response headers for a website.
16693 //
16694 // @param tmpReq - UpdateHttpIncomingResponseHeaderModificationRuleRequest
16695 //
16696 // @param runtime - runtime options for this request RuntimeOptions
16697 //
16698 // @return UpdateHttpIncomingResponseHeaderModificationRuleResponse
16699 func UpdateHttpIncomingResponseHeaderModificationRuleWithContext(ctx context.Context, client *Client, tmpReq *UpdateHttpIncomingResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateHttpIncomingResponseHeaderModificationRuleResponse, _err error) {
16700 if dara.BoolValue(client.EnableValidate) == true {
16701 _err = tmpReq.Validate()
16702 if _err != nil {
16703 return _result, _err
16704 }
16705 }
16706 request := &UpdateHttpIncomingResponseHeaderModificationRuleShrinkRequest{}
16707 openapiutil.Convert(tmpReq, request)
16708 if !dara.IsNil(tmpReq.ResponseHeaderModification) {
16709 request.ResponseHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ResponseHeaderModification, dara.String("ResponseHeaderModification"), dara.String("json"))
16710 }
16711
16712 query := map[string]interface{}{}
16713 if !dara.IsNil(request.ConfigId) {
16714 query["ConfigId"] = request.ConfigId
16715 }
16716
16717 if !dara.IsNil(request.ResponseHeaderModificationShrink) {
16718 query["ResponseHeaderModification"] = request.ResponseHeaderModificationShrink
16719 }
16720
16721 if !dara.IsNil(request.Rule) {
16722 query["Rule"] = request.Rule
16723 }
16724
16725 if !dara.IsNil(request.RuleEnable) {
16726 query["RuleEnable"] = request.RuleEnable
16727 }
16728
16729 if !dara.IsNil(request.RuleName) {
16730 query["RuleName"] = request.RuleName
16731 }
16732
16733 if !dara.IsNil(request.Sequence) {
16734 query["Sequence"] = request.Sequence
16735 }
16736
16737 if !dara.IsNil(request.SiteId) {
16738 query["SiteId"] = request.SiteId
16739 }
16740
16741 req := &openapiutil.OpenApiRequest{
16742 Query: openapiutil.Query(query),
16743 }
16744 params := &openapiutil.Params{
16745 Action: dara.String("UpdateHttpIncomingResponseHeaderModificationRule"),
16746 Version: dara.String("2024-09-10"),
16747 Protocol: dara.String("HTTPS"),
16748 Pathname: dara.String("/"),
16749 Method: dara.String("POST"),
16750 AuthType: dara.String("AK"),
16751 Style: dara.String("RPC"),
16752 ReqBodyType: dara.String("formData"),
16753 BodyType: dara.String("json"),
16754 }
16755 _result = &UpdateHttpIncomingResponseHeaderModificationRuleResponse{}
16756 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
16757 if _err != nil {
16758 return _result, _err
16759 }
16760 _err = dara.Convert(_body, &_result)
16761 return _result, _err
16762 }
16763
16764 // Summary:
16765 //
16766 // # Modify HTTP Request Header Rules
16767 //
16768 // @param tmpReq - UpdateHttpRequestHeaderModificationRuleRequest
16769 //
16770 // @param runtime - runtime options for this request RuntimeOptions
16771 //
16772 // @return UpdateHttpRequestHeaderModificationRuleResponse
16773 func UpdateHttpRequestHeaderModificationRuleWithContext(ctx context.Context, client *Client, tmpReq *UpdateHttpRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateHttpRequestHeaderModificationRuleResponse, _err error) {
16774 if dara.BoolValue(client.EnableValidate) == true {
16775 _err = tmpReq.Validate()
16776 if _err != nil {
16777 return _result, _err
16778 }
16779 }
16780 request := &UpdateHttpRequestHeaderModificationRuleShrinkRequest{}
16781 openapiutil.Convert(tmpReq, request)
16782 if !dara.IsNil(tmpReq.RequestHeaderModification) {
16783 request.RequestHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RequestHeaderModification, dara.String("RequestHeaderModification"), dara.String("json"))
16784 }
16785
16786 query := map[string]interface{}{}
16787 if !dara.IsNil(request.ConfigId) {
16788 query["ConfigId"] = request.ConfigId
16789 }
16790
16791 if !dara.IsNil(request.RequestHeaderModificationShrink) {
16792 query["RequestHeaderModification"] = request.RequestHeaderModificationShrink
16793 }
16794
16795 if !dara.IsNil(request.Rule) {
16796 query["Rule"] = request.Rule
16797 }
16798
16799 if !dara.IsNil(request.RuleEnable) {
16800 query["RuleEnable"] = request.RuleEnable
16801 }
16802
16803 if !dara.IsNil(request.RuleName) {
16804 query["RuleName"] = request.RuleName
16805 }
16806
16807 if !dara.IsNil(request.Sequence) {
16808 query["Sequence"] = request.Sequence
16809 }
16810
16811 if !dara.IsNil(request.SiteId) {
16812 query["SiteId"] = request.SiteId
16813 }
16814
16815 req := &openapiutil.OpenApiRequest{
16816 Query: openapiutil.Query(query),
16817 }
16818 params := &openapiutil.Params{
16819 Action: dara.String("UpdateHttpRequestHeaderModificationRule"),
16820 Version: dara.String("2024-09-10"),
16821 Protocol: dara.String("HTTPS"),
16822 Pathname: dara.String("/"),
16823 Method: dara.String("POST"),
16824 AuthType: dara.String("AK"),
16825 Style: dara.String("RPC"),
16826 ReqBodyType: dara.String("formData"),
16827 BodyType: dara.String("json"),
16828 }
16829 _result = &UpdateHttpRequestHeaderModificationRuleResponse{}
16830 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
16831 if _err != nil {
16832 return _result, _err
16833 }
16834 _err = dara.Convert(_body, &_result)
16835 return _result, _err
16836 }
16837
16838 // Summary:
16839 //
16840 // # Modify HTTP response header rules
16841 //
16842 // @param tmpReq - UpdateHttpResponseHeaderModificationRuleRequest
16843 //
16844 // @param runtime - runtime options for this request RuntimeOptions
16845 //
16846 // @return UpdateHttpResponseHeaderModificationRuleResponse
16847 func UpdateHttpResponseHeaderModificationRuleWithContext(ctx context.Context, client *Client, tmpReq *UpdateHttpResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateHttpResponseHeaderModificationRuleResponse, _err error) {
16848 if dara.BoolValue(client.EnableValidate) == true {
16849 _err = tmpReq.Validate()
16850 if _err != nil {
16851 return _result, _err
16852 }
16853 }
16854 request := &UpdateHttpResponseHeaderModificationRuleShrinkRequest{}
16855 openapiutil.Convert(tmpReq, request)
16856 if !dara.IsNil(tmpReq.ResponseHeaderModification) {
16857 request.ResponseHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ResponseHeaderModification, dara.String("ResponseHeaderModification"), dara.String("json"))
16858 }
16859
16860 query := map[string]interface{}{}
16861 if !dara.IsNil(request.ConfigId) {
16862 query["ConfigId"] = request.ConfigId
16863 }
16864
16865 if !dara.IsNil(request.ResponseHeaderModificationShrink) {
16866 query["ResponseHeaderModification"] = request.ResponseHeaderModificationShrink
16867 }
16868
16869 if !dara.IsNil(request.Rule) {
16870 query["Rule"] = request.Rule
16871 }
16872
16873 if !dara.IsNil(request.RuleEnable) {
16874 query["RuleEnable"] = request.RuleEnable
16875 }
16876
16877 if !dara.IsNil(request.RuleName) {
16878 query["RuleName"] = request.RuleName
16879 }
16880
16881 if !dara.IsNil(request.Sequence) {
16882 query["Sequence"] = request.Sequence
16883 }
16884
16885 if !dara.IsNil(request.SiteId) {
16886 query["SiteId"] = request.SiteId
16887 }
16888
16889 req := &openapiutil.OpenApiRequest{
16890 Query: openapiutil.Query(query),
16891 }
16892 params := &openapiutil.Params{
16893 Action: dara.String("UpdateHttpResponseHeaderModificationRule"),
16894 Version: dara.String("2024-09-10"),
16895 Protocol: dara.String("HTTPS"),
16896 Pathname: dara.String("/"),
16897 Method: dara.String("POST"),
16898 AuthType: dara.String("AK"),
16899 Style: dara.String("RPC"),
16900 ReqBodyType: dara.String("formData"),
16901 BodyType: dara.String("json"),
16902 }
16903 _result = &UpdateHttpResponseHeaderModificationRuleResponse{}
16904 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
16905 if _err != nil {
16906 return _result, _err
16907 }
16908 _err = dara.Convert(_body, &_result)
16909 return _result, _err
16910 }
16911
16912 // Summary:
16913 //
16914 // # Modify HTTPS Application Configuration
16915 //
16916 // @param request - UpdateHttpsApplicationConfigurationRequest
16917 //
16918 // @param runtime - runtime options for this request RuntimeOptions
16919 //
16920 // @return UpdateHttpsApplicationConfigurationResponse
16921 func UpdateHttpsApplicationConfigurationWithContext(ctx context.Context, client *Client, request *UpdateHttpsApplicationConfigurationRequest, runtime *dara.RuntimeOptions) (_result *UpdateHttpsApplicationConfigurationResponse, _err error) {
16922 if dara.BoolValue(client.EnableValidate) == true {
16923 _err = request.Validate()
16924 if _err != nil {
16925 return _result, _err
16926 }
16927 }
16928 query := map[string]interface{}{}
16929 if !dara.IsNil(request.AltSvc) {
16930 query["AltSvc"] = request.AltSvc
16931 }
16932
16933 if !dara.IsNil(request.AltSvcClear) {
16934 query["AltSvcClear"] = request.AltSvcClear
16935 }
16936
16937 if !dara.IsNil(request.AltSvcMa) {
16938 query["AltSvcMa"] = request.AltSvcMa
16939 }
16940
16941 if !dara.IsNil(request.AltSvcPersist) {
16942 query["AltSvcPersist"] = request.AltSvcPersist
16943 }
16944
16945 if !dara.IsNil(request.ConfigId) {
16946 query["ConfigId"] = request.ConfigId
16947 }
16948
16949 if !dara.IsNil(request.Hsts) {
16950 query["Hsts"] = request.Hsts
16951 }
16952
16953 if !dara.IsNil(request.HstsIncludeSubdomains) {
16954 query["HstsIncludeSubdomains"] = request.HstsIncludeSubdomains
16955 }
16956
16957 if !dara.IsNil(request.HstsMaxAge) {
16958 query["HstsMaxAge"] = request.HstsMaxAge
16959 }
16960
16961 if !dara.IsNil(request.HstsPreload) {
16962 query["HstsPreload"] = request.HstsPreload
16963 }
16964
16965 if !dara.IsNil(request.HttpsForce) {
16966 query["HttpsForce"] = request.HttpsForce
16967 }
16968
16969 if !dara.IsNil(request.HttpsForceCode) {
16970 query["HttpsForceCode"] = request.HttpsForceCode
16971 }
16972
16973 if !dara.IsNil(request.HttpsNoSniDeny) {
16974 query["HttpsNoSniDeny"] = request.HttpsNoSniDeny
16975 }
16976
16977 if !dara.IsNil(request.HttpsSniVerify) {
16978 query["HttpsSniVerify"] = request.HttpsSniVerify
16979 }
16980
16981 if !dara.IsNil(request.HttpsSniWhitelist) {
16982 query["HttpsSniWhitelist"] = request.HttpsSniWhitelist
16983 }
16984
16985 if !dara.IsNil(request.Rule) {
16986 query["Rule"] = request.Rule
16987 }
16988
16989 if !dara.IsNil(request.RuleEnable) {
16990 query["RuleEnable"] = request.RuleEnable
16991 }
16992
16993 if !dara.IsNil(request.RuleName) {
16994 query["RuleName"] = request.RuleName
16995 }
16996
16997 if !dara.IsNil(request.Sequence) {
16998 query["Sequence"] = request.Sequence
16999 }
17000
17001 if !dara.IsNil(request.SiteId) {
17002 query["SiteId"] = request.SiteId
17003 }
17004
17005 req := &openapiutil.OpenApiRequest{
17006 Query: openapiutil.Query(query),
17007 }
17008 params := &openapiutil.Params{
17009 Action: dara.String("UpdateHttpsApplicationConfiguration"),
17010 Version: dara.String("2024-09-10"),
17011 Protocol: dara.String("HTTPS"),
17012 Pathname: dara.String("/"),
17013 Method: dara.String("POST"),
17014 AuthType: dara.String("AK"),
17015 Style: dara.String("RPC"),
17016 ReqBodyType: dara.String("formData"),
17017 BodyType: dara.String("json"),
17018 }
17019 _result = &UpdateHttpsApplicationConfigurationResponse{}
17020 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17021 if _err != nil {
17022 return _result, _err
17023 }
17024 _err = dara.Convert(_body, &_result)
17025 return _result, _err
17026 }
17027
17028 // Summary:
17029 //
17030 // # Modify HTTPS Basic Configuration
17031 //
17032 // @param request - UpdateHttpsBasicConfigurationRequest
17033 //
17034 // @param runtime - runtime options for this request RuntimeOptions
17035 //
17036 // @return UpdateHttpsBasicConfigurationResponse
17037 func UpdateHttpsBasicConfigurationWithContext(ctx context.Context, client *Client, request *UpdateHttpsBasicConfigurationRequest, runtime *dara.RuntimeOptions) (_result *UpdateHttpsBasicConfigurationResponse, _err error) {
17038 if dara.BoolValue(client.EnableValidate) == true {
17039 _err = request.Validate()
17040 if _err != nil {
17041 return _result, _err
17042 }
17043 }
17044 query := map[string]interface{}{}
17045 if !dara.IsNil(request.Ciphersuite) {
17046 query["Ciphersuite"] = request.Ciphersuite
17047 }
17048
17049 if !dara.IsNil(request.CiphersuiteGroup) {
17050 query["CiphersuiteGroup"] = request.CiphersuiteGroup
17051 }
17052
17053 if !dara.IsNil(request.ConfigId) {
17054 query["ConfigId"] = request.ConfigId
17055 }
17056
17057 if !dara.IsNil(request.Http2) {
17058 query["Http2"] = request.Http2
17059 }
17060
17061 if !dara.IsNil(request.Http3) {
17062 query["Http3"] = request.Http3
17063 }
17064
17065 if !dara.IsNil(request.Https) {
17066 query["Https"] = request.Https
17067 }
17068
17069 if !dara.IsNil(request.OcspStapling) {
17070 query["OcspStapling"] = request.OcspStapling
17071 }
17072
17073 if !dara.IsNil(request.Rule) {
17074 query["Rule"] = request.Rule
17075 }
17076
17077 if !dara.IsNil(request.RuleEnable) {
17078 query["RuleEnable"] = request.RuleEnable
17079 }
17080
17081 if !dara.IsNil(request.RuleName) {
17082 query["RuleName"] = request.RuleName
17083 }
17084
17085 if !dara.IsNil(request.Sequence) {
17086 query["Sequence"] = request.Sequence
17087 }
17088
17089 if !dara.IsNil(request.SiteId) {
17090 query["SiteId"] = request.SiteId
17091 }
17092
17093 if !dara.IsNil(request.Tls10) {
17094 query["Tls10"] = request.Tls10
17095 }
17096
17097 if !dara.IsNil(request.Tls11) {
17098 query["Tls11"] = request.Tls11
17099 }
17100
17101 if !dara.IsNil(request.Tls12) {
17102 query["Tls12"] = request.Tls12
17103 }
17104
17105 if !dara.IsNil(request.Tls13) {
17106 query["Tls13"] = request.Tls13
17107 }
17108
17109 req := &openapiutil.OpenApiRequest{
17110 Query: openapiutil.Query(query),
17111 }
17112 params := &openapiutil.Params{
17113 Action: dara.String("UpdateHttpsBasicConfiguration"),
17114 Version: dara.String("2024-09-10"),
17115 Protocol: dara.String("HTTPS"),
17116 Pathname: dara.String("/"),
17117 Method: dara.String("POST"),
17118 AuthType: dara.String("AK"),
17119 Style: dara.String("RPC"),
17120 ReqBodyType: dara.String("formData"),
17121 BodyType: dara.String("json"),
17122 }
17123 _result = &UpdateHttpsBasicConfigurationResponse{}
17124 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17125 if _err != nil {
17126 return _result, _err
17127 }
17128 _err = dara.Convert(_body, &_result)
17129 return _result, _err
17130 }
17131
17132 // Summary:
17133 //
17134 // Modifies the IPv6 configuration of a website.
17135 //
17136 // @param request - UpdateIPv6Request
17137 //
17138 // @param runtime - runtime options for this request RuntimeOptions
17139 //
17140 // @return UpdateIPv6Response
17141 func UpdateIPv6WithContext(ctx context.Context, client *Client, request *UpdateIPv6Request, runtime *dara.RuntimeOptions) (_result *UpdateIPv6Response, _err error) {
17142 if dara.BoolValue(client.EnableValidate) == true {
17143 _err = request.Validate()
17144 if _err != nil {
17145 return _result, _err
17146 }
17147 }
17148 query := map[string]interface{}{}
17149 if !dara.IsNil(request.Enable) {
17150 query["Enable"] = request.Enable
17151 }
17152
17153 if !dara.IsNil(request.Region) {
17154 query["Region"] = request.Region
17155 }
17156
17157 if !dara.IsNil(request.SiteId) {
17158 query["SiteId"] = request.SiteId
17159 }
17160
17161 req := &openapiutil.OpenApiRequest{
17162 Query: openapiutil.Query(query),
17163 }
17164 params := &openapiutil.Params{
17165 Action: dara.String("UpdateIPv6"),
17166 Version: dara.String("2024-09-10"),
17167 Protocol: dara.String("HTTPS"),
17168 Pathname: dara.String("/"),
17169 Method: dara.String("POST"),
17170 AuthType: dara.String("AK"),
17171 Style: dara.String("RPC"),
17172 ReqBodyType: dara.String("formData"),
17173 BodyType: dara.String("json"),
17174 }
17175 _result = &UpdateIPv6Response{}
17176 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17177 if _err != nil {
17178 return _result, _err
17179 }
17180 _err = dara.Convert(_body, &_result)
17181 return _result, _err
17182 }
17183
17184 // Summary:
17185 //
17186 // # Modify Site Image Transformation Configuration
17187 //
17188 // @param request - UpdateImageTransformRequest
17189 //
17190 // @param runtime - runtime options for this request RuntimeOptions
17191 //
17192 // @return UpdateImageTransformResponse
17193 func UpdateImageTransformWithContext(ctx context.Context, client *Client, request *UpdateImageTransformRequest, runtime *dara.RuntimeOptions) (_result *UpdateImageTransformResponse, _err error) {
17194 if dara.BoolValue(client.EnableValidate) == true {
17195 _err = request.Validate()
17196 if _err != nil {
17197 return _result, _err
17198 }
17199 }
17200 query := map[string]interface{}{}
17201 if !dara.IsNil(request.ConfigId) {
17202 query["ConfigId"] = request.ConfigId
17203 }
17204
17205 if !dara.IsNil(request.Enable) {
17206 query["Enable"] = request.Enable
17207 }
17208
17209 if !dara.IsNil(request.Rule) {
17210 query["Rule"] = request.Rule
17211 }
17212
17213 if !dara.IsNil(request.RuleEnable) {
17214 query["RuleEnable"] = request.RuleEnable
17215 }
17216
17217 if !dara.IsNil(request.RuleName) {
17218 query["RuleName"] = request.RuleName
17219 }
17220
17221 if !dara.IsNil(request.Sequence) {
17222 query["Sequence"] = request.Sequence
17223 }
17224
17225 if !dara.IsNil(request.SiteId) {
17226 query["SiteId"] = request.SiteId
17227 }
17228
17229 req := &openapiutil.OpenApiRequest{
17230 Query: openapiutil.Query(query),
17231 }
17232 params := &openapiutil.Params{
17233 Action: dara.String("UpdateImageTransform"),
17234 Version: dara.String("2024-09-10"),
17235 Protocol: dara.String("HTTPS"),
17236 Pathname: dara.String("/"),
17237 Method: dara.String("POST"),
17238 AuthType: dara.String("AK"),
17239 Style: dara.String("RPC"),
17240 ReqBodyType: dara.String("formData"),
17241 BodyType: dara.String("json"),
17242 }
17243 _result = &UpdateImageTransformResponse{}
17244 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17245 if _err != nil {
17246 return _result, _err
17247 }
17248 _err = dara.Convert(_body, &_result)
17249 return _result, _err
17250 }
17251
17252 // Summary:
17253 //
17254 // Updates a custom list.
17255 //
17256 // @param tmpReq - UpdateListRequest
17257 //
17258 // @param runtime - runtime options for this request RuntimeOptions
17259 //
17260 // @return UpdateListResponse
17261 func UpdateListWithContext(ctx context.Context, client *Client, tmpReq *UpdateListRequest, runtime *dara.RuntimeOptions) (_result *UpdateListResponse, _err error) {
17262 if dara.BoolValue(client.EnableValidate) == true {
17263 _err = tmpReq.Validate()
17264 if _err != nil {
17265 return _result, _err
17266 }
17267 }
17268 request := &UpdateListShrinkRequest{}
17269 openapiutil.Convert(tmpReq, request)
17270 if !dara.IsNil(tmpReq.Items) {
17271 request.ItemsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Items, dara.String("Items"), dara.String("json"))
17272 }
17273
17274 body := map[string]interface{}{}
17275 if !dara.IsNil(request.Description) {
17276 body["Description"] = request.Description
17277 }
17278
17279 if !dara.IsNil(request.Id) {
17280 body["Id"] = request.Id
17281 }
17282
17283 if !dara.IsNil(request.ItemsShrink) {
17284 body["Items"] = request.ItemsShrink
17285 }
17286
17287 if !dara.IsNil(request.Name) {
17288 body["Name"] = request.Name
17289 }
17290
17291 req := &openapiutil.OpenApiRequest{
17292 Body: openapiutil.ParseToMap(body),
17293 }
17294 params := &openapiutil.Params{
17295 Action: dara.String("UpdateList"),
17296 Version: dara.String("2024-09-10"),
17297 Protocol: dara.String("HTTPS"),
17298 Pathname: dara.String("/"),
17299 Method: dara.String("POST"),
17300 AuthType: dara.String("AK"),
17301 Style: dara.String("RPC"),
17302 ReqBodyType: dara.String("formData"),
17303 BodyType: dara.String("json"),
17304 }
17305 _result = &UpdateListResponse{}
17306 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17307 if _err != nil {
17308 return _result, _err
17309 }
17310 _err = dara.Convert(_body, &_result)
17311 return _result, _err
17312 }
17313
17314 // Summary:
17315 //
17316 // # Modify Load Balancer
17317 //
17318 // Description:
17319 //
17320 // Through this interface, you can modify multiple configurations of the load balancer, including but not limited to the name of the load balancer, whether to enable acceleration, session persistence strategy, and various advanced settings related to traffic routing. Notice: Changes to certain parameters may affect the stability of existing services, please operate with caution.
17321 //
17322 // @param tmpReq - UpdateLoadBalancerRequest
17323 //
17324 // @param runtime - runtime options for this request RuntimeOptions
17325 //
17326 // @return UpdateLoadBalancerResponse
17327 func UpdateLoadBalancerWithContext(ctx context.Context, client *Client, tmpReq *UpdateLoadBalancerRequest, runtime *dara.RuntimeOptions) (_result *UpdateLoadBalancerResponse, _err error) {
17328 if dara.BoolValue(client.EnableValidate) == true {
17329 _err = tmpReq.Validate()
17330 if _err != nil {
17331 return _result, _err
17332 }
17333 }
17334 request := &UpdateLoadBalancerShrinkRequest{}
17335 openapiutil.Convert(tmpReq, request)
17336 if !dara.IsNil(tmpReq.AdaptiveRouting) {
17337 request.AdaptiveRoutingShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AdaptiveRouting, dara.String("AdaptiveRouting"), dara.String("json"))
17338 }
17339
17340 if !dara.IsNil(tmpReq.DefaultPools) {
17341 request.DefaultPoolsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.DefaultPools, dara.String("DefaultPools"), dara.String("json"))
17342 }
17343
17344 if !dara.IsNil(tmpReq.Monitor) {
17345 request.MonitorShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Monitor, dara.String("Monitor"), dara.String("json"))
17346 }
17347
17348 if !dara.IsNil(tmpReq.RandomSteering) {
17349 request.RandomSteeringShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RandomSteering, dara.String("RandomSteering"), dara.String("json"))
17350 }
17351
17352 if !dara.IsNil(tmpReq.Rules) {
17353 request.RulesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Rules, dara.String("Rules"), dara.String("json"))
17354 }
17355
17356 query := map[string]interface{}{}
17357 if !dara.IsNil(request.AdaptiveRoutingShrink) {
17358 query["AdaptiveRouting"] = request.AdaptiveRoutingShrink
17359 }
17360
17361 if !dara.IsNil(request.DefaultPoolsShrink) {
17362 query["DefaultPools"] = request.DefaultPoolsShrink
17363 }
17364
17365 if !dara.IsNil(request.Description) {
17366 query["Description"] = request.Description
17367 }
17368
17369 if !dara.IsNil(request.Enabled) {
17370 query["Enabled"] = request.Enabled
17371 }
17372
17373 if !dara.IsNil(request.FallbackPool) {
17374 query["FallbackPool"] = request.FallbackPool
17375 }
17376
17377 if !dara.IsNil(request.Id) {
17378 query["Id"] = request.Id
17379 }
17380
17381 if !dara.IsNil(request.MonitorShrink) {
17382 query["Monitor"] = request.MonitorShrink
17383 }
17384
17385 if !dara.IsNil(request.RandomSteeringShrink) {
17386 query["RandomSteering"] = request.RandomSteeringShrink
17387 }
17388
17389 if !dara.IsNil(request.RegionPools) {
17390 query["RegionPools"] = request.RegionPools
17391 }
17392
17393 if !dara.IsNil(request.RulesShrink) {
17394 query["Rules"] = request.RulesShrink
17395 }
17396
17397 if !dara.IsNil(request.SessionAffinity) {
17398 query["SessionAffinity"] = request.SessionAffinity
17399 }
17400
17401 if !dara.IsNil(request.SiteId) {
17402 query["SiteId"] = request.SiteId
17403 }
17404
17405 if !dara.IsNil(request.SteeringPolicy) {
17406 query["SteeringPolicy"] = request.SteeringPolicy
17407 }
17408
17409 if !dara.IsNil(request.SubRegionPools) {
17410 query["SubRegionPools"] = request.SubRegionPools
17411 }
17412
17413 if !dara.IsNil(request.Ttl) {
17414 query["Ttl"] = request.Ttl
17415 }
17416
17417 req := &openapiutil.OpenApiRequest{
17418 Query: openapiutil.Query(query),
17419 }
17420 params := &openapiutil.Params{
17421 Action: dara.String("UpdateLoadBalancer"),
17422 Version: dara.String("2024-09-10"),
17423 Protocol: dara.String("HTTPS"),
17424 Pathname: dara.String("/"),
17425 Method: dara.String("POST"),
17426 AuthType: dara.String("AK"),
17427 Style: dara.String("RPC"),
17428 ReqBodyType: dara.String("formData"),
17429 BodyType: dara.String("json"),
17430 }
17431 _result = &UpdateLoadBalancerResponse{}
17432 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17433 if _err != nil {
17434 return _result, _err
17435 }
17436 _err = dara.Convert(_body, &_result)
17437 return _result, _err
17438 }
17439
17440 // Summary:
17441 //
17442 // Modifies the configuration of managed transforms for your website.
17443 //
17444 // @param request - UpdateManagedTransformRequest
17445 //
17446 // @param runtime - runtime options for this request RuntimeOptions
17447 //
17448 // @return UpdateManagedTransformResponse
17449 func UpdateManagedTransformWithContext(ctx context.Context, client *Client, request *UpdateManagedTransformRequest, runtime *dara.RuntimeOptions) (_result *UpdateManagedTransformResponse, _err error) {
17450 if dara.BoolValue(client.EnableValidate) == true {
17451 _err = request.Validate()
17452 if _err != nil {
17453 return _result, _err
17454 }
17455 }
17456 query := map[string]interface{}{}
17457 if !dara.IsNil(request.AddClientGeolocationHeader) {
17458 query["AddClientGeolocationHeader"] = request.AddClientGeolocationHeader
17459 }
17460
17461 if !dara.IsNil(request.AddRealClientIpHeader) {
17462 query["AddRealClientIpHeader"] = request.AddRealClientIpHeader
17463 }
17464
17465 if !dara.IsNil(request.RealClientIpHeaderName) {
17466 query["RealClientIpHeaderName"] = request.RealClientIpHeaderName
17467 }
17468
17469 if !dara.IsNil(request.SiteId) {
17470 query["SiteId"] = request.SiteId
17471 }
17472
17473 if !dara.IsNil(request.SiteVersion) {
17474 query["SiteVersion"] = request.SiteVersion
17475 }
17476
17477 req := &openapiutil.OpenApiRequest{
17478 Query: openapiutil.Query(query),
17479 }
17480 params := &openapiutil.Params{
17481 Action: dara.String("UpdateManagedTransform"),
17482 Version: dara.String("2024-09-10"),
17483 Protocol: dara.String("HTTPS"),
17484 Pathname: dara.String("/"),
17485 Method: dara.String("POST"),
17486 AuthType: dara.String("AK"),
17487 Style: dara.String("RPC"),
17488 ReqBodyType: dara.String("formData"),
17489 BodyType: dara.String("json"),
17490 }
17491 _result = &UpdateManagedTransformResponse{}
17492 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17493 if _err != nil {
17494 return _result, _err
17495 }
17496 _err = dara.Convert(_body, &_result)
17497 return _result, _err
17498 }
17499
17500 // Summary:
17501 //
17502 // # Modify network optimization configuration
17503 //
17504 // @param request - UpdateNetworkOptimizationRequest
17505 //
17506 // @param runtime - runtime options for this request RuntimeOptions
17507 //
17508 // @return UpdateNetworkOptimizationResponse
17509 func UpdateNetworkOptimizationWithContext(ctx context.Context, client *Client, request *UpdateNetworkOptimizationRequest, runtime *dara.RuntimeOptions) (_result *UpdateNetworkOptimizationResponse, _err error) {
17510 if dara.BoolValue(client.EnableValidate) == true {
17511 _err = request.Validate()
17512 if _err != nil {
17513 return _result, _err
17514 }
17515 }
17516 query := map[string]interface{}{}
17517 if !dara.IsNil(request.ConfigId) {
17518 query["ConfigId"] = request.ConfigId
17519 }
17520
17521 if !dara.IsNil(request.Grpc) {
17522 query["Grpc"] = request.Grpc
17523 }
17524
17525 if !dara.IsNil(request.Http2Origin) {
17526 query["Http2Origin"] = request.Http2Origin
17527 }
17528
17529 if !dara.IsNil(request.Rule) {
17530 query["Rule"] = request.Rule
17531 }
17532
17533 if !dara.IsNil(request.RuleEnable) {
17534 query["RuleEnable"] = request.RuleEnable
17535 }
17536
17537 if !dara.IsNil(request.RuleName) {
17538 query["RuleName"] = request.RuleName
17539 }
17540
17541 if !dara.IsNil(request.Sequence) {
17542 query["Sequence"] = request.Sequence
17543 }
17544
17545 if !dara.IsNil(request.SiteId) {
17546 query["SiteId"] = request.SiteId
17547 }
17548
17549 if !dara.IsNil(request.SmartRouting) {
17550 query["SmartRouting"] = request.SmartRouting
17551 }
17552
17553 if !dara.IsNil(request.UploadMaxFilesize) {
17554 query["UploadMaxFilesize"] = request.UploadMaxFilesize
17555 }
17556
17557 if !dara.IsNil(request.Websocket) {
17558 query["Websocket"] = request.Websocket
17559 }
17560
17561 req := &openapiutil.OpenApiRequest{
17562 Query: openapiutil.Query(query),
17563 }
17564 params := &openapiutil.Params{
17565 Action: dara.String("UpdateNetworkOptimization"),
17566 Version: dara.String("2024-09-10"),
17567 Protocol: dara.String("HTTPS"),
17568 Pathname: dara.String("/"),
17569 Method: dara.String("POST"),
17570 AuthType: dara.String("AK"),
17571 Style: dara.String("RPC"),
17572 ReqBodyType: dara.String("formData"),
17573 BodyType: dara.String("json"),
17574 }
17575 _result = &UpdateNetworkOptimizationResponse{}
17576 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17577 if _err != nil {
17578 return _result, _err
17579 }
17580 _err = dara.Convert(_body, &_result)
17581 return _result, _err
17582 }
17583
17584 // Summary:
17585 //
17586 // # Modify the Monitor
17587 //
17588 // @param tmpReq - UpdateOriginPoolRequest
17589 //
17590 // @param runtime - runtime options for this request RuntimeOptions
17591 //
17592 // @return UpdateOriginPoolResponse
17593 func UpdateOriginPoolWithContext(ctx context.Context, client *Client, tmpReq *UpdateOriginPoolRequest, runtime *dara.RuntimeOptions) (_result *UpdateOriginPoolResponse, _err error) {
17594 if dara.BoolValue(client.EnableValidate) == true {
17595 _err = tmpReq.Validate()
17596 if _err != nil {
17597 return _result, _err
17598 }
17599 }
17600 request := &UpdateOriginPoolShrinkRequest{}
17601 openapiutil.Convert(tmpReq, request)
17602 if !dara.IsNil(tmpReq.Origins) {
17603 request.OriginsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Origins, dara.String("Origins"), dara.String("json"))
17604 }
17605
17606 query := map[string]interface{}{}
17607 if !dara.IsNil(request.Enabled) {
17608 query["Enabled"] = request.Enabled
17609 }
17610
17611 if !dara.IsNil(request.Id) {
17612 query["Id"] = request.Id
17613 }
17614
17615 if !dara.IsNil(request.OriginsShrink) {
17616 query["Origins"] = request.OriginsShrink
17617 }
17618
17619 if !dara.IsNil(request.SiteId) {
17620 query["SiteId"] = request.SiteId
17621 }
17622
17623 req := &openapiutil.OpenApiRequest{
17624 Query: openapiutil.Query(query),
17625 }
17626 params := &openapiutil.Params{
17627 Action: dara.String("UpdateOriginPool"),
17628 Version: dara.String("2024-09-10"),
17629 Protocol: dara.String("HTTPS"),
17630 Pathname: dara.String("/"),
17631 Method: dara.String("POST"),
17632 AuthType: dara.String("AK"),
17633 Style: dara.String("RPC"),
17634 ReqBodyType: dara.String("formData"),
17635 BodyType: dara.String("json"),
17636 }
17637 _result = &UpdateOriginPoolResponse{}
17638 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17639 if _err != nil {
17640 return _result, _err
17641 }
17642 _err = dara.Convert(_body, &_result)
17643 return _result, _err
17644 }
17645
17646 // Summary:
17647 //
17648 // Enables or disables IP convergence.
17649 //
17650 // @param request - UpdateOriginProtectionRequest
17651 //
17652 // @param runtime - runtime options for this request RuntimeOptions
17653 //
17654 // @return UpdateOriginProtectionResponse
17655 func UpdateOriginProtectionWithContext(ctx context.Context, client *Client, request *UpdateOriginProtectionRequest, runtime *dara.RuntimeOptions) (_result *UpdateOriginProtectionResponse, _err error) {
17656 if dara.BoolValue(client.EnableValidate) == true {
17657 _err = request.Validate()
17658 if _err != nil {
17659 return _result, _err
17660 }
17661 }
17662 query := map[string]interface{}{}
17663 if !dara.IsNil(request.AutoConfirmIPList) {
17664 query["AutoConfirmIPList"] = request.AutoConfirmIPList
17665 }
17666
17667 if !dara.IsNil(request.OriginConverge) {
17668 query["OriginConverge"] = request.OriginConverge
17669 }
17670
17671 if !dara.IsNil(request.SiteId) {
17672 query["SiteId"] = request.SiteId
17673 }
17674
17675 req := &openapiutil.OpenApiRequest{
17676 Query: openapiutil.Query(query),
17677 }
17678 params := &openapiutil.Params{
17679 Action: dara.String("UpdateOriginProtection"),
17680 Version: dara.String("2024-09-10"),
17681 Protocol: dara.String("HTTPS"),
17682 Pathname: dara.String("/"),
17683 Method: dara.String("POST"),
17684 AuthType: dara.String("AK"),
17685 Style: dara.String("RPC"),
17686 ReqBodyType: dara.String("formData"),
17687 BodyType: dara.String("json"),
17688 }
17689 _result = &UpdateOriginProtectionResponse{}
17690 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17691 if _err != nil {
17692 return _result, _err
17693 }
17694 _err = dara.Convert(_body, &_result)
17695 return _result, _err
17696 }
17697
17698 // Summary:
17699 //
17700 // Updates the IP whitelist for origin protection used by a website to the latest version.
17701 //
17702 // @param request - UpdateOriginProtectionIpWhiteListRequest
17703 //
17704 // @param runtime - runtime options for this request RuntimeOptions
17705 //
17706 // @return UpdateOriginProtectionIpWhiteListResponse
17707 func UpdateOriginProtectionIpWhiteListWithContext(ctx context.Context, client *Client, request *UpdateOriginProtectionIpWhiteListRequest, runtime *dara.RuntimeOptions) (_result *UpdateOriginProtectionIpWhiteListResponse, _err error) {
17708 if dara.BoolValue(client.EnableValidate) == true {
17709 _err = request.Validate()
17710 if _err != nil {
17711 return _result, _err
17712 }
17713 }
17714 query := map[string]interface{}{}
17715 if !dara.IsNil(request.SiteId) {
17716 query["SiteId"] = request.SiteId
17717 }
17718
17719 req := &openapiutil.OpenApiRequest{
17720 Query: openapiutil.Query(query),
17721 }
17722 params := &openapiutil.Params{
17723 Action: dara.String("UpdateOriginProtectionIpWhiteList"),
17724 Version: dara.String("2024-09-10"),
17725 Protocol: dara.String("HTTPS"),
17726 Pathname: dara.String("/"),
17727 Method: dara.String("POST"),
17728 AuthType: dara.String("AK"),
17729 Style: dara.String("RPC"),
17730 ReqBodyType: dara.String("formData"),
17731 BodyType: dara.String("json"),
17732 }
17733 _result = &UpdateOriginProtectionIpWhiteListResponse{}
17734 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17735 if _err != nil {
17736 return _result, _err
17737 }
17738 _err = dara.Convert(_body, &_result)
17739 return _result, _err
17740 }
17741
17742 // Summary:
17743 //
17744 // # Modify Origin Rule Configuration for Site
17745 //
17746 // @param request - UpdateOriginRuleRequest
17747 //
17748 // @param runtime - runtime options for this request RuntimeOptions
17749 //
17750 // @return UpdateOriginRuleResponse
17751 func UpdateOriginRuleWithContext(ctx context.Context, client *Client, request *UpdateOriginRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateOriginRuleResponse, _err error) {
17752 if dara.BoolValue(client.EnableValidate) == true {
17753 _err = request.Validate()
17754 if _err != nil {
17755 return _result, _err
17756 }
17757 }
17758 query := map[string]interface{}{}
17759 if !dara.IsNil(request.ConfigId) {
17760 query["ConfigId"] = request.ConfigId
17761 }
17762
17763 if !dara.IsNil(request.DnsRecord) {
17764 query["DnsRecord"] = request.DnsRecord
17765 }
17766
17767 if !dara.IsNil(request.Follow302Enable) {
17768 query["Follow302Enable"] = request.Follow302Enable
17769 }
17770
17771 if !dara.IsNil(request.Follow302MaxTries) {
17772 query["Follow302MaxTries"] = request.Follow302MaxTries
17773 }
17774
17775 if !dara.IsNil(request.Follow302RetainArgs) {
17776 query["Follow302RetainArgs"] = request.Follow302RetainArgs
17777 }
17778
17779 if !dara.IsNil(request.Follow302RetainHeader) {
17780 query["Follow302RetainHeader"] = request.Follow302RetainHeader
17781 }
17782
17783 if !dara.IsNil(request.Follow302TargetHost) {
17784 query["Follow302TargetHost"] = request.Follow302TargetHost
17785 }
17786
17787 if !dara.IsNil(request.OriginHost) {
17788 query["OriginHost"] = request.OriginHost
17789 }
17790
17791 if !dara.IsNil(request.OriginHttpPort) {
17792 query["OriginHttpPort"] = request.OriginHttpPort
17793 }
17794
17795 if !dara.IsNil(request.OriginHttpsPort) {
17796 query["OriginHttpsPort"] = request.OriginHttpsPort
17797 }
17798
17799 if !dara.IsNil(request.OriginMtls) {
17800 query["OriginMtls"] = request.OriginMtls
17801 }
17802
17803 if !dara.IsNil(request.OriginReadTimeout) {
17804 query["OriginReadTimeout"] = request.OriginReadTimeout
17805 }
17806
17807 if !dara.IsNil(request.OriginScheme) {
17808 query["OriginScheme"] = request.OriginScheme
17809 }
17810
17811 if !dara.IsNil(request.OriginSni) {
17812 query["OriginSni"] = request.OriginSni
17813 }
17814
17815 if !dara.IsNil(request.OriginVerify) {
17816 query["OriginVerify"] = request.OriginVerify
17817 }
17818
17819 if !dara.IsNil(request.Range) {
17820 query["Range"] = request.Range
17821 }
17822
17823 if !dara.IsNil(request.RangeChunkSize) {
17824 query["RangeChunkSize"] = request.RangeChunkSize
17825 }
17826
17827 if !dara.IsNil(request.Rule) {
17828 query["Rule"] = request.Rule
17829 }
17830
17831 if !dara.IsNil(request.RuleEnable) {
17832 query["RuleEnable"] = request.RuleEnable
17833 }
17834
17835 if !dara.IsNil(request.RuleName) {
17836 query["RuleName"] = request.RuleName
17837 }
17838
17839 if !dara.IsNil(request.Sequence) {
17840 query["Sequence"] = request.Sequence
17841 }
17842
17843 if !dara.IsNil(request.SiteId) {
17844 query["SiteId"] = request.SiteId
17845 }
17846
17847 req := &openapiutil.OpenApiRequest{
17848 Query: openapiutil.Query(query),
17849 }
17850 params := &openapiutil.Params{
17851 Action: dara.String("UpdateOriginRule"),
17852 Version: dara.String("2024-09-10"),
17853 Protocol: dara.String("HTTPS"),
17854 Pathname: dara.String("/"),
17855 Method: dara.String("POST"),
17856 AuthType: dara.String("AK"),
17857 Style: dara.String("RPC"),
17858 ReqBodyType: dara.String("formData"),
17859 BodyType: dara.String("json"),
17860 }
17861 _result = &UpdateOriginRuleResponse{}
17862 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17863 if _err != nil {
17864 return _result, _err
17865 }
17866 _err = dara.Convert(_body, &_result)
17867 return _result, _err
17868 }
17869
17870 // Summary:
17871 //
17872 // Modifies the configurations of a custom error page, such as the name, description, content type, and content of the page.
17873 //
17874 // @param request - UpdatePageRequest
17875 //
17876 // @param runtime - runtime options for this request RuntimeOptions
17877 //
17878 // @return UpdatePageResponse
17879 func UpdatePageWithContext(ctx context.Context, client *Client, request *UpdatePageRequest, runtime *dara.RuntimeOptions) (_result *UpdatePageResponse, _err error) {
17880 if dara.BoolValue(client.EnableValidate) == true {
17881 _err = request.Validate()
17882 if _err != nil {
17883 return _result, _err
17884 }
17885 }
17886 body := map[string]interface{}{}
17887 if !dara.IsNil(request.Content) {
17888 body["Content"] = request.Content
17889 }
17890
17891 if !dara.IsNil(request.ContentType) {
17892 body["ContentType"] = request.ContentType
17893 }
17894
17895 if !dara.IsNil(request.Description) {
17896 body["Description"] = request.Description
17897 }
17898
17899 if !dara.IsNil(request.Id) {
17900 body["Id"] = request.Id
17901 }
17902
17903 if !dara.IsNil(request.Name) {
17904 body["Name"] = request.Name
17905 }
17906
17907 req := &openapiutil.OpenApiRequest{
17908 Body: openapiutil.ParseToMap(body),
17909 }
17910 params := &openapiutil.Params{
17911 Action: dara.String("UpdatePage"),
17912 Version: dara.String("2024-09-10"),
17913 Protocol: dara.String("HTTPS"),
17914 Pathname: dara.String("/"),
17915 Method: dara.String("POST"),
17916 AuthType: dara.String("AK"),
17917 Style: dara.String("RPC"),
17918 ReqBodyType: dara.String("formData"),
17919 BodyType: dara.String("json"),
17920 }
17921 _result = &UpdatePageResponse{}
17922 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17923 if _err != nil {
17924 return _result, _err
17925 }
17926 _err = dara.Convert(_body, &_result)
17927 return _result, _err
17928 }
17929
17930 // Summary:
17931 //
17932 // 套餐变配
17933 //
17934 // @param request - UpdateRatePlanSpecRequest
17935 //
17936 // @param runtime - runtime options for this request RuntimeOptions
17937 //
17938 // @return UpdateRatePlanSpecResponse
17939 func UpdateRatePlanSpecWithContext(ctx context.Context, client *Client, request *UpdateRatePlanSpecRequest, runtime *dara.RuntimeOptions) (_result *UpdateRatePlanSpecResponse, _err error) {
17940 if dara.BoolValue(client.EnableValidate) == true {
17941 _err = request.Validate()
17942 if _err != nil {
17943 return _result, _err
17944 }
17945 }
17946 query := map[string]interface{}{}
17947 if !dara.IsNil(request.AutoPay) {
17948 query["AutoPay"] = request.AutoPay
17949 }
17950
17951 if !dara.IsNil(request.ChargeType) {
17952 query["ChargeType"] = request.ChargeType
17953 }
17954
17955 if !dara.IsNil(request.InstanceId) {
17956 query["InstanceId"] = request.InstanceId
17957 }
17958
17959 if !dara.IsNil(request.OrderType) {
17960 query["OrderType"] = request.OrderType
17961 }
17962
17963 if !dara.IsNil(request.TargetPlanCode) {
17964 query["TargetPlanCode"] = request.TargetPlanCode
17965 }
17966
17967 if !dara.IsNil(request.TargetPlanName) {
17968 query["TargetPlanName"] = request.TargetPlanName
17969 }
17970
17971 req := &openapiutil.OpenApiRequest{
17972 Query: openapiutil.Query(query),
17973 }
17974 params := &openapiutil.Params{
17975 Action: dara.String("UpdateRatePlanSpec"),
17976 Version: dara.String("2024-09-10"),
17977 Protocol: dara.String("HTTPS"),
17978 Pathname: dara.String("/"),
17979 Method: dara.String("POST"),
17980 AuthType: dara.String("AK"),
17981 Style: dara.String("RPC"),
17982 ReqBodyType: dara.String("formData"),
17983 BodyType: dara.String("json"),
17984 }
17985 _result = &UpdateRatePlanSpecResponse{}
17986 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
17987 if _err != nil {
17988 return _result, _err
17989 }
17990 _err = dara.Convert(_body, &_result)
17991 return _result, _err
17992 }
17993
17994 // Summary:
17995 //
17996 // Updates multiple types of DNS records and origin authentication configurations.
17997 //
17998 // Description:
17999 //
18000 // This operation allows you to update multiple types of DNS records, including but not limited to A/AAAA, CNAME, NS, MX, TXT, CAA, SRV, and URI. You can modify the record content by providing the necessary fields such as Value, Priority, and Flag. For origins added in CNAME records such as OSS and S3, the API enables you to configure authentication details to ensure secure access.
18001 //
18002 // ### [](#)Usage notes
18003 //
18004 // - The record value (Value) must match the record type. For example, the CNAME record should correspond to the target domain name.
18005 //
18006 // - You must specify a priority (Priority) for some record types, such as MX and SRV.
18007 //
18008 // - You must specify specific fields such as Flag and Tag for CAA records.
18009 //
18010 // - When you update security records such as CERT and SSHFP, you must accurately set fields such as Type and Algorithm.
18011 //
18012 // - If your origin type is OSS or S3, configure the authentication details in AuthConf based on the permissions.
18013 //
18014 // @param tmpReq - UpdateRecordRequest
18015 //
18016 // @param runtime - runtime options for this request RuntimeOptions
18017 //
18018 // @return UpdateRecordResponse
18019 func UpdateRecordWithContext(ctx context.Context, client *Client, tmpReq *UpdateRecordRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecordResponse, _err error) {
18020 if dara.BoolValue(client.EnableValidate) == true {
18021 _err = tmpReq.Validate()
18022 if _err != nil {
18023 return _result, _err
18024 }
18025 }
18026 request := &UpdateRecordShrinkRequest{}
18027 openapiutil.Convert(tmpReq, request)
18028 if !dara.IsNil(tmpReq.AuthConf) {
18029 request.AuthConfShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AuthConf, dara.String("AuthConf"), dara.String("json"))
18030 }
18031
18032 if !dara.IsNil(tmpReq.Data) {
18033 request.DataShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Data, dara.String("Data"), dara.String("json"))
18034 }
18035
18036 query := map[string]interface{}{}
18037 if !dara.IsNil(request.AuthConfShrink) {
18038 query["AuthConf"] = request.AuthConfShrink
18039 }
18040
18041 if !dara.IsNil(request.BizName) {
18042 query["BizName"] = request.BizName
18043 }
18044
18045 if !dara.IsNil(request.Comment) {
18046 query["Comment"] = request.Comment
18047 }
18048
18049 if !dara.IsNil(request.DataShrink) {
18050 query["Data"] = request.DataShrink
18051 }
18052
18053 if !dara.IsNil(request.HostPolicy) {
18054 query["HostPolicy"] = request.HostPolicy
18055 }
18056
18057 if !dara.IsNil(request.Proxied) {
18058 query["Proxied"] = request.Proxied
18059 }
18060
18061 if !dara.IsNil(request.RecordId) {
18062 query["RecordId"] = request.RecordId
18063 }
18064
18065 if !dara.IsNil(request.SourceType) {
18066 query["SourceType"] = request.SourceType
18067 }
18068
18069 if !dara.IsNil(request.Ttl) {
18070 query["Ttl"] = request.Ttl
18071 }
18072
18073 if !dara.IsNil(request.Type) {
18074 query["Type"] = request.Type
18075 }
18076
18077 req := &openapiutil.OpenApiRequest{
18078 Query: openapiutil.Query(query),
18079 }
18080 params := &openapiutil.Params{
18081 Action: dara.String("UpdateRecord"),
18082 Version: dara.String("2024-09-10"),
18083 Protocol: dara.String("HTTPS"),
18084 Pathname: dara.String("/"),
18085 Method: dara.String("POST"),
18086 AuthType: dara.String("AK"),
18087 Style: dara.String("RPC"),
18088 ReqBodyType: dara.String("formData"),
18089 BodyType: dara.String("json"),
18090 }
18091 _result = &UpdateRecordResponse{}
18092 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18093 if _err != nil {
18094 return _result, _err
18095 }
18096 _err = dara.Convert(_body, &_result)
18097 return _result, _err
18098 }
18099
18100 // Summary:
18101 //
18102 // # Update Redirect Rule
18103 //
18104 // @param request - UpdateRedirectRuleRequest
18105 //
18106 // @param runtime - runtime options for this request RuntimeOptions
18107 //
18108 // @return UpdateRedirectRuleResponse
18109 func UpdateRedirectRuleWithContext(ctx context.Context, client *Client, request *UpdateRedirectRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateRedirectRuleResponse, _err error) {
18110 if dara.BoolValue(client.EnableValidate) == true {
18111 _err = request.Validate()
18112 if _err != nil {
18113 return _result, _err
18114 }
18115 }
18116 query := map[string]interface{}{}
18117 if !dara.IsNil(request.ConfigId) {
18118 query["ConfigId"] = request.ConfigId
18119 }
18120
18121 if !dara.IsNil(request.ReserveQueryString) {
18122 query["ReserveQueryString"] = request.ReserveQueryString
18123 }
18124
18125 if !dara.IsNil(request.Rule) {
18126 query["Rule"] = request.Rule
18127 }
18128
18129 if !dara.IsNil(request.RuleEnable) {
18130 query["RuleEnable"] = request.RuleEnable
18131 }
18132
18133 if !dara.IsNil(request.RuleName) {
18134 query["RuleName"] = request.RuleName
18135 }
18136
18137 if !dara.IsNil(request.Sequence) {
18138 query["Sequence"] = request.Sequence
18139 }
18140
18141 if !dara.IsNil(request.SiteId) {
18142 query["SiteId"] = request.SiteId
18143 }
18144
18145 if !dara.IsNil(request.StatusCode) {
18146 query["StatusCode"] = request.StatusCode
18147 }
18148
18149 if !dara.IsNil(request.TargetUrl) {
18150 query["TargetUrl"] = request.TargetUrl
18151 }
18152
18153 if !dara.IsNil(request.Type) {
18154 query["Type"] = request.Type
18155 }
18156
18157 req := &openapiutil.OpenApiRequest{
18158 Query: openapiutil.Query(query),
18159 }
18160 params := &openapiutil.Params{
18161 Action: dara.String("UpdateRedirectRule"),
18162 Version: dara.String("2024-09-10"),
18163 Protocol: dara.String("HTTPS"),
18164 Pathname: dara.String("/"),
18165 Method: dara.String("POST"),
18166 AuthType: dara.String("AK"),
18167 Style: dara.String("RPC"),
18168 ReqBodyType: dara.String("formData"),
18169 BodyType: dara.String("json"),
18170 }
18171 _result = &UpdateRedirectRuleResponse{}
18172 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18173 if _err != nil {
18174 return _result, _err
18175 }
18176 _err = dara.Convert(_body, &_result)
18177 return _result, _err
18178 }
18179
18180 // Summary:
18181 //
18182 // # Modify Rewrite URL Rule
18183 //
18184 // @param request - UpdateRewriteUrlRuleRequest
18185 //
18186 // @param runtime - runtime options for this request RuntimeOptions
18187 //
18188 // @return UpdateRewriteUrlRuleResponse
18189 func UpdateRewriteUrlRuleWithContext(ctx context.Context, client *Client, request *UpdateRewriteUrlRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateRewriteUrlRuleResponse, _err error) {
18190 if dara.BoolValue(client.EnableValidate) == true {
18191 _err = request.Validate()
18192 if _err != nil {
18193 return _result, _err
18194 }
18195 }
18196 query := map[string]interface{}{}
18197 if !dara.IsNil(request.ConfigId) {
18198 query["ConfigId"] = request.ConfigId
18199 }
18200
18201 if !dara.IsNil(request.QueryString) {
18202 query["QueryString"] = request.QueryString
18203 }
18204
18205 if !dara.IsNil(request.RewriteQueryStringType) {
18206 query["RewriteQueryStringType"] = request.RewriteQueryStringType
18207 }
18208
18209 if !dara.IsNil(request.RewriteUriType) {
18210 query["RewriteUriType"] = request.RewriteUriType
18211 }
18212
18213 if !dara.IsNil(request.Rule) {
18214 query["Rule"] = request.Rule
18215 }
18216
18217 if !dara.IsNil(request.RuleEnable) {
18218 query["RuleEnable"] = request.RuleEnable
18219 }
18220
18221 if !dara.IsNil(request.RuleName) {
18222 query["RuleName"] = request.RuleName
18223 }
18224
18225 if !dara.IsNil(request.Sequence) {
18226 query["Sequence"] = request.Sequence
18227 }
18228
18229 if !dara.IsNil(request.SiteId) {
18230 query["SiteId"] = request.SiteId
18231 }
18232
18233 if !dara.IsNil(request.Uri) {
18234 query["Uri"] = request.Uri
18235 }
18236
18237 req := &openapiutil.OpenApiRequest{
18238 Query: openapiutil.Query(query),
18239 }
18240 params := &openapiutil.Params{
18241 Action: dara.String("UpdateRewriteUrlRule"),
18242 Version: dara.String("2024-09-10"),
18243 Protocol: dara.String("HTTPS"),
18244 Pathname: dara.String("/"),
18245 Method: dara.String("POST"),
18246 AuthType: dara.String("AK"),
18247 Style: dara.String("RPC"),
18248 ReqBodyType: dara.String("formData"),
18249 BodyType: dara.String("json"),
18250 }
18251 _result = &UpdateRewriteUrlRuleResponse{}
18252 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18253 if _err != nil {
18254 return _result, _err
18255 }
18256 _err = dara.Convert(_body, &_result)
18257 return _result, _err
18258 }
18259
18260 // Summary:
18261 //
18262 // Modifies the description of a routine.
18263 //
18264 // @param request - UpdateRoutineConfigDescriptionRequest
18265 //
18266 // @param runtime - runtime options for this request RuntimeOptions
18267 //
18268 // @return UpdateRoutineConfigDescriptionResponse
18269 func UpdateRoutineConfigDescriptionWithContext(ctx context.Context, client *Client, request *UpdateRoutineConfigDescriptionRequest, runtime *dara.RuntimeOptions) (_result *UpdateRoutineConfigDescriptionResponse, _err error) {
18270 if dara.BoolValue(client.EnableValidate) == true {
18271 _err = request.Validate()
18272 if _err != nil {
18273 return _result, _err
18274 }
18275 }
18276 body := map[string]interface{}{}
18277 if !dara.IsNil(request.Description) {
18278 body["Description"] = request.Description
18279 }
18280
18281 if !dara.IsNil(request.Name) {
18282 body["Name"] = request.Name
18283 }
18284
18285 req := &openapiutil.OpenApiRequest{
18286 Body: openapiutil.ParseToMap(body),
18287 }
18288 params := &openapiutil.Params{
18289 Action: dara.String("UpdateRoutineConfigDescription"),
18290 Version: dara.String("2024-09-10"),
18291 Protocol: dara.String("HTTPS"),
18292 Pathname: dara.String("/"),
18293 Method: dara.String("POST"),
18294 AuthType: dara.String("AK"),
18295 Style: dara.String("RPC"),
18296 ReqBodyType: dara.String("formData"),
18297 BodyType: dara.String("json"),
18298 }
18299 _result = &UpdateRoutineConfigDescriptionResponse{}
18300 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18301 if _err != nil {
18302 return _result, _err
18303 }
18304 _err = dara.Convert(_body, &_result)
18305 return _result, _err
18306 }
18307
18308 // Summary:
18309 //
18310 // Modifies the route configuration of an edge function.
18311 //
18312 // @param request - UpdateRoutineRouteRequest
18313 //
18314 // @param runtime - runtime options for this request RuntimeOptions
18315 //
18316 // @return UpdateRoutineRouteResponse
18317 func UpdateRoutineRouteWithContext(ctx context.Context, client *Client, request *UpdateRoutineRouteRequest, runtime *dara.RuntimeOptions) (_result *UpdateRoutineRouteResponse, _err error) {
18318 if dara.BoolValue(client.EnableValidate) == true {
18319 _err = request.Validate()
18320 if _err != nil {
18321 return _result, _err
18322 }
18323 }
18324 query := map[string]interface{}{}
18325 if !dara.IsNil(request.Bypass) {
18326 query["Bypass"] = request.Bypass
18327 }
18328
18329 if !dara.IsNil(request.ConfigId) {
18330 query["ConfigId"] = request.ConfigId
18331 }
18332
18333 if !dara.IsNil(request.Fallback) {
18334 query["Fallback"] = request.Fallback
18335 }
18336
18337 if !dara.IsNil(request.RouteEnable) {
18338 query["RouteEnable"] = request.RouteEnable
18339 }
18340
18341 if !dara.IsNil(request.RouteName) {
18342 query["RouteName"] = request.RouteName
18343 }
18344
18345 if !dara.IsNil(request.RoutineName) {
18346 query["RoutineName"] = request.RoutineName
18347 }
18348
18349 if !dara.IsNil(request.Rule) {
18350 query["Rule"] = request.Rule
18351 }
18352
18353 if !dara.IsNil(request.Sequence) {
18354 query["Sequence"] = request.Sequence
18355 }
18356
18357 if !dara.IsNil(request.SiteId) {
18358 query["SiteId"] = request.SiteId
18359 }
18360
18361 req := &openapiutil.OpenApiRequest{
18362 Query: openapiutil.Query(query),
18363 }
18364 params := &openapiutil.Params{
18365 Action: dara.String("UpdateRoutineRoute"),
18366 Version: dara.String("2024-09-10"),
18367 Protocol: dara.String("HTTPS"),
18368 Pathname: dara.String("/"),
18369 Method: dara.String("POST"),
18370 AuthType: dara.String("AK"),
18371 Style: dara.String("RPC"),
18372 ReqBodyType: dara.String("formData"),
18373 BodyType: dara.String("json"),
18374 }
18375 _result = &UpdateRoutineRouteResponse{}
18376 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18377 if _err != nil {
18378 return _result, _err
18379 }
18380 _err = dara.Convert(_body, &_result)
18381 return _result, _err
18382 }
18383
18384 // Summary:
18385 //
18386 // Updates a scheduled prefetch plan based on the plan ID.
18387 //
18388 // @param request - UpdateScheduledPreloadExecutionRequest
18389 //
18390 // @param runtime - runtime options for this request RuntimeOptions
18391 //
18392 // @return UpdateScheduledPreloadExecutionResponse
18393 func UpdateScheduledPreloadExecutionWithContext(ctx context.Context, client *Client, request *UpdateScheduledPreloadExecutionRequest, runtime *dara.RuntimeOptions) (_result *UpdateScheduledPreloadExecutionResponse, _err error) {
18394 if dara.BoolValue(client.EnableValidate) == true {
18395 _err = request.Validate()
18396 if _err != nil {
18397 return _result, _err
18398 }
18399 }
18400 query := map[string]interface{}{}
18401 if !dara.IsNil(request.Id) {
18402 query["Id"] = request.Id
18403 }
18404
18405 body := map[string]interface{}{}
18406 if !dara.IsNil(request.EndTime) {
18407 body["EndTime"] = request.EndTime
18408 }
18409
18410 if !dara.IsNil(request.Interval) {
18411 body["Interval"] = request.Interval
18412 }
18413
18414 if !dara.IsNil(request.SliceLen) {
18415 body["SliceLen"] = request.SliceLen
18416 }
18417
18418 if !dara.IsNil(request.StartTime) {
18419 body["StartTime"] = request.StartTime
18420 }
18421
18422 req := &openapiutil.OpenApiRequest{
18423 Query: openapiutil.Query(query),
18424 Body: openapiutil.ParseToMap(body),
18425 }
18426 params := &openapiutil.Params{
18427 Action: dara.String("UpdateScheduledPreloadExecution"),
18428 Version: dara.String("2024-09-10"),
18429 Protocol: dara.String("HTTPS"),
18430 Pathname: dara.String("/"),
18431 Method: dara.String("POST"),
18432 AuthType: dara.String("AK"),
18433 Style: dara.String("RPC"),
18434 ReqBodyType: dara.String("formData"),
18435 BodyType: dara.String("json"),
18436 }
18437 _result = &UpdateScheduledPreloadExecutionResponse{}
18438 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18439 if _err != nil {
18440 return _result, _err
18441 }
18442 _err = dara.Convert(_body, &_result)
18443 return _result, _err
18444 }
18445
18446 // Summary:
18447 //
18448 // Modifies the search engine crawler configuration for a website.
18449 //
18450 // @param request - UpdateSeoBypassRequest
18451 //
18452 // @param runtime - runtime options for this request RuntimeOptions
18453 //
18454 // @return UpdateSeoBypassResponse
18455 func UpdateSeoBypassWithContext(ctx context.Context, client *Client, request *UpdateSeoBypassRequest, runtime *dara.RuntimeOptions) (_result *UpdateSeoBypassResponse, _err error) {
18456 if dara.BoolValue(client.EnableValidate) == true {
18457 _err = request.Validate()
18458 if _err != nil {
18459 return _result, _err
18460 }
18461 }
18462 query := map[string]interface{}{}
18463 if !dara.IsNil(request.Enable) {
18464 query["Enable"] = request.Enable
18465 }
18466
18467 if !dara.IsNil(request.SiteId) {
18468 query["SiteId"] = request.SiteId
18469 }
18470
18471 req := &openapiutil.OpenApiRequest{
18472 Query: openapiutil.Query(query),
18473 }
18474 params := &openapiutil.Params{
18475 Action: dara.String("UpdateSeoBypass"),
18476 Version: dara.String("2024-09-10"),
18477 Protocol: dara.String("HTTPS"),
18478 Pathname: dara.String("/"),
18479 Method: dara.String("POST"),
18480 AuthType: dara.String("AK"),
18481 Style: dara.String("RPC"),
18482 ReqBodyType: dara.String("formData"),
18483 BodyType: dara.String("json"),
18484 }
18485 _result = &UpdateSeoBypassResponse{}
18486 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18487 if _err != nil {
18488 return _result, _err
18489 }
18490 _err = dara.Convert(_body, &_result)
18491 return _result, _err
18492 }
18493
18494 // Summary:
18495 //
18496 // Converts the DNS setup option of a website.
18497 //
18498 // Description:
18499 //
18500 // When you change the DNS setup of a website from NS to CNAME, note the following prerequisites:
18501 //
18502 // - The website only has proxied A/AAAA and CNAME records.
18503 //
18504 // - The DNS passthrough mode and custom nameserver features are not enabled for the website.
18505 //
18506 // @param request - UpdateSiteAccessTypeRequest
18507 //
18508 // @param runtime - runtime options for this request RuntimeOptions
18509 //
18510 // @return UpdateSiteAccessTypeResponse
18511 func UpdateSiteAccessTypeWithContext(ctx context.Context, client *Client, request *UpdateSiteAccessTypeRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteAccessTypeResponse, _err error) {
18512 if dara.BoolValue(client.EnableValidate) == true {
18513 _err = request.Validate()
18514 if _err != nil {
18515 return _result, _err
18516 }
18517 }
18518 query := map[string]interface{}{}
18519 if !dara.IsNil(request.AccessType) {
18520 query["AccessType"] = request.AccessType
18521 }
18522
18523 if !dara.IsNil(request.SiteId) {
18524 query["SiteId"] = request.SiteId
18525 }
18526
18527 req := &openapiutil.OpenApiRequest{
18528 Query: openapiutil.Query(query),
18529 }
18530 params := &openapiutil.Params{
18531 Action: dara.String("UpdateSiteAccessType"),
18532 Version: dara.String("2024-09-10"),
18533 Protocol: dara.String("HTTPS"),
18534 Pathname: dara.String("/"),
18535 Method: dara.String("POST"),
18536 AuthType: dara.String("AK"),
18537 Style: dara.String("RPC"),
18538 ReqBodyType: dara.String("formData"),
18539 BodyType: dara.String("json"),
18540 }
18541 _result = &UpdateSiteAccessTypeResponse{}
18542 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18543 if _err != nil {
18544 return _result, _err
18545 }
18546 _err = dara.Convert(_body, &_result)
18547 return _result, _err
18548 }
18549
18550 // Summary:
18551 //
18552 // Modifies the service location for a single website. This updates the acceleration configuration of the website to adapt to changes in traffic distribution, and improve user experience in specific regions.
18553 //
18554 // @param request - UpdateSiteCoverageRequest
18555 //
18556 // @param runtime - runtime options for this request RuntimeOptions
18557 //
18558 // @return UpdateSiteCoverageResponse
18559 func UpdateSiteCoverageWithContext(ctx context.Context, client *Client, request *UpdateSiteCoverageRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteCoverageResponse, _err error) {
18560 if dara.BoolValue(client.EnableValidate) == true {
18561 _err = request.Validate()
18562 if _err != nil {
18563 return _result, _err
18564 }
18565 }
18566 query := map[string]interface{}{}
18567 if !dara.IsNil(request.Coverage) {
18568 query["Coverage"] = request.Coverage
18569 }
18570
18571 if !dara.IsNil(request.SiteId) {
18572 query["SiteId"] = request.SiteId
18573 }
18574
18575 req := &openapiutil.OpenApiRequest{
18576 Query: openapiutil.Query(query),
18577 }
18578 params := &openapiutil.Params{
18579 Action: dara.String("UpdateSiteCoverage"),
18580 Version: dara.String("2024-09-10"),
18581 Protocol: dara.String("HTTPS"),
18582 Pathname: dara.String("/"),
18583 Method: dara.String("POST"),
18584 AuthType: dara.String("AK"),
18585 Style: dara.String("RPC"),
18586 ReqBodyType: dara.String("formData"),
18587 BodyType: dara.String("json"),
18588 }
18589 _result = &UpdateSiteCoverageResponse{}
18590 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18591 if _err != nil {
18592 return _result, _err
18593 }
18594 _err = dara.Convert(_body, &_result)
18595 return _result, _err
18596 }
18597
18598 // Summary:
18599 //
18600 // Modifies the configuration of custom request header, response header, and cookie fields that are used to capture logs of a website.
18601 //
18602 // @param tmpReq - UpdateSiteCustomLogRequest
18603 //
18604 // @param runtime - runtime options for this request RuntimeOptions
18605 //
18606 // @return UpdateSiteCustomLogResponse
18607 func UpdateSiteCustomLogWithContext(ctx context.Context, client *Client, tmpReq *UpdateSiteCustomLogRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteCustomLogResponse, _err error) {
18608 if dara.BoolValue(client.EnableValidate) == true {
18609 _err = tmpReq.Validate()
18610 if _err != nil {
18611 return _result, _err
18612 }
18613 }
18614 request := &UpdateSiteCustomLogShrinkRequest{}
18615 openapiutil.Convert(tmpReq, request)
18616 if !dara.IsNil(tmpReq.Cookies) {
18617 request.CookiesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Cookies, dara.String("Cookies"), dara.String("json"))
18618 }
18619
18620 if !dara.IsNil(tmpReq.RequestHeaders) {
18621 request.RequestHeadersShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RequestHeaders, dara.String("RequestHeaders"), dara.String("json"))
18622 }
18623
18624 if !dara.IsNil(tmpReq.ResponseHeaders) {
18625 request.ResponseHeadersShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ResponseHeaders, dara.String("ResponseHeaders"), dara.String("json"))
18626 }
18627
18628 body := map[string]interface{}{}
18629 if !dara.IsNil(request.CookiesShrink) {
18630 body["Cookies"] = request.CookiesShrink
18631 }
18632
18633 if !dara.IsNil(request.RequestHeadersShrink) {
18634 body["RequestHeaders"] = request.RequestHeadersShrink
18635 }
18636
18637 if !dara.IsNil(request.ResponseHeadersShrink) {
18638 body["ResponseHeaders"] = request.ResponseHeadersShrink
18639 }
18640
18641 if !dara.IsNil(request.SiteId) {
18642 body["SiteId"] = request.SiteId
18643 }
18644
18645 req := &openapiutil.OpenApiRequest{
18646 Body: openapiutil.ParseToMap(body),
18647 }
18648 params := &openapiutil.Params{
18649 Action: dara.String("UpdateSiteCustomLog"),
18650 Version: dara.String("2024-09-10"),
18651 Protocol: dara.String("HTTPS"),
18652 Pathname: dara.String("/"),
18653 Method: dara.String("POST"),
18654 AuthType: dara.String("AK"),
18655 Style: dara.String("RPC"),
18656 ReqBodyType: dara.String("formData"),
18657 BodyType: dara.String("json"),
18658 }
18659 _result = &UpdateSiteCustomLogResponse{}
18660 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18661 if _err != nil {
18662 return _result, _err
18663 }
18664 _err = dara.Convert(_body, &_result)
18665 return _result, _err
18666 }
18667
18668 // Summary:
18669 //
18670 // Modifies a real-time log delivery task.
18671 //
18672 // @param request - UpdateSiteDeliveryTaskRequest
18673 //
18674 // @param runtime - runtime options for this request RuntimeOptions
18675 //
18676 // @return UpdateSiteDeliveryTaskResponse
18677 func UpdateSiteDeliveryTaskWithContext(ctx context.Context, client *Client, request *UpdateSiteDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteDeliveryTaskResponse, _err error) {
18678 if dara.BoolValue(client.EnableValidate) == true {
18679 _err = request.Validate()
18680 if _err != nil {
18681 return _result, _err
18682 }
18683 }
18684 body := map[string]interface{}{}
18685 if !dara.IsNil(request.BusinessType) {
18686 body["BusinessType"] = request.BusinessType
18687 }
18688
18689 if !dara.IsNil(request.DiscardRate) {
18690 body["DiscardRate"] = request.DiscardRate
18691 }
18692
18693 if !dara.IsNil(request.FieldName) {
18694 body["FieldName"] = request.FieldName
18695 }
18696
18697 if !dara.IsNil(request.FilterVer) {
18698 body["FilterVer"] = request.FilterVer
18699 }
18700
18701 if !dara.IsNil(request.SiteId) {
18702 body["SiteId"] = request.SiteId
18703 }
18704
18705 if !dara.IsNil(request.TaskName) {
18706 body["TaskName"] = request.TaskName
18707 }
18708
18709 req := &openapiutil.OpenApiRequest{
18710 Body: openapiutil.ParseToMap(body),
18711 }
18712 params := &openapiutil.Params{
18713 Action: dara.String("UpdateSiteDeliveryTask"),
18714 Version: dara.String("2024-09-10"),
18715 Protocol: dara.String("HTTPS"),
18716 Pathname: dara.String("/"),
18717 Method: dara.String("POST"),
18718 AuthType: dara.String("AK"),
18719 Style: dara.String("RPC"),
18720 ReqBodyType: dara.String("formData"),
18721 BodyType: dara.String("json"),
18722 }
18723 _result = &UpdateSiteDeliveryTaskResponse{}
18724 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18725 if _err != nil {
18726 return _result, _err
18727 }
18728 _err = dara.Convert(_body, &_result)
18729 return _result, _err
18730 }
18731
18732 // Summary:
18733 //
18734 // Changes the status of a real-time log delivery task.
18735 //
18736 // @param request - UpdateSiteDeliveryTaskStatusRequest
18737 //
18738 // @param runtime - runtime options for this request RuntimeOptions
18739 //
18740 // @return UpdateSiteDeliveryTaskStatusResponse
18741 func UpdateSiteDeliveryTaskStatusWithContext(ctx context.Context, client *Client, request *UpdateSiteDeliveryTaskStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteDeliveryTaskStatusResponse, _err error) {
18742 if dara.BoolValue(client.EnableValidate) == true {
18743 _err = request.Validate()
18744 if _err != nil {
18745 return _result, _err
18746 }
18747 }
18748 query := openapiutil.Query(dara.ToMap(request))
18749 req := &openapiutil.OpenApiRequest{
18750 Query: openapiutil.Query(query),
18751 }
18752 params := &openapiutil.Params{
18753 Action: dara.String("UpdateSiteDeliveryTaskStatus"),
18754 Version: dara.String("2024-09-10"),
18755 Protocol: dara.String("HTTPS"),
18756 Pathname: dara.String("/"),
18757 Method: dara.String("GET"),
18758 AuthType: dara.String("AK"),
18759 Style: dara.String("RPC"),
18760 ReqBodyType: dara.String("formData"),
18761 BodyType: dara.String("json"),
18762 }
18763 _result = &UpdateSiteDeliveryTaskStatusResponse{}
18764 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18765 if _err != nil {
18766 return _result, _err
18767 }
18768 _err = dara.Convert(_body, &_result)
18769 return _result, _err
18770 }
18771
18772 // Summary:
18773 //
18774 // Modifies the site hold configuration of a website. After you enable site hold, other accounts cannot add your website domain or its subdomains to ESA.
18775 //
18776 // @param request - UpdateSiteNameExclusiveRequest
18777 //
18778 // @param runtime - runtime options for this request RuntimeOptions
18779 //
18780 // @return UpdateSiteNameExclusiveResponse
18781 func UpdateSiteNameExclusiveWithContext(ctx context.Context, client *Client, request *UpdateSiteNameExclusiveRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteNameExclusiveResponse, _err error) {
18782 if dara.BoolValue(client.EnableValidate) == true {
18783 _err = request.Validate()
18784 if _err != nil {
18785 return _result, _err
18786 }
18787 }
18788 query := map[string]interface{}{}
18789 if !dara.IsNil(request.Enable) {
18790 query["Enable"] = request.Enable
18791 }
18792
18793 if !dara.IsNil(request.SiteId) {
18794 query["SiteId"] = request.SiteId
18795 }
18796
18797 req := &openapiutil.OpenApiRequest{
18798 Query: openapiutil.Query(query),
18799 }
18800 params := &openapiutil.Params{
18801 Action: dara.String("UpdateSiteNameExclusive"),
18802 Version: dara.String("2024-09-10"),
18803 Protocol: dara.String("HTTPS"),
18804 Pathname: dara.String("/"),
18805 Method: dara.String("POST"),
18806 AuthType: dara.String("AK"),
18807 Style: dara.String("RPC"),
18808 ReqBodyType: dara.String("formData"),
18809 BodyType: dara.String("json"),
18810 }
18811 _result = &UpdateSiteNameExclusiveResponse{}
18812 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18813 if _err != nil {
18814 return _result, _err
18815 }
18816 _err = dara.Convert(_body, &_result)
18817 return _result, _err
18818 }
18819
18820 // Summary:
18821 //
18822 // Modifies the ESA proxy configuration of a website.
18823 //
18824 // @param request - UpdateSitePauseRequest
18825 //
18826 // @param runtime - runtime options for this request RuntimeOptions
18827 //
18828 // @return UpdateSitePauseResponse
18829 func UpdateSitePauseWithContext(ctx context.Context, client *Client, request *UpdateSitePauseRequest, runtime *dara.RuntimeOptions) (_result *UpdateSitePauseResponse, _err error) {
18830 if dara.BoolValue(client.EnableValidate) == true {
18831 _err = request.Validate()
18832 if _err != nil {
18833 return _result, _err
18834 }
18835 }
18836 query := map[string]interface{}{}
18837 if !dara.IsNil(request.Paused) {
18838 query["Paused"] = request.Paused
18839 }
18840
18841 if !dara.IsNil(request.SiteId) {
18842 query["SiteId"] = request.SiteId
18843 }
18844
18845 req := &openapiutil.OpenApiRequest{
18846 Query: openapiutil.Query(query),
18847 }
18848 params := &openapiutil.Params{
18849 Action: dara.String("UpdateSitePause"),
18850 Version: dara.String("2024-09-10"),
18851 Protocol: dara.String("HTTPS"),
18852 Pathname: dara.String("/"),
18853 Method: dara.String("POST"),
18854 AuthType: dara.String("AK"),
18855 Style: dara.String("RPC"),
18856 ReqBodyType: dara.String("formData"),
18857 BodyType: dara.String("json"),
18858 }
18859 _result = &UpdateSitePauseResponse{}
18860 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18861 if _err != nil {
18862 return _result, _err
18863 }
18864 _err = dara.Convert(_body, &_result)
18865 return _result, _err
18866 }
18867
18868 // Summary:
18869 //
18870 // Updates the custom nameserver names for a single website.
18871 //
18872 // @param request - UpdateSiteVanityNSRequest
18873 //
18874 // @param runtime - runtime options for this request RuntimeOptions
18875 //
18876 // @return UpdateSiteVanityNSResponse
18877 func UpdateSiteVanityNSWithContext(ctx context.Context, client *Client, request *UpdateSiteVanityNSRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteVanityNSResponse, _err error) {
18878 if dara.BoolValue(client.EnableValidate) == true {
18879 _err = request.Validate()
18880 if _err != nil {
18881 return _result, _err
18882 }
18883 }
18884 query := map[string]interface{}{}
18885 if !dara.IsNil(request.SiteId) {
18886 query["SiteId"] = request.SiteId
18887 }
18888
18889 if !dara.IsNil(request.VanityNSList) {
18890 query["VanityNSList"] = request.VanityNSList
18891 }
18892
18893 req := &openapiutil.OpenApiRequest{
18894 Query: openapiutil.Query(query),
18895 }
18896 params := &openapiutil.Params{
18897 Action: dara.String("UpdateSiteVanityNS"),
18898 Version: dara.String("2024-09-10"),
18899 Protocol: dara.String("HTTPS"),
18900 Pathname: dara.String("/"),
18901 Method: dara.String("POST"),
18902 AuthType: dara.String("AK"),
18903 Style: dara.String("RPC"),
18904 ReqBodyType: dara.String("formData"),
18905 BodyType: dara.String("json"),
18906 }
18907 _result = &UpdateSiteVanityNSResponse{}
18908 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18909 if _err != nil {
18910 return _result, _err
18911 }
18912 _err = dara.Convert(_body, &_result)
18913 return _result, _err
18914 }
18915
18916 // Summary:
18917 //
18918 // Modifies the tiered cache configuration of your website.
18919 //
18920 // @param request - UpdateTieredCacheRequest
18921 //
18922 // @param runtime - runtime options for this request RuntimeOptions
18923 //
18924 // @return UpdateTieredCacheResponse
18925 func UpdateTieredCacheWithContext(ctx context.Context, client *Client, request *UpdateTieredCacheRequest, runtime *dara.RuntimeOptions) (_result *UpdateTieredCacheResponse, _err error) {
18926 if dara.BoolValue(client.EnableValidate) == true {
18927 _err = request.Validate()
18928 if _err != nil {
18929 return _result, _err
18930 }
18931 }
18932 query := map[string]interface{}{}
18933 if !dara.IsNil(request.CacheArchitectureMode) {
18934 query["CacheArchitectureMode"] = request.CacheArchitectureMode
18935 }
18936
18937 if !dara.IsNil(request.SiteId) {
18938 query["SiteId"] = request.SiteId
18939 }
18940
18941 req := &openapiutil.OpenApiRequest{
18942 Query: openapiutil.Query(query),
18943 }
18944 params := &openapiutil.Params{
18945 Action: dara.String("UpdateTieredCache"),
18946 Version: dara.String("2024-09-10"),
18947 Protocol: dara.String("HTTPS"),
18948 Pathname: dara.String("/"),
18949 Method: dara.String("POST"),
18950 AuthType: dara.String("AK"),
18951 Style: dara.String("RPC"),
18952 ReqBodyType: dara.String("formData"),
18953 BodyType: dara.String("json"),
18954 }
18955 _result = &UpdateTieredCacheResponse{}
18956 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
18957 if _err != nil {
18958 return _result, _err
18959 }
18960 _err = dara.Convert(_body, &_result)
18961 return _result, _err
18962 }
18963
18964 // Summary:
18965 //
18966 // # Modify Transport Layer Application
18967 //
18968 // @param tmpReq - UpdateTransportLayerApplicationRequest
18969 //
18970 // @param runtime - runtime options for this request RuntimeOptions
18971 //
18972 // @return UpdateTransportLayerApplicationResponse
18973 func UpdateTransportLayerApplicationWithContext(ctx context.Context, client *Client, tmpReq *UpdateTransportLayerApplicationRequest, runtime *dara.RuntimeOptions) (_result *UpdateTransportLayerApplicationResponse, _err error) {
18974 if dara.BoolValue(client.EnableValidate) == true {
18975 _err = tmpReq.Validate()
18976 if _err != nil {
18977 return _result, _err
18978 }
18979 }
18980 request := &UpdateTransportLayerApplicationShrinkRequest{}
18981 openapiutil.Convert(tmpReq, request)
18982 if !dara.IsNil(tmpReq.Rules) {
18983 request.RulesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Rules, dara.String("Rules"), dara.String("json"))
18984 }
18985
18986 query := map[string]interface{}{}
18987 if !dara.IsNil(request.ApplicationId) {
18988 query["ApplicationId"] = request.ApplicationId
18989 }
18990
18991 if !dara.IsNil(request.CrossBorderOptimization) {
18992 query["CrossBorderOptimization"] = request.CrossBorderOptimization
18993 }
18994
18995 if !dara.IsNil(request.IpAccessRule) {
18996 query["IpAccessRule"] = request.IpAccessRule
18997 }
18998
18999 if !dara.IsNil(request.Ipv6) {
19000 query["Ipv6"] = request.Ipv6
19001 }
19002
19003 if !dara.IsNil(request.RulesShrink) {
19004 query["Rules"] = request.RulesShrink
19005 }
19006
19007 if !dara.IsNil(request.SiteId) {
19008 query["SiteId"] = request.SiteId
19009 }
19010
19011 if !dara.IsNil(request.StaticIp) {
19012 query["StaticIp"] = request.StaticIp
19013 }
19014
19015 req := &openapiutil.OpenApiRequest{
19016 Query: openapiutil.Query(query),
19017 }
19018 params := &openapiutil.Params{
19019 Action: dara.String("UpdateTransportLayerApplication"),
19020 Version: dara.String("2024-09-10"),
19021 Protocol: dara.String("HTTPS"),
19022 Pathname: dara.String("/"),
19023 Method: dara.String("POST"),
19024 AuthType: dara.String("AK"),
19025 Style: dara.String("RPC"),
19026 ReqBodyType: dara.String("formData"),
19027 BodyType: dara.String("json"),
19028 }
19029 _result = &UpdateTransportLayerApplicationResponse{}
19030 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19031 if _err != nil {
19032 return _result, _err
19033 }
19034 _err = dara.Convert(_body, &_result)
19035 return _result, _err
19036 }
19037
19038 // Summary:
19039 //
19040 // Updates the webpage monitoring configuration.
19041 //
19042 // @param request - UpdateUrlObservationRequest
19043 //
19044 // @param runtime - runtime options for this request RuntimeOptions
19045 //
19046 // @return UpdateUrlObservationResponse
19047 func UpdateUrlObservationWithContext(ctx context.Context, client *Client, request *UpdateUrlObservationRequest, runtime *dara.RuntimeOptions) (_result *UpdateUrlObservationResponse, _err error) {
19048 if dara.BoolValue(client.EnableValidate) == true {
19049 _err = request.Validate()
19050 if _err != nil {
19051 return _result, _err
19052 }
19053 }
19054 query := map[string]interface{}{}
19055 if !dara.IsNil(request.ConfigId) {
19056 query["ConfigId"] = request.ConfigId
19057 }
19058
19059 if !dara.IsNil(request.SdkType) {
19060 query["SdkType"] = request.SdkType
19061 }
19062
19063 if !dara.IsNil(request.SiteId) {
19064 query["SiteId"] = request.SiteId
19065 }
19066
19067 req := &openapiutil.OpenApiRequest{
19068 Query: openapiutil.Query(query),
19069 }
19070 params := &openapiutil.Params{
19071 Action: dara.String("UpdateUrlObservation"),
19072 Version: dara.String("2024-09-10"),
19073 Protocol: dara.String("HTTPS"),
19074 Pathname: dara.String("/"),
19075 Method: dara.String("POST"),
19076 AuthType: dara.String("AK"),
19077 Style: dara.String("RPC"),
19078 ReqBodyType: dara.String("formData"),
19079 BodyType: dara.String("json"),
19080 }
19081 _result = &UpdateUrlObservationResponse{}
19082 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19083 if _err != nil {
19084 return _result, _err
19085 }
19086 _err = dara.Convert(_body, &_result)
19087 return _result, _err
19088 }
19089
19090 // Summary:
19091 //
19092 // Modifies the configurations of a delivery task, including the task name, log field, log category, and discard rate.
19093 //
19094 // @param request - UpdateUserDeliveryTaskRequest
19095 //
19096 // @param runtime - runtime options for this request RuntimeOptions
19097 //
19098 // @return UpdateUserDeliveryTaskResponse
19099 func UpdateUserDeliveryTaskWithContext(ctx context.Context, client *Client, request *UpdateUserDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *UpdateUserDeliveryTaskResponse, _err error) {
19100 if dara.BoolValue(client.EnableValidate) == true {
19101 _err = request.Validate()
19102 if _err != nil {
19103 return _result, _err
19104 }
19105 }
19106 body := map[string]interface{}{}
19107 if !dara.IsNil(request.BusinessType) {
19108 body["BusinessType"] = request.BusinessType
19109 }
19110
19111 if !dara.IsNil(request.Details) {
19112 body["Details"] = request.Details
19113 }
19114
19115 if !dara.IsNil(request.DiscardRate) {
19116 body["DiscardRate"] = request.DiscardRate
19117 }
19118
19119 if !dara.IsNil(request.FieldName) {
19120 body["FieldName"] = request.FieldName
19121 }
19122
19123 if !dara.IsNil(request.FilterVer) {
19124 body["FilterVer"] = request.FilterVer
19125 }
19126
19127 if !dara.IsNil(request.TaskName) {
19128 body["TaskName"] = request.TaskName
19129 }
19130
19131 req := &openapiutil.OpenApiRequest{
19132 Body: openapiutil.ParseToMap(body),
19133 }
19134 params := &openapiutil.Params{
19135 Action: dara.String("UpdateUserDeliveryTask"),
19136 Version: dara.String("2024-09-10"),
19137 Protocol: dara.String("HTTPS"),
19138 Pathname: dara.String("/"),
19139 Method: dara.String("POST"),
19140 AuthType: dara.String("AK"),
19141 Style: dara.String("RPC"),
19142 ReqBodyType: dara.String("formData"),
19143 BodyType: dara.String("json"),
19144 }
19145 _result = &UpdateUserDeliveryTaskResponse{}
19146 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19147 if _err != nil {
19148 return _result, _err
19149 }
19150 _err = dara.Convert(_body, &_result)
19151 return _result, _err
19152 }
19153
19154 // Summary:
19155 //
19156 // Changes the status of a delivery task in your Alibaba Cloud account.
19157 //
19158 // Description:
19159 //
19160 // ## [](#)
19161 //
19162 // You can call this operation to enable or disable a delivery task by using TaskName and Method. The response includes the most recent status and operation result details of the task.
19163 //
19164 // @param request - UpdateUserDeliveryTaskStatusRequest
19165 //
19166 // @param runtime - runtime options for this request RuntimeOptions
19167 //
19168 // @return UpdateUserDeliveryTaskStatusResponse
19169 func UpdateUserDeliveryTaskStatusWithContext(ctx context.Context, client *Client, request *UpdateUserDeliveryTaskStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateUserDeliveryTaskStatusResponse, _err error) {
19170 if dara.BoolValue(client.EnableValidate) == true {
19171 _err = request.Validate()
19172 if _err != nil {
19173 return _result, _err
19174 }
19175 }
19176 query := openapiutil.Query(dara.ToMap(request))
19177 req := &openapiutil.OpenApiRequest{
19178 Query: openapiutil.Query(query),
19179 }
19180 params := &openapiutil.Params{
19181 Action: dara.String("UpdateUserDeliveryTaskStatus"),
19182 Version: dara.String("2024-09-10"),
19183 Protocol: dara.String("HTTPS"),
19184 Pathname: dara.String("/"),
19185 Method: dara.String("GET"),
19186 AuthType: dara.String("AK"),
19187 Style: dara.String("RPC"),
19188 ReqBodyType: dara.String("formData"),
19189 BodyType: dara.String("json"),
19190 }
19191 _result = &UpdateUserDeliveryTaskStatusResponse{}
19192 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19193 if _err != nil {
19194 return _result, _err
19195 }
19196 _err = dara.Convert(_body, &_result)
19197 return _result, _err
19198 }
19199
19200 // Summary:
19201 //
19202 // 用于更新实例级别的Web应用防火墙规则集，支持多种类型的防护规则。
19203 //
19204 // Description:
19205 //
19206 // ## 请求说明
19207 //
19208 // - 本API允许用户为指定实例创建新的WAF（Web Application Firewall）规则集。
19209 //
19210 // - `InstanceId` 是必需参数，指定了要为其创建规则集的具体实例。
19211 //
19212 // - `Phase` 参数定义了规则集的应用阶段，例如自定义规则、频次控制等。
19213 //
19214 // - `Name` 和 `Expression` 是必填项，分别代表规则集的名字和具体的匹配表达式。
19215 //
19216 // - 可选参数 `Description` 提供了对规则集功能或用途的文字描述。
19217 //
19218 // - `Status` 控制着规则集是否立即生效 (`on`) 或者处于关闭状态 (`off`)。
19219 //
19220 // - 通过 `Rules` 参数可以进一步配置更详细的规则列表，每个规则都包含名称、位置、表达式及动作等属性。
19221 //
19222 // - 成功响应将返回新创建规则集的唯一标识符 `Id` 以及所有关联规则的ID列表 `RuleIds`。
19223 //
19224 // @param tmpReq - UpdateUserWafRulesetRequest
19225 //
19226 // @param runtime - runtime options for this request RuntimeOptions
19227 //
19228 // @return UpdateUserWafRulesetResponse
19229 func UpdateUserWafRulesetWithContext(ctx context.Context, client *Client, tmpReq *UpdateUserWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *UpdateUserWafRulesetResponse, _err error) {
19230 if dara.BoolValue(client.EnableValidate) == true {
19231 _err = tmpReq.Validate()
19232 if _err != nil {
19233 return _result, _err
19234 }
19235 }
19236 request := &UpdateUserWafRulesetShrinkRequest{}
19237 openapiutil.Convert(tmpReq, request)
19238 if !dara.IsNil(tmpReq.Rules) {
19239 request.RulesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Rules, dara.String("Rules"), dara.String("json"))
19240 }
19241
19242 if !dara.IsNil(tmpReq.Shared) {
19243 request.SharedShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Shared, dara.String("Shared"), dara.String("json"))
19244 }
19245
19246 query := map[string]interface{}{}
19247 if !dara.IsNil(request.InstanceId) {
19248 query["InstanceId"] = request.InstanceId
19249 }
19250
19251 body := map[string]interface{}{}
19252 if !dara.IsNil(request.Description) {
19253 body["Description"] = request.Description
19254 }
19255
19256 if !dara.IsNil(request.Expression) {
19257 body["Expression"] = request.Expression
19258 }
19259
19260 if !dara.IsNil(request.Id) {
19261 body["Id"] = request.Id
19262 }
19263
19264 if !dara.IsNil(request.Name) {
19265 body["Name"] = request.Name
19266 }
19267
19268 if !dara.IsNil(request.Position) {
19269 body["Position"] = request.Position
19270 }
19271
19272 if !dara.IsNil(request.RulesShrink) {
19273 body["Rules"] = request.RulesShrink
19274 }
19275
19276 if !dara.IsNil(request.SharedShrink) {
19277 body["Shared"] = request.SharedShrink
19278 }
19279
19280 if !dara.IsNil(request.Status) {
19281 body["Status"] = request.Status
19282 }
19283
19284 req := &openapiutil.OpenApiRequest{
19285 Query: openapiutil.Query(query),
19286 Body: openapiutil.ParseToMap(body),
19287 }
19288 params := &openapiutil.Params{
19289 Action: dara.String("UpdateUserWafRuleset"),
19290 Version: dara.String("2024-09-10"),
19291 Protocol: dara.String("HTTPS"),
19292 Pathname: dara.String("/"),
19293 Method: dara.String("POST"),
19294 AuthType: dara.String("AK"),
19295 Style: dara.String("RPC"),
19296 ReqBodyType: dara.String("formData"),
19297 BodyType: dara.String("json"),
19298 }
19299 _result = &UpdateUserWafRulesetResponse{}
19300 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19301 if _err != nil {
19302 return _result, _err
19303 }
19304 _err = dara.Convert(_body, &_result)
19305 return _result, _err
19306 }
19307
19308 // Summary:
19309 //
19310 // Modifies the video processing configuration of the site.
19311 //
19312 // @param request - UpdateVideoProcessingRequest
19313 //
19314 // @param runtime - runtime options for this request RuntimeOptions
19315 //
19316 // @return UpdateVideoProcessingResponse
19317 func UpdateVideoProcessingWithContext(ctx context.Context, client *Client, request *UpdateVideoProcessingRequest, runtime *dara.RuntimeOptions) (_result *UpdateVideoProcessingResponse, _err error) {
19318 if dara.BoolValue(client.EnableValidate) == true {
19319 _err = request.Validate()
19320 if _err != nil {
19321 return _result, _err
19322 }
19323 }
19324 query := map[string]interface{}{}
19325 if !dara.IsNil(request.ConfigId) {
19326 query["ConfigId"] = request.ConfigId
19327 }
19328
19329 if !dara.IsNil(request.FlvSeekEnd) {
19330 query["FlvSeekEnd"] = request.FlvSeekEnd
19331 }
19332
19333 if !dara.IsNil(request.FlvSeekStart) {
19334 query["FlvSeekStart"] = request.FlvSeekStart
19335 }
19336
19337 if !dara.IsNil(request.FlvVideoSeekMode) {
19338 query["FlvVideoSeekMode"] = request.FlvVideoSeekMode
19339 }
19340
19341 if !dara.IsNil(request.Mp4SeekEnd) {
19342 query["Mp4SeekEnd"] = request.Mp4SeekEnd
19343 }
19344
19345 if !dara.IsNil(request.Mp4SeekStart) {
19346 query["Mp4SeekStart"] = request.Mp4SeekStart
19347 }
19348
19349 if !dara.IsNil(request.Rule) {
19350 query["Rule"] = request.Rule
19351 }
19352
19353 if !dara.IsNil(request.RuleEnable) {
19354 query["RuleEnable"] = request.RuleEnable
19355 }
19356
19357 if !dara.IsNil(request.RuleName) {
19358 query["RuleName"] = request.RuleName
19359 }
19360
19361 if !dara.IsNil(request.Sequence) {
19362 query["Sequence"] = request.Sequence
19363 }
19364
19365 if !dara.IsNil(request.SiteId) {
19366 query["SiteId"] = request.SiteId
19367 }
19368
19369 if !dara.IsNil(request.VideoSeekEnable) {
19370 query["VideoSeekEnable"] = request.VideoSeekEnable
19371 }
19372
19373 req := &openapiutil.OpenApiRequest{
19374 Query: openapiutil.Query(query),
19375 }
19376 params := &openapiutil.Params{
19377 Action: dara.String("UpdateVideoProcessing"),
19378 Version: dara.String("2024-09-10"),
19379 Protocol: dara.String("HTTPS"),
19380 Pathname: dara.String("/"),
19381 Method: dara.String("POST"),
19382 AuthType: dara.String("AK"),
19383 Style: dara.String("RPC"),
19384 ReqBodyType: dara.String("formData"),
19385 BodyType: dara.String("json"),
19386 }
19387 _result = &UpdateVideoProcessingResponse{}
19388 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19389 if _err != nil {
19390 return _result, _err
19391 }
19392 _err = dara.Convert(_body, &_result)
19393 return _result, _err
19394 }
19395
19396 // Summary:
19397 //
19398 // # Update WAF Rule Page
19399 //
19400 // @param tmpReq - UpdateWafRuleRequest
19401 //
19402 // @param runtime - runtime options for this request RuntimeOptions
19403 //
19404 // @return UpdateWafRuleResponse
19405 func UpdateWafRuleWithContext(ctx context.Context, client *Client, tmpReq *UpdateWafRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateWafRuleResponse, _err error) {
19406 if dara.BoolValue(client.EnableValidate) == true {
19407 _err = tmpReq.Validate()
19408 if _err != nil {
19409 return _result, _err
19410 }
19411 }
19412 request := &UpdateWafRuleShrinkRequest{}
19413 openapiutil.Convert(tmpReq, request)
19414 if !dara.IsNil(tmpReq.Config) {
19415 request.ConfigShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Config, dara.String("Config"), dara.String("json"))
19416 }
19417
19418 query := map[string]interface{}{}
19419 if !dara.IsNil(request.SiteId) {
19420 query["SiteId"] = request.SiteId
19421 }
19422
19423 if !dara.IsNil(request.SiteVersion) {
19424 query["SiteVersion"] = request.SiteVersion
19425 }
19426
19427 body := map[string]interface{}{}
19428 if !dara.IsNil(request.ConfigShrink) {
19429 body["Config"] = request.ConfigShrink
19430 }
19431
19432 if !dara.IsNil(request.Id) {
19433 body["Id"] = request.Id
19434 }
19435
19436 if !dara.IsNil(request.Position) {
19437 body["Position"] = request.Position
19438 }
19439
19440 if !dara.IsNil(request.Status) {
19441 body["Status"] = request.Status
19442 }
19443
19444 req := &openapiutil.OpenApiRequest{
19445 Query: openapiutil.Query(query),
19446 Body: openapiutil.ParseToMap(body),
19447 }
19448 params := &openapiutil.Params{
19449 Action: dara.String("UpdateWafRule"),
19450 Version: dara.String("2024-09-10"),
19451 Protocol: dara.String("HTTPS"),
19452 Pathname: dara.String("/"),
19453 Method: dara.String("POST"),
19454 AuthType: dara.String("AK"),
19455 Style: dara.String("RPC"),
19456 ReqBodyType: dara.String("formData"),
19457 BodyType: dara.String("json"),
19458 }
19459 _result = &UpdateWafRuleResponse{}
19460 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19461 if _err != nil {
19462 return _result, _err
19463 }
19464 _err = dara.Convert(_body, &_result)
19465 return _result, _err
19466 }
19467
19468 // Summary:
19469 //
19470 // # Update WAF Ruleset
19471 //
19472 // @param request - UpdateWafRulesetRequest
19473 //
19474 // @param runtime - runtime options for this request RuntimeOptions
19475 //
19476 // @return UpdateWafRulesetResponse
19477 func UpdateWafRulesetWithContext(ctx context.Context, client *Client, request *UpdateWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *UpdateWafRulesetResponse, _err error) {
19478 if dara.BoolValue(client.EnableValidate) == true {
19479 _err = request.Validate()
19480 if _err != nil {
19481 return _result, _err
19482 }
19483 }
19484 query := map[string]interface{}{}
19485 if !dara.IsNil(request.SiteId) {
19486 query["SiteId"] = request.SiteId
19487 }
19488
19489 if !dara.IsNil(request.SiteVersion) {
19490 query["SiteVersion"] = request.SiteVersion
19491 }
19492
19493 body := map[string]interface{}{}
19494 if !dara.IsNil(request.Id) {
19495 body["Id"] = request.Id
19496 }
19497
19498 if !dara.IsNil(request.Status) {
19499 body["Status"] = request.Status
19500 }
19501
19502 req := &openapiutil.OpenApiRequest{
19503 Query: openapiutil.Query(query),
19504 Body: openapiutil.ParseToMap(body),
19505 }
19506 params := &openapiutil.Params{
19507 Action: dara.String("UpdateWafRuleset"),
19508 Version: dara.String("2024-09-10"),
19509 Protocol: dara.String("HTTPS"),
19510 Pathname: dara.String("/"),
19511 Method: dara.String("POST"),
19512 AuthType: dara.String("AK"),
19513 Style: dara.String("RPC"),
19514 ReqBodyType: dara.String("formData"),
19515 BodyType: dara.String("json"),
19516 }
19517 _result = &UpdateWafRulesetResponse{}
19518 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19519 if _err != nil {
19520 return _result, _err
19521 }
19522 _err = dara.Convert(_body, &_result)
19523 return _result, _err
19524 }
19525
19526 // Summary:
19527 //
19528 // Modifies the configurations of a waiting room.
19529 //
19530 // @param tmpReq - UpdateWaitingRoomRequest
19531 //
19532 // @param runtime - runtime options for this request RuntimeOptions
19533 //
19534 // @return UpdateWaitingRoomResponse
19535 func UpdateWaitingRoomWithContext(ctx context.Context, client *Client, tmpReq *UpdateWaitingRoomRequest, runtime *dara.RuntimeOptions) (_result *UpdateWaitingRoomResponse, _err error) {
19536 if dara.BoolValue(client.EnableValidate) == true {
19537 _err = tmpReq.Validate()
19538 if _err != nil {
19539 return _result, _err
19540 }
19541 }
19542 request := &UpdateWaitingRoomShrinkRequest{}
19543 openapiutil.Convert(tmpReq, request)
19544 if !dara.IsNil(tmpReq.HostNameAndPath) {
19545 request.HostNameAndPathShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.HostNameAndPath, dara.String("HostNameAndPath"), dara.String("json"))
19546 }
19547
19548 query := map[string]interface{}{}
19549 if !dara.IsNil(request.CookieName) {
19550 query["CookieName"] = request.CookieName
19551 }
19552
19553 if !dara.IsNil(request.CustomPageHtml) {
19554 query["CustomPageHtml"] = request.CustomPageHtml
19555 }
19556
19557 if !dara.IsNil(request.Description) {
19558 query["Description"] = request.Description
19559 }
19560
19561 if !dara.IsNil(request.DisableSessionRenewalEnable) {
19562 query["DisableSessionRenewalEnable"] = request.DisableSessionRenewalEnable
19563 }
19564
19565 if !dara.IsNil(request.Enable) {
19566 query["Enable"] = request.Enable
19567 }
19568
19569 if !dara.IsNil(request.HostNameAndPathShrink) {
19570 query["HostNameAndPath"] = request.HostNameAndPathShrink
19571 }
19572
19573 if !dara.IsNil(request.JsonResponseEnable) {
19574 query["JsonResponseEnable"] = request.JsonResponseEnable
19575 }
19576
19577 if !dara.IsNil(request.Language) {
19578 query["Language"] = request.Language
19579 }
19580
19581 if !dara.IsNil(request.Name) {
19582 query["Name"] = request.Name
19583 }
19584
19585 if !dara.IsNil(request.NewUsersPerMinute) {
19586 query["NewUsersPerMinute"] = request.NewUsersPerMinute
19587 }
19588
19589 if !dara.IsNil(request.QueueAllEnable) {
19590 query["QueueAllEnable"] = request.QueueAllEnable
19591 }
19592
19593 if !dara.IsNil(request.QueuingMethod) {
19594 query["QueuingMethod"] = request.QueuingMethod
19595 }
19596
19597 if !dara.IsNil(request.QueuingStatusCode) {
19598 query["QueuingStatusCode"] = request.QueuingStatusCode
19599 }
19600
19601 if !dara.IsNil(request.SessionDuration) {
19602 query["SessionDuration"] = request.SessionDuration
19603 }
19604
19605 if !dara.IsNil(request.SiteId) {
19606 query["SiteId"] = request.SiteId
19607 }
19608
19609 if !dara.IsNil(request.TotalActiveUsers) {
19610 query["TotalActiveUsers"] = request.TotalActiveUsers
19611 }
19612
19613 if !dara.IsNil(request.WaitingRoomId) {
19614 query["WaitingRoomId"] = request.WaitingRoomId
19615 }
19616
19617 if !dara.IsNil(request.WaitingRoomType) {
19618 query["WaitingRoomType"] = request.WaitingRoomType
19619 }
19620
19621 req := &openapiutil.OpenApiRequest{
19622 Query: openapiutil.Query(query),
19623 }
19624 params := &openapiutil.Params{
19625 Action: dara.String("UpdateWaitingRoom"),
19626 Version: dara.String("2024-09-10"),
19627 Protocol: dara.String("HTTPS"),
19628 Pathname: dara.String("/"),
19629 Method: dara.String("POST"),
19630 AuthType: dara.String("AK"),
19631 Style: dara.String("RPC"),
19632 ReqBodyType: dara.String("formData"),
19633 BodyType: dara.String("json"),
19634 }
19635 _result = &UpdateWaitingRoomResponse{}
19636 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19637 if _err != nil {
19638 return _result, _err
19639 }
19640 _err = dara.Convert(_body, &_result)
19641 return _result, _err
19642 }
19643
19644 // Summary:
19645 //
19646 // Modifies the configurations of a waiting room event.
19647 //
19648 // @param request - UpdateWaitingRoomEventRequest
19649 //
19650 // @param runtime - runtime options for this request RuntimeOptions
19651 //
19652 // @return UpdateWaitingRoomEventResponse
19653 func UpdateWaitingRoomEventWithContext(ctx context.Context, client *Client, request *UpdateWaitingRoomEventRequest, runtime *dara.RuntimeOptions) (_result *UpdateWaitingRoomEventResponse, _err error) {
19654 if dara.BoolValue(client.EnableValidate) == true {
19655 _err = request.Validate()
19656 if _err != nil {
19657 return _result, _err
19658 }
19659 }
19660 query := map[string]interface{}{}
19661 if !dara.IsNil(request.CustomPageHtml) {
19662 query["CustomPageHtml"] = request.CustomPageHtml
19663 }
19664
19665 if !dara.IsNil(request.Description) {
19666 query["Description"] = request.Description
19667 }
19668
19669 if !dara.IsNil(request.DisableSessionRenewalEnable) {
19670 query["DisableSessionRenewalEnable"] = request.DisableSessionRenewalEnable
19671 }
19672
19673 if !dara.IsNil(request.Enable) {
19674 query["Enable"] = request.Enable
19675 }
19676
19677 if !dara.IsNil(request.EndTime) {
19678 query["EndTime"] = request.EndTime
19679 }
19680
19681 if !dara.IsNil(request.JsonResponseEnable) {
19682 query["JsonResponseEnable"] = request.JsonResponseEnable
19683 }
19684
19685 if !dara.IsNil(request.Language) {
19686 query["Language"] = request.Language
19687 }
19688
19689 if !dara.IsNil(request.Name) {
19690 query["Name"] = request.Name
19691 }
19692
19693 if !dara.IsNil(request.NewUsersPerMinute) {
19694 query["NewUsersPerMinute"] = request.NewUsersPerMinute
19695 }
19696
19697 if !dara.IsNil(request.PreQueueEnable) {
19698 query["PreQueueEnable"] = request.PreQueueEnable
19699 }
19700
19701 if !dara.IsNil(request.PreQueueStartTime) {
19702 query["PreQueueStartTime"] = request.PreQueueStartTime
19703 }
19704
19705 if !dara.IsNil(request.QueuingMethod) {
19706 query["QueuingMethod"] = request.QueuingMethod
19707 }
19708
19709 if !dara.IsNil(request.QueuingStatusCode) {
19710 query["QueuingStatusCode"] = request.QueuingStatusCode
19711 }
19712
19713 if !dara.IsNil(request.RandomPreQueueEnable) {
19714 query["RandomPreQueueEnable"] = request.RandomPreQueueEnable
19715 }
19716
19717 if !dara.IsNil(request.SessionDuration) {
19718 query["SessionDuration"] = request.SessionDuration
19719 }
19720
19721 if !dara.IsNil(request.SiteId) {
19722 query["SiteId"] = request.SiteId
19723 }
19724
19725 if !dara.IsNil(request.StartTime) {
19726 query["StartTime"] = request.StartTime
19727 }
19728
19729 if !dara.IsNil(request.TotalActiveUsers) {
19730 query["TotalActiveUsers"] = request.TotalActiveUsers
19731 }
19732
19733 if !dara.IsNil(request.WaitingRoomEventId) {
19734 query["WaitingRoomEventId"] = request.WaitingRoomEventId
19735 }
19736
19737 if !dara.IsNil(request.WaitingRoomType) {
19738 query["WaitingRoomType"] = request.WaitingRoomType
19739 }
19740
19741 req := &openapiutil.OpenApiRequest{
19742 Query: openapiutil.Query(query),
19743 }
19744 params := &openapiutil.Params{
19745 Action: dara.String("UpdateWaitingRoomEvent"),
19746 Version: dara.String("2024-09-10"),
19747 Protocol: dara.String("HTTPS"),
19748 Pathname: dara.String("/"),
19749 Method: dara.String("POST"),
19750 AuthType: dara.String("AK"),
19751 Style: dara.String("RPC"),
19752 ReqBodyType: dara.String("formData"),
19753 BodyType: dara.String("json"),
19754 }
19755 _result = &UpdateWaitingRoomEventResponse{}
19756 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19757 if _err != nil {
19758 return _result, _err
19759 }
19760 _err = dara.Convert(_body, &_result)
19761 return _result, _err
19762 }
19763
19764 // Summary:
19765 //
19766 // # Modify Waiting Room Rule
19767 //
19768 // Description:
19769 //
19770 // This interface allows you to modify the rule settings of a specific waiting room in a site, including the rule name, enable status, and rule content, etc.
19771 //
19772 // @param request - UpdateWaitingRoomRuleRequest
19773 //
19774 // @param runtime - runtime options for this request RuntimeOptions
19775 //
19776 // @return UpdateWaitingRoomRuleResponse
19777 func UpdateWaitingRoomRuleWithContext(ctx context.Context, client *Client, request *UpdateWaitingRoomRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateWaitingRoomRuleResponse, _err error) {
19778 if dara.BoolValue(client.EnableValidate) == true {
19779 _err = request.Validate()
19780 if _err != nil {
19781 return _result, _err
19782 }
19783 }
19784 query := map[string]interface{}{}
19785 if !dara.IsNil(request.Rule) {
19786 query["Rule"] = request.Rule
19787 }
19788
19789 if !dara.IsNil(request.RuleEnable) {
19790 query["RuleEnable"] = request.RuleEnable
19791 }
19792
19793 if !dara.IsNil(request.RuleName) {
19794 query["RuleName"] = request.RuleName
19795 }
19796
19797 if !dara.IsNil(request.SiteId) {
19798 query["SiteId"] = request.SiteId
19799 }
19800
19801 if !dara.IsNil(request.WaitingRoomRuleId) {
19802 query["WaitingRoomRuleId"] = request.WaitingRoomRuleId
19803 }
19804
19805 req := &openapiutil.OpenApiRequest{
19806 Query: openapiutil.Query(query),
19807 }
19808 params := &openapiutil.Params{
19809 Action: dara.String("UpdateWaitingRoomRule"),
19810 Version: dara.String("2024-09-10"),
19811 Protocol: dara.String("HTTPS"),
19812 Pathname: dara.String("/"),
19813 Method: dara.String("POST"),
19814 AuthType: dara.String("AK"),
19815 Style: dara.String("RPC"),
19816 ReqBodyType: dara.String("formData"),
19817 BodyType: dara.String("json"),
19818 }
19819 _result = &UpdateWaitingRoomRuleResponse{}
19820 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19821 if _err != nil {
19822 return _result, _err
19823 }
19824 _err = dara.Convert(_body, &_result)
19825 return _result, _err
19826 }
19827
19828 // Summary:
19829 //
19830 // Uploads a client certificate authority (CA) certificate.
19831 //
19832 // @param request - UploadClientCaCertificateRequest
19833 //
19834 // @param runtime - runtime options for this request RuntimeOptions
19835 //
19836 // @return UploadClientCaCertificateResponse
19837 func UploadClientCaCertificateWithContext(ctx context.Context, client *Client, request *UploadClientCaCertificateRequest, runtime *dara.RuntimeOptions) (_result *UploadClientCaCertificateResponse, _err error) {
19838 if dara.BoolValue(client.EnableValidate) == true {
19839 _err = request.Validate()
19840 if _err != nil {
19841 return _result, _err
19842 }
19843 }
19844 query := map[string]interface{}{}
19845 if !dara.IsNil(request.SiteId) {
19846 query["SiteId"] = request.SiteId
19847 }
19848
19849 body := map[string]interface{}{}
19850 if !dara.IsNil(request.Certificate) {
19851 body["Certificate"] = request.Certificate
19852 }
19853
19854 if !dara.IsNil(request.Name) {
19855 body["Name"] = request.Name
19856 }
19857
19858 req := &openapiutil.OpenApiRequest{
19859 Query: openapiutil.Query(query),
19860 Body: openapiutil.ParseToMap(body),
19861 }
19862 params := &openapiutil.Params{
19863 Action: dara.String("UploadClientCaCertificate"),
19864 Version: dara.String("2024-09-10"),
19865 Protocol: dara.String("HTTPS"),
19866 Pathname: dara.String("/"),
19867 Method: dara.String("POST"),
19868 AuthType: dara.String("AK"),
19869 Style: dara.String("RPC"),
19870 ReqBodyType: dara.String("formData"),
19871 BodyType: dara.String("json"),
19872 }
19873 _result = &UploadClientCaCertificateResponse{}
19874 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19875 if _err != nil {
19876 return _result, _err
19877 }
19878 _err = dara.Convert(_body, &_result)
19879 return _result, _err
19880 }
19881
19882 // Summary:
19883 //
19884 // Uploads the file that contains resources to be purged or prefetched.
19885 //
19886 // Description:
19887 //
19888 // >
19889 //
19890 // - The file can be up to 10 MB in size.
19891 //
19892 // @param request - UploadFileRequest
19893 //
19894 // @param runtime - runtime options for this request RuntimeOptions
19895 //
19896 // @return UploadFileResponse
19897 func UploadFileWithContext(ctx context.Context, client *Client, request *UploadFileRequest, runtime *dara.RuntimeOptions) (_result *UploadFileResponse, _err error) {
19898 if dara.BoolValue(client.EnableValidate) == true {
19899 _err = request.Validate()
19900 if _err != nil {
19901 return _result, _err
19902 }
19903 }
19904 query := map[string]interface{}{}
19905 if !dara.IsNil(request.SiteId) {
19906 query["SiteId"] = request.SiteId
19907 }
19908
19909 if !dara.IsNil(request.Type) {
19910 query["Type"] = request.Type
19911 }
19912
19913 if !dara.IsNil(request.UploadTaskName) {
19914 query["UploadTaskName"] = request.UploadTaskName
19915 }
19916
19917 if !dara.IsNil(request.Url) {
19918 query["Url"] = request.Url
19919 }
19920
19921 req := &openapiutil.OpenApiRequest{
19922 Query: openapiutil.Query(query),
19923 }
19924 params := &openapiutil.Params{
19925 Action: dara.String("UploadFile"),
19926 Version: dara.String("2024-09-10"),
19927 Protocol: dara.String("HTTPS"),
19928 Pathname: dara.String("/"),
19929 Method: dara.String("POST"),
19930 AuthType: dara.String("AK"),
19931 Style: dara.String("RPC"),
19932 ReqBodyType: dara.String("formData"),
19933 BodyType: dara.String("json"),
19934 }
19935 _result = &UploadFileResponse{}
19936 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19937 if _err != nil {
19938 return _result, _err
19939 }
19940 _err = dara.Convert(_body, &_result)
19941 return _result, _err
19942 }
19943
19944 // Summary:
19945 //
19946 // 上传源服务器CA证书
19947 //
19948 // @param request - UploadOriginCaCertificateRequest
19949 //
19950 // @param runtime - runtime options for this request RuntimeOptions
19951 //
19952 // @return UploadOriginCaCertificateResponse
19953 func UploadOriginCaCertificateWithContext(ctx context.Context, client *Client, request *UploadOriginCaCertificateRequest, runtime *dara.RuntimeOptions) (_result *UploadOriginCaCertificateResponse, _err error) {
19954 if dara.BoolValue(client.EnableValidate) == true {
19955 _err = request.Validate()
19956 if _err != nil {
19957 return _result, _err
19958 }
19959 }
19960 body := map[string]interface{}{}
19961 if !dara.IsNil(request.Certificate) {
19962 body["Certificate"] = request.Certificate
19963 }
19964
19965 if !dara.IsNil(request.Name) {
19966 body["Name"] = request.Name
19967 }
19968
19969 if !dara.IsNil(request.SiteId) {
19970 body["SiteId"] = request.SiteId
19971 }
19972
19973 req := &openapiutil.OpenApiRequest{
19974 Body: openapiutil.ParseToMap(body),
19975 }
19976 params := &openapiutil.Params{
19977 Action: dara.String("UploadOriginCaCertificate"),
19978 Version: dara.String("2024-09-10"),
19979 Protocol: dara.String("HTTPS"),
19980 Pathname: dara.String("/"),
19981 Method: dara.String("POST"),
19982 AuthType: dara.String("AK"),
19983 Style: dara.String("RPC"),
19984 ReqBodyType: dara.String("formData"),
19985 BodyType: dara.String("json"),
19986 }
19987 _result = &UploadOriginCaCertificateResponse{}
19988 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
19989 if _err != nil {
19990 return _result, _err
19991 }
19992 _err = dara.Convert(_body, &_result)
19993 return _result, _err
19994 }
19995
19996 // Summary:
19997 //
19998 // 上传域名回源客户端证书
19999 //
20000 // @param request - UploadOriginClientCertificateRequest
20001 //
20002 // @param runtime - runtime options for this request RuntimeOptions
20003 //
20004 // @return UploadOriginClientCertificateResponse
20005 func UploadOriginClientCertificateWithContext(ctx context.Context, client *Client, request *UploadOriginClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *UploadOriginClientCertificateResponse, _err error) {
20006 if dara.BoolValue(client.EnableValidate) == true {
20007 _err = request.Validate()
20008 if _err != nil {
20009 return _result, _err
20010 }
20011 }
20012 query := map[string]interface{}{}
20013 if !dara.IsNil(request.SiteId) {
20014 query["SiteId"] = request.SiteId
20015 }
20016
20017 body := map[string]interface{}{}
20018 if !dara.IsNil(request.Certificate) {
20019 body["Certificate"] = request.Certificate
20020 }
20021
20022 if !dara.IsNil(request.Name) {
20023 body["Name"] = request.Name
20024 }
20025
20026 if !dara.IsNil(request.PrivateKey) {
20027 body["PrivateKey"] = request.PrivateKey
20028 }
20029
20030 req := &openapiutil.OpenApiRequest{
20031 Query: openapiutil.Query(query),
20032 Body: openapiutil.ParseToMap(body),
20033 }
20034 params := &openapiutil.Params{
20035 Action: dara.String("UploadOriginClientCertificate"),
20036 Version: dara.String("2024-09-10"),
20037 Protocol: dara.String("HTTPS"),
20038 Pathname: dara.String("/"),
20039 Method: dara.String("POST"),
20040 AuthType: dara.String("AK"),
20041 Style: dara.String("RPC"),
20042 ReqBodyType: dara.String("formData"),
20043 BodyType: dara.String("json"),
20044 }
20045 _result = &UploadOriginClientCertificateResponse{}
20046 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
20047 if _err != nil {
20048 return _result, _err
20049 }
20050 _err = dara.Convert(_body, &_result)
20051 return _result, _err
20052 }
20053
20054 // Summary:
20055 //
20056 // # Upload site origin client certificate
20057 //
20058 // @param request - UploadSiteOriginClientCertificateRequest
20059 //
20060 // @param runtime - runtime options for this request RuntimeOptions
20061 //
20062 // @return UploadSiteOriginClientCertificateResponse
20063 func UploadSiteOriginClientCertificateWithContext(ctx context.Context, client *Client, request *UploadSiteOriginClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *UploadSiteOriginClientCertificateResponse, _err error) {
20064 if dara.BoolValue(client.EnableValidate) == true {
20065 _err = request.Validate()
20066 if _err != nil {
20067 return _result, _err
20068 }
20069 }
20070 query := map[string]interface{}{}
20071 if !dara.IsNil(request.SiteId) {
20072 query["SiteId"] = request.SiteId
20073 }
20074
20075 body := map[string]interface{}{}
20076 if !dara.IsNil(request.Certificate) {
20077 body["Certificate"] = request.Certificate
20078 }
20079
20080 if !dara.IsNil(request.Name) {
20081 body["Name"] = request.Name
20082 }
20083
20084 if !dara.IsNil(request.PrivateKey) {
20085 body["PrivateKey"] = request.PrivateKey
20086 }
20087
20088 req := &openapiutil.OpenApiRequest{
20089 Query: openapiutil.Query(query),
20090 Body: openapiutil.ParseToMap(body),
20091 }
20092 params := &openapiutil.Params{
20093 Action: dara.String("UploadSiteOriginClientCertificate"),
20094 Version: dara.String("2024-09-10"),
20095 Protocol: dara.String("HTTPS"),
20096 Pathname: dara.String("/"),
20097 Method: dara.String("POST"),
20098 AuthType: dara.String("AK"),
20099 Style: dara.String("RPC"),
20100 ReqBodyType: dara.String("formData"),
20101 BodyType: dara.String("json"),
20102 }
20103 _result = &UploadSiteOriginClientCertificateResponse{}
20104 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
20105 if _err != nil {
20106 return _result, _err
20107 }
20108 _err = dara.Convert(_body, &_result)
20109 return _result, _err
20110 }
20111
20112 // Summary:
20113 //
20114 // Verifies the ownership of a website domain. Websites that pass the verification are automatically activated.
20115 //
20116 // Description:
20117 //
20118 // 1. For a website connected by using NS setup, this operation verifies whether the nameservers of the website are the nameservers assigned by Alibaba Cloud.
20119 //
20120 // 2. For a website connected by using CNAME setup, this operation verifies whether the website has a TXT record whose hostname is _esaauth.[websiteDomainName] and record value is the value of VerifyCode to the DNS records of your domain. You can see the VerifyCode field in the site information.
20121 //
20122 // @param request - VerifySiteRequest
20123 //
20124 // @param runtime - runtime options for this request RuntimeOptions
20125 //
20126 // @return VerifySiteResponse
20127 func VerifySiteWithContext(ctx context.Context, client *Client, request *VerifySiteRequest, runtime *dara.RuntimeOptions) (_result *VerifySiteResponse, _err error) {
20128 if dara.BoolValue(client.EnableValidate) == true {
20129 _err = request.Validate()
20130 if _err != nil {
20131 return _result, _err
20132 }
20133 }
20134 query := map[string]interface{}{}
20135 if !dara.IsNil(request.SiteId) {
20136 query["SiteId"] = request.SiteId
20137 }
20138
20139 req := &openapiutil.OpenApiRequest{
20140 Query: openapiutil.Query(query),
20141 }
20142 params := &openapiutil.Params{
20143 Action: dara.String("VerifySite"),
20144 Version: dara.String("2024-09-10"),
20145 Protocol: dara.String("HTTPS"),
20146 Pathname: dara.String("/"),
20147 Method: dara.String("POST"),
20148 AuthType: dara.String("AK"),
20149 Style: dara.String("RPC"),
20150 ReqBodyType: dara.String("formData"),
20151 BodyType: dara.String("json"),
20152 }
20153 _result = &VerifySiteResponse{}
20154 _body, _err := client.CallApiWithCtx(ctx, params, req, runtime)
20155 if _err != nil {
20156 return _result, _err
20157 }
20158 _err = dara.Convert(_body, &_result)
20159 return _result, _err
20160 }
20161