modifiedclient.go raw
1 // This file is auto-generated, don't edit it. Thanks.
2 package client
3
4 import (
5 openapi "github.com/alibabacloud-go/darabonba-openapi/v2/client"
6 openapiutil "github.com/alibabacloud-go/darabonba-openapi/v2/utils"
7 "github.com/alibabacloud-go/tea/dara"
8 )
9
10 type Client struct {
11 openapi.Client
12 DisableSDKError *bool
13 EnableValidate *bool
14 }
15
16 func NewClient(config *openapiutil.Config) (*Client, error) {
17 client := new(Client)
18 err := client.Init(config)
19 return client, err
20 }
21
22 func (client *Client) Init(config *openapiutil.Config) (_err error) {
23 _err = client.Client.Init(config)
24 if _err != nil {
25 return _err
26 }
27 client.EndpointRule = dara.String("")
28 _err = client.CheckConfig(config)
29 if _err != nil {
30 return _err
31 }
32 client.Endpoint, _err = GetEndpoint(client,dara.String("esa"), client.RegionId, client.EndpointRule, client.Network, client.Suffix, client.EndpointMap, client.Endpoint)
33 if _err != nil {
34 return _err
35 }
36
37 return nil
38 }
39
40 func _postOSSObject(client *Client, bucketName *string, form map[string]interface{}, runtime *dara.RuntimeOptions) (_result map[string]interface{}, _err error) {
41 _runtime := dara.NewRuntimeObject(map[string]interface{}{
42 "key": dara.ToString(dara.Default(dara.StringValue(runtime.Key), dara.StringValue(client.Key))),
43 "cert": dara.ToString(dara.Default(dara.StringValue(runtime.Cert), dara.StringValue(client.Cert))),
44 "ca": dara.ToString(dara.Default(dara.StringValue(runtime.Ca), dara.StringValue(client.Ca))),
45 "readTimeout": dara.ForceInt(dara.Default(dara.IntValue(runtime.ReadTimeout), dara.IntValue(client.ReadTimeout))),
46 "connectTimeout": dara.ForceInt(dara.Default(dara.IntValue(runtime.ConnectTimeout), dara.IntValue(client.ConnectTimeout))),
47 "httpProxy": dara.ToString(dara.Default(dara.StringValue(runtime.HttpProxy), dara.StringValue(client.HttpProxy))),
48 "httpsProxy": dara.ToString(dara.Default(dara.StringValue(runtime.HttpsProxy), dara.StringValue(client.HttpsProxy))),
49 "noProxy": dara.ToString(dara.Default(dara.StringValue(runtime.NoProxy), dara.StringValue(client.NoProxy))),
50 "socks5Proxy": dara.ToString(dara.Default(dara.StringValue(runtime.Socks5Proxy), dara.StringValue(client.Socks5Proxy))),
51 "socks5NetWork": dara.ToString(dara.Default(dara.StringValue(runtime.Socks5NetWork), dara.StringValue(client.Socks5NetWork))),
52 "maxIdleConns": dara.ForceInt(dara.Default(dara.IntValue(runtime.MaxIdleConns), dara.IntValue(client.MaxIdleConns))),
53 "retryOptions": client.RetryOptions,
54 "ignoreSSL": dara.ForceBoolean(dara.Default(dara.BoolValue(runtime.IgnoreSSL), false)),
55 "tlsMinVersion": dara.StringValue(client.TlsMinVersion),
56 })
57
58 var retryPolicyContext *dara.RetryPolicyContext
59 var request_ *dara.Request
60 var response_ *dara.Response
61 var _resultErr error
62 retriesAttempted := int(0)
63 retryPolicyContext = &dara.RetryPolicyContext{
64 RetriesAttempted: retriesAttempted,
65 }
66
67 _result = make(map[string]interface{})
68 for dara.ShouldRetry(_runtime.RetryOptions, retryPolicyContext) {
69 _resultErr = nil
70 _backoffDelayTime := dara.GetBackoffDelay(_runtime.RetryOptions, retryPolicyContext)
71 dara.Sleep(_backoffDelayTime)
72
73 request_ = dara.NewRequest()
74 boundary := dara.GetBoundary()
75 request_.Protocol = dara.String("HTTPS")
76 request_.Method = dara.String("POST")
77 request_.Pathname = dara.String("/")
78 request_.Headers = map[string]*string{
79 "host": dara.String(dara.ToString(form["host"])),
80 "date": openapiutil.GetDateUTCString(),
81 "user-agent": openapiutil.GetUserAgent(dara.String("")),
82 }
83 request_.Headers["content-type"] = dara.String("multipart/form-data; boundary=" + boundary)
84 request_.Body = dara.ToFileForm(form, boundary)
85 response_, _err = dara.DoRequest(request_, _runtime)
86 if _err != nil {
87 retriesAttempted++
88 retryPolicyContext = &dara.RetryPolicyContext{
89 RetriesAttempted: retriesAttempted,
90 HttpRequest: request_,
91 HttpResponse: response_,
92 Exception: _err,
93 }
94 _resultErr = _err
95 continue
96 }
97
98 _result, _err = _postOSSObject_opResponse(response_)
99 if _err != nil {
100 retriesAttempted++
101 retryPolicyContext = &dara.RetryPolicyContext{
102 RetriesAttempted: retriesAttempted,
103 HttpRequest: request_,
104 HttpResponse: response_,
105 Exception: _err,
106 }
107 _resultErr = _err
108 continue
109 }
110
111 return _result, _err
112 }
113 if dara.BoolValue(client.DisableSDKError) != true {
114 _resultErr = dara.TeaSDKError(_resultErr)
115 }
116 return _result, _resultErr
117 }
118
119 func GetEndpoint(client *Client, productId *string, regionId *string, endpointRule *string, network *string, suffix *string, endpointMap map[string]*string, endpoint *string) (_result *string, _err error) {
120 if !dara.IsNil(endpoint) {
121 _result = endpoint
122 return _result, _err
123 }
124
125 if !dara.IsNil(endpointMap) && !dara.IsNil(endpointMap[dara.StringValue(regionId)]) {
126 _result = endpointMap[dara.StringValue(regionId)]
127 return _result, _err
128 }
129
130 _body, _err := openapiutil.GetEndpointRules(productId, regionId, endpointRule, network, suffix)
131 if _err != nil {
132 return _result, _err
133 }
134 _result = _body
135 return _result, _err
136 }
137
138 // Summary:
139 //
140 // Activates the client based on the certificate ID.
141 //
142 // @param request - ActivateClientCertificateRequest
143 //
144 // @param runtime - runtime options for this request RuntimeOptions
145 //
146 // @return ActivateClientCertificateResponse
147 func ActivateClientCertificateWithOptions(client *Client, request *ActivateClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *ActivateClientCertificateResponse, _err error) {
148 if dara.BoolValue(client.EnableValidate) == true {
149 _err = request.Validate()
150 if _err != nil {
151 return _result, _err
152 }
153 }
154 query := openapiutil.Query(dara.ToMap(request))
155 req := &openapiutil.OpenApiRequest{
156 Query: openapiutil.Query(query),
157 }
158 params := &openapiutil.Params{
159 Action: dara.String("ActivateClientCertificate"),
160 Version: dara.String("2024-09-10"),
161 Protocol: dara.String("HTTPS"),
162 Pathname: dara.String("/"),
163 Method: dara.String("GET"),
164 AuthType: dara.String("AK"),
165 Style: dara.String("RPC"),
166 ReqBodyType: dara.String("formData"),
167 BodyType: dara.String("json"),
168 }
169 _result = &ActivateClientCertificateResponse{}
170 _body, _err := client.CallApi(params, req, runtime)
171 if _err != nil {
172 return _result, _err
173 }
174 _err = dara.Convert(_body, &_result)
175 return _result, _err
176 }
177
178 // Summary:
179 //
180 // Activates the client based on the certificate ID.
181 //
182 // @param request - ActivateClientCertificateRequest
183 //
184 // @return ActivateClientCertificateResponse
185 func ActivateClientCertificate(client *Client, request *ActivateClientCertificateRequest) (_result *ActivateClientCertificateResponse, _err error) {
186 runtime := &dara.RuntimeOptions{}
187 _result = &ActivateClientCertificateResponse{}
188 _body, _err := ActivateClientCertificateWithOptions(client,request, runtime)
189 if _err != nil {
190 return _result, _err
191 }
192 _result = _body
193 return _result, _err
194 }
195
196 // Summary:
197 //
198 // # Enable Version Management
199 //
200 // @param request - ActivateVersionManagementRequest
201 //
202 // @param runtime - runtime options for this request RuntimeOptions
203 //
204 // @return ActivateVersionManagementResponse
205 func ActivateVersionManagementWithOptions(client *Client, request *ActivateVersionManagementRequest, runtime *dara.RuntimeOptions) (_result *ActivateVersionManagementResponse, _err error) {
206 if dara.BoolValue(client.EnableValidate) == true {
207 _err = request.Validate()
208 if _err != nil {
209 return _result, _err
210 }
211 }
212 query := map[string]interface{}{}
213 if !dara.IsNil(request.SiteId) {
214 query["SiteId"] = request.SiteId
215 }
216
217 req := &openapiutil.OpenApiRequest{
218 Query: openapiutil.Query(query),
219 }
220 params := &openapiutil.Params{
221 Action: dara.String("ActivateVersionManagement"),
222 Version: dara.String("2024-09-10"),
223 Protocol: dara.String("HTTPS"),
224 Pathname: dara.String("/"),
225 Method: dara.String("POST"),
226 AuthType: dara.String("AK"),
227 Style: dara.String("RPC"),
228 ReqBodyType: dara.String("formData"),
229 BodyType: dara.String("json"),
230 }
231 _result = &ActivateVersionManagementResponse{}
232 _body, _err := client.CallApi(params, req, runtime)
233 if _err != nil {
234 return _result, _err
235 }
236 _err = dara.Convert(_body, &_result)
237 return _result, _err
238 }
239
240 // Summary:
241 //
242 // # Enable Version Management
243 //
244 // @param request - ActivateVersionManagementRequest
245 //
246 // @return ActivateVersionManagementResponse
247 func ActivateVersionManagement(client *Client, request *ActivateVersionManagementRequest) (_result *ActivateVersionManagementResponse, _err error) {
248 runtime := &dara.RuntimeOptions{}
249 _result = &ActivateVersionManagementResponse{}
250 _body, _err := ActivateVersionManagementWithOptions(client,request, runtime)
251 if _err != nil {
252 return _result, _err
253 }
254 _result = _body
255 return _result, _err
256 }
257
258 // Summary:
259 //
260 // Applies for a free SSL certificate.
261 //
262 // @param request - ApplyCertificateRequest
263 //
264 // @param runtime - runtime options for this request RuntimeOptions
265 //
266 // @return ApplyCertificateResponse
267 func ApplyCertificateWithOptions(client *Client, request *ApplyCertificateRequest, runtime *dara.RuntimeOptions) (_result *ApplyCertificateResponse, _err error) {
268 if dara.BoolValue(client.EnableValidate) == true {
269 _err = request.Validate()
270 if _err != nil {
271 return _result, _err
272 }
273 }
274 query := openapiutil.Query(dara.ToMap(request))
275 req := &openapiutil.OpenApiRequest{
276 Query: openapiutil.Query(query),
277 }
278 params := &openapiutil.Params{
279 Action: dara.String("ApplyCertificate"),
280 Version: dara.String("2024-09-10"),
281 Protocol: dara.String("HTTPS"),
282 Pathname: dara.String("/"),
283 Method: dara.String("GET"),
284 AuthType: dara.String("AK"),
285 Style: dara.String("RPC"),
286 ReqBodyType: dara.String("formData"),
287 BodyType: dara.String("json"),
288 }
289 _result = &ApplyCertificateResponse{}
290 _body, _err := client.CallApi(params, req, runtime)
291 if _err != nil {
292 return _result, _err
293 }
294 _err = dara.Convert(_body, &_result)
295 return _result, _err
296 }
297
298 // Summary:
299 //
300 // Applies for a free SSL certificate.
301 //
302 // @param request - ApplyCertificateRequest
303 //
304 // @return ApplyCertificateResponse
305 func ApplyCertificate(client *Client, request *ApplyCertificateRequest) (_result *ApplyCertificateResponse, _err error) {
306 runtime := &dara.RuntimeOptions{}
307 _result = &ApplyCertificateResponse{}
308 _body, _err := ApplyCertificateWithOptions(client,request, runtime)
309 if _err != nil {
310 return _result, _err
311 }
312 _result = _body
313 return _result, _err
314 }
315
316 // Summary:
317 //
318 // Adds DNS records of different record types at a time..
319 //
320 // Description:
321 //
322 // 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.
323 //
324 // Successful and failed records along with error messages are listed in the response.
325 //
326 // @param tmpReq - BatchCreateRecordsRequest
327 //
328 // @param runtime - runtime options for this request RuntimeOptions
329 //
330 // @return BatchCreateRecordsResponse
331 func BatchCreateRecordsWithOptions(client *Client, tmpReq *BatchCreateRecordsRequest, runtime *dara.RuntimeOptions) (_result *BatchCreateRecordsResponse, _err error) {
332 if dara.BoolValue(client.EnableValidate) == true {
333 _err = tmpReq.Validate()
334 if _err != nil {
335 return _result, _err
336 }
337 }
338 request := &BatchCreateRecordsShrinkRequest{}
339 openapiutil.Convert(tmpReq, request)
340 if !dara.IsNil(tmpReq.RecordList) {
341 request.RecordListShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RecordList, dara.String("RecordList"), dara.String("json"))
342 }
343
344 query := map[string]interface{}{}
345 if !dara.IsNil(request.RecordListShrink) {
346 query["RecordList"] = request.RecordListShrink
347 }
348
349 if !dara.IsNil(request.SiteId) {
350 query["SiteId"] = request.SiteId
351 }
352
353 req := &openapiutil.OpenApiRequest{
354 Query: openapiutil.Query(query),
355 }
356 params := &openapiutil.Params{
357 Action: dara.String("BatchCreateRecords"),
358 Version: dara.String("2024-09-10"),
359 Protocol: dara.String("HTTPS"),
360 Pathname: dara.String("/"),
361 Method: dara.String("POST"),
362 AuthType: dara.String("AK"),
363 Style: dara.String("RPC"),
364 ReqBodyType: dara.String("formData"),
365 BodyType: dara.String("json"),
366 }
367 _result = &BatchCreateRecordsResponse{}
368 _body, _err := client.CallApi(params, req, runtime)
369 if _err != nil {
370 return _result, _err
371 }
372 _err = dara.Convert(_body, &_result)
373 return _result, _err
374 }
375
376 // Summary:
377 //
378 // Adds DNS records of different record types at a time..
379 //
380 // Description:
381 //
382 // 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.
383 //
384 // Successful and failed records along with error messages are listed in the response.
385 //
386 // @param request - BatchCreateRecordsRequest
387 //
388 // @return BatchCreateRecordsResponse
389 func BatchCreateRecords(client *Client, request *BatchCreateRecordsRequest) (_result *BatchCreateRecordsResponse, _err error) {
390 runtime := &dara.RuntimeOptions{}
391 _result = &BatchCreateRecordsResponse{}
392 _body, _err := BatchCreateRecordsWithOptions(client,request, runtime)
393 if _err != nil {
394 return _result, _err
395 }
396 _result = _body
397 return _result, _err
398 }
399
400 // Summary:
401 //
402 // # Batch Create WAF Rules
403 //
404 // @param tmpReq - BatchCreateWafRulesRequest
405 //
406 // @param runtime - runtime options for this request RuntimeOptions
407 //
408 // @return BatchCreateWafRulesResponse
409 func BatchCreateWafRulesWithOptions(client *Client, tmpReq *BatchCreateWafRulesRequest, runtime *dara.RuntimeOptions) (_result *BatchCreateWafRulesResponse, _err error) {
410 if dara.BoolValue(client.EnableValidate) == true {
411 _err = tmpReq.Validate()
412 if _err != nil {
413 return _result, _err
414 }
415 }
416 request := &BatchCreateWafRulesShrinkRequest{}
417 openapiutil.Convert(tmpReq, request)
418 if !dara.IsNil(tmpReq.Configs) {
419 request.ConfigsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Configs, dara.String("Configs"), dara.String("json"))
420 }
421
422 if !dara.IsNil(tmpReq.Shared) {
423 request.SharedShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Shared, dara.String("Shared"), dara.String("json"))
424 }
425
426 query := map[string]interface{}{}
427 if !dara.IsNil(request.SiteId) {
428 query["SiteId"] = request.SiteId
429 }
430
431 if !dara.IsNil(request.SiteVersion) {
432 query["SiteVersion"] = request.SiteVersion
433 }
434
435 body := map[string]interface{}{}
436 if !dara.IsNil(request.ConfigsShrink) {
437 body["Configs"] = request.ConfigsShrink
438 }
439
440 if !dara.IsNil(request.Phase) {
441 body["Phase"] = request.Phase
442 }
443
444 if !dara.IsNil(request.RulesetId) {
445 body["RulesetId"] = request.RulesetId
446 }
447
448 if !dara.IsNil(request.SharedShrink) {
449 body["Shared"] = request.SharedShrink
450 }
451
452 req := &openapiutil.OpenApiRequest{
453 Query: openapiutil.Query(query),
454 Body: openapiutil.ParseToMap(body),
455 }
456 params := &openapiutil.Params{
457 Action: dara.String("BatchCreateWafRules"),
458 Version: dara.String("2024-09-10"),
459 Protocol: dara.String("HTTPS"),
460 Pathname: dara.String("/"),
461 Method: dara.String("POST"),
462 AuthType: dara.String("AK"),
463 Style: dara.String("RPC"),
464 ReqBodyType: dara.String("formData"),
465 BodyType: dara.String("json"),
466 }
467 _result = &BatchCreateWafRulesResponse{}
468 _body, _err := client.CallApi(params, req, runtime)
469 if _err != nil {
470 return _result, _err
471 }
472 _err = dara.Convert(_body, &_result)
473 return _result, _err
474 }
475
476 // Summary:
477 //
478 // # Batch Create WAF Rules
479 //
480 // @param request - BatchCreateWafRulesRequest
481 //
482 // @return BatchCreateWafRulesResponse
483 func BatchCreateWafRules(client *Client, request *BatchCreateWafRulesRequest) (_result *BatchCreateWafRulesResponse, _err error) {
484 runtime := &dara.RuntimeOptions{}
485 _result = &BatchCreateWafRulesResponse{}
486 _body, _err := BatchCreateWafRulesWithOptions(client,request, runtime)
487 if _err != nil {
488 return _result, _err
489 }
490 _result = _body
491 return _result, _err
492 }
493
494 // Summary:
495 //
496 // Deletes key-value pairs from a namespace at a time based on keys.
497 //
498 // @param tmpReq - BatchDeleteKvRequest
499 //
500 // @param runtime - runtime options for this request RuntimeOptions
501 //
502 // @return BatchDeleteKvResponse
503 func BatchDeleteKvWithOptions(client *Client, tmpReq *BatchDeleteKvRequest, runtime *dara.RuntimeOptions) (_result *BatchDeleteKvResponse, _err error) {
504 if dara.BoolValue(client.EnableValidate) == true {
505 _err = tmpReq.Validate()
506 if _err != nil {
507 return _result, _err
508 }
509 }
510 request := &BatchDeleteKvShrinkRequest{}
511 openapiutil.Convert(tmpReq, request)
512 if !dara.IsNil(tmpReq.Keys) {
513 request.KeysShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Keys, dara.String("Keys"), dara.String("json"))
514 }
515
516 query := map[string]interface{}{}
517 if !dara.IsNil(request.Namespace) {
518 query["Namespace"] = request.Namespace
519 }
520
521 body := map[string]interface{}{}
522 if !dara.IsNil(request.KeysShrink) {
523 body["Keys"] = request.KeysShrink
524 }
525
526 req := &openapiutil.OpenApiRequest{
527 Query: openapiutil.Query(query),
528 Body: openapiutil.ParseToMap(body),
529 }
530 params := &openapiutil.Params{
531 Action: dara.String("BatchDeleteKv"),
532 Version: dara.String("2024-09-10"),
533 Protocol: dara.String("HTTPS"),
534 Pathname: dara.String("/"),
535 Method: dara.String("POST"),
536 AuthType: dara.String("AK"),
537 Style: dara.String("RPC"),
538 ReqBodyType: dara.String("formData"),
539 BodyType: dara.String("json"),
540 }
541 _result = &BatchDeleteKvResponse{}
542 _body, _err := client.CallApi(params, req, runtime)
543 if _err != nil {
544 return _result, _err
545 }
546 _err = dara.Convert(_body, &_result)
547 return _result, _err
548 }
549
550 // Summary:
551 //
552 // Deletes key-value pairs from a namespace at a time based on keys.
553 //
554 // @param request - BatchDeleteKvRequest
555 //
556 // @return BatchDeleteKvResponse
557 func BatchDeleteKv(client *Client, request *BatchDeleteKvRequest) (_result *BatchDeleteKvResponse, _err error) {
558 runtime := &dara.RuntimeOptions{}
559 _result = &BatchDeleteKvResponse{}
560 _body, _err := BatchDeleteKvWithOptions(client,request, runtime)
561 if _err != nil {
562 return _result, _err
563 }
564 _result = _body
565 return _result, _err
566 }
567
568 // Summary:
569 //
570 // Deletes multiple key-value pairs from a namespace at a time based on specified keys. The request body can be up to 100 MB.
571 //
572 // Description:
573 //
574 // 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.
575 //
576 // func TestBatchDeleteWithHighCapacity() error {
577 //
578 // // Initialize the configurations.
579 //
580 // cfg := new(openapi.Config)
581 //
582 // cfg.SetAccessKeyId("xxxxxxxxx")
583 //
584 // cfg.SetAccessKeySecret("xxxxxxxxxx")
585 //
586 // cli, err := NewClient(cfg)
587 //
588 // if err != nil {
589 //
590 // return err
591 //
592 // }
593 //
594 // runtime := &util.RuntimeOptions{}
595 //
596 // // Construct a request for deleting key-value pairs at a time.
597 //
598 // namespace := "test_batch_put"
599 //
600 // rawReq := BatchDeleteKvRequest{
601 //
602 // Namespace: &namespace,
603 //
604 // }
605 //
606 // for i := 0; i < 10000; i++ {
607 //
608 // key := fmt.Sprintf("test_key_%d", i)
609 //
610 // rawReq.Keys = append(rawReq.Keys, &key)
611 //
612 // }
613 //
614 // payload, err := json.Marshal(rawReq)
615 //
616 // if err != nil {
617 //
618 // return err
619 //
620 // }
621 //
622 // // If the payload is greater than 2 MB, call the BatchDeleteKvWithHighCapacity operation for deletion.
623 //
624 // reqHighCapacity := BatchDeleteKvWithHighCapacityAdvanceRequest{
625 //
626 // Namespace: &namespace,
627 //
628 // UrlObject: bytes.NewReader(payload),
629 //
630 // }
631 //
632 // resp, err := cli.BatchDeleteKvWithHighCapacityAdvance(&reqHighCapacity, runtime)
633 //
634 // if err != nil {
635 //
636 // return err
637 //
638 // }
639 //
640 // return nil
641 //
642 // }
643 //
644 // @param request - BatchDeleteKvWithHighCapacityRequest
645 //
646 // @param runtime - runtime options for this request RuntimeOptions
647 //
648 // @return BatchDeleteKvWithHighCapacityResponse
649 func BatchDeleteKvWithHighCapacityWithOptions(client *Client, request *BatchDeleteKvWithHighCapacityRequest, runtime *dara.RuntimeOptions) (_result *BatchDeleteKvWithHighCapacityResponse, _err error) {
650 if dara.BoolValue(client.EnableValidate) == true {
651 _err = request.Validate()
652 if _err != nil {
653 return _result, _err
654 }
655 }
656 query := map[string]interface{}{}
657 if !dara.IsNil(request.Namespace) {
658 query["Namespace"] = request.Namespace
659 }
660
661 if !dara.IsNil(request.Url) {
662 query["Url"] = request.Url
663 }
664
665 req := &openapiutil.OpenApiRequest{
666 Query: openapiutil.Query(query),
667 }
668 params := &openapiutil.Params{
669 Action: dara.String("BatchDeleteKvWithHighCapacity"),
670 Version: dara.String("2024-09-10"),
671 Protocol: dara.String("HTTPS"),
672 Pathname: dara.String("/"),
673 Method: dara.String("POST"),
674 AuthType: dara.String("AK"),
675 Style: dara.String("RPC"),
676 ReqBodyType: dara.String("formData"),
677 BodyType: dara.String("json"),
678 }
679 _result = &BatchDeleteKvWithHighCapacityResponse{}
680 _body, _err := client.CallApi(params, req, runtime)
681 if _err != nil {
682 return _result, _err
683 }
684 _err = dara.Convert(_body, &_result)
685 return _result, _err
686 }
687
688 // Summary:
689 //
690 // Deletes multiple key-value pairs from a namespace at a time based on specified keys. The request body can be up to 100 MB.
691 //
692 // Description:
693 //
694 // 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.
695 //
696 // func TestBatchDeleteWithHighCapacity() error {
697 //
698 // // Initialize the configurations.
699 //
700 // cfg := new(openapi.Config)
701 //
702 // cfg.SetAccessKeyId("xxxxxxxxx")
703 //
704 // cfg.SetAccessKeySecret("xxxxxxxxxx")
705 //
706 // cli, err := NewClient(cfg)
707 //
708 // if err != nil {
709 //
710 // return err
711 //
712 // }
713 //
714 // runtime := &util.RuntimeOptions{}
715 //
716 // // Construct a request for deleting key-value pairs at a time.
717 //
718 // namespace := "test_batch_put"
719 //
720 // rawReq := BatchDeleteKvRequest{
721 //
722 // Namespace: &namespace,
723 //
724 // }
725 //
726 // for i := 0; i < 10000; i++ {
727 //
728 // key := fmt.Sprintf("test_key_%d", i)
729 //
730 // rawReq.Keys = append(rawReq.Keys, &key)
731 //
732 // }
733 //
734 // payload, err := json.Marshal(rawReq)
735 //
736 // if err != nil {
737 //
738 // return err
739 //
740 // }
741 //
742 // // If the payload is greater than 2 MB, call the BatchDeleteKvWithHighCapacity operation for deletion.
743 //
744 // reqHighCapacity := BatchDeleteKvWithHighCapacityAdvanceRequest{
745 //
746 // Namespace: &namespace,
747 //
748 // UrlObject: bytes.NewReader(payload),
749 //
750 // }
751 //
752 // resp, err := cli.BatchDeleteKvWithHighCapacityAdvance(&reqHighCapacity, runtime)
753 //
754 // if err != nil {
755 //
756 // return err
757 //
758 // }
759 //
760 // return nil
761 //
762 // }
763 //
764 // @param request - BatchDeleteKvWithHighCapacityRequest
765 //
766 // @return BatchDeleteKvWithHighCapacityResponse
767 func BatchDeleteKvWithHighCapacity(client *Client, request *BatchDeleteKvWithHighCapacityRequest) (_result *BatchDeleteKvWithHighCapacityResponse, _err error) {
768 runtime := &dara.RuntimeOptions{}
769 _result = &BatchDeleteKvWithHighCapacityResponse{}
770 _body, _err := BatchDeleteKvWithHighCapacityWithOptions(client,request, runtime)
771 if _err != nil {
772 return _result, _err
773 }
774 _result = _body
775 return _result, _err
776 }
777
778 func BatchDeleteKvWithHighCapacityAdvance(client *Client, request *BatchDeleteKvWithHighCapacityAdvanceRequest, runtime *dara.RuntimeOptions) (_result *BatchDeleteKvWithHighCapacityResponse, _err error) {
779 // Step 0: init client
780 if dara.IsNil(client.Credential) {
781 _err = &openapi.ClientError{
782 Code: dara.String("InvalidCredentials"),
783 Message: dara.String("Please set up the credentials correctly. If you are setting them through environment variables, please ensure that ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set correctly. See https://help.aliyun.com/zh/sdk/developer-reference/configure-the-alibaba-cloud-accesskey-environment-variable-on-linux-macos-and-windows-systems for more details."),
784 }
785 return _result, _err
786 }
787
788 credentialModel, _err := client.Credential.GetCredential()
789 if _err != nil {
790 return _result, _err
791 }
792
793 accessKeyId := dara.StringValue(credentialModel.AccessKeyId)
794 accessKeySecret := dara.StringValue(credentialModel.AccessKeySecret)
795 securityToken := dara.StringValue(credentialModel.SecurityToken)
796 credentialType := dara.StringValue(credentialModel.Type)
797 openPlatformEndpoint := dara.StringValue(client.OpenPlatformEndpoint)
798 if dara.IsNil(dara.String(openPlatformEndpoint)) || openPlatformEndpoint == "" {
799 openPlatformEndpoint = "openplatform.aliyuncs.com"
800 }
801
802 if dara.IsNil(dara.String(credentialType)) {
803 credentialType = "access_key"
804 }
805
806 authConfig := &openapiutil.Config{
807 AccessKeyId: dara.String(accessKeyId),
808 AccessKeySecret: dara.String(accessKeySecret),
809 SecurityToken: dara.String(securityToken),
810 Type: dara.String(credentialType),
811 Endpoint: dara.String(openPlatformEndpoint),
812 Protocol: client.Protocol,
813 RegionId: client.RegionId,
814 }
815 authClient, _err := openapi.NewClient(authConfig)
816 if _err != nil {
817 return _result, _err
818 }
819
820 authRequest := map[string]*string{
821 "Product": dara.String("ESA"),
822 "RegionId": client.RegionId,
823 }
824 authReq := &openapiutil.OpenApiRequest{
825 Query: openapiutil.Query(authRequest),
826 }
827 authParams := &openapiutil.Params{
828 Action: dara.String("AuthorizeFileUpload"),
829 Version: dara.String("2019-12-19"),
830 Protocol: dara.String("HTTPS"),
831 Pathname: dara.String("/"),
832 Method: dara.String("GET"),
833 AuthType: dara.String("AK"),
834 Style: dara.String("RPC"),
835 ReqBodyType: dara.String("formData"),
836 BodyType: dara.String("json"),
837 }
838 authResponse := map[string]interface{}{}
839 fileObj := &dara.FileField{}
840 ossHeader := map[string]interface{}{}
841 tmpBody := map[string]interface{}{}
842 useAccelerate := false
843 authResponseBody := make(map[string]*string)
844 batchDeleteKvWithHighCapacityReq := &BatchDeleteKvWithHighCapacityRequest{}
845 openapiutil.Convert(request, batchDeleteKvWithHighCapacityReq)
846 if !dara.IsNil(request.UrlObject) {
847 authResponse, _err = authClient.CallApi(authParams, authReq, runtime)
848 if _err != nil {
849 return _result, _err
850 }
851
852 tmpBody = dara.ToMap(authResponse["body"])
853 useAccelerate = dara.ForceBoolean(tmpBody["UseAccelerate"])
854 authResponseBody = openapiutil.StringifyMapValue(tmpBody)
855 fileObj = &dara.FileField{
856 Filename: authResponseBody["ObjectKey"],
857 Content: request.UrlObject,
858 ContentType: dara.String(""),
859 }
860 ossHeader = map[string]interface{}{
861 "host": dara.StringValue(authResponseBody["Bucket"]) + "." + dara.StringValue(openapiutil.GetEndpoint(authResponseBody["Endpoint"], dara.Bool(useAccelerate), client.EndpointType)),
862 "OSSAccessKeyId": dara.StringValue(authResponseBody["AccessKeyId"]),
863 "policy": dara.StringValue(authResponseBody["EncodedPolicy"]),
864 "Signature": dara.StringValue(authResponseBody["Signature"]),
865 "key": dara.StringValue(authResponseBody["ObjectKey"]),
866 "file": fileObj,
867 "success_action_status": "201",
868 }
869 _, _err = _postOSSObject(client,authResponseBody["Bucket"], ossHeader, runtime)
870 if _err != nil {
871 return _result, _err
872 }
873 batchDeleteKvWithHighCapacityReq.Url = dara.String("http://" + dara.StringValue(authResponseBody["Bucket"]) + "." + dara.StringValue(authResponseBody["Endpoint"]) + "/" + dara.StringValue(authResponseBody["ObjectKey"]))
874 }
875
876 batchDeleteKvWithHighCapacityResp, _err := BatchDeleteKvWithHighCapacityWithOptions(client,batchDeleteKvWithHighCapacityReq, runtime)
877 if _err != nil {
878 return _result, _err
879 }
880
881 _result = batchDeleteKvWithHighCapacityResp
882 return _result, _err
883 }
884
885 // Summary:
886 //
887 // # Batch Get Expression Matches
888 //
889 // @param tmpReq - BatchGetExpressionFieldsRequest
890 //
891 // @param runtime - runtime options for this request RuntimeOptions
892 //
893 // @return BatchGetExpressionFieldsResponse
894 func BatchGetExpressionFieldsWithOptions(client *Client, tmpReq *BatchGetExpressionFieldsRequest, runtime *dara.RuntimeOptions) (_result *BatchGetExpressionFieldsResponse, _err error) {
895 if dara.BoolValue(client.EnableValidate) == true {
896 _err = tmpReq.Validate()
897 if _err != nil {
898 return _result, _err
899 }
900 }
901 request := &BatchGetExpressionFieldsShrinkRequest{}
902 openapiutil.Convert(tmpReq, request)
903 if !dara.IsNil(tmpReq.Expressions) {
904 request.ExpressionsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Expressions, dara.String("Expressions"), dara.String("json"))
905 }
906
907 query := map[string]interface{}{}
908 if !dara.IsNil(request.InstanceId) {
909 query["InstanceId"] = request.InstanceId
910 }
911
912 if !dara.IsNil(request.PlanNameEn) {
913 query["PlanNameEn"] = request.PlanNameEn
914 }
915
916 if !dara.IsNil(request.SiteId) {
917 query["SiteId"] = request.SiteId
918 }
919
920 body := map[string]interface{}{}
921 if !dara.IsNil(request.ExpressionsShrink) {
922 body["Expressions"] = request.ExpressionsShrink
923 }
924
925 if !dara.IsNil(request.Kind) {
926 body["Kind"] = request.Kind
927 }
928
929 if !dara.IsNil(request.Phase) {
930 body["Phase"] = request.Phase
931 }
932
933 req := &openapiutil.OpenApiRequest{
934 Query: openapiutil.Query(query),
935 Body: openapiutil.ParseToMap(body),
936 }
937 params := &openapiutil.Params{
938 Action: dara.String("BatchGetExpressionFields"),
939 Version: dara.String("2024-09-10"),
940 Protocol: dara.String("HTTPS"),
941 Pathname: dara.String("/"),
942 Method: dara.String("POST"),
943 AuthType: dara.String("AK"),
944 Style: dara.String("RPC"),
945 ReqBodyType: dara.String("formData"),
946 BodyType: dara.String("json"),
947 }
948 _result = &BatchGetExpressionFieldsResponse{}
949 _body, _err := client.CallApi(params, req, runtime)
950 if _err != nil {
951 return _result, _err
952 }
953 _err = dara.Convert(_body, &_result)
954 return _result, _err
955 }
956
957 // Summary:
958 //
959 // # Batch Get Expression Matches
960 //
961 // @param request - BatchGetExpressionFieldsRequest
962 //
963 // @return BatchGetExpressionFieldsResponse
964 func BatchGetExpressionFields(client *Client, request *BatchGetExpressionFieldsRequest) (_result *BatchGetExpressionFieldsResponse, _err error) {
965 runtime := &dara.RuntimeOptions{}
966 _result = &BatchGetExpressionFieldsResponse{}
967 _body, _err := BatchGetExpressionFieldsWithOptions(client,request, runtime)
968 if _err != nil {
969 return _result, _err
970 }
971 _result = _body
972 return _result, _err
973 }
974
975 // Summary:
976 //
977 // Configures key-value pairs for a namespace at a time based on specified keys.
978 //
979 // @param tmpReq - BatchPutKvRequest
980 //
981 // @param runtime - runtime options for this request RuntimeOptions
982 //
983 // @return BatchPutKvResponse
984 func BatchPutKvWithOptions(client *Client, tmpReq *BatchPutKvRequest, runtime *dara.RuntimeOptions) (_result *BatchPutKvResponse, _err error) {
985 if dara.BoolValue(client.EnableValidate) == true {
986 _err = tmpReq.Validate()
987 if _err != nil {
988 return _result, _err
989 }
990 }
991 request := &BatchPutKvShrinkRequest{}
992 openapiutil.Convert(tmpReq, request)
993 if !dara.IsNil(tmpReq.KvList) {
994 request.KvListShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.KvList, dara.String("KvList"), dara.String("json"))
995 }
996
997 query := map[string]interface{}{}
998 if !dara.IsNil(request.Namespace) {
999 query["Namespace"] = request.Namespace
1000 }
1001
1002 body := map[string]interface{}{}
1003 if !dara.IsNil(request.KvListShrink) {
1004 body["KvList"] = request.KvListShrink
1005 }
1006
1007 req := &openapiutil.OpenApiRequest{
1008 Query: openapiutil.Query(query),
1009 Body: openapiutil.ParseToMap(body),
1010 }
1011 params := &openapiutil.Params{
1012 Action: dara.String("BatchPutKv"),
1013 Version: dara.String("2024-09-10"),
1014 Protocol: dara.String("HTTPS"),
1015 Pathname: dara.String("/"),
1016 Method: dara.String("POST"),
1017 AuthType: dara.String("AK"),
1018 Style: dara.String("RPC"),
1019 ReqBodyType: dara.String("formData"),
1020 BodyType: dara.String("json"),
1021 }
1022 _result = &BatchPutKvResponse{}
1023 _body, _err := client.CallApi(params, req, runtime)
1024 if _err != nil {
1025 return _result, _err
1026 }
1027 _err = dara.Convert(_body, &_result)
1028 return _result, _err
1029 }
1030
1031 // Summary:
1032 //
1033 // Configures key-value pairs for a namespace at a time based on specified keys.
1034 //
1035 // @param request - BatchPutKvRequest
1036 //
1037 // @return BatchPutKvResponse
1038 func BatchPutKv(client *Client, request *BatchPutKvRequest) (_result *BatchPutKvResponse, _err error) {
1039 runtime := &dara.RuntimeOptions{}
1040 _result = &BatchPutKvResponse{}
1041 _body, _err := BatchPutKvWithOptions(client,request, runtime)
1042 if _err != nil {
1043 return _result, _err
1044 }
1045 _result = _body
1046 return _result, _err
1047 }
1048
1049 // Summary:
1050 //
1051 // Configures key-value pairs for a namespace at a time based on specified keys. The request body can be up to 100 MB.
1052 //
1053 // Description:
1054 //
1055 // 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.
1056 //
1057 // func TestBatchPutKvWithHighCapacity() error {
1058 //
1059 // // Initialize the configurations.
1060 //
1061 // cfg := new(openapi.Config)
1062 //
1063 // cfg.SetAccessKeyId("xxxxxxxxx")
1064 //
1065 // cfg.SetAccessKeySecret("xxxxxxxxxx")
1066 //
1067 // cli, err := NewClient(cfg)
1068 //
1069 // if err != nil {
1070 //
1071 // return err
1072 //
1073 // }
1074 //
1075 // runtime := &util.RuntimeOptions{}
1076 //
1077 // // Construct a request for uploading key-value pairs at a time.
1078 //
1079 // namespace := "test_batch_put"
1080 //
1081 // numKv := 10000
1082 //
1083 // kvList := make([]*BatchPutKvRequestKvList, numKv)
1084 //
1085 // test_value := strings.Repeat("a", 10*1024)
1086 //
1087 // for i := 0; i < numKv; i++ {
1088 //
1089 // key := fmt.Sprintf("test_key_%d", i)
1090 //
1091 // value := test_value
1092 //
1093 // kvList[i] = &BatchPutKvRequestKvList{
1094 //
1095 // Key: &key,
1096 //
1097 // Value: &value,
1098 //
1099 // }
1100 //
1101 // }
1102 //
1103 // rawReq := BatchPutKvRequest{
1104 //
1105 // Namespace: &namespace,
1106 //
1107 // KvList: kvList,
1108 //
1109 // }
1110 //
1111 // payload, err := json.Marshal(rawReq)
1112 //
1113 // if err != nil {
1114 //
1115 // return err
1116 //
1117 // }
1118 //
1119 // // If the payload is greater than 2 MB, call the BatchPutKvWithHighCapacity operation for upload.
1120 //
1121 // reqHighCapacity := BatchPutKvWithHighCapacityAdvanceRequest{
1122 //
1123 // Namespace: &namespace,
1124 //
1125 // UrlObject: bytes.NewReader(payload),
1126 //
1127 // }
1128 //
1129 // resp, err := cli.BatchPutKvWithHighCapacityAdvance(&reqHighCapacity, runtime)
1130 //
1131 // if err != nil {
1132 //
1133 // return err
1134 //
1135 // }
1136 //
1137 // return nil
1138 //
1139 // }
1140 //
1141 // @param request - BatchPutKvWithHighCapacityRequest
1142 //
1143 // @param runtime - runtime options for this request RuntimeOptions
1144 //
1145 // @return BatchPutKvWithHighCapacityResponse
1146 func BatchPutKvWithHighCapacityWithOptions(client *Client, request *BatchPutKvWithHighCapacityRequest, runtime *dara.RuntimeOptions) (_result *BatchPutKvWithHighCapacityResponse, _err error) {
1147 if dara.BoolValue(client.EnableValidate) == true {
1148 _err = request.Validate()
1149 if _err != nil {
1150 return _result, _err
1151 }
1152 }
1153 query := map[string]interface{}{}
1154 if !dara.IsNil(request.Namespace) {
1155 query["Namespace"] = request.Namespace
1156 }
1157
1158 if !dara.IsNil(request.Url) {
1159 query["Url"] = request.Url
1160 }
1161
1162 req := &openapiutil.OpenApiRequest{
1163 Query: openapiutil.Query(query),
1164 }
1165 params := &openapiutil.Params{
1166 Action: dara.String("BatchPutKvWithHighCapacity"),
1167 Version: dara.String("2024-09-10"),
1168 Protocol: dara.String("HTTPS"),
1169 Pathname: dara.String("/"),
1170 Method: dara.String("POST"),
1171 AuthType: dara.String("AK"),
1172 Style: dara.String("RPC"),
1173 ReqBodyType: dara.String("formData"),
1174 BodyType: dara.String("json"),
1175 }
1176 _result = &BatchPutKvWithHighCapacityResponse{}
1177 _body, _err := client.CallApi(params, req, runtime)
1178 if _err != nil {
1179 return _result, _err
1180 }
1181 _err = dara.Convert(_body, &_result)
1182 return _result, _err
1183 }
1184
1185 // Summary:
1186 //
1187 // Configures key-value pairs for a namespace at a time based on specified keys. The request body can be up to 100 MB.
1188 //
1189 // Description:
1190 //
1191 // 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.
1192 //
1193 // func TestBatchPutKvWithHighCapacity() error {
1194 //
1195 // // Initialize the configurations.
1196 //
1197 // cfg := new(openapi.Config)
1198 //
1199 // cfg.SetAccessKeyId("xxxxxxxxx")
1200 //
1201 // cfg.SetAccessKeySecret("xxxxxxxxxx")
1202 //
1203 // cli, err := NewClient(cfg)
1204 //
1205 // if err != nil {
1206 //
1207 // return err
1208 //
1209 // }
1210 //
1211 // runtime := &util.RuntimeOptions{}
1212 //
1213 // // Construct a request for uploading key-value pairs at a time.
1214 //
1215 // namespace := "test_batch_put"
1216 //
1217 // numKv := 10000
1218 //
1219 // kvList := make([]*BatchPutKvRequestKvList, numKv)
1220 //
1221 // test_value := strings.Repeat("a", 10*1024)
1222 //
1223 // for i := 0; i < numKv; i++ {
1224 //
1225 // key := fmt.Sprintf("test_key_%d", i)
1226 //
1227 // value := test_value
1228 //
1229 // kvList[i] = &BatchPutKvRequestKvList{
1230 //
1231 // Key: &key,
1232 //
1233 // Value: &value,
1234 //
1235 // }
1236 //
1237 // }
1238 //
1239 // rawReq := BatchPutKvRequest{
1240 //
1241 // Namespace: &namespace,
1242 //
1243 // KvList: kvList,
1244 //
1245 // }
1246 //
1247 // payload, err := json.Marshal(rawReq)
1248 //
1249 // if err != nil {
1250 //
1251 // return err
1252 //
1253 // }
1254 //
1255 // // If the payload is greater than 2 MB, call the BatchPutKvWithHighCapacity operation for upload.
1256 //
1257 // reqHighCapacity := BatchPutKvWithHighCapacityAdvanceRequest{
1258 //
1259 // Namespace: &namespace,
1260 //
1261 // UrlObject: bytes.NewReader(payload),
1262 //
1263 // }
1264 //
1265 // resp, err := cli.BatchPutKvWithHighCapacityAdvance(&reqHighCapacity, runtime)
1266 //
1267 // if err != nil {
1268 //
1269 // return err
1270 //
1271 // }
1272 //
1273 // return nil
1274 //
1275 // }
1276 //
1277 // @param request - BatchPutKvWithHighCapacityRequest
1278 //
1279 // @return BatchPutKvWithHighCapacityResponse
1280 func BatchPutKvWithHighCapacity(client *Client, request *BatchPutKvWithHighCapacityRequest) (_result *BatchPutKvWithHighCapacityResponse, _err error) {
1281 runtime := &dara.RuntimeOptions{}
1282 _result = &BatchPutKvWithHighCapacityResponse{}
1283 _body, _err := BatchPutKvWithHighCapacityWithOptions(client,request, runtime)
1284 if _err != nil {
1285 return _result, _err
1286 }
1287 _result = _body
1288 return _result, _err
1289 }
1290
1291 func BatchPutKvWithHighCapacityAdvance(client *Client, request *BatchPutKvWithHighCapacityAdvanceRequest, runtime *dara.RuntimeOptions) (_result *BatchPutKvWithHighCapacityResponse, _err error) {
1292 // Step 0: init client
1293 if dara.IsNil(client.Credential) {
1294 _err = &openapi.ClientError{
1295 Code: dara.String("InvalidCredentials"),
1296 Message: dara.String("Please set up the credentials correctly. If you are setting them through environment variables, please ensure that ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set correctly. See https://help.aliyun.com/zh/sdk/developer-reference/configure-the-alibaba-cloud-accesskey-environment-variable-on-linux-macos-and-windows-systems for more details."),
1297 }
1298 return _result, _err
1299 }
1300
1301 credentialModel, _err := client.Credential.GetCredential()
1302 if _err != nil {
1303 return _result, _err
1304 }
1305
1306 accessKeyId := dara.StringValue(credentialModel.AccessKeyId)
1307 accessKeySecret := dara.StringValue(credentialModel.AccessKeySecret)
1308 securityToken := dara.StringValue(credentialModel.SecurityToken)
1309 credentialType := dara.StringValue(credentialModel.Type)
1310 openPlatformEndpoint := dara.StringValue(client.OpenPlatformEndpoint)
1311 if dara.IsNil(dara.String(openPlatformEndpoint)) || openPlatformEndpoint == "" {
1312 openPlatformEndpoint = "openplatform.aliyuncs.com"
1313 }
1314
1315 if dara.IsNil(dara.String(credentialType)) {
1316 credentialType = "access_key"
1317 }
1318
1319 authConfig := &openapiutil.Config{
1320 AccessKeyId: dara.String(accessKeyId),
1321 AccessKeySecret: dara.String(accessKeySecret),
1322 SecurityToken: dara.String(securityToken),
1323 Type: dara.String(credentialType),
1324 Endpoint: dara.String(openPlatformEndpoint),
1325 Protocol: client.Protocol,
1326 RegionId: client.RegionId,
1327 }
1328 authClient, _err := openapi.NewClient(authConfig)
1329 if _err != nil {
1330 return _result, _err
1331 }
1332
1333 authRequest := map[string]*string{
1334 "Product": dara.String("ESA"),
1335 "RegionId": client.RegionId,
1336 }
1337 authReq := &openapiutil.OpenApiRequest{
1338 Query: openapiutil.Query(authRequest),
1339 }
1340 authParams := &openapiutil.Params{
1341 Action: dara.String("AuthorizeFileUpload"),
1342 Version: dara.String("2019-12-19"),
1343 Protocol: dara.String("HTTPS"),
1344 Pathname: dara.String("/"),
1345 Method: dara.String("GET"),
1346 AuthType: dara.String("AK"),
1347 Style: dara.String("RPC"),
1348 ReqBodyType: dara.String("formData"),
1349 BodyType: dara.String("json"),
1350 }
1351 authResponse := map[string]interface{}{}
1352 fileObj := &dara.FileField{}
1353 ossHeader := map[string]interface{}{}
1354 tmpBody := map[string]interface{}{}
1355 useAccelerate := false
1356 authResponseBody := make(map[string]*string)
1357 batchPutKvWithHighCapacityReq := &BatchPutKvWithHighCapacityRequest{}
1358 openapiutil.Convert(request, batchPutKvWithHighCapacityReq)
1359 if !dara.IsNil(request.UrlObject) {
1360 authResponse, _err = authClient.CallApi(authParams, authReq, runtime)
1361 if _err != nil {
1362 return _result, _err
1363 }
1364
1365 tmpBody = dara.ToMap(authResponse["body"])
1366 useAccelerate = dara.ForceBoolean(tmpBody["UseAccelerate"])
1367 authResponseBody = openapiutil.StringifyMapValue(tmpBody)
1368 fileObj = &dara.FileField{
1369 Filename: authResponseBody["ObjectKey"],
1370 Content: request.UrlObject,
1371 ContentType: dara.String(""),
1372 }
1373 ossHeader = map[string]interface{}{
1374 "host": dara.StringValue(authResponseBody["Bucket"]) + "." + dara.StringValue(openapiutil.GetEndpoint(authResponseBody["Endpoint"], dara.Bool(useAccelerate), client.EndpointType)),
1375 "OSSAccessKeyId": dara.StringValue(authResponseBody["AccessKeyId"]),
1376 "policy": dara.StringValue(authResponseBody["EncodedPolicy"]),
1377 "Signature": dara.StringValue(authResponseBody["Signature"]),
1378 "key": dara.StringValue(authResponseBody["ObjectKey"]),
1379 "file": fileObj,
1380 "success_action_status": "201",
1381 }
1382 _, _err = _postOSSObject(client,authResponseBody["Bucket"], ossHeader, runtime)
1383 if _err != nil {
1384 return _result, _err
1385 }
1386 batchPutKvWithHighCapacityReq.Url = dara.String("http://" + dara.StringValue(authResponseBody["Bucket"]) + "." + dara.StringValue(authResponseBody["Endpoint"]) + "/" + dara.StringValue(authResponseBody["ObjectKey"]))
1387 }
1388
1389 batchPutKvWithHighCapacityResp, _err := BatchPutKvWithHighCapacityWithOptions(client,batchPutKvWithHighCapacityReq, runtime)
1390 if _err != nil {
1391 return _result, _err
1392 }
1393
1394 _result = batchPutKvWithHighCapacityResp
1395 return _result, _err
1396 }
1397
1398 // Summary:
1399 //
1400 // Modifies multiple rules in a specific Web Application Firewall (WAF) ruleset at a time.
1401 //
1402 // @param tmpReq - BatchUpdateWafRulesRequest
1403 //
1404 // @param runtime - runtime options for this request RuntimeOptions
1405 //
1406 // @return BatchUpdateWafRulesResponse
1407 func BatchUpdateWafRulesWithOptions(client *Client, tmpReq *BatchUpdateWafRulesRequest, runtime *dara.RuntimeOptions) (_result *BatchUpdateWafRulesResponse, _err error) {
1408 if dara.BoolValue(client.EnableValidate) == true {
1409 _err = tmpReq.Validate()
1410 if _err != nil {
1411 return _result, _err
1412 }
1413 }
1414 request := &BatchUpdateWafRulesShrinkRequest{}
1415 openapiutil.Convert(tmpReq, request)
1416 if !dara.IsNil(tmpReq.Configs) {
1417 request.ConfigsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Configs, dara.String("Configs"), dara.String("json"))
1418 }
1419
1420 if !dara.IsNil(tmpReq.Shared) {
1421 request.SharedShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Shared, dara.String("Shared"), dara.String("json"))
1422 }
1423
1424 query := map[string]interface{}{}
1425 if !dara.IsNil(request.SiteId) {
1426 query["SiteId"] = request.SiteId
1427 }
1428
1429 if !dara.IsNil(request.SiteVersion) {
1430 query["SiteVersion"] = request.SiteVersion
1431 }
1432
1433 body := map[string]interface{}{}
1434 if !dara.IsNil(request.ConfigsShrink) {
1435 body["Configs"] = request.ConfigsShrink
1436 }
1437
1438 if !dara.IsNil(request.Phase) {
1439 body["Phase"] = request.Phase
1440 }
1441
1442 if !dara.IsNil(request.RulesetId) {
1443 body["RulesetId"] = request.RulesetId
1444 }
1445
1446 if !dara.IsNil(request.SharedShrink) {
1447 body["Shared"] = request.SharedShrink
1448 }
1449
1450 req := &openapiutil.OpenApiRequest{
1451 Query: openapiutil.Query(query),
1452 Body: openapiutil.ParseToMap(body),
1453 }
1454 params := &openapiutil.Params{
1455 Action: dara.String("BatchUpdateWafRules"),
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 = &BatchUpdateWafRulesResponse{}
1466 _body, _err := client.CallApi(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 // Modifies multiple rules in a specific Web Application Firewall (WAF) ruleset at a time.
1477 //
1478 // @param request - BatchUpdateWafRulesRequest
1479 //
1480 // @return BatchUpdateWafRulesResponse
1481 func BatchUpdateWafRules(client *Client, request *BatchUpdateWafRulesRequest) (_result *BatchUpdateWafRulesResponse, _err error) {
1482 runtime := &dara.RuntimeOptions{}
1483 _result = &BatchUpdateWafRulesResponse{}
1484 _body, _err := BatchUpdateWafRulesWithOptions(client,request, runtime)
1485 if _err != nil {
1486 return _result, _err
1487 }
1488 _result = _body
1489 return _result, _err
1490 }
1491
1492 // Summary:
1493 //
1494 // Blocks URLs.
1495 //
1496 // @param tmpReq - BlockObjectRequest
1497 //
1498 // @param runtime - runtime options for this request RuntimeOptions
1499 //
1500 // @return BlockObjectResponse
1501 func BlockObjectWithOptions(client *Client, tmpReq *BlockObjectRequest, runtime *dara.RuntimeOptions) (_result *BlockObjectResponse, _err error) {
1502 if dara.BoolValue(client.EnableValidate) == true {
1503 _err = tmpReq.Validate()
1504 if _err != nil {
1505 return _result, _err
1506 }
1507 }
1508 request := &BlockObjectShrinkRequest{}
1509 openapiutil.Convert(tmpReq, request)
1510 if !dara.IsNil(tmpReq.Content) {
1511 request.ContentShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Content, dara.String("Content"), dara.String("json"))
1512 }
1513
1514 query := map[string]interface{}{}
1515 if !dara.IsNil(request.ContentShrink) {
1516 query["Content"] = request.ContentShrink
1517 }
1518
1519 if !dara.IsNil(request.Extension) {
1520 query["Extension"] = request.Extension
1521 }
1522
1523 if !dara.IsNil(request.Maxage) {
1524 query["Maxage"] = request.Maxage
1525 }
1526
1527 if !dara.IsNil(request.SiteId) {
1528 query["SiteId"] = request.SiteId
1529 }
1530
1531 if !dara.IsNil(request.Type) {
1532 query["Type"] = request.Type
1533 }
1534
1535 req := &openapiutil.OpenApiRequest{
1536 Query: openapiutil.Query(query),
1537 }
1538 params := &openapiutil.Params{
1539 Action: dara.String("BlockObject"),
1540 Version: dara.String("2024-09-10"),
1541 Protocol: dara.String("HTTPS"),
1542 Pathname: dara.String("/"),
1543 Method: dara.String("POST"),
1544 AuthType: dara.String("AK"),
1545 Style: dara.String("RPC"),
1546 ReqBodyType: dara.String("formData"),
1547 BodyType: dara.String("json"),
1548 }
1549 _result = &BlockObjectResponse{}
1550 _body, _err := client.CallApi(params, req, runtime)
1551 if _err != nil {
1552 return _result, _err
1553 }
1554 _err = dara.Convert(_body, &_result)
1555 return _result, _err
1556 }
1557
1558 // Summary:
1559 //
1560 // Blocks URLs.
1561 //
1562 // @param request - BlockObjectRequest
1563 //
1564 // @return BlockObjectResponse
1565 func BlockObject(client *Client, request *BlockObjectRequest) (_result *BlockObjectResponse, _err error) {
1566 runtime := &dara.RuntimeOptions{}
1567 _result = &BlockObjectResponse{}
1568 _body, _err := BlockObjectWithOptions(client,request, runtime)
1569 if _err != nil {
1570 return _result, _err
1571 }
1572 _result = _body
1573 return _result, _err
1574 }
1575
1576 // Summary:
1577 //
1578 // 检查实时日志slr角色是否已创建
1579 //
1580 // @param request - CheckAssumeSlrRoleRequest
1581 //
1582 // @param runtime - runtime options for this request RuntimeOptions
1583 //
1584 // @return CheckAssumeSlrRoleResponse
1585 func CheckAssumeSlrRoleWithOptions(client *Client, runtime *dara.RuntimeOptions) (_result *CheckAssumeSlrRoleResponse, _err error) {
1586 req := &openapiutil.OpenApiRequest{}
1587 params := &openapiutil.Params{
1588 Action: dara.String("CheckAssumeSlrRole"),
1589 Version: dara.String("2024-09-10"),
1590 Protocol: dara.String("HTTPS"),
1591 Pathname: dara.String("/"),
1592 Method: dara.String("GET"),
1593 AuthType: dara.String("AK"),
1594 Style: dara.String("RPC"),
1595 ReqBodyType: dara.String("formData"),
1596 BodyType: dara.String("json"),
1597 }
1598 _result = &CheckAssumeSlrRoleResponse{}
1599 _body, _err := client.CallApi(params, req, runtime)
1600 if _err != nil {
1601 return _result, _err
1602 }
1603 _err = dara.Convert(_body, &_result)
1604 return _result, _err
1605 }
1606
1607 // Summary:
1608 //
1609 // 检查实时日志slr角色是否已创建
1610 //
1611 // @return CheckAssumeSlrRoleResponse
1612 func CheckAssumeSlrRole(client *Client, ) (_result *CheckAssumeSlrRoleResponse, _err error) {
1613 runtime := &dara.RuntimeOptions{}
1614 _result = &CheckAssumeSlrRoleResponse{}
1615 _body, _err := CheckAssumeSlrRoleWithOptions(client,runtime)
1616 if _err != nil {
1617 return _result, _err
1618 }
1619 _result = _body
1620 return _result, _err
1621 }
1622
1623 // Summary:
1624 //
1625 // Checks whether a specified website name is available.
1626 //
1627 // @param request - CheckSiteNameRequest
1628 //
1629 // @param runtime - runtime options for this request RuntimeOptions
1630 //
1631 // @return CheckSiteNameResponse
1632 func CheckSiteNameWithOptions(client *Client, request *CheckSiteNameRequest, runtime *dara.RuntimeOptions) (_result *CheckSiteNameResponse, _err error) {
1633 if dara.BoolValue(client.EnableValidate) == true {
1634 _err = request.Validate()
1635 if _err != nil {
1636 return _result, _err
1637 }
1638 }
1639 query := map[string]interface{}{}
1640 if !dara.IsNil(request.SiteName) {
1641 query["SiteName"] = request.SiteName
1642 }
1643
1644 req := &openapiutil.OpenApiRequest{
1645 Query: openapiutil.Query(query),
1646 }
1647 params := &openapiutil.Params{
1648 Action: dara.String("CheckSiteName"),
1649 Version: dara.String("2024-09-10"),
1650 Protocol: dara.String("HTTPS"),
1651 Pathname: dara.String("/"),
1652 Method: dara.String("POST"),
1653 AuthType: dara.String("AK"),
1654 Style: dara.String("RPC"),
1655 ReqBodyType: dara.String("formData"),
1656 BodyType: dara.String("json"),
1657 }
1658 _result = &CheckSiteNameResponse{}
1659 _body, _err := client.CallApi(params, req, runtime)
1660 if _err != nil {
1661 return _result, _err
1662 }
1663 _err = dara.Convert(_body, &_result)
1664 return _result, _err
1665 }
1666
1667 // Summary:
1668 //
1669 // Checks whether a specified website name is available.
1670 //
1671 // @param request - CheckSiteNameRequest
1672 //
1673 // @return CheckSiteNameResponse
1674 func CheckSiteName(client *Client, request *CheckSiteNameRequest) (_result *CheckSiteNameResponse, _err error) {
1675 runtime := &dara.RuntimeOptions{}
1676 _result = &CheckSiteNameResponse{}
1677 _body, _err := CheckSiteNameWithOptions(client,request, runtime)
1678 if _err != nil {
1679 return _result, _err
1680 }
1681 _result = _body
1682 return _result, _err
1683 }
1684
1685 // Summary:
1686 //
1687 // Checks the name of a real-time log delivery task.
1688 //
1689 // @param request - CheckSiteProjectNameRequest
1690 //
1691 // @param runtime - runtime options for this request RuntimeOptions
1692 //
1693 // @return CheckSiteProjectNameResponse
1694 func CheckSiteProjectNameWithOptions(client *Client, request *CheckSiteProjectNameRequest, runtime *dara.RuntimeOptions) (_result *CheckSiteProjectNameResponse, _err error) {
1695 if dara.BoolValue(client.EnableValidate) == true {
1696 _err = request.Validate()
1697 if _err != nil {
1698 return _result, _err
1699 }
1700 }
1701 query := openapiutil.Query(dara.ToMap(request))
1702 req := &openapiutil.OpenApiRequest{
1703 Query: openapiutil.Query(query),
1704 }
1705 params := &openapiutil.Params{
1706 Action: dara.String("CheckSiteProjectName"),
1707 Version: dara.String("2024-09-10"),
1708 Protocol: dara.String("HTTPS"),
1709 Pathname: dara.String("/"),
1710 Method: dara.String("GET"),
1711 AuthType: dara.String("AK"),
1712 Style: dara.String("RPC"),
1713 ReqBodyType: dara.String("formData"),
1714 BodyType: dara.String("json"),
1715 }
1716 _result = &CheckSiteProjectNameResponse{}
1717 _body, _err := client.CallApi(params, req, runtime)
1718 if _err != nil {
1719 return _result, _err
1720 }
1721 _err = dara.Convert(_body, &_result)
1722 return _result, _err
1723 }
1724
1725 // Summary:
1726 //
1727 // Checks the name of a real-time log delivery task.
1728 //
1729 // @param request - CheckSiteProjectNameRequest
1730 //
1731 // @return CheckSiteProjectNameResponse
1732 func CheckSiteProjectName(client *Client, request *CheckSiteProjectNameRequest) (_result *CheckSiteProjectNameResponse, _err error) {
1733 runtime := &dara.RuntimeOptions{}
1734 _result = &CheckSiteProjectNameResponse{}
1735 _body, _err := CheckSiteProjectNameWithOptions(client,request, runtime)
1736 if _err != nil {
1737 return _result, _err
1738 }
1739 _result = _body
1740 return _result, _err
1741 }
1742
1743 // Summary:
1744 //
1745 // Checks the name of a real-time log delivery task by account.
1746 //
1747 // @param request - CheckUserProjectNameRequest
1748 //
1749 // @param runtime - runtime options for this request RuntimeOptions
1750 //
1751 // @return CheckUserProjectNameResponse
1752 func CheckUserProjectNameWithOptions(client *Client, request *CheckUserProjectNameRequest, runtime *dara.RuntimeOptions) (_result *CheckUserProjectNameResponse, _err error) {
1753 if dara.BoolValue(client.EnableValidate) == true {
1754 _err = request.Validate()
1755 if _err != nil {
1756 return _result, _err
1757 }
1758 }
1759 query := openapiutil.Query(dara.ToMap(request))
1760 req := &openapiutil.OpenApiRequest{
1761 Query: openapiutil.Query(query),
1762 }
1763 params := &openapiutil.Params{
1764 Action: dara.String("CheckUserProjectName"),
1765 Version: dara.String("2024-09-10"),
1766 Protocol: dara.String("HTTPS"),
1767 Pathname: dara.String("/"),
1768 Method: dara.String("GET"),
1769 AuthType: dara.String("AK"),
1770 Style: dara.String("RPC"),
1771 ReqBodyType: dara.String("formData"),
1772 BodyType: dara.String("json"),
1773 }
1774 _result = &CheckUserProjectNameResponse{}
1775 _body, _err := client.CallApi(params, req, runtime)
1776 if _err != nil {
1777 return _result, _err
1778 }
1779 _err = dara.Convert(_body, &_result)
1780 return _result, _err
1781 }
1782
1783 // Summary:
1784 //
1785 // Checks the name of a real-time log delivery task by account.
1786 //
1787 // @param request - CheckUserProjectNameRequest
1788 //
1789 // @return CheckUserProjectNameResponse
1790 func CheckUserProjectName(client *Client, request *CheckUserProjectNameRequest) (_result *CheckUserProjectNameResponse, _err error) {
1791 runtime := &dara.RuntimeOptions{}
1792 _result = &CheckUserProjectNameResponse{}
1793 _body, _err := CheckUserProjectNameWithOptions(client,request, runtime)
1794 if _err != nil {
1795 return _result, _err
1796 }
1797 _result = _body
1798 return _result, _err
1799 }
1800
1801 // Summary:
1802 //
1803 // Commits the unstable code in the staging environment to generate an official code version.
1804 //
1805 // @param request - CommitRoutineStagingCodeRequest
1806 //
1807 // @param runtime - runtime options for this request RuntimeOptions
1808 //
1809 // @return CommitRoutineStagingCodeResponse
1810 func CommitRoutineStagingCodeWithOptions(client *Client, request *CommitRoutineStagingCodeRequest, runtime *dara.RuntimeOptions) (_result *CommitRoutineStagingCodeResponse, _err error) {
1811 if dara.BoolValue(client.EnableValidate) == true {
1812 _err = request.Validate()
1813 if _err != nil {
1814 return _result, _err
1815 }
1816 }
1817 body := map[string]interface{}{}
1818 if !dara.IsNil(request.CodeDescription) {
1819 body["CodeDescription"] = request.CodeDescription
1820 }
1821
1822 if !dara.IsNil(request.Name) {
1823 body["Name"] = request.Name
1824 }
1825
1826 req := &openapiutil.OpenApiRequest{
1827 Body: openapiutil.ParseToMap(body),
1828 }
1829 params := &openapiutil.Params{
1830 Action: dara.String("CommitRoutineStagingCode"),
1831 Version: dara.String("2024-09-10"),
1832 Protocol: dara.String("HTTPS"),
1833 Pathname: dara.String("/"),
1834 Method: dara.String("POST"),
1835 AuthType: dara.String("AK"),
1836 Style: dara.String("RPC"),
1837 ReqBodyType: dara.String("formData"),
1838 BodyType: dara.String("json"),
1839 }
1840 _result = &CommitRoutineStagingCodeResponse{}
1841 _body, _err := client.CallApi(params, req, runtime)
1842 if _err != nil {
1843 return _result, _err
1844 }
1845 _err = dara.Convert(_body, &_result)
1846 return _result, _err
1847 }
1848
1849 // Summary:
1850 //
1851 // Commits the unstable code in the staging environment to generate an official code version.
1852 //
1853 // @param request - CommitRoutineStagingCodeRequest
1854 //
1855 // @return CommitRoutineStagingCodeResponse
1856 func CommitRoutineStagingCode(client *Client, request *CommitRoutineStagingCodeRequest) (_result *CommitRoutineStagingCodeResponse, _err error) {
1857 runtime := &dara.RuntimeOptions{}
1858 _result = &CommitRoutineStagingCodeResponse{}
1859 _body, _err := CommitRoutineStagingCodeWithOptions(client,request, runtime)
1860 if _err != nil {
1861 return _result, _err
1862 }
1863 _result = _body
1864 return _result, _err
1865 }
1866
1867 // Summary:
1868 //
1869 // # Create a new site cache configuration
1870 //
1871 // @param request - CreateCacheRuleRequest
1872 //
1873 // @param runtime - runtime options for this request RuntimeOptions
1874 //
1875 // @return CreateCacheRuleResponse
1876 func CreateCacheRuleWithOptions(client *Client, request *CreateCacheRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateCacheRuleResponse, _err error) {
1877 if dara.BoolValue(client.EnableValidate) == true {
1878 _err = request.Validate()
1879 if _err != nil {
1880 return _result, _err
1881 }
1882 }
1883 query := map[string]interface{}{}
1884 if !dara.IsNil(request.AdditionalCacheablePorts) {
1885 query["AdditionalCacheablePorts"] = request.AdditionalCacheablePorts
1886 }
1887
1888 if !dara.IsNil(request.BrowserCacheMode) {
1889 query["BrowserCacheMode"] = request.BrowserCacheMode
1890 }
1891
1892 if !dara.IsNil(request.BrowserCacheTtl) {
1893 query["BrowserCacheTtl"] = request.BrowserCacheTtl
1894 }
1895
1896 if !dara.IsNil(request.BypassCache) {
1897 query["BypassCache"] = request.BypassCache
1898 }
1899
1900 if !dara.IsNil(request.CacheDeceptionArmor) {
1901 query["CacheDeceptionArmor"] = request.CacheDeceptionArmor
1902 }
1903
1904 if !dara.IsNil(request.CacheReserveEligibility) {
1905 query["CacheReserveEligibility"] = request.CacheReserveEligibility
1906 }
1907
1908 if !dara.IsNil(request.CheckPresenceCookie) {
1909 query["CheckPresenceCookie"] = request.CheckPresenceCookie
1910 }
1911
1912 if !dara.IsNil(request.CheckPresenceHeader) {
1913 query["CheckPresenceHeader"] = request.CheckPresenceHeader
1914 }
1915
1916 if !dara.IsNil(request.EdgeCacheMode) {
1917 query["EdgeCacheMode"] = request.EdgeCacheMode
1918 }
1919
1920 if !dara.IsNil(request.EdgeCacheTtl) {
1921 query["EdgeCacheTtl"] = request.EdgeCacheTtl
1922 }
1923
1924 if !dara.IsNil(request.EdgeStatusCodeCacheTtl) {
1925 query["EdgeStatusCodeCacheTtl"] = request.EdgeStatusCodeCacheTtl
1926 }
1927
1928 if !dara.IsNil(request.IncludeCookie) {
1929 query["IncludeCookie"] = request.IncludeCookie
1930 }
1931
1932 if !dara.IsNil(request.IncludeHeader) {
1933 query["IncludeHeader"] = request.IncludeHeader
1934 }
1935
1936 if !dara.IsNil(request.PostBodyCacheKey) {
1937 query["PostBodyCacheKey"] = request.PostBodyCacheKey
1938 }
1939
1940 if !dara.IsNil(request.PostBodySizeLimit) {
1941 query["PostBodySizeLimit"] = request.PostBodySizeLimit
1942 }
1943
1944 if !dara.IsNil(request.PostCache) {
1945 query["PostCache"] = request.PostCache
1946 }
1947
1948 if !dara.IsNil(request.QueryString) {
1949 query["QueryString"] = request.QueryString
1950 }
1951
1952 if !dara.IsNil(request.QueryStringMode) {
1953 query["QueryStringMode"] = request.QueryStringMode
1954 }
1955
1956 if !dara.IsNil(request.Rule) {
1957 query["Rule"] = request.Rule
1958 }
1959
1960 if !dara.IsNil(request.RuleEnable) {
1961 query["RuleEnable"] = request.RuleEnable
1962 }
1963
1964 if !dara.IsNil(request.RuleName) {
1965 query["RuleName"] = request.RuleName
1966 }
1967
1968 if !dara.IsNil(request.Sequence) {
1969 query["Sequence"] = request.Sequence
1970 }
1971
1972 if !dara.IsNil(request.ServeStale) {
1973 query["ServeStale"] = request.ServeStale
1974 }
1975
1976 if !dara.IsNil(request.SiteId) {
1977 query["SiteId"] = request.SiteId
1978 }
1979
1980 if !dara.IsNil(request.SiteVersion) {
1981 query["SiteVersion"] = request.SiteVersion
1982 }
1983
1984 if !dara.IsNil(request.SortQueryStringForCache) {
1985 query["SortQueryStringForCache"] = request.SortQueryStringForCache
1986 }
1987
1988 if !dara.IsNil(request.UserDeviceType) {
1989 query["UserDeviceType"] = request.UserDeviceType
1990 }
1991
1992 if !dara.IsNil(request.UserGeo) {
1993 query["UserGeo"] = request.UserGeo
1994 }
1995
1996 if !dara.IsNil(request.UserLanguage) {
1997 query["UserLanguage"] = request.UserLanguage
1998 }
1999
2000 req := &openapiutil.OpenApiRequest{
2001 Query: openapiutil.Query(query),
2002 }
2003 params := &openapiutil.Params{
2004 Action: dara.String("CreateCacheRule"),
2005 Version: dara.String("2024-09-10"),
2006 Protocol: dara.String("HTTPS"),
2007 Pathname: dara.String("/"),
2008 Method: dara.String("POST"),
2009 AuthType: dara.String("AK"),
2010 Style: dara.String("RPC"),
2011 ReqBodyType: dara.String("formData"),
2012 BodyType: dara.String("json"),
2013 }
2014 _result = &CreateCacheRuleResponse{}
2015 _body, _err := client.CallApi(params, req, runtime)
2016 if _err != nil {
2017 return _result, _err
2018 }
2019 _err = dara.Convert(_body, &_result)
2020 return _result, _err
2021 }
2022
2023 // Summary:
2024 //
2025 // # Create a new site cache configuration
2026 //
2027 // @param request - CreateCacheRuleRequest
2028 //
2029 // @return CreateCacheRuleResponse
2030 func CreateCacheRule(client *Client, request *CreateCacheRuleRequest) (_result *CreateCacheRuleResponse, _err error) {
2031 runtime := &dara.RuntimeOptions{}
2032 _result = &CreateCacheRuleResponse{}
2033 _body, _err := CreateCacheRuleWithOptions(client,request, runtime)
2034 if _err != nil {
2035 return _result, _err
2036 }
2037 _result = _body
2038 return _result, _err
2039 }
2040
2041 // Summary:
2042 //
2043 // Uses the ESA-managed certificate authority (CA) to issue client certificates.
2044 //
2045 // @param request - CreateClientCertificateRequest
2046 //
2047 // @param runtime - runtime options for this request RuntimeOptions
2048 //
2049 // @return CreateClientCertificateResponse
2050 func CreateClientCertificateWithOptions(client *Client, request *CreateClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *CreateClientCertificateResponse, _err error) {
2051 if dara.BoolValue(client.EnableValidate) == true {
2052 _err = request.Validate()
2053 if _err != nil {
2054 return _result, _err
2055 }
2056 }
2057 query := map[string]interface{}{}
2058 if !dara.IsNil(request.SiteId) {
2059 query["SiteId"] = request.SiteId
2060 }
2061
2062 body := map[string]interface{}{}
2063 if !dara.IsNil(request.CSR) {
2064 body["CSR"] = request.CSR
2065 }
2066
2067 if !dara.IsNil(request.PkeyType) {
2068 body["PkeyType"] = request.PkeyType
2069 }
2070
2071 if !dara.IsNil(request.ValidityDays) {
2072 body["ValidityDays"] = request.ValidityDays
2073 }
2074
2075 req := &openapiutil.OpenApiRequest{
2076 Query: openapiutil.Query(query),
2077 Body: openapiutil.ParseToMap(body),
2078 }
2079 params := &openapiutil.Params{
2080 Action: dara.String("CreateClientCertificate"),
2081 Version: dara.String("2024-09-10"),
2082 Protocol: dara.String("HTTPS"),
2083 Pathname: dara.String("/"),
2084 Method: dara.String("POST"),
2085 AuthType: dara.String("AK"),
2086 Style: dara.String("RPC"),
2087 ReqBodyType: dara.String("formData"),
2088 BodyType: dara.String("json"),
2089 }
2090 _result = &CreateClientCertificateResponse{}
2091 _body, _err := client.CallApi(params, req, runtime)
2092 if _err != nil {
2093 return _result, _err
2094 }
2095 _err = dara.Convert(_body, &_result)
2096 return _result, _err
2097 }
2098
2099 // Summary:
2100 //
2101 // Uses the ESA-managed certificate authority (CA) to issue client certificates.
2102 //
2103 // @param request - CreateClientCertificateRequest
2104 //
2105 // @return CreateClientCertificateResponse
2106 func CreateClientCertificate(client *Client, request *CreateClientCertificateRequest) (_result *CreateClientCertificateResponse, _err error) {
2107 runtime := &dara.RuntimeOptions{}
2108 _result = &CreateClientCertificateResponse{}
2109 _body, _err := CreateClientCertificateWithOptions(client,request, runtime)
2110 if _err != nil {
2111 return _result, _err
2112 }
2113 _result = _body
2114 return _result, _err
2115 }
2116
2117 // Summary:
2118 //
2119 // # Add a compression rule
2120 //
2121 // @param request - CreateCompressionRuleRequest
2122 //
2123 // @param runtime - runtime options for this request RuntimeOptions
2124 //
2125 // @return CreateCompressionRuleResponse
2126 func CreateCompressionRuleWithOptions(client *Client, request *CreateCompressionRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateCompressionRuleResponse, _err error) {
2127 if dara.BoolValue(client.EnableValidate) == true {
2128 _err = request.Validate()
2129 if _err != nil {
2130 return _result, _err
2131 }
2132 }
2133 query := map[string]interface{}{}
2134 if !dara.IsNil(request.Brotli) {
2135 query["Brotli"] = request.Brotli
2136 }
2137
2138 if !dara.IsNil(request.Gzip) {
2139 query["Gzip"] = request.Gzip
2140 }
2141
2142 if !dara.IsNil(request.Rule) {
2143 query["Rule"] = request.Rule
2144 }
2145
2146 if !dara.IsNil(request.RuleEnable) {
2147 query["RuleEnable"] = request.RuleEnable
2148 }
2149
2150 if !dara.IsNil(request.RuleName) {
2151 query["RuleName"] = request.RuleName
2152 }
2153
2154 if !dara.IsNil(request.Sequence) {
2155 query["Sequence"] = request.Sequence
2156 }
2157
2158 if !dara.IsNil(request.SiteId) {
2159 query["SiteId"] = request.SiteId
2160 }
2161
2162 if !dara.IsNil(request.SiteVersion) {
2163 query["SiteVersion"] = request.SiteVersion
2164 }
2165
2166 if !dara.IsNil(request.Zstd) {
2167 query["Zstd"] = request.Zstd
2168 }
2169
2170 req := &openapiutil.OpenApiRequest{
2171 Query: openapiutil.Query(query),
2172 }
2173 params := &openapiutil.Params{
2174 Action: dara.String("CreateCompressionRule"),
2175 Version: dara.String("2024-09-10"),
2176 Protocol: dara.String("HTTPS"),
2177 Pathname: dara.String("/"),
2178 Method: dara.String("POST"),
2179 AuthType: dara.String("AK"),
2180 Style: dara.String("RPC"),
2181 ReqBodyType: dara.String("formData"),
2182 BodyType: dara.String("json"),
2183 }
2184 _result = &CreateCompressionRuleResponse{}
2185 _body, _err := client.CallApi(params, req, runtime)
2186 if _err != nil {
2187 return _result, _err
2188 }
2189 _err = dara.Convert(_body, &_result)
2190 return _result, _err
2191 }
2192
2193 // Summary:
2194 //
2195 // # Add a compression rule
2196 //
2197 // @param request - CreateCompressionRuleRequest
2198 //
2199 // @return CreateCompressionRuleResponse
2200 func CreateCompressionRule(client *Client, request *CreateCompressionRuleRequest) (_result *CreateCompressionRuleResponse, _err error) {
2201 runtime := &dara.RuntimeOptions{}
2202 _result = &CreateCompressionRuleResponse{}
2203 _body, _err := CreateCompressionRuleWithOptions(client,request, runtime)
2204 if _err != nil {
2205 return _result, _err
2206 }
2207 _result = _body
2208 return _result, _err
2209 }
2210
2211 // Summary:
2212 //
2213 // Creates an account-level custom scenario policy. You can execute a policy after you associate the policy with a website.
2214 //
2215 // @param request - CreateCustomScenePolicyRequest
2216 //
2217 // @param runtime - runtime options for this request RuntimeOptions
2218 //
2219 // @return CreateCustomScenePolicyResponse
2220 func CreateCustomScenePolicyWithOptions(client *Client, request *CreateCustomScenePolicyRequest, runtime *dara.RuntimeOptions) (_result *CreateCustomScenePolicyResponse, _err error) {
2221 if dara.BoolValue(client.EnableValidate) == true {
2222 _err = request.Validate()
2223 if _err != nil {
2224 return _result, _err
2225 }
2226 }
2227 query := map[string]interface{}{}
2228 if !dara.IsNil(request.EndTime) {
2229 query["EndTime"] = request.EndTime
2230 }
2231
2232 if !dara.IsNil(request.Name) {
2233 query["Name"] = request.Name
2234 }
2235
2236 if !dara.IsNil(request.Objects) {
2237 query["Objects"] = request.Objects
2238 }
2239
2240 if !dara.IsNil(request.SiteIds) {
2241 query["SiteIds"] = request.SiteIds
2242 }
2243
2244 if !dara.IsNil(request.StartTime) {
2245 query["StartTime"] = request.StartTime
2246 }
2247
2248 if !dara.IsNil(request.Template) {
2249 query["Template"] = request.Template
2250 }
2251
2252 req := &openapiutil.OpenApiRequest{
2253 Query: openapiutil.Query(query),
2254 }
2255 params := &openapiutil.Params{
2256 Action: dara.String("CreateCustomScenePolicy"),
2257 Version: dara.String("2024-09-10"),
2258 Protocol: dara.String("HTTPS"),
2259 Pathname: dara.String("/"),
2260 Method: dara.String("POST"),
2261 AuthType: dara.String("AK"),
2262 Style: dara.String("RPC"),
2263 ReqBodyType: dara.String("formData"),
2264 BodyType: dara.String("json"),
2265 }
2266 _result = &CreateCustomScenePolicyResponse{}
2267 _body, _err := client.CallApi(params, req, runtime)
2268 if _err != nil {
2269 return _result, _err
2270 }
2271 _err = dara.Convert(_body, &_result)
2272 return _result, _err
2273 }
2274
2275 // Summary:
2276 //
2277 // Creates an account-level custom scenario policy. You can execute a policy after you associate the policy with a website.
2278 //
2279 // @param request - CreateCustomScenePolicyRequest
2280 //
2281 // @return CreateCustomScenePolicyResponse
2282 func CreateCustomScenePolicy(client *Client, request *CreateCustomScenePolicyRequest) (_result *CreateCustomScenePolicyResponse, _err error) {
2283 runtime := &dara.RuntimeOptions{}
2284 _result = &CreateCustomScenePolicyResponse{}
2285 _body, _err := CreateCustomScenePolicyWithOptions(client,request, runtime)
2286 if _err != nil {
2287 return _result, _err
2288 }
2289 _result = _body
2290 return _result, _err
2291 }
2292
2293 // Summary:
2294 //
2295 // Creates a containerized application. You can deploy and release a version of the application across points of presence (POPs).
2296 //
2297 // @param request - CreateEdgeContainerAppRequest
2298 //
2299 // @param runtime - runtime options for this request RuntimeOptions
2300 //
2301 // @return CreateEdgeContainerAppResponse
2302 func CreateEdgeContainerAppWithOptions(client *Client, request *CreateEdgeContainerAppRequest, runtime *dara.RuntimeOptions) (_result *CreateEdgeContainerAppResponse, _err error) {
2303 if dara.BoolValue(client.EnableValidate) == true {
2304 _err = request.Validate()
2305 if _err != nil {
2306 return _result, _err
2307 }
2308 }
2309 body := map[string]interface{}{}
2310 if !dara.IsNil(request.HealthCheckFailTimes) {
2311 body["HealthCheckFailTimes"] = request.HealthCheckFailTimes
2312 }
2313
2314 if !dara.IsNil(request.HealthCheckHost) {
2315 body["HealthCheckHost"] = request.HealthCheckHost
2316 }
2317
2318 if !dara.IsNil(request.HealthCheckHttpCode) {
2319 body["HealthCheckHttpCode"] = request.HealthCheckHttpCode
2320 }
2321
2322 if !dara.IsNil(request.HealthCheckInterval) {
2323 body["HealthCheckInterval"] = request.HealthCheckInterval
2324 }
2325
2326 if !dara.IsNil(request.HealthCheckMethod) {
2327 body["HealthCheckMethod"] = request.HealthCheckMethod
2328 }
2329
2330 if !dara.IsNil(request.HealthCheckPort) {
2331 body["HealthCheckPort"] = request.HealthCheckPort
2332 }
2333
2334 if !dara.IsNil(request.HealthCheckSuccTimes) {
2335 body["HealthCheckSuccTimes"] = request.HealthCheckSuccTimes
2336 }
2337
2338 if !dara.IsNil(request.HealthCheckTimeout) {
2339 body["HealthCheckTimeout"] = request.HealthCheckTimeout
2340 }
2341
2342 if !dara.IsNil(request.HealthCheckType) {
2343 body["HealthCheckType"] = request.HealthCheckType
2344 }
2345
2346 if !dara.IsNil(request.HealthCheckURI) {
2347 body["HealthCheckURI"] = request.HealthCheckURI
2348 }
2349
2350 if !dara.IsNil(request.Name) {
2351 body["Name"] = request.Name
2352 }
2353
2354 if !dara.IsNil(request.Remarks) {
2355 body["Remarks"] = request.Remarks
2356 }
2357
2358 if !dara.IsNil(request.ServicePort) {
2359 body["ServicePort"] = request.ServicePort
2360 }
2361
2362 if !dara.IsNil(request.TargetPort) {
2363 body["TargetPort"] = request.TargetPort
2364 }
2365
2366 req := &openapiutil.OpenApiRequest{
2367 Body: openapiutil.ParseToMap(body),
2368 }
2369 params := &openapiutil.Params{
2370 Action: dara.String("CreateEdgeContainerApp"),
2371 Version: dara.String("2024-09-10"),
2372 Protocol: dara.String("HTTPS"),
2373 Pathname: dara.String("/"),
2374 Method: dara.String("POST"),
2375 AuthType: dara.String("AK"),
2376 Style: dara.String("RPC"),
2377 ReqBodyType: dara.String("formData"),
2378 BodyType: dara.String("json"),
2379 }
2380 _result = &CreateEdgeContainerAppResponse{}
2381 _body, _err := client.CallApi(params, req, runtime)
2382 if _err != nil {
2383 return _result, _err
2384 }
2385 _err = dara.Convert(_body, &_result)
2386 return _result, _err
2387 }
2388
2389 // Summary:
2390 //
2391 // Creates a containerized application. You can deploy and release a version of the application across points of presence (POPs).
2392 //
2393 // @param request - CreateEdgeContainerAppRequest
2394 //
2395 // @return CreateEdgeContainerAppResponse
2396 func CreateEdgeContainerApp(client *Client, request *CreateEdgeContainerAppRequest) (_result *CreateEdgeContainerAppResponse, _err error) {
2397 runtime := &dara.RuntimeOptions{}
2398 _result = &CreateEdgeContainerAppResponse{}
2399 _body, _err := CreateEdgeContainerAppWithOptions(client,request, runtime)
2400 if _err != nil {
2401 return _result, _err
2402 }
2403 _result = _body
2404 return _result, _err
2405 }
2406
2407 // Summary:
2408 //
2409 // 创建边缘容器应用的镜像秘钥
2410 //
2411 // @param request - CreateEdgeContainerAppImageSecretRequest
2412 //
2413 // @param runtime - runtime options for this request RuntimeOptions
2414 //
2415 // @return CreateEdgeContainerAppImageSecretResponse
2416 func CreateEdgeContainerAppImageSecretWithOptions(client *Client, request *CreateEdgeContainerAppImageSecretRequest, runtime *dara.RuntimeOptions) (_result *CreateEdgeContainerAppImageSecretResponse, _err error) {
2417 if dara.BoolValue(client.EnableValidate) == true {
2418 _err = request.Validate()
2419 if _err != nil {
2420 return _result, _err
2421 }
2422 }
2423 query := map[string]interface{}{}
2424 if !dara.IsNil(request.AppId) {
2425 query["AppId"] = request.AppId
2426 }
2427
2428 if !dara.IsNil(request.Password) {
2429 query["Password"] = request.Password
2430 }
2431
2432 if !dara.IsNil(request.Registry) {
2433 query["Registry"] = request.Registry
2434 }
2435
2436 if !dara.IsNil(request.Username) {
2437 query["Username"] = request.Username
2438 }
2439
2440 req := &openapiutil.OpenApiRequest{
2441 Query: openapiutil.Query(query),
2442 }
2443 params := &openapiutil.Params{
2444 Action: dara.String("CreateEdgeContainerAppImageSecret"),
2445 Version: dara.String("2024-09-10"),
2446 Protocol: dara.String("HTTPS"),
2447 Pathname: dara.String("/"),
2448 Method: dara.String("POST"),
2449 AuthType: dara.String("AK"),
2450 Style: dara.String("RPC"),
2451 ReqBodyType: dara.String("formData"),
2452 BodyType: dara.String("json"),
2453 }
2454 _result = &CreateEdgeContainerAppImageSecretResponse{}
2455 _body, _err := client.CallApi(params, req, runtime)
2456 if _err != nil {
2457 return _result, _err
2458 }
2459 _err = dara.Convert(_body, &_result)
2460 return _result, _err
2461 }
2462
2463 // Summary:
2464 //
2465 // 创建边缘容器应用的镜像秘钥
2466 //
2467 // @param request - CreateEdgeContainerAppImageSecretRequest
2468 //
2469 // @return CreateEdgeContainerAppImageSecretResponse
2470 func CreateEdgeContainerAppImageSecret(client *Client, request *CreateEdgeContainerAppImageSecretRequest) (_result *CreateEdgeContainerAppImageSecretResponse, _err error) {
2471 runtime := &dara.RuntimeOptions{}
2472 _result = &CreateEdgeContainerAppImageSecretResponse{}
2473 _body, _err := CreateEdgeContainerAppImageSecretWithOptions(client,request, runtime)
2474 if _err != nil {
2475 return _result, _err
2476 }
2477 _result = _body
2478 return _result, _err
2479 }
2480
2481 // Summary:
2482 //
2483 // Associates a domain name with a containerized application. This way, requests destined for the associated domain name are forwarded to the application.
2484 //
2485 // @param request - CreateEdgeContainerAppRecordRequest
2486 //
2487 // @param runtime - runtime options for this request RuntimeOptions
2488 //
2489 // @return CreateEdgeContainerAppRecordResponse
2490 func CreateEdgeContainerAppRecordWithOptions(client *Client, request *CreateEdgeContainerAppRecordRequest, runtime *dara.RuntimeOptions) (_result *CreateEdgeContainerAppRecordResponse, _err error) {
2491 if dara.BoolValue(client.EnableValidate) == true {
2492 _err = request.Validate()
2493 if _err != nil {
2494 return _result, _err
2495 }
2496 }
2497 body := map[string]interface{}{}
2498 if !dara.IsNil(request.AppId) {
2499 body["AppId"] = request.AppId
2500 }
2501
2502 if !dara.IsNil(request.RecordName) {
2503 body["RecordName"] = request.RecordName
2504 }
2505
2506 if !dara.IsNil(request.SiteId) {
2507 body["SiteId"] = request.SiteId
2508 }
2509
2510 req := &openapiutil.OpenApiRequest{
2511 Body: openapiutil.ParseToMap(body),
2512 }
2513 params := &openapiutil.Params{
2514 Action: dara.String("CreateEdgeContainerAppRecord"),
2515 Version: dara.String("2024-09-10"),
2516 Protocol: dara.String("HTTPS"),
2517 Pathname: dara.String("/"),
2518 Method: dara.String("POST"),
2519 AuthType: dara.String("AK"),
2520 Style: dara.String("RPC"),
2521 ReqBodyType: dara.String("formData"),
2522 BodyType: dara.String("json"),
2523 }
2524 _result = &CreateEdgeContainerAppRecordResponse{}
2525 _body, _err := client.CallApi(params, req, runtime)
2526 if _err != nil {
2527 return _result, _err
2528 }
2529 _err = dara.Convert(_body, &_result)
2530 return _result, _err
2531 }
2532
2533 // Summary:
2534 //
2535 // Associates a domain name with a containerized application. This way, requests destined for the associated domain name are forwarded to the application.
2536 //
2537 // @param request - CreateEdgeContainerAppRecordRequest
2538 //
2539 // @return CreateEdgeContainerAppRecordResponse
2540 func CreateEdgeContainerAppRecord(client *Client, request *CreateEdgeContainerAppRecordRequest) (_result *CreateEdgeContainerAppRecordResponse, _err error) {
2541 runtime := &dara.RuntimeOptions{}
2542 _result = &CreateEdgeContainerAppRecordResponse{}
2543 _body, _err := CreateEdgeContainerAppRecordWithOptions(client,request, runtime)
2544 if _err != nil {
2545 return _result, _err
2546 }
2547 _result = _body
2548 return _result, _err
2549 }
2550
2551 // Summary:
2552 //
2553 // Creates a version for a containerized application. You can iterate the application based on the version.
2554 //
2555 // @param tmpReq - CreateEdgeContainerAppVersionRequest
2556 //
2557 // @param runtime - runtime options for this request RuntimeOptions
2558 //
2559 // @return CreateEdgeContainerAppVersionResponse
2560 func CreateEdgeContainerAppVersionWithOptions(client *Client, tmpReq *CreateEdgeContainerAppVersionRequest, runtime *dara.RuntimeOptions) (_result *CreateEdgeContainerAppVersionResponse, _err error) {
2561 if dara.BoolValue(client.EnableValidate) == true {
2562 _err = tmpReq.Validate()
2563 if _err != nil {
2564 return _result, _err
2565 }
2566 }
2567 request := &CreateEdgeContainerAppVersionShrinkRequest{}
2568 openapiutil.Convert(tmpReq, request)
2569 if !dara.IsNil(tmpReq.Containers) {
2570 request.ContainersShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Containers, dara.String("Containers"), dara.String("json"))
2571 }
2572
2573 body := map[string]interface{}{}
2574 if !dara.IsNil(request.AppId) {
2575 body["AppId"] = request.AppId
2576 }
2577
2578 if !dara.IsNil(request.ContainersShrink) {
2579 body["Containers"] = request.ContainersShrink
2580 }
2581
2582 if !dara.IsNil(request.Name) {
2583 body["Name"] = request.Name
2584 }
2585
2586 if !dara.IsNil(request.Remarks) {
2587 body["Remarks"] = request.Remarks
2588 }
2589
2590 req := &openapiutil.OpenApiRequest{
2591 Body: openapiutil.ParseToMap(body),
2592 }
2593 params := &openapiutil.Params{
2594 Action: dara.String("CreateEdgeContainerAppVersion"),
2595 Version: dara.String("2024-09-10"),
2596 Protocol: dara.String("HTTPS"),
2597 Pathname: dara.String("/"),
2598 Method: dara.String("POST"),
2599 AuthType: dara.String("AK"),
2600 Style: dara.String("RPC"),
2601 ReqBodyType: dara.String("formData"),
2602 BodyType: dara.String("json"),
2603 }
2604 _result = &CreateEdgeContainerAppVersionResponse{}
2605 _body, _err := client.CallApi(params, req, runtime)
2606 if _err != nil {
2607 return _result, _err
2608 }
2609 _err = dara.Convert(_body, &_result)
2610 return _result, _err
2611 }
2612
2613 // Summary:
2614 //
2615 // Creates a version for a containerized application. You can iterate the application based on the version.
2616 //
2617 // @param request - CreateEdgeContainerAppVersionRequest
2618 //
2619 // @return CreateEdgeContainerAppVersionResponse
2620 func CreateEdgeContainerAppVersion(client *Client, request *CreateEdgeContainerAppVersionRequest) (_result *CreateEdgeContainerAppVersionResponse, _err error) {
2621 runtime := &dara.RuntimeOptions{}
2622 _result = &CreateEdgeContainerAppVersionResponse{}
2623 _body, _err := CreateEdgeContainerAppVersionWithOptions(client,request, runtime)
2624 if _err != nil {
2625 return _result, _err
2626 }
2627 _result = _body
2628 return _result, _err
2629 }
2630
2631 // Summary:
2632 //
2633 // Adds the configuration of modifying HTTP request headers for a website.
2634 //
2635 // @param tmpReq - CreateHttpIncomingRequestHeaderModificationRuleRequest
2636 //
2637 // @param runtime - runtime options for this request RuntimeOptions
2638 //
2639 // @return CreateHttpIncomingRequestHeaderModificationRuleResponse
2640 func CreateHttpIncomingRequestHeaderModificationRuleWithOptions(client *Client, tmpReq *CreateHttpIncomingRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateHttpIncomingRequestHeaderModificationRuleResponse, _err error) {
2641 if dara.BoolValue(client.EnableValidate) == true {
2642 _err = tmpReq.Validate()
2643 if _err != nil {
2644 return _result, _err
2645 }
2646 }
2647 request := &CreateHttpIncomingRequestHeaderModificationRuleShrinkRequest{}
2648 openapiutil.Convert(tmpReq, request)
2649 if !dara.IsNil(tmpReq.RequestHeaderModification) {
2650 request.RequestHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RequestHeaderModification, dara.String("RequestHeaderModification"), dara.String("json"))
2651 }
2652
2653 query := map[string]interface{}{}
2654 if !dara.IsNil(request.RequestHeaderModificationShrink) {
2655 query["RequestHeaderModification"] = request.RequestHeaderModificationShrink
2656 }
2657
2658 if !dara.IsNil(request.Rule) {
2659 query["Rule"] = request.Rule
2660 }
2661
2662 if !dara.IsNil(request.RuleEnable) {
2663 query["RuleEnable"] = request.RuleEnable
2664 }
2665
2666 if !dara.IsNil(request.RuleName) {
2667 query["RuleName"] = request.RuleName
2668 }
2669
2670 if !dara.IsNil(request.Sequence) {
2671 query["Sequence"] = request.Sequence
2672 }
2673
2674 if !dara.IsNil(request.SiteId) {
2675 query["SiteId"] = request.SiteId
2676 }
2677
2678 if !dara.IsNil(request.SiteVersion) {
2679 query["SiteVersion"] = request.SiteVersion
2680 }
2681
2682 req := &openapiutil.OpenApiRequest{
2683 Query: openapiutil.Query(query),
2684 }
2685 params := &openapiutil.Params{
2686 Action: dara.String("CreateHttpIncomingRequestHeaderModificationRule"),
2687 Version: dara.String("2024-09-10"),
2688 Protocol: dara.String("HTTPS"),
2689 Pathname: dara.String("/"),
2690 Method: dara.String("POST"),
2691 AuthType: dara.String("AK"),
2692 Style: dara.String("RPC"),
2693 ReqBodyType: dara.String("formData"),
2694 BodyType: dara.String("json"),
2695 }
2696 _result = &CreateHttpIncomingRequestHeaderModificationRuleResponse{}
2697 _body, _err := client.CallApi(params, req, runtime)
2698 if _err != nil {
2699 return _result, _err
2700 }
2701 _err = dara.Convert(_body, &_result)
2702 return _result, _err
2703 }
2704
2705 // Summary:
2706 //
2707 // Adds the configuration of modifying HTTP request headers for a website.
2708 //
2709 // @param request - CreateHttpIncomingRequestHeaderModificationRuleRequest
2710 //
2711 // @return CreateHttpIncomingRequestHeaderModificationRuleResponse
2712 func CreateHttpIncomingRequestHeaderModificationRule(client *Client, request *CreateHttpIncomingRequestHeaderModificationRuleRequest) (_result *CreateHttpIncomingRequestHeaderModificationRuleResponse, _err error) {
2713 runtime := &dara.RuntimeOptions{}
2714 _result = &CreateHttpIncomingRequestHeaderModificationRuleResponse{}
2715 _body, _err := CreateHttpIncomingRequestHeaderModificationRuleWithOptions(client,request, runtime)
2716 if _err != nil {
2717 return _result, _err
2718 }
2719 _result = _body
2720 return _result, _err
2721 }
2722
2723 // Summary:
2724 //
2725 // Adds the configuration of modifying HTTP response headers for a website.
2726 //
2727 // @param tmpReq - CreateHttpIncomingResponseHeaderModificationRuleRequest
2728 //
2729 // @param runtime - runtime options for this request RuntimeOptions
2730 //
2731 // @return CreateHttpIncomingResponseHeaderModificationRuleResponse
2732 func CreateHttpIncomingResponseHeaderModificationRuleWithOptions(client *Client, tmpReq *CreateHttpIncomingResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateHttpIncomingResponseHeaderModificationRuleResponse, _err error) {
2733 if dara.BoolValue(client.EnableValidate) == true {
2734 _err = tmpReq.Validate()
2735 if _err != nil {
2736 return _result, _err
2737 }
2738 }
2739 request := &CreateHttpIncomingResponseHeaderModificationRuleShrinkRequest{}
2740 openapiutil.Convert(tmpReq, request)
2741 if !dara.IsNil(tmpReq.ResponseHeaderModification) {
2742 request.ResponseHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ResponseHeaderModification, dara.String("ResponseHeaderModification"), dara.String("json"))
2743 }
2744
2745 query := map[string]interface{}{}
2746 if !dara.IsNil(request.ResponseHeaderModificationShrink) {
2747 query["ResponseHeaderModification"] = request.ResponseHeaderModificationShrink
2748 }
2749
2750 if !dara.IsNil(request.Rule) {
2751 query["Rule"] = request.Rule
2752 }
2753
2754 if !dara.IsNil(request.RuleEnable) {
2755 query["RuleEnable"] = request.RuleEnable
2756 }
2757
2758 if !dara.IsNil(request.RuleName) {
2759 query["RuleName"] = request.RuleName
2760 }
2761
2762 if !dara.IsNil(request.Sequence) {
2763 query["Sequence"] = request.Sequence
2764 }
2765
2766 if !dara.IsNil(request.SiteId) {
2767 query["SiteId"] = request.SiteId
2768 }
2769
2770 if !dara.IsNil(request.SiteVersion) {
2771 query["SiteVersion"] = request.SiteVersion
2772 }
2773
2774 req := &openapiutil.OpenApiRequest{
2775 Query: openapiutil.Query(query),
2776 }
2777 params := &openapiutil.Params{
2778 Action: dara.String("CreateHttpIncomingResponseHeaderModificationRule"),
2779 Version: dara.String("2024-09-10"),
2780 Protocol: dara.String("HTTPS"),
2781 Pathname: dara.String("/"),
2782 Method: dara.String("POST"),
2783 AuthType: dara.String("AK"),
2784 Style: dara.String("RPC"),
2785 ReqBodyType: dara.String("formData"),
2786 BodyType: dara.String("json"),
2787 }
2788 _result = &CreateHttpIncomingResponseHeaderModificationRuleResponse{}
2789 _body, _err := client.CallApi(params, req, runtime)
2790 if _err != nil {
2791 return _result, _err
2792 }
2793 _err = dara.Convert(_body, &_result)
2794 return _result, _err
2795 }
2796
2797 // Summary:
2798 //
2799 // Adds the configuration of modifying HTTP response headers for a website.
2800 //
2801 // @param request - CreateHttpIncomingResponseHeaderModificationRuleRequest
2802 //
2803 // @return CreateHttpIncomingResponseHeaderModificationRuleResponse
2804 func CreateHttpIncomingResponseHeaderModificationRule(client *Client, request *CreateHttpIncomingResponseHeaderModificationRuleRequest) (_result *CreateHttpIncomingResponseHeaderModificationRuleResponse, _err error) {
2805 runtime := &dara.RuntimeOptions{}
2806 _result = &CreateHttpIncomingResponseHeaderModificationRuleResponse{}
2807 _body, _err := CreateHttpIncomingResponseHeaderModificationRuleWithOptions(client,request, runtime)
2808 if _err != nil {
2809 return _result, _err
2810 }
2811 _result = _body
2812 return _result, _err
2813 }
2814
2815 // Summary:
2816 //
2817 // # Add HTTP Request Header Rule
2818 //
2819 // @param tmpReq - CreateHttpRequestHeaderModificationRuleRequest
2820 //
2821 // @param runtime - runtime options for this request RuntimeOptions
2822 //
2823 // @return CreateHttpRequestHeaderModificationRuleResponse
2824 func CreateHttpRequestHeaderModificationRuleWithOptions(client *Client, tmpReq *CreateHttpRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateHttpRequestHeaderModificationRuleResponse, _err error) {
2825 if dara.BoolValue(client.EnableValidate) == true {
2826 _err = tmpReq.Validate()
2827 if _err != nil {
2828 return _result, _err
2829 }
2830 }
2831 request := &CreateHttpRequestHeaderModificationRuleShrinkRequest{}
2832 openapiutil.Convert(tmpReq, request)
2833 if !dara.IsNil(tmpReq.RequestHeaderModification) {
2834 request.RequestHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RequestHeaderModification, dara.String("RequestHeaderModification"), dara.String("json"))
2835 }
2836
2837 query := map[string]interface{}{}
2838 if !dara.IsNil(request.RequestHeaderModificationShrink) {
2839 query["RequestHeaderModification"] = request.RequestHeaderModificationShrink
2840 }
2841
2842 if !dara.IsNil(request.Rule) {
2843 query["Rule"] = request.Rule
2844 }
2845
2846 if !dara.IsNil(request.RuleEnable) {
2847 query["RuleEnable"] = request.RuleEnable
2848 }
2849
2850 if !dara.IsNil(request.RuleName) {
2851 query["RuleName"] = request.RuleName
2852 }
2853
2854 if !dara.IsNil(request.Sequence) {
2855 query["Sequence"] = request.Sequence
2856 }
2857
2858 if !dara.IsNil(request.SiteId) {
2859 query["SiteId"] = request.SiteId
2860 }
2861
2862 if !dara.IsNil(request.SiteVersion) {
2863 query["SiteVersion"] = request.SiteVersion
2864 }
2865
2866 req := &openapiutil.OpenApiRequest{
2867 Query: openapiutil.Query(query),
2868 }
2869 params := &openapiutil.Params{
2870 Action: dara.String("CreateHttpRequestHeaderModificationRule"),
2871 Version: dara.String("2024-09-10"),
2872 Protocol: dara.String("HTTPS"),
2873 Pathname: dara.String("/"),
2874 Method: dara.String("POST"),
2875 AuthType: dara.String("AK"),
2876 Style: dara.String("RPC"),
2877 ReqBodyType: dara.String("formData"),
2878 BodyType: dara.String("json"),
2879 }
2880 _result = &CreateHttpRequestHeaderModificationRuleResponse{}
2881 _body, _err := client.CallApi(params, req, runtime)
2882 if _err != nil {
2883 return _result, _err
2884 }
2885 _err = dara.Convert(_body, &_result)
2886 return _result, _err
2887 }
2888
2889 // Summary:
2890 //
2891 // # Add HTTP Request Header Rule
2892 //
2893 // @param request - CreateHttpRequestHeaderModificationRuleRequest
2894 //
2895 // @return CreateHttpRequestHeaderModificationRuleResponse
2896 func CreateHttpRequestHeaderModificationRule(client *Client, request *CreateHttpRequestHeaderModificationRuleRequest) (_result *CreateHttpRequestHeaderModificationRuleResponse, _err error) {
2897 runtime := &dara.RuntimeOptions{}
2898 _result = &CreateHttpRequestHeaderModificationRuleResponse{}
2899 _body, _err := CreateHttpRequestHeaderModificationRuleWithOptions(client,request, runtime)
2900 if _err != nil {
2901 return _result, _err
2902 }
2903 _result = _body
2904 return _result, _err
2905 }
2906
2907 // Summary:
2908 //
2909 // # Add HTTP Response Header Rule
2910 //
2911 // @param tmpReq - CreateHttpResponseHeaderModificationRuleRequest
2912 //
2913 // @param runtime - runtime options for this request RuntimeOptions
2914 //
2915 // @return CreateHttpResponseHeaderModificationRuleResponse
2916 func CreateHttpResponseHeaderModificationRuleWithOptions(client *Client, tmpReq *CreateHttpResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateHttpResponseHeaderModificationRuleResponse, _err error) {
2917 if dara.BoolValue(client.EnableValidate) == true {
2918 _err = tmpReq.Validate()
2919 if _err != nil {
2920 return _result, _err
2921 }
2922 }
2923 request := &CreateHttpResponseHeaderModificationRuleShrinkRequest{}
2924 openapiutil.Convert(tmpReq, request)
2925 if !dara.IsNil(tmpReq.ResponseHeaderModification) {
2926 request.ResponseHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ResponseHeaderModification, dara.String("ResponseHeaderModification"), dara.String("json"))
2927 }
2928
2929 query := map[string]interface{}{}
2930 if !dara.IsNil(request.ResponseHeaderModificationShrink) {
2931 query["ResponseHeaderModification"] = request.ResponseHeaderModificationShrink
2932 }
2933
2934 if !dara.IsNil(request.Rule) {
2935 query["Rule"] = request.Rule
2936 }
2937
2938 if !dara.IsNil(request.RuleEnable) {
2939 query["RuleEnable"] = request.RuleEnable
2940 }
2941
2942 if !dara.IsNil(request.RuleName) {
2943 query["RuleName"] = request.RuleName
2944 }
2945
2946 if !dara.IsNil(request.Sequence) {
2947 query["Sequence"] = request.Sequence
2948 }
2949
2950 if !dara.IsNil(request.SiteId) {
2951 query["SiteId"] = request.SiteId
2952 }
2953
2954 if !dara.IsNil(request.SiteVersion) {
2955 query["SiteVersion"] = request.SiteVersion
2956 }
2957
2958 req := &openapiutil.OpenApiRequest{
2959 Query: openapiutil.Query(query),
2960 }
2961 params := &openapiutil.Params{
2962 Action: dara.String("CreateHttpResponseHeaderModificationRule"),
2963 Version: dara.String("2024-09-10"),
2964 Protocol: dara.String("HTTPS"),
2965 Pathname: dara.String("/"),
2966 Method: dara.String("POST"),
2967 AuthType: dara.String("AK"),
2968 Style: dara.String("RPC"),
2969 ReqBodyType: dara.String("formData"),
2970 BodyType: dara.String("json"),
2971 }
2972 _result = &CreateHttpResponseHeaderModificationRuleResponse{}
2973 _body, _err := client.CallApi(params, req, runtime)
2974 if _err != nil {
2975 return _result, _err
2976 }
2977 _err = dara.Convert(_body, &_result)
2978 return _result, _err
2979 }
2980
2981 // Summary:
2982 //
2983 // # Add HTTP Response Header Rule
2984 //
2985 // @param request - CreateHttpResponseHeaderModificationRuleRequest
2986 //
2987 // @return CreateHttpResponseHeaderModificationRuleResponse
2988 func CreateHttpResponseHeaderModificationRule(client *Client, request *CreateHttpResponseHeaderModificationRuleRequest) (_result *CreateHttpResponseHeaderModificationRuleResponse, _err error) {
2989 runtime := &dara.RuntimeOptions{}
2990 _result = &CreateHttpResponseHeaderModificationRuleResponse{}
2991 _body, _err := CreateHttpResponseHeaderModificationRuleWithOptions(client,request, runtime)
2992 if _err != nil {
2993 return _result, _err
2994 }
2995 _result = _body
2996 return _result, _err
2997 }
2998
2999 // Summary:
3000 //
3001 // # Create a new site HTTPS application configuration
3002 //
3003 // @param request - CreateHttpsApplicationConfigurationRequest
3004 //
3005 // @param runtime - runtime options for this request RuntimeOptions
3006 //
3007 // @return CreateHttpsApplicationConfigurationResponse
3008 func CreateHttpsApplicationConfigurationWithOptions(client *Client, request *CreateHttpsApplicationConfigurationRequest, runtime *dara.RuntimeOptions) (_result *CreateHttpsApplicationConfigurationResponse, _err error) {
3009 if dara.BoolValue(client.EnableValidate) == true {
3010 _err = request.Validate()
3011 if _err != nil {
3012 return _result, _err
3013 }
3014 }
3015 query := map[string]interface{}{}
3016 if !dara.IsNil(request.AltSvc) {
3017 query["AltSvc"] = request.AltSvc
3018 }
3019
3020 if !dara.IsNil(request.AltSvcClear) {
3021 query["AltSvcClear"] = request.AltSvcClear
3022 }
3023
3024 if !dara.IsNil(request.AltSvcMa) {
3025 query["AltSvcMa"] = request.AltSvcMa
3026 }
3027
3028 if !dara.IsNil(request.AltSvcPersist) {
3029 query["AltSvcPersist"] = request.AltSvcPersist
3030 }
3031
3032 if !dara.IsNil(request.Hsts) {
3033 query["Hsts"] = request.Hsts
3034 }
3035
3036 if !dara.IsNil(request.HstsIncludeSubdomains) {
3037 query["HstsIncludeSubdomains"] = request.HstsIncludeSubdomains
3038 }
3039
3040 if !dara.IsNil(request.HstsMaxAge) {
3041 query["HstsMaxAge"] = request.HstsMaxAge
3042 }
3043
3044 if !dara.IsNil(request.HstsPreload) {
3045 query["HstsPreload"] = request.HstsPreload
3046 }
3047
3048 if !dara.IsNil(request.HttpsForce) {
3049 query["HttpsForce"] = request.HttpsForce
3050 }
3051
3052 if !dara.IsNil(request.HttpsForceCode) {
3053 query["HttpsForceCode"] = request.HttpsForceCode
3054 }
3055
3056 if !dara.IsNil(request.HttpsNoSniDeny) {
3057 query["HttpsNoSniDeny"] = request.HttpsNoSniDeny
3058 }
3059
3060 if !dara.IsNil(request.HttpsSniVerify) {
3061 query["HttpsSniVerify"] = request.HttpsSniVerify
3062 }
3063
3064 if !dara.IsNil(request.HttpsSniWhitelist) {
3065 query["HttpsSniWhitelist"] = request.HttpsSniWhitelist
3066 }
3067
3068 if !dara.IsNil(request.Rule) {
3069 query["Rule"] = request.Rule
3070 }
3071
3072 if !dara.IsNil(request.RuleEnable) {
3073 query["RuleEnable"] = request.RuleEnable
3074 }
3075
3076 if !dara.IsNil(request.RuleName) {
3077 query["RuleName"] = request.RuleName
3078 }
3079
3080 if !dara.IsNil(request.Sequence) {
3081 query["Sequence"] = request.Sequence
3082 }
3083
3084 if !dara.IsNil(request.SiteId) {
3085 query["SiteId"] = request.SiteId
3086 }
3087
3088 if !dara.IsNil(request.SiteVersion) {
3089 query["SiteVersion"] = request.SiteVersion
3090 }
3091
3092 req := &openapiutil.OpenApiRequest{
3093 Query: openapiutil.Query(query),
3094 }
3095 params := &openapiutil.Params{
3096 Action: dara.String("CreateHttpsApplicationConfiguration"),
3097 Version: dara.String("2024-09-10"),
3098 Protocol: dara.String("HTTPS"),
3099 Pathname: dara.String("/"),
3100 Method: dara.String("POST"),
3101 AuthType: dara.String("AK"),
3102 Style: dara.String("RPC"),
3103 ReqBodyType: dara.String("formData"),
3104 BodyType: dara.String("json"),
3105 }
3106 _result = &CreateHttpsApplicationConfigurationResponse{}
3107 _body, _err := client.CallApi(params, req, runtime)
3108 if _err != nil {
3109 return _result, _err
3110 }
3111 _err = dara.Convert(_body, &_result)
3112 return _result, _err
3113 }
3114
3115 // Summary:
3116 //
3117 // # Create a new site HTTPS application configuration
3118 //
3119 // @param request - CreateHttpsApplicationConfigurationRequest
3120 //
3121 // @return CreateHttpsApplicationConfigurationResponse
3122 func CreateHttpsApplicationConfiguration(client *Client, request *CreateHttpsApplicationConfigurationRequest) (_result *CreateHttpsApplicationConfigurationResponse, _err error) {
3123 runtime := &dara.RuntimeOptions{}
3124 _result = &CreateHttpsApplicationConfigurationResponse{}
3125 _body, _err := CreateHttpsApplicationConfigurationWithOptions(client,request, runtime)
3126 if _err != nil {
3127 return _result, _err
3128 }
3129 _result = _body
3130 return _result, _err
3131 }
3132
3133 // Summary:
3134 //
3135 // # Create a new site HTTPS basic configuration
3136 //
3137 // @param request - CreateHttpsBasicConfigurationRequest
3138 //
3139 // @param runtime - runtime options for this request RuntimeOptions
3140 //
3141 // @return CreateHttpsBasicConfigurationResponse
3142 func CreateHttpsBasicConfigurationWithOptions(client *Client, request *CreateHttpsBasicConfigurationRequest, runtime *dara.RuntimeOptions) (_result *CreateHttpsBasicConfigurationResponse, _err error) {
3143 if dara.BoolValue(client.EnableValidate) == true {
3144 _err = request.Validate()
3145 if _err != nil {
3146 return _result, _err
3147 }
3148 }
3149 query := map[string]interface{}{}
3150 if !dara.IsNil(request.Ciphersuite) {
3151 query["Ciphersuite"] = request.Ciphersuite
3152 }
3153
3154 if !dara.IsNil(request.CiphersuiteGroup) {
3155 query["CiphersuiteGroup"] = request.CiphersuiteGroup
3156 }
3157
3158 if !dara.IsNil(request.Http2) {
3159 query["Http2"] = request.Http2
3160 }
3161
3162 if !dara.IsNil(request.Http3) {
3163 query["Http3"] = request.Http3
3164 }
3165
3166 if !dara.IsNil(request.Https) {
3167 query["Https"] = request.Https
3168 }
3169
3170 if !dara.IsNil(request.OcspStapling) {
3171 query["OcspStapling"] = request.OcspStapling
3172 }
3173
3174 if !dara.IsNil(request.Rule) {
3175 query["Rule"] = request.Rule
3176 }
3177
3178 if !dara.IsNil(request.RuleEnable) {
3179 query["RuleEnable"] = request.RuleEnable
3180 }
3181
3182 if !dara.IsNil(request.RuleName) {
3183 query["RuleName"] = request.RuleName
3184 }
3185
3186 if !dara.IsNil(request.Sequence) {
3187 query["Sequence"] = request.Sequence
3188 }
3189
3190 if !dara.IsNil(request.SiteId) {
3191 query["SiteId"] = request.SiteId
3192 }
3193
3194 if !dara.IsNil(request.Tls10) {
3195 query["Tls10"] = request.Tls10
3196 }
3197
3198 if !dara.IsNil(request.Tls11) {
3199 query["Tls11"] = request.Tls11
3200 }
3201
3202 if !dara.IsNil(request.Tls12) {
3203 query["Tls12"] = request.Tls12
3204 }
3205
3206 if !dara.IsNil(request.Tls13) {
3207 query["Tls13"] = request.Tls13
3208 }
3209
3210 req := &openapiutil.OpenApiRequest{
3211 Query: openapiutil.Query(query),
3212 }
3213 params := &openapiutil.Params{
3214 Action: dara.String("CreateHttpsBasicConfiguration"),
3215 Version: dara.String("2024-09-10"),
3216 Protocol: dara.String("HTTPS"),
3217 Pathname: dara.String("/"),
3218 Method: dara.String("POST"),
3219 AuthType: dara.String("AK"),
3220 Style: dara.String("RPC"),
3221 ReqBodyType: dara.String("formData"),
3222 BodyType: dara.String("json"),
3223 }
3224 _result = &CreateHttpsBasicConfigurationResponse{}
3225 _body, _err := client.CallApi(params, req, runtime)
3226 if _err != nil {
3227 return _result, _err
3228 }
3229 _err = dara.Convert(_body, &_result)
3230 return _result, _err
3231 }
3232
3233 // Summary:
3234 //
3235 // # Create a new site HTTPS basic configuration
3236 //
3237 // @param request - CreateHttpsBasicConfigurationRequest
3238 //
3239 // @return CreateHttpsBasicConfigurationResponse
3240 func CreateHttpsBasicConfiguration(client *Client, request *CreateHttpsBasicConfigurationRequest) (_result *CreateHttpsBasicConfigurationResponse, _err error) {
3241 runtime := &dara.RuntimeOptions{}
3242 _result = &CreateHttpsBasicConfigurationResponse{}
3243 _body, _err := CreateHttpsBasicConfigurationWithOptions(client,request, runtime)
3244 if _err != nil {
3245 return _result, _err
3246 }
3247 _result = _body
3248 return _result, _err
3249 }
3250
3251 // Summary:
3252 //
3253 // # Add Site Image Transformation Configuration
3254 //
3255 // @param request - CreateImageTransformRequest
3256 //
3257 // @param runtime - runtime options for this request RuntimeOptions
3258 //
3259 // @return CreateImageTransformResponse
3260 func CreateImageTransformWithOptions(client *Client, request *CreateImageTransformRequest, runtime *dara.RuntimeOptions) (_result *CreateImageTransformResponse, _err error) {
3261 if dara.BoolValue(client.EnableValidate) == true {
3262 _err = request.Validate()
3263 if _err != nil {
3264 return _result, _err
3265 }
3266 }
3267 query := map[string]interface{}{}
3268 if !dara.IsNil(request.Enable) {
3269 query["Enable"] = request.Enable
3270 }
3271
3272 if !dara.IsNil(request.Rule) {
3273 query["Rule"] = request.Rule
3274 }
3275
3276 if !dara.IsNil(request.RuleEnable) {
3277 query["RuleEnable"] = request.RuleEnable
3278 }
3279
3280 if !dara.IsNil(request.RuleName) {
3281 query["RuleName"] = request.RuleName
3282 }
3283
3284 if !dara.IsNil(request.Sequence) {
3285 query["Sequence"] = request.Sequence
3286 }
3287
3288 if !dara.IsNil(request.SiteId) {
3289 query["SiteId"] = request.SiteId
3290 }
3291
3292 if !dara.IsNil(request.SiteVersion) {
3293 query["SiteVersion"] = request.SiteVersion
3294 }
3295
3296 req := &openapiutil.OpenApiRequest{
3297 Query: openapiutil.Query(query),
3298 }
3299 params := &openapiutil.Params{
3300 Action: dara.String("CreateImageTransform"),
3301 Version: dara.String("2024-09-10"),
3302 Protocol: dara.String("HTTPS"),
3303 Pathname: dara.String("/"),
3304 Method: dara.String("POST"),
3305 AuthType: dara.String("AK"),
3306 Style: dara.String("RPC"),
3307 ReqBodyType: dara.String("formData"),
3308 BodyType: dara.String("json"),
3309 }
3310 _result = &CreateImageTransformResponse{}
3311 _body, _err := client.CallApi(params, req, runtime)
3312 if _err != nil {
3313 return _result, _err
3314 }
3315 _err = dara.Convert(_body, &_result)
3316 return _result, _err
3317 }
3318
3319 // Summary:
3320 //
3321 // # Add Site Image Transformation Configuration
3322 //
3323 // @param request - CreateImageTransformRequest
3324 //
3325 // @return CreateImageTransformResponse
3326 func CreateImageTransform(client *Client, request *CreateImageTransformRequest) (_result *CreateImageTransformResponse, _err error) {
3327 runtime := &dara.RuntimeOptions{}
3328 _result = &CreateImageTransformResponse{}
3329 _body, _err := CreateImageTransformWithOptions(client,request, runtime)
3330 if _err != nil {
3331 return _result, _err
3332 }
3333 _result = _body
3334 return _result, _err
3335 }
3336
3337 // Summary:
3338 //
3339 // Create a namespace in your Alibaba Cloud account.
3340 //
3341 // @param request - CreateKvNamespaceRequest
3342 //
3343 // @param runtime - runtime options for this request RuntimeOptions
3344 //
3345 // @return CreateKvNamespaceResponse
3346 func CreateKvNamespaceWithOptions(client *Client, request *CreateKvNamespaceRequest, runtime *dara.RuntimeOptions) (_result *CreateKvNamespaceResponse, _err error) {
3347 if dara.BoolValue(client.EnableValidate) == true {
3348 _err = request.Validate()
3349 if _err != nil {
3350 return _result, _err
3351 }
3352 }
3353 body := map[string]interface{}{}
3354 if !dara.IsNil(request.Description) {
3355 body["Description"] = request.Description
3356 }
3357
3358 if !dara.IsNil(request.Namespace) {
3359 body["Namespace"] = request.Namespace
3360 }
3361
3362 req := &openapiutil.OpenApiRequest{
3363 Body: openapiutil.ParseToMap(body),
3364 }
3365 params := &openapiutil.Params{
3366 Action: dara.String("CreateKvNamespace"),
3367 Version: dara.String("2024-09-10"),
3368 Protocol: dara.String("HTTPS"),
3369 Pathname: dara.String("/"),
3370 Method: dara.String("POST"),
3371 AuthType: dara.String("AK"),
3372 Style: dara.String("RPC"),
3373 ReqBodyType: dara.String("formData"),
3374 BodyType: dara.String("json"),
3375 }
3376 _result = &CreateKvNamespaceResponse{}
3377 _body, _err := client.CallApi(params, req, runtime)
3378 if _err != nil {
3379 return _result, _err
3380 }
3381 _err = dara.Convert(_body, &_result)
3382 return _result, _err
3383 }
3384
3385 // Summary:
3386 //
3387 // Create a namespace in your Alibaba Cloud account.
3388 //
3389 // @param request - CreateKvNamespaceRequest
3390 //
3391 // @return CreateKvNamespaceResponse
3392 func CreateKvNamespace(client *Client, request *CreateKvNamespaceRequest) (_result *CreateKvNamespaceResponse, _err error) {
3393 runtime := &dara.RuntimeOptions{}
3394 _result = &CreateKvNamespaceResponse{}
3395 _body, _err := CreateKvNamespaceWithOptions(client,request, runtime)
3396 if _err != nil {
3397 return _result, _err
3398 }
3399 _result = _body
3400 return _result, _err
3401 }
3402
3403 // Summary:
3404 //
3405 // Creates a list. Lists are used for the referencing of values in the rules engine to implement complex logic and control in security policies.
3406 //
3407 // @param tmpReq - CreateListRequest
3408 //
3409 // @param runtime - runtime options for this request RuntimeOptions
3410 //
3411 // @return CreateListResponse
3412 func CreateListWithOptions(client *Client, tmpReq *CreateListRequest, runtime *dara.RuntimeOptions) (_result *CreateListResponse, _err error) {
3413 if dara.BoolValue(client.EnableValidate) == true {
3414 _err = tmpReq.Validate()
3415 if _err != nil {
3416 return _result, _err
3417 }
3418 }
3419 request := &CreateListShrinkRequest{}
3420 openapiutil.Convert(tmpReq, request)
3421 if !dara.IsNil(tmpReq.Items) {
3422 request.ItemsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Items, dara.String("Items"), dara.String("json"))
3423 }
3424
3425 body := map[string]interface{}{}
3426 if !dara.IsNil(request.Description) {
3427 body["Description"] = request.Description
3428 }
3429
3430 if !dara.IsNil(request.ItemsShrink) {
3431 body["Items"] = request.ItemsShrink
3432 }
3433
3434 if !dara.IsNil(request.Kind) {
3435 body["Kind"] = request.Kind
3436 }
3437
3438 if !dara.IsNil(request.Name) {
3439 body["Name"] = request.Name
3440 }
3441
3442 req := &openapiutil.OpenApiRequest{
3443 Body: openapiutil.ParseToMap(body),
3444 }
3445 params := &openapiutil.Params{
3446 Action: dara.String("CreateList"),
3447 Version: dara.String("2024-09-10"),
3448 Protocol: dara.String("HTTPS"),
3449 Pathname: dara.String("/"),
3450 Method: dara.String("POST"),
3451 AuthType: dara.String("AK"),
3452 Style: dara.String("RPC"),
3453 ReqBodyType: dara.String("formData"),
3454 BodyType: dara.String("json"),
3455 }
3456 _result = &CreateListResponse{}
3457 _body, _err := client.CallApi(params, req, runtime)
3458 if _err != nil {
3459 return _result, _err
3460 }
3461 _err = dara.Convert(_body, &_result)
3462 return _result, _err
3463 }
3464
3465 // Summary:
3466 //
3467 // Creates a list. Lists are used for the referencing of values in the rules engine to implement complex logic and control in security policies.
3468 //
3469 // @param request - CreateListRequest
3470 //
3471 // @return CreateListResponse
3472 func CreateList(client *Client, request *CreateListRequest) (_result *CreateListResponse, _err error) {
3473 runtime := &dara.RuntimeOptions{}
3474 _result = &CreateListResponse{}
3475 _body, _err := CreateListWithOptions(client,request, runtime)
3476 if _err != nil {
3477 return _result, _err
3478 }
3479 _result = _body
3480 return _result, _err
3481 }
3482
3483 // Summary:
3484 //
3485 // # Add a New Load Balancer
3486 //
3487 // Description:
3488 //
3489 // 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.
3490 //
3491 // @param tmpReq - CreateLoadBalancerRequest
3492 //
3493 // @param runtime - runtime options for this request RuntimeOptions
3494 //
3495 // @return CreateLoadBalancerResponse
3496 func CreateLoadBalancerWithOptions(client *Client, tmpReq *CreateLoadBalancerRequest, runtime *dara.RuntimeOptions) (_result *CreateLoadBalancerResponse, _err error) {
3497 if dara.BoolValue(client.EnableValidate) == true {
3498 _err = tmpReq.Validate()
3499 if _err != nil {
3500 return _result, _err
3501 }
3502 }
3503 request := &CreateLoadBalancerShrinkRequest{}
3504 openapiutil.Convert(tmpReq, request)
3505 if !dara.IsNil(tmpReq.AdaptiveRouting) {
3506 request.AdaptiveRoutingShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AdaptiveRouting, dara.String("AdaptiveRouting"), dara.String("json"))
3507 }
3508
3509 if !dara.IsNil(tmpReq.DefaultPools) {
3510 request.DefaultPoolsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.DefaultPools, dara.String("DefaultPools"), dara.String("json"))
3511 }
3512
3513 if !dara.IsNil(tmpReq.Monitor) {
3514 request.MonitorShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Monitor, dara.String("Monitor"), dara.String("json"))
3515 }
3516
3517 if !dara.IsNil(tmpReq.RandomSteering) {
3518 request.RandomSteeringShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RandomSteering, dara.String("RandomSteering"), dara.String("json"))
3519 }
3520
3521 if !dara.IsNil(tmpReq.Rules) {
3522 request.RulesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Rules, dara.String("Rules"), dara.String("json"))
3523 }
3524
3525 query := map[string]interface{}{}
3526 if !dara.IsNil(request.AdaptiveRoutingShrink) {
3527 query["AdaptiveRouting"] = request.AdaptiveRoutingShrink
3528 }
3529
3530 if !dara.IsNil(request.DefaultPoolsShrink) {
3531 query["DefaultPools"] = request.DefaultPoolsShrink
3532 }
3533
3534 if !dara.IsNil(request.Description) {
3535 query["Description"] = request.Description
3536 }
3537
3538 if !dara.IsNil(request.Enabled) {
3539 query["Enabled"] = request.Enabled
3540 }
3541
3542 if !dara.IsNil(request.FallbackPool) {
3543 query["FallbackPool"] = request.FallbackPool
3544 }
3545
3546 if !dara.IsNil(request.MonitorShrink) {
3547 query["Monitor"] = request.MonitorShrink
3548 }
3549
3550 if !dara.IsNil(request.Name) {
3551 query["Name"] = request.Name
3552 }
3553
3554 if !dara.IsNil(request.RandomSteeringShrink) {
3555 query["RandomSteering"] = request.RandomSteeringShrink
3556 }
3557
3558 if !dara.IsNil(request.RegionPools) {
3559 query["RegionPools"] = request.RegionPools
3560 }
3561
3562 if !dara.IsNil(request.RulesShrink) {
3563 query["Rules"] = request.RulesShrink
3564 }
3565
3566 if !dara.IsNil(request.SessionAffinity) {
3567 query["SessionAffinity"] = request.SessionAffinity
3568 }
3569
3570 if !dara.IsNil(request.SiteId) {
3571 query["SiteId"] = request.SiteId
3572 }
3573
3574 if !dara.IsNil(request.SteeringPolicy) {
3575 query["SteeringPolicy"] = request.SteeringPolicy
3576 }
3577
3578 if !dara.IsNil(request.SubRegionPools) {
3579 query["SubRegionPools"] = request.SubRegionPools
3580 }
3581
3582 if !dara.IsNil(request.Ttl) {
3583 query["Ttl"] = request.Ttl
3584 }
3585
3586 req := &openapiutil.OpenApiRequest{
3587 Query: openapiutil.Query(query),
3588 }
3589 params := &openapiutil.Params{
3590 Action: dara.String("CreateLoadBalancer"),
3591 Version: dara.String("2024-09-10"),
3592 Protocol: dara.String("HTTPS"),
3593 Pathname: dara.String("/"),
3594 Method: dara.String("POST"),
3595 AuthType: dara.String("AK"),
3596 Style: dara.String("RPC"),
3597 ReqBodyType: dara.String("formData"),
3598 BodyType: dara.String("json"),
3599 }
3600 _result = &CreateLoadBalancerResponse{}
3601 _body, _err := client.CallApi(params, req, runtime)
3602 if _err != nil {
3603 return _result, _err
3604 }
3605 _err = dara.Convert(_body, &_result)
3606 return _result, _err
3607 }
3608
3609 // Summary:
3610 //
3611 // # Add a New Load Balancer
3612 //
3613 // Description:
3614 //
3615 // 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.
3616 //
3617 // @param request - CreateLoadBalancerRequest
3618 //
3619 // @return CreateLoadBalancerResponse
3620 func CreateLoadBalancer(client *Client, request *CreateLoadBalancerRequest) (_result *CreateLoadBalancerResponse, _err error) {
3621 runtime := &dara.RuntimeOptions{}
3622 _result = &CreateLoadBalancerResponse{}
3623 _body, _err := CreateLoadBalancerWithOptions(client,request, runtime)
3624 if _err != nil {
3625 return _result, _err
3626 }
3627 _result = _body
3628 return _result, _err
3629 }
3630
3631 // Summary:
3632 //
3633 // # Create a new site network optimization configuration
3634 //
3635 // @param request - CreateNetworkOptimizationRequest
3636 //
3637 // @param runtime - runtime options for this request RuntimeOptions
3638 //
3639 // @return CreateNetworkOptimizationResponse
3640 func CreateNetworkOptimizationWithOptions(client *Client, request *CreateNetworkOptimizationRequest, runtime *dara.RuntimeOptions) (_result *CreateNetworkOptimizationResponse, _err error) {
3641 if dara.BoolValue(client.EnableValidate) == true {
3642 _err = request.Validate()
3643 if _err != nil {
3644 return _result, _err
3645 }
3646 }
3647 query := map[string]interface{}{}
3648 if !dara.IsNil(request.Grpc) {
3649 query["Grpc"] = request.Grpc
3650 }
3651
3652 if !dara.IsNil(request.Http2Origin) {
3653 query["Http2Origin"] = request.Http2Origin
3654 }
3655
3656 if !dara.IsNil(request.Rule) {
3657 query["Rule"] = request.Rule
3658 }
3659
3660 if !dara.IsNil(request.RuleEnable) {
3661 query["RuleEnable"] = request.RuleEnable
3662 }
3663
3664 if !dara.IsNil(request.RuleName) {
3665 query["RuleName"] = request.RuleName
3666 }
3667
3668 if !dara.IsNil(request.Sequence) {
3669 query["Sequence"] = request.Sequence
3670 }
3671
3672 if !dara.IsNil(request.SiteId) {
3673 query["SiteId"] = request.SiteId
3674 }
3675
3676 if !dara.IsNil(request.SiteVersion) {
3677 query["SiteVersion"] = request.SiteVersion
3678 }
3679
3680 if !dara.IsNil(request.SmartRouting) {
3681 query["SmartRouting"] = request.SmartRouting
3682 }
3683
3684 if !dara.IsNil(request.UploadMaxFilesize) {
3685 query["UploadMaxFilesize"] = request.UploadMaxFilesize
3686 }
3687
3688 if !dara.IsNil(request.Websocket) {
3689 query["Websocket"] = request.Websocket
3690 }
3691
3692 req := &openapiutil.OpenApiRequest{
3693 Query: openapiutil.Query(query),
3694 }
3695 params := &openapiutil.Params{
3696 Action: dara.String("CreateNetworkOptimization"),
3697 Version: dara.String("2024-09-10"),
3698 Protocol: dara.String("HTTPS"),
3699 Pathname: dara.String("/"),
3700 Method: dara.String("POST"),
3701 AuthType: dara.String("AK"),
3702 Style: dara.String("RPC"),
3703 ReqBodyType: dara.String("formData"),
3704 BodyType: dara.String("json"),
3705 }
3706 _result = &CreateNetworkOptimizationResponse{}
3707 _body, _err := client.CallApi(params, req, runtime)
3708 if _err != nil {
3709 return _result, _err
3710 }
3711 _err = dara.Convert(_body, &_result)
3712 return _result, _err
3713 }
3714
3715 // Summary:
3716 //
3717 // # Create a new site network optimization configuration
3718 //
3719 // @param request - CreateNetworkOptimizationRequest
3720 //
3721 // @return CreateNetworkOptimizationResponse
3722 func CreateNetworkOptimization(client *Client, request *CreateNetworkOptimizationRequest) (_result *CreateNetworkOptimizationResponse, _err error) {
3723 runtime := &dara.RuntimeOptions{}
3724 _result = &CreateNetworkOptimizationResponse{}
3725 _body, _err := CreateNetworkOptimizationWithOptions(client,request, runtime)
3726 if _err != nil {
3727 return _result, _err
3728 }
3729 _result = _body
3730 return _result, _err
3731 }
3732
3733 // Summary:
3734 //
3735 // # Add a new origin address pool
3736 //
3737 // Description:
3738 //
3739 // 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.
3740 //
3741 // @param tmpReq - CreateOriginPoolRequest
3742 //
3743 // @param runtime - runtime options for this request RuntimeOptions
3744 //
3745 // @return CreateOriginPoolResponse
3746 func CreateOriginPoolWithOptions(client *Client, tmpReq *CreateOriginPoolRequest, runtime *dara.RuntimeOptions) (_result *CreateOriginPoolResponse, _err error) {
3747 if dara.BoolValue(client.EnableValidate) == true {
3748 _err = tmpReq.Validate()
3749 if _err != nil {
3750 return _result, _err
3751 }
3752 }
3753 request := &CreateOriginPoolShrinkRequest{}
3754 openapiutil.Convert(tmpReq, request)
3755 if !dara.IsNil(tmpReq.Origins) {
3756 request.OriginsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Origins, dara.String("Origins"), dara.String("json"))
3757 }
3758
3759 query := map[string]interface{}{}
3760 if !dara.IsNil(request.Enabled) {
3761 query["Enabled"] = request.Enabled
3762 }
3763
3764 if !dara.IsNil(request.Name) {
3765 query["Name"] = request.Name
3766 }
3767
3768 if !dara.IsNil(request.OriginsShrink) {
3769 query["Origins"] = request.OriginsShrink
3770 }
3771
3772 if !dara.IsNil(request.SiteId) {
3773 query["SiteId"] = request.SiteId
3774 }
3775
3776 req := &openapiutil.OpenApiRequest{
3777 Query: openapiutil.Query(query),
3778 }
3779 params := &openapiutil.Params{
3780 Action: dara.String("CreateOriginPool"),
3781 Version: dara.String("2024-09-10"),
3782 Protocol: dara.String("HTTPS"),
3783 Pathname: dara.String("/"),
3784 Method: dara.String("POST"),
3785 AuthType: dara.String("AK"),
3786 Style: dara.String("RPC"),
3787 ReqBodyType: dara.String("formData"),
3788 BodyType: dara.String("json"),
3789 }
3790 _result = &CreateOriginPoolResponse{}
3791 _body, _err := client.CallApi(params, req, runtime)
3792 if _err != nil {
3793 return _result, _err
3794 }
3795 _err = dara.Convert(_body, &_result)
3796 return _result, _err
3797 }
3798
3799 // Summary:
3800 //
3801 // # Add a new origin address pool
3802 //
3803 // Description:
3804 //
3805 // 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.
3806 //
3807 // @param request - CreateOriginPoolRequest
3808 //
3809 // @return CreateOriginPoolResponse
3810 func CreateOriginPool(client *Client, request *CreateOriginPoolRequest) (_result *CreateOriginPoolResponse, _err error) {
3811 runtime := &dara.RuntimeOptions{}
3812 _result = &CreateOriginPoolResponse{}
3813 _body, _err := CreateOriginPoolWithOptions(client,request, runtime)
3814 if _err != nil {
3815 return _result, _err
3816 }
3817 _result = _body
3818 return _result, _err
3819 }
3820
3821 // Summary:
3822 //
3823 // Enables origin protection.
3824 //
3825 // @param request - CreateOriginProtectionRequest
3826 //
3827 // @param runtime - runtime options for this request RuntimeOptions
3828 //
3829 // @return CreateOriginProtectionResponse
3830 func CreateOriginProtectionWithOptions(client *Client, request *CreateOriginProtectionRequest, runtime *dara.RuntimeOptions) (_result *CreateOriginProtectionResponse, _err error) {
3831 if dara.BoolValue(client.EnableValidate) == true {
3832 _err = request.Validate()
3833 if _err != nil {
3834 return _result, _err
3835 }
3836 }
3837 query := map[string]interface{}{}
3838 if !dara.IsNil(request.AutoConfirmIPList) {
3839 query["AutoConfirmIPList"] = request.AutoConfirmIPList
3840 }
3841
3842 if !dara.IsNil(request.SiteId) {
3843 query["SiteId"] = request.SiteId
3844 }
3845
3846 req := &openapiutil.OpenApiRequest{
3847 Query: openapiutil.Query(query),
3848 }
3849 params := &openapiutil.Params{
3850 Action: dara.String("CreateOriginProtection"),
3851 Version: dara.String("2024-09-10"),
3852 Protocol: dara.String("HTTPS"),
3853 Pathname: dara.String("/"),
3854 Method: dara.String("POST"),
3855 AuthType: dara.String("AK"),
3856 Style: dara.String("RPC"),
3857 ReqBodyType: dara.String("formData"),
3858 BodyType: dara.String("json"),
3859 }
3860 _result = &CreateOriginProtectionResponse{}
3861 _body, _err := client.CallApi(params, req, runtime)
3862 if _err != nil {
3863 return _result, _err
3864 }
3865 _err = dara.Convert(_body, &_result)
3866 return _result, _err
3867 }
3868
3869 // Summary:
3870 //
3871 // Enables origin protection.
3872 //
3873 // @param request - CreateOriginProtectionRequest
3874 //
3875 // @return CreateOriginProtectionResponse
3876 func CreateOriginProtection(client *Client, request *CreateOriginProtectionRequest) (_result *CreateOriginProtectionResponse, _err error) {
3877 runtime := &dara.RuntimeOptions{}
3878 _result = &CreateOriginProtectionResponse{}
3879 _body, _err := CreateOriginProtectionWithOptions(client,request, runtime)
3880 if _err != nil {
3881 return _result, _err
3882 }
3883 _result = _body
3884 return _result, _err
3885 }
3886
3887 // Summary:
3888 //
3889 // # Create a new origin rule configuration for the site
3890 //
3891 // @param request - CreateOriginRuleRequest
3892 //
3893 // @param runtime - runtime options for this request RuntimeOptions
3894 //
3895 // @return CreateOriginRuleResponse
3896 func CreateOriginRuleWithOptions(client *Client, request *CreateOriginRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateOriginRuleResponse, _err error) {
3897 if dara.BoolValue(client.EnableValidate) == true {
3898 _err = request.Validate()
3899 if _err != nil {
3900 return _result, _err
3901 }
3902 }
3903 query := map[string]interface{}{}
3904 if !dara.IsNil(request.DnsRecord) {
3905 query["DnsRecord"] = request.DnsRecord
3906 }
3907
3908 if !dara.IsNil(request.Follow302Enable) {
3909 query["Follow302Enable"] = request.Follow302Enable
3910 }
3911
3912 if !dara.IsNil(request.Follow302MaxTries) {
3913 query["Follow302MaxTries"] = request.Follow302MaxTries
3914 }
3915
3916 if !dara.IsNil(request.Follow302RetainArgs) {
3917 query["Follow302RetainArgs"] = request.Follow302RetainArgs
3918 }
3919
3920 if !dara.IsNil(request.Follow302RetainHeader) {
3921 query["Follow302RetainHeader"] = request.Follow302RetainHeader
3922 }
3923
3924 if !dara.IsNil(request.Follow302TargetHost) {
3925 query["Follow302TargetHost"] = request.Follow302TargetHost
3926 }
3927
3928 if !dara.IsNil(request.OriginHost) {
3929 query["OriginHost"] = request.OriginHost
3930 }
3931
3932 if !dara.IsNil(request.OriginHttpPort) {
3933 query["OriginHttpPort"] = request.OriginHttpPort
3934 }
3935
3936 if !dara.IsNil(request.OriginHttpsPort) {
3937 query["OriginHttpsPort"] = request.OriginHttpsPort
3938 }
3939
3940 if !dara.IsNil(request.OriginMtls) {
3941 query["OriginMtls"] = request.OriginMtls
3942 }
3943
3944 if !dara.IsNil(request.OriginReadTimeout) {
3945 query["OriginReadTimeout"] = request.OriginReadTimeout
3946 }
3947
3948 if !dara.IsNil(request.OriginScheme) {
3949 query["OriginScheme"] = request.OriginScheme
3950 }
3951
3952 if !dara.IsNil(request.OriginSni) {
3953 query["OriginSni"] = request.OriginSni
3954 }
3955
3956 if !dara.IsNil(request.OriginVerify) {
3957 query["OriginVerify"] = request.OriginVerify
3958 }
3959
3960 if !dara.IsNil(request.Range) {
3961 query["Range"] = request.Range
3962 }
3963
3964 if !dara.IsNil(request.RangeChunkSize) {
3965 query["RangeChunkSize"] = request.RangeChunkSize
3966 }
3967
3968 if !dara.IsNil(request.Rule) {
3969 query["Rule"] = request.Rule
3970 }
3971
3972 if !dara.IsNil(request.RuleEnable) {
3973 query["RuleEnable"] = request.RuleEnable
3974 }
3975
3976 if !dara.IsNil(request.RuleName) {
3977 query["RuleName"] = request.RuleName
3978 }
3979
3980 if !dara.IsNil(request.Sequence) {
3981 query["Sequence"] = request.Sequence
3982 }
3983
3984 if !dara.IsNil(request.SiteId) {
3985 query["SiteId"] = request.SiteId
3986 }
3987
3988 if !dara.IsNil(request.SiteVersion) {
3989 query["SiteVersion"] = request.SiteVersion
3990 }
3991
3992 req := &openapiutil.OpenApiRequest{
3993 Query: openapiutil.Query(query),
3994 }
3995 params := &openapiutil.Params{
3996 Action: dara.String("CreateOriginRule"),
3997 Version: dara.String("2024-09-10"),
3998 Protocol: dara.String("HTTPS"),
3999 Pathname: dara.String("/"),
4000 Method: dara.String("POST"),
4001 AuthType: dara.String("AK"),
4002 Style: dara.String("RPC"),
4003 ReqBodyType: dara.String("formData"),
4004 BodyType: dara.String("json"),
4005 }
4006 _result = &CreateOriginRuleResponse{}
4007 _body, _err := client.CallApi(params, req, runtime)
4008 if _err != nil {
4009 return _result, _err
4010 }
4011 _err = dara.Convert(_body, &_result)
4012 return _result, _err
4013 }
4014
4015 // Summary:
4016 //
4017 // # Create a new origin rule configuration for the site
4018 //
4019 // @param request - CreateOriginRuleRequest
4020 //
4021 // @return CreateOriginRuleResponse
4022 func CreateOriginRule(client *Client, request *CreateOriginRuleRequest) (_result *CreateOriginRuleResponse, _err error) {
4023 runtime := &dara.RuntimeOptions{}
4024 _result = &CreateOriginRuleResponse{}
4025 _body, _err := CreateOriginRuleWithOptions(client,request, runtime)
4026 if _err != nil {
4027 return _result, _err
4028 }
4029 _result = _body
4030 return _result, _err
4031 }
4032
4033 // Summary:
4034 //
4035 // 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.
4036 //
4037 // @param request - CreatePageRequest
4038 //
4039 // @param runtime - runtime options for this request RuntimeOptions
4040 //
4041 // @return CreatePageResponse
4042 func CreatePageWithOptions(client *Client, request *CreatePageRequest, runtime *dara.RuntimeOptions) (_result *CreatePageResponse, _err error) {
4043 if dara.BoolValue(client.EnableValidate) == true {
4044 _err = request.Validate()
4045 if _err != nil {
4046 return _result, _err
4047 }
4048 }
4049 body := map[string]interface{}{}
4050 if !dara.IsNil(request.Content) {
4051 body["Content"] = request.Content
4052 }
4053
4054 if !dara.IsNil(request.ContentType) {
4055 body["ContentType"] = request.ContentType
4056 }
4057
4058 if !dara.IsNil(request.Description) {
4059 body["Description"] = request.Description
4060 }
4061
4062 if !dara.IsNil(request.Name) {
4063 body["Name"] = request.Name
4064 }
4065
4066 req := &openapiutil.OpenApiRequest{
4067 Body: openapiutil.ParseToMap(body),
4068 }
4069 params := &openapiutil.Params{
4070 Action: dara.String("CreatePage"),
4071 Version: dara.String("2024-09-10"),
4072 Protocol: dara.String("HTTPS"),
4073 Pathname: dara.String("/"),
4074 Method: dara.String("POST"),
4075 AuthType: dara.String("AK"),
4076 Style: dara.String("RPC"),
4077 ReqBodyType: dara.String("formData"),
4078 BodyType: dara.String("json"),
4079 }
4080 _result = &CreatePageResponse{}
4081 _body, _err := client.CallApi(params, req, runtime)
4082 if _err != nil {
4083 return _result, _err
4084 }
4085 _err = dara.Convert(_body, &_result)
4086 return _result, _err
4087 }
4088
4089 // Summary:
4090 //
4091 // 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.
4092 //
4093 // @param request - CreatePageRequest
4094 //
4095 // @return CreatePageResponse
4096 func CreatePage(client *Client, request *CreatePageRequest) (_result *CreatePageResponse, _err error) {
4097 runtime := &dara.RuntimeOptions{}
4098 _result = &CreatePageResponse{}
4099 _body, _err := CreatePageWithOptions(client,request, runtime)
4100 if _err != nil {
4101 return _result, _err
4102 }
4103 _result = _body
4104 return _result, _err
4105 }
4106
4107 // Summary:
4108 //
4109 // Creates a DNS record for a specific website.
4110 //
4111 // @param tmpReq - CreateRecordRequest
4112 //
4113 // @param runtime - runtime options for this request RuntimeOptions
4114 //
4115 // @return CreateRecordResponse
4116 func CreateRecordWithOptions(client *Client, tmpReq *CreateRecordRequest, runtime *dara.RuntimeOptions) (_result *CreateRecordResponse, _err error) {
4117 if dara.BoolValue(client.EnableValidate) == true {
4118 _err = tmpReq.Validate()
4119 if _err != nil {
4120 return _result, _err
4121 }
4122 }
4123 request := &CreateRecordShrinkRequest{}
4124 openapiutil.Convert(tmpReq, request)
4125 if !dara.IsNil(tmpReq.AuthConf) {
4126 request.AuthConfShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AuthConf, dara.String("AuthConf"), dara.String("json"))
4127 }
4128
4129 if !dara.IsNil(tmpReq.Data) {
4130 request.DataShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Data, dara.String("Data"), dara.String("json"))
4131 }
4132
4133 query := map[string]interface{}{}
4134 if !dara.IsNil(request.AuthConfShrink) {
4135 query["AuthConf"] = request.AuthConfShrink
4136 }
4137
4138 if !dara.IsNil(request.BizName) {
4139 query["BizName"] = request.BizName
4140 }
4141
4142 if !dara.IsNil(request.Comment) {
4143 query["Comment"] = request.Comment
4144 }
4145
4146 if !dara.IsNil(request.DataShrink) {
4147 query["Data"] = request.DataShrink
4148 }
4149
4150 if !dara.IsNil(request.HostPolicy) {
4151 query["HostPolicy"] = request.HostPolicy
4152 }
4153
4154 if !dara.IsNil(request.Proxied) {
4155 query["Proxied"] = request.Proxied
4156 }
4157
4158 if !dara.IsNil(request.RecordName) {
4159 query["RecordName"] = request.RecordName
4160 }
4161
4162 if !dara.IsNil(request.SiteId) {
4163 query["SiteId"] = request.SiteId
4164 }
4165
4166 if !dara.IsNil(request.SourceType) {
4167 query["SourceType"] = request.SourceType
4168 }
4169
4170 if !dara.IsNil(request.Ttl) {
4171 query["Ttl"] = request.Ttl
4172 }
4173
4174 if !dara.IsNil(request.Type) {
4175 query["Type"] = request.Type
4176 }
4177
4178 req := &openapiutil.OpenApiRequest{
4179 Query: openapiutil.Query(query),
4180 }
4181 params := &openapiutil.Params{
4182 Action: dara.String("CreateRecord"),
4183 Version: dara.String("2024-09-10"),
4184 Protocol: dara.String("HTTPS"),
4185 Pathname: dara.String("/"),
4186 Method: dara.String("POST"),
4187 AuthType: dara.String("AK"),
4188 Style: dara.String("RPC"),
4189 ReqBodyType: dara.String("formData"),
4190 BodyType: dara.String("json"),
4191 }
4192 _result = &CreateRecordResponse{}
4193 _body, _err := client.CallApi(params, req, runtime)
4194 if _err != nil {
4195 return _result, _err
4196 }
4197 _err = dara.Convert(_body, &_result)
4198 return _result, _err
4199 }
4200
4201 // Summary:
4202 //
4203 // Creates a DNS record for a specific website.
4204 //
4205 // @param request - CreateRecordRequest
4206 //
4207 // @return CreateRecordResponse
4208 func CreateRecord(client *Client, request *CreateRecordRequest) (_result *CreateRecordResponse, _err error) {
4209 runtime := &dara.RuntimeOptions{}
4210 _result = &CreateRecordResponse{}
4211 _body, _err := CreateRecordWithOptions(client,request, runtime)
4212 if _err != nil {
4213 return _result, _err
4214 }
4215 _result = _body
4216 return _result, _err
4217 }
4218
4219 // Summary:
4220 //
4221 // # Add a Redirect Rule
4222 //
4223 // @param request - CreateRedirectRuleRequest
4224 //
4225 // @param runtime - runtime options for this request RuntimeOptions
4226 //
4227 // @return CreateRedirectRuleResponse
4228 func CreateRedirectRuleWithOptions(client *Client, request *CreateRedirectRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateRedirectRuleResponse, _err error) {
4229 if dara.BoolValue(client.EnableValidate) == true {
4230 _err = request.Validate()
4231 if _err != nil {
4232 return _result, _err
4233 }
4234 }
4235 query := map[string]interface{}{}
4236 if !dara.IsNil(request.ReserveQueryString) {
4237 query["ReserveQueryString"] = request.ReserveQueryString
4238 }
4239
4240 if !dara.IsNil(request.Rule) {
4241 query["Rule"] = request.Rule
4242 }
4243
4244 if !dara.IsNil(request.RuleEnable) {
4245 query["RuleEnable"] = request.RuleEnable
4246 }
4247
4248 if !dara.IsNil(request.RuleName) {
4249 query["RuleName"] = request.RuleName
4250 }
4251
4252 if !dara.IsNil(request.Sequence) {
4253 query["Sequence"] = request.Sequence
4254 }
4255
4256 if !dara.IsNil(request.SiteId) {
4257 query["SiteId"] = request.SiteId
4258 }
4259
4260 if !dara.IsNil(request.SiteVersion) {
4261 query["SiteVersion"] = request.SiteVersion
4262 }
4263
4264 if !dara.IsNil(request.StatusCode) {
4265 query["StatusCode"] = request.StatusCode
4266 }
4267
4268 if !dara.IsNil(request.TargetUrl) {
4269 query["TargetUrl"] = request.TargetUrl
4270 }
4271
4272 if !dara.IsNil(request.Type) {
4273 query["Type"] = request.Type
4274 }
4275
4276 req := &openapiutil.OpenApiRequest{
4277 Query: openapiutil.Query(query),
4278 }
4279 params := &openapiutil.Params{
4280 Action: dara.String("CreateRedirectRule"),
4281 Version: dara.String("2024-09-10"),
4282 Protocol: dara.String("HTTPS"),
4283 Pathname: dara.String("/"),
4284 Method: dara.String("POST"),
4285 AuthType: dara.String("AK"),
4286 Style: dara.String("RPC"),
4287 ReqBodyType: dara.String("formData"),
4288 BodyType: dara.String("json"),
4289 }
4290 _result = &CreateRedirectRuleResponse{}
4291 _body, _err := client.CallApi(params, req, runtime)
4292 if _err != nil {
4293 return _result, _err
4294 }
4295 _err = dara.Convert(_body, &_result)
4296 return _result, _err
4297 }
4298
4299 // Summary:
4300 //
4301 // # Add a Redirect Rule
4302 //
4303 // @param request - CreateRedirectRuleRequest
4304 //
4305 // @return CreateRedirectRuleResponse
4306 func CreateRedirectRule(client *Client, request *CreateRedirectRuleRequest) (_result *CreateRedirectRuleResponse, _err error) {
4307 runtime := &dara.RuntimeOptions{}
4308 _result = &CreateRedirectRuleResponse{}
4309 _body, _err := CreateRedirectRuleWithOptions(client,request, runtime)
4310 if _err != nil {
4311 return _result, _err
4312 }
4313 _result = _body
4314 return _result, _err
4315 }
4316
4317 // Summary:
4318 //
4319 // # Add Rewrite URL Rule
4320 //
4321 // @param request - CreateRewriteUrlRuleRequest
4322 //
4323 // @param runtime - runtime options for this request RuntimeOptions
4324 //
4325 // @return CreateRewriteUrlRuleResponse
4326 func CreateRewriteUrlRuleWithOptions(client *Client, request *CreateRewriteUrlRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateRewriteUrlRuleResponse, _err error) {
4327 if dara.BoolValue(client.EnableValidate) == true {
4328 _err = request.Validate()
4329 if _err != nil {
4330 return _result, _err
4331 }
4332 }
4333 query := map[string]interface{}{}
4334 if !dara.IsNil(request.QueryString) {
4335 query["QueryString"] = request.QueryString
4336 }
4337
4338 if !dara.IsNil(request.RewriteQueryStringType) {
4339 query["RewriteQueryStringType"] = request.RewriteQueryStringType
4340 }
4341
4342 if !dara.IsNil(request.RewriteUriType) {
4343 query["RewriteUriType"] = request.RewriteUriType
4344 }
4345
4346 if !dara.IsNil(request.Rule) {
4347 query["Rule"] = request.Rule
4348 }
4349
4350 if !dara.IsNil(request.RuleEnable) {
4351 query["RuleEnable"] = request.RuleEnable
4352 }
4353
4354 if !dara.IsNil(request.RuleName) {
4355 query["RuleName"] = request.RuleName
4356 }
4357
4358 if !dara.IsNil(request.Sequence) {
4359 query["Sequence"] = request.Sequence
4360 }
4361
4362 if !dara.IsNil(request.SiteId) {
4363 query["SiteId"] = request.SiteId
4364 }
4365
4366 if !dara.IsNil(request.SiteVersion) {
4367 query["SiteVersion"] = request.SiteVersion
4368 }
4369
4370 if !dara.IsNil(request.Uri) {
4371 query["Uri"] = request.Uri
4372 }
4373
4374 req := &openapiutil.OpenApiRequest{
4375 Query: openapiutil.Query(query),
4376 }
4377 params := &openapiutil.Params{
4378 Action: dara.String("CreateRewriteUrlRule"),
4379 Version: dara.String("2024-09-10"),
4380 Protocol: dara.String("HTTPS"),
4381 Pathname: dara.String("/"),
4382 Method: dara.String("POST"),
4383 AuthType: dara.String("AK"),
4384 Style: dara.String("RPC"),
4385 ReqBodyType: dara.String("formData"),
4386 BodyType: dara.String("json"),
4387 }
4388 _result = &CreateRewriteUrlRuleResponse{}
4389 _body, _err := client.CallApi(params, req, runtime)
4390 if _err != nil {
4391 return _result, _err
4392 }
4393 _err = dara.Convert(_body, &_result)
4394 return _result, _err
4395 }
4396
4397 // Summary:
4398 //
4399 // # Add Rewrite URL Rule
4400 //
4401 // @param request - CreateRewriteUrlRuleRequest
4402 //
4403 // @return CreateRewriteUrlRuleResponse
4404 func CreateRewriteUrlRule(client *Client, request *CreateRewriteUrlRuleRequest) (_result *CreateRewriteUrlRuleResponse, _err error) {
4405 runtime := &dara.RuntimeOptions{}
4406 _result = &CreateRewriteUrlRuleResponse{}
4407 _body, _err := CreateRewriteUrlRuleWithOptions(client,request, runtime)
4408 if _err != nil {
4409 return _result, _err
4410 }
4411 _result = _body
4412 return _result, _err
4413 }
4414
4415 // Summary:
4416 //
4417 // Creates a routine.
4418 //
4419 // @param request - CreateRoutineRequest
4420 //
4421 // @param runtime - runtime options for this request RuntimeOptions
4422 //
4423 // @return CreateRoutineResponse
4424 func CreateRoutineWithOptions(client *Client, request *CreateRoutineRequest, runtime *dara.RuntimeOptions) (_result *CreateRoutineResponse, _err error) {
4425 if dara.BoolValue(client.EnableValidate) == true {
4426 _err = request.Validate()
4427 if _err != nil {
4428 return _result, _err
4429 }
4430 }
4431 body := map[string]interface{}{}
4432 if !dara.IsNil(request.Description) {
4433 body["Description"] = request.Description
4434 }
4435
4436 if !dara.IsNil(request.HasAssets) {
4437 body["HasAssets"] = request.HasAssets
4438 }
4439
4440 if !dara.IsNil(request.Name) {
4441 body["Name"] = request.Name
4442 }
4443
4444 req := &openapiutil.OpenApiRequest{
4445 Body: openapiutil.ParseToMap(body),
4446 }
4447 params := &openapiutil.Params{
4448 Action: dara.String("CreateRoutine"),
4449 Version: dara.String("2024-09-10"),
4450 Protocol: dara.String("HTTPS"),
4451 Pathname: dara.String("/"),
4452 Method: dara.String("POST"),
4453 AuthType: dara.String("AK"),
4454 Style: dara.String("RPC"),
4455 ReqBodyType: dara.String("formData"),
4456 BodyType: dara.String("json"),
4457 }
4458 _result = &CreateRoutineResponse{}
4459 _body, _err := client.CallApi(params, req, runtime)
4460 if _err != nil {
4461 return _result, _err
4462 }
4463 _err = dara.Convert(_body, &_result)
4464 return _result, _err
4465 }
4466
4467 // Summary:
4468 //
4469 // Creates a routine.
4470 //
4471 // @param request - CreateRoutineRequest
4472 //
4473 // @return CreateRoutineResponse
4474 func CreateRoutine(client *Client, request *CreateRoutineRequest) (_result *CreateRoutineResponse, _err error) {
4475 runtime := &dara.RuntimeOptions{}
4476 _result = &CreateRoutineResponse{}
4477 _body, _err := CreateRoutineWithOptions(client,request, runtime)
4478 if _err != nil {
4479 return _result, _err
4480 }
4481 _result = _body
4482 return _result, _err
4483 }
4484
4485 // Summary:
4486 //
4487 // Release the version of the function code in proportion to the specified environment.
4488 //
4489 // Description:
4490 //
4491 // ## [](#)Request description
4492 //
4493 // - 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`.
4494 //
4495 // - `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%.
4496 //
4497 // @param tmpReq - CreateRoutineCodeDeploymentRequest
4498 //
4499 // @param runtime - runtime options for this request RuntimeOptions
4500 //
4501 // @return CreateRoutineCodeDeploymentResponse
4502 func CreateRoutineCodeDeploymentWithOptions(client *Client, tmpReq *CreateRoutineCodeDeploymentRequest, runtime *dara.RuntimeOptions) (_result *CreateRoutineCodeDeploymentResponse, _err error) {
4503 if dara.BoolValue(client.EnableValidate) == true {
4504 _err = tmpReq.Validate()
4505 if _err != nil {
4506 return _result, _err
4507 }
4508 }
4509 request := &CreateRoutineCodeDeploymentShrinkRequest{}
4510 openapiutil.Convert(tmpReq, request)
4511 if !dara.IsNil(tmpReq.CodeVersions) {
4512 request.CodeVersionsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.CodeVersions, dara.String("CodeVersions"), dara.String("json"))
4513 }
4514
4515 body := map[string]interface{}{}
4516 if !dara.IsNil(request.CodeVersionsShrink) {
4517 body["CodeVersions"] = request.CodeVersionsShrink
4518 }
4519
4520 if !dara.IsNil(request.Env) {
4521 body["Env"] = request.Env
4522 }
4523
4524 if !dara.IsNil(request.Name) {
4525 body["Name"] = request.Name
4526 }
4527
4528 if !dara.IsNil(request.Strategy) {
4529 body["Strategy"] = request.Strategy
4530 }
4531
4532 req := &openapiutil.OpenApiRequest{
4533 Body: openapiutil.ParseToMap(body),
4534 }
4535 params := &openapiutil.Params{
4536 Action: dara.String("CreateRoutineCodeDeployment"),
4537 Version: dara.String("2024-09-10"),
4538 Protocol: dara.String("HTTPS"),
4539 Pathname: dara.String("/"),
4540 Method: dara.String("POST"),
4541 AuthType: dara.String("AK"),
4542 Style: dara.String("RPC"),
4543 ReqBodyType: dara.String("formData"),
4544 BodyType: dara.String("json"),
4545 }
4546 _result = &CreateRoutineCodeDeploymentResponse{}
4547 _body, _err := client.CallApi(params, req, runtime)
4548 if _err != nil {
4549 return _result, _err
4550 }
4551 _err = dara.Convert(_body, &_result)
4552 return _result, _err
4553 }
4554
4555 // Summary:
4556 //
4557 // Release the version of the function code in proportion to the specified environment.
4558 //
4559 // Description:
4560 //
4561 // ## [](#)Request description
4562 //
4563 // - 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`.
4564 //
4565 // - `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%.
4566 //
4567 // @param request - CreateRoutineCodeDeploymentRequest
4568 //
4569 // @return CreateRoutineCodeDeploymentResponse
4570 func CreateRoutineCodeDeployment(client *Client, request *CreateRoutineCodeDeploymentRequest) (_result *CreateRoutineCodeDeploymentResponse, _err error) {
4571 runtime := &dara.RuntimeOptions{}
4572 _result = &CreateRoutineCodeDeploymentResponse{}
4573 _body, _err := CreateRoutineCodeDeploymentWithOptions(client,request, runtime)
4574 if _err != nil {
4575 return _result, _err
4576 }
4577 _result = _body
4578 return _result, _err
4579 }
4580
4581 // Summary:
4582 //
4583 // Adds a record to map a domain that is associated with a routine. This record is used to trigger the associated routine code.
4584 //
4585 // @param request - CreateRoutineRelatedRecordRequest
4586 //
4587 // @param runtime - runtime options for this request RuntimeOptions
4588 //
4589 // @return CreateRoutineRelatedRecordResponse
4590 func CreateRoutineRelatedRecordWithOptions(client *Client, request *CreateRoutineRelatedRecordRequest, runtime *dara.RuntimeOptions) (_result *CreateRoutineRelatedRecordResponse, _err error) {
4591 if dara.BoolValue(client.EnableValidate) == true {
4592 _err = request.Validate()
4593 if _err != nil {
4594 return _result, _err
4595 }
4596 }
4597 body := map[string]interface{}{}
4598 if !dara.IsNil(request.Name) {
4599 body["Name"] = request.Name
4600 }
4601
4602 if !dara.IsNil(request.RecordName) {
4603 body["RecordName"] = request.RecordName
4604 }
4605
4606 if !dara.IsNil(request.SiteId) {
4607 body["SiteId"] = request.SiteId
4608 }
4609
4610 req := &openapiutil.OpenApiRequest{
4611 Body: openapiutil.ParseToMap(body),
4612 }
4613 params := &openapiutil.Params{
4614 Action: dara.String("CreateRoutineRelatedRecord"),
4615 Version: dara.String("2024-09-10"),
4616 Protocol: dara.String("HTTPS"),
4617 Pathname: dara.String("/"),
4618 Method: dara.String("POST"),
4619 AuthType: dara.String("AK"),
4620 Style: dara.String("RPC"),
4621 ReqBodyType: dara.String("formData"),
4622 BodyType: dara.String("json"),
4623 }
4624 _result = &CreateRoutineRelatedRecordResponse{}
4625 _body, _err := client.CallApi(params, req, runtime)
4626 if _err != nil {
4627 return _result, _err
4628 }
4629 _err = dara.Convert(_body, &_result)
4630 return _result, _err
4631 }
4632
4633 // Summary:
4634 //
4635 // Adds a record to map a domain that is associated with a routine. This record is used to trigger the associated routine code.
4636 //
4637 // @param request - CreateRoutineRelatedRecordRequest
4638 //
4639 // @return CreateRoutineRelatedRecordResponse
4640 func CreateRoutineRelatedRecord(client *Client, request *CreateRoutineRelatedRecordRequest) (_result *CreateRoutineRelatedRecordResponse, _err error) {
4641 runtime := &dara.RuntimeOptions{}
4642 _result = &CreateRoutineRelatedRecordResponse{}
4643 _body, _err := CreateRoutineRelatedRecordWithOptions(client,request, runtime)
4644 if _err != nil {
4645 return _result, _err
4646 }
4647 _result = _body
4648 return _result, _err
4649 }
4650
4651 // Summary:
4652 //
4653 // Adds edge function routing configurations.
4654 //
4655 // @param request - CreateRoutineRouteRequest
4656 //
4657 // @param runtime - runtime options for this request RuntimeOptions
4658 //
4659 // @return CreateRoutineRouteResponse
4660 func CreateRoutineRouteWithOptions(client *Client, request *CreateRoutineRouteRequest, runtime *dara.RuntimeOptions) (_result *CreateRoutineRouteResponse, _err error) {
4661 if dara.BoolValue(client.EnableValidate) == true {
4662 _err = request.Validate()
4663 if _err != nil {
4664 return _result, _err
4665 }
4666 }
4667 query := map[string]interface{}{}
4668 if !dara.IsNil(request.Bypass) {
4669 query["Bypass"] = request.Bypass
4670 }
4671
4672 if !dara.IsNil(request.Fallback) {
4673 query["Fallback"] = request.Fallback
4674 }
4675
4676 if !dara.IsNil(request.RouteEnable) {
4677 query["RouteEnable"] = request.RouteEnable
4678 }
4679
4680 if !dara.IsNil(request.RouteName) {
4681 query["RouteName"] = request.RouteName
4682 }
4683
4684 if !dara.IsNil(request.RoutineName) {
4685 query["RoutineName"] = request.RoutineName
4686 }
4687
4688 if !dara.IsNil(request.Rule) {
4689 query["Rule"] = request.Rule
4690 }
4691
4692 if !dara.IsNil(request.Sequence) {
4693 query["Sequence"] = request.Sequence
4694 }
4695
4696 if !dara.IsNil(request.SiteId) {
4697 query["SiteId"] = request.SiteId
4698 }
4699
4700 req := &openapiutil.OpenApiRequest{
4701 Query: openapiutil.Query(query),
4702 }
4703 params := &openapiutil.Params{
4704 Action: dara.String("CreateRoutineRoute"),
4705 Version: dara.String("2024-09-10"),
4706 Protocol: dara.String("HTTPS"),
4707 Pathname: dara.String("/"),
4708 Method: dara.String("POST"),
4709 AuthType: dara.String("AK"),
4710 Style: dara.String("RPC"),
4711 ReqBodyType: dara.String("formData"),
4712 BodyType: dara.String("json"),
4713 }
4714 _result = &CreateRoutineRouteResponse{}
4715 _body, _err := client.CallApi(params, req, runtime)
4716 if _err != nil {
4717 return _result, _err
4718 }
4719 _err = dara.Convert(_body, &_result)
4720 return _result, _err
4721 }
4722
4723 // Summary:
4724 //
4725 // Adds edge function routing configurations.
4726 //
4727 // @param request - CreateRoutineRouteRequest
4728 //
4729 // @return CreateRoutineRouteResponse
4730 func CreateRoutineRoute(client *Client, request *CreateRoutineRouteRequest) (_result *CreateRoutineRouteResponse, _err error) {
4731 runtime := &dara.RuntimeOptions{}
4732 _result = &CreateRoutineRouteResponse{}
4733 _body, _err := CreateRoutineRouteWithOptions(client,request, runtime)
4734 if _err != nil {
4735 return _result, _err
4736 }
4737 _result = _body
4738 return _result, _err
4739 }
4740
4741 // Summary:
4742 //
4743 // 创建带Assets资源的Routine代码版本
4744 //
4745 // @param tmpReq - CreateRoutineWithAssetsCodeVersionRequest
4746 //
4747 // @param runtime - runtime options for this request RuntimeOptions
4748 //
4749 // @return CreateRoutineWithAssetsCodeVersionResponse
4750 func CreateRoutineWithAssetsCodeVersionWithOptions(client *Client, tmpReq *CreateRoutineWithAssetsCodeVersionRequest, runtime *dara.RuntimeOptions) (_result *CreateRoutineWithAssetsCodeVersionResponse, _err error) {
4751 if dara.BoolValue(client.EnableValidate) == true {
4752 _err = tmpReq.Validate()
4753 if _err != nil {
4754 return _result, _err
4755 }
4756 }
4757 request := &CreateRoutineWithAssetsCodeVersionShrinkRequest{}
4758 openapiutil.Convert(tmpReq, request)
4759 if !dara.IsNil(tmpReq.ConfOptions) {
4760 request.ConfOptionsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ConfOptions, dara.String("ConfOptions"), dara.String("json"))
4761 }
4762
4763 body := map[string]interface{}{}
4764 if !dara.IsNil(request.BuildId) {
4765 body["BuildId"] = request.BuildId
4766 }
4767
4768 if !dara.IsNil(request.CodeDescription) {
4769 body["CodeDescription"] = request.CodeDescription
4770 }
4771
4772 if !dara.IsNil(request.ConfOptionsShrink) {
4773 body["ConfOptions"] = request.ConfOptionsShrink
4774 }
4775
4776 if !dara.IsNil(request.ExtraInfo) {
4777 body["ExtraInfo"] = request.ExtraInfo
4778 }
4779
4780 if !dara.IsNil(request.Name) {
4781 body["Name"] = request.Name
4782 }
4783
4784 req := &openapiutil.OpenApiRequest{
4785 Body: openapiutil.ParseToMap(body),
4786 }
4787 params := &openapiutil.Params{
4788 Action: dara.String("CreateRoutineWithAssetsCodeVersion"),
4789 Version: dara.String("2024-09-10"),
4790 Protocol: dara.String("HTTPS"),
4791 Pathname: dara.String("/"),
4792 Method: dara.String("POST"),
4793 AuthType: dara.String("AK"),
4794 Style: dara.String("RPC"),
4795 ReqBodyType: dara.String("formData"),
4796 BodyType: dara.String("json"),
4797 }
4798 _result = &CreateRoutineWithAssetsCodeVersionResponse{}
4799 _body, _err := client.CallApi(params, req, runtime)
4800 if _err != nil {
4801 return _result, _err
4802 }
4803 _err = dara.Convert(_body, &_result)
4804 return _result, _err
4805 }
4806
4807 // Summary:
4808 //
4809 // 创建带Assets资源的Routine代码版本
4810 //
4811 // @param request - CreateRoutineWithAssetsCodeVersionRequest
4812 //
4813 // @return CreateRoutineWithAssetsCodeVersionResponse
4814 func CreateRoutineWithAssetsCodeVersion(client *Client, request *CreateRoutineWithAssetsCodeVersionRequest) (_result *CreateRoutineWithAssetsCodeVersionResponse, _err error) {
4815 runtime := &dara.RuntimeOptions{}
4816 _result = &CreateRoutineWithAssetsCodeVersionResponse{}
4817 _body, _err := CreateRoutineWithAssetsCodeVersionWithOptions(client,request, runtime)
4818 if _err != nil {
4819 return _result, _err
4820 }
4821 _result = _body
4822 return _result, _err
4823 }
4824
4825 // Summary:
4826 //
4827 // Creates scheduled prefetch plans.
4828 //
4829 // @param tmpReq - CreateScheduledPreloadExecutionsRequest
4830 //
4831 // @param runtime - runtime options for this request RuntimeOptions
4832 //
4833 // @return CreateScheduledPreloadExecutionsResponse
4834 func CreateScheduledPreloadExecutionsWithOptions(client *Client, tmpReq *CreateScheduledPreloadExecutionsRequest, runtime *dara.RuntimeOptions) (_result *CreateScheduledPreloadExecutionsResponse, _err error) {
4835 if dara.BoolValue(client.EnableValidate) == true {
4836 _err = tmpReq.Validate()
4837 if _err != nil {
4838 return _result, _err
4839 }
4840 }
4841 request := &CreateScheduledPreloadExecutionsShrinkRequest{}
4842 openapiutil.Convert(tmpReq, request)
4843 if !dara.IsNil(tmpReq.Executions) {
4844 request.ExecutionsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Executions, dara.String("Executions"), dara.String("json"))
4845 }
4846
4847 query := map[string]interface{}{}
4848 if !dara.IsNil(request.Id) {
4849 query["Id"] = request.Id
4850 }
4851
4852 body := map[string]interface{}{}
4853 if !dara.IsNil(request.ExecutionsShrink) {
4854 body["Executions"] = request.ExecutionsShrink
4855 }
4856
4857 req := &openapiutil.OpenApiRequest{
4858 Query: openapiutil.Query(query),
4859 Body: openapiutil.ParseToMap(body),
4860 }
4861 params := &openapiutil.Params{
4862 Action: dara.String("CreateScheduledPreloadExecutions"),
4863 Version: dara.String("2024-09-10"),
4864 Protocol: dara.String("HTTPS"),
4865 Pathname: dara.String("/"),
4866 Method: dara.String("POST"),
4867 AuthType: dara.String("AK"),
4868 Style: dara.String("RPC"),
4869 ReqBodyType: dara.String("formData"),
4870 BodyType: dara.String("json"),
4871 }
4872 _result = &CreateScheduledPreloadExecutionsResponse{}
4873 _body, _err := client.CallApi(params, req, runtime)
4874 if _err != nil {
4875 return _result, _err
4876 }
4877 _err = dara.Convert(_body, &_result)
4878 return _result, _err
4879 }
4880
4881 // Summary:
4882 //
4883 // Creates scheduled prefetch plans.
4884 //
4885 // @param request - CreateScheduledPreloadExecutionsRequest
4886 //
4887 // @return CreateScheduledPreloadExecutionsResponse
4888 func CreateScheduledPreloadExecutions(client *Client, request *CreateScheduledPreloadExecutionsRequest) (_result *CreateScheduledPreloadExecutionsResponse, _err error) {
4889 runtime := &dara.RuntimeOptions{}
4890 _result = &CreateScheduledPreloadExecutionsResponse{}
4891 _body, _err := CreateScheduledPreloadExecutionsWithOptions(client,request, runtime)
4892 if _err != nil {
4893 return _result, _err
4894 }
4895 _result = _body
4896 return _result, _err
4897 }
4898
4899 // Summary:
4900 //
4901 // Adds a scheduled prefetch task.
4902 //
4903 // @param request - CreateScheduledPreloadJobRequest
4904 //
4905 // @param runtime - runtime options for this request RuntimeOptions
4906 //
4907 // @return CreateScheduledPreloadJobResponse
4908 func CreateScheduledPreloadJobWithOptions(client *Client, request *CreateScheduledPreloadJobRequest, runtime *dara.RuntimeOptions) (_result *CreateScheduledPreloadJobResponse, _err error) {
4909 if dara.BoolValue(client.EnableValidate) == true {
4910 _err = request.Validate()
4911 if _err != nil {
4912 return _result, _err
4913 }
4914 }
4915 body := map[string]interface{}{}
4916 if !dara.IsNil(request.InsertWay) {
4917 body["InsertWay"] = request.InsertWay
4918 }
4919
4920 if !dara.IsNil(request.Name) {
4921 body["Name"] = request.Name
4922 }
4923
4924 if !dara.IsNil(request.OssUrl) {
4925 body["OssUrl"] = request.OssUrl
4926 }
4927
4928 if !dara.IsNil(request.SiteId) {
4929 body["SiteId"] = request.SiteId
4930 }
4931
4932 if !dara.IsNil(request.UrlList) {
4933 body["UrlList"] = request.UrlList
4934 }
4935
4936 req := &openapiutil.OpenApiRequest{
4937 Body: openapiutil.ParseToMap(body),
4938 }
4939 params := &openapiutil.Params{
4940 Action: dara.String("CreateScheduledPreloadJob"),
4941 Version: dara.String("2024-09-10"),
4942 Protocol: dara.String("HTTPS"),
4943 Pathname: dara.String("/"),
4944 Method: dara.String("POST"),
4945 AuthType: dara.String("AK"),
4946 Style: dara.String("RPC"),
4947 ReqBodyType: dara.String("formData"),
4948 BodyType: dara.String("json"),
4949 }
4950 _result = &CreateScheduledPreloadJobResponse{}
4951 _body, _err := client.CallApi(params, req, runtime)
4952 if _err != nil {
4953 return _result, _err
4954 }
4955 _err = dara.Convert(_body, &_result)
4956 return _result, _err
4957 }
4958
4959 // Summary:
4960 //
4961 // Adds a scheduled prefetch task.
4962 //
4963 // @param request - CreateScheduledPreloadJobRequest
4964 //
4965 // @return CreateScheduledPreloadJobResponse
4966 func CreateScheduledPreloadJob(client *Client, request *CreateScheduledPreloadJobRequest) (_result *CreateScheduledPreloadJobResponse, _err error) {
4967 runtime := &dara.RuntimeOptions{}
4968 _result = &CreateScheduledPreloadJobResponse{}
4969 _body, _err := CreateScheduledPreloadJobWithOptions(client,request, runtime)
4970 if _err != nil {
4971 return _result, _err
4972 }
4973 _result = _body
4974 return _result, _err
4975 }
4976
4977 // Summary:
4978 //
4979 // Adds a website.
4980 //
4981 // Description:
4982 //
4983 // Make sure that you have an available plan before you add a website.
4984 //
4985 // - Make sure that your website domain name has an ICP filing if the location you want to specify covers the Chinese mainland.
4986 //
4987 // @param request - CreateSiteRequest
4988 //
4989 // @param runtime - runtime options for this request RuntimeOptions
4990 //
4991 // @return CreateSiteResponse
4992 func CreateSiteWithOptions(client *Client, request *CreateSiteRequest, runtime *dara.RuntimeOptions) (_result *CreateSiteResponse, _err error) {
4993 if dara.BoolValue(client.EnableValidate) == true {
4994 _err = request.Validate()
4995 if _err != nil {
4996 return _result, _err
4997 }
4998 }
4999 query := map[string]interface{}{}
5000 if !dara.IsNil(request.AccessType) {
5001 query["AccessType"] = request.AccessType
5002 }
5003
5004 if !dara.IsNil(request.Coverage) {
5005 query["Coverage"] = request.Coverage
5006 }
5007
5008 if !dara.IsNil(request.InstanceId) {
5009 query["InstanceId"] = request.InstanceId
5010 }
5011
5012 if !dara.IsNil(request.ResourceGroupId) {
5013 query["ResourceGroupId"] = request.ResourceGroupId
5014 }
5015
5016 if !dara.IsNil(request.SiteName) {
5017 query["SiteName"] = request.SiteName
5018 }
5019
5020 req := &openapiutil.OpenApiRequest{
5021 Query: openapiutil.Query(query),
5022 }
5023 params := &openapiutil.Params{
5024 Action: dara.String("CreateSite"),
5025 Version: dara.String("2024-09-10"),
5026 Protocol: dara.String("HTTPS"),
5027 Pathname: dara.String("/"),
5028 Method: dara.String("POST"),
5029 AuthType: dara.String("AK"),
5030 Style: dara.String("RPC"),
5031 ReqBodyType: dara.String("formData"),
5032 BodyType: dara.String("json"),
5033 }
5034 _result = &CreateSiteResponse{}
5035 _body, _err := client.CallApi(params, req, runtime)
5036 if _err != nil {
5037 return _result, _err
5038 }
5039 _err = dara.Convert(_body, &_result)
5040 return _result, _err
5041 }
5042
5043 // Summary:
5044 //
5045 // Adds a website.
5046 //
5047 // Description:
5048 //
5049 // Make sure that you have an available plan before you add a website.
5050 //
5051 // - Make sure that your website domain name has an ICP filing if the location you want to specify covers the Chinese mainland.
5052 //
5053 // @param request - CreateSiteRequest
5054 //
5055 // @return CreateSiteResponse
5056 func CreateSite(client *Client, request *CreateSiteRequest) (_result *CreateSiteResponse, _err error) {
5057 runtime := &dara.RuntimeOptions{}
5058 _result = &CreateSiteResponse{}
5059 _body, _err := CreateSiteWithOptions(client,request, runtime)
5060 if _err != nil {
5061 return _result, _err
5062 }
5063 _result = _body
5064 return _result, _err
5065 }
5066
5067 // Summary:
5068 //
5069 // Adds the configuration of custom request header, response header, and cookie fields that are used to capture logs of a website.
5070 //
5071 // Description:
5072 //
5073 // **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.
5074 //
5075 // - **Parameter passing**: Submit `SiteId`, `RequestHeaders`, `ResponseHeaders`, and `Cookies` by using `formData`. Each array element matches a custom field name.
5076 //
5077 // - **(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.
5078 //
5079 // @param tmpReq - CreateSiteCustomLogRequest
5080 //
5081 // @param runtime - runtime options for this request RuntimeOptions
5082 //
5083 // @return CreateSiteCustomLogResponse
5084 func CreateSiteCustomLogWithOptions(client *Client, tmpReq *CreateSiteCustomLogRequest, runtime *dara.RuntimeOptions) (_result *CreateSiteCustomLogResponse, _err error) {
5085 if dara.BoolValue(client.EnableValidate) == true {
5086 _err = tmpReq.Validate()
5087 if _err != nil {
5088 return _result, _err
5089 }
5090 }
5091 request := &CreateSiteCustomLogShrinkRequest{}
5092 openapiutil.Convert(tmpReq, request)
5093 if !dara.IsNil(tmpReq.Cookies) {
5094 request.CookiesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Cookies, dara.String("Cookies"), dara.String("json"))
5095 }
5096
5097 if !dara.IsNil(tmpReq.RequestHeaders) {
5098 request.RequestHeadersShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RequestHeaders, dara.String("RequestHeaders"), dara.String("json"))
5099 }
5100
5101 if !dara.IsNil(tmpReq.ResponseHeaders) {
5102 request.ResponseHeadersShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ResponseHeaders, dara.String("ResponseHeaders"), dara.String("json"))
5103 }
5104
5105 body := map[string]interface{}{}
5106 if !dara.IsNil(request.CookiesShrink) {
5107 body["Cookies"] = request.CookiesShrink
5108 }
5109
5110 if !dara.IsNil(request.RequestHeadersShrink) {
5111 body["RequestHeaders"] = request.RequestHeadersShrink
5112 }
5113
5114 if !dara.IsNil(request.ResponseHeadersShrink) {
5115 body["ResponseHeaders"] = request.ResponseHeadersShrink
5116 }
5117
5118 if !dara.IsNil(request.SiteId) {
5119 body["SiteId"] = request.SiteId
5120 }
5121
5122 req := &openapiutil.OpenApiRequest{
5123 Body: openapiutil.ParseToMap(body),
5124 }
5125 params := &openapiutil.Params{
5126 Action: dara.String("CreateSiteCustomLog"),
5127 Version: dara.String("2024-09-10"),
5128 Protocol: dara.String("HTTPS"),
5129 Pathname: dara.String("/"),
5130 Method: dara.String("POST"),
5131 AuthType: dara.String("AK"),
5132 Style: dara.String("RPC"),
5133 ReqBodyType: dara.String("formData"),
5134 BodyType: dara.String("json"),
5135 }
5136 _result = &CreateSiteCustomLogResponse{}
5137 _body, _err := client.CallApi(params, req, runtime)
5138 if _err != nil {
5139 return _result, _err
5140 }
5141 _err = dara.Convert(_body, &_result)
5142 return _result, _err
5143 }
5144
5145 // Summary:
5146 //
5147 // Adds the configuration of custom request header, response header, and cookie fields that are used to capture logs of a website.
5148 //
5149 // Description:
5150 //
5151 // **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.
5152 //
5153 // - **Parameter passing**: Submit `SiteId`, `RequestHeaders`, `ResponseHeaders`, and `Cookies` by using `formData`. Each array element matches a custom field name.
5154 //
5155 // - **(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.
5156 //
5157 // @param request - CreateSiteCustomLogRequest
5158 //
5159 // @return CreateSiteCustomLogResponse
5160 func CreateSiteCustomLog(client *Client, request *CreateSiteCustomLogRequest) (_result *CreateSiteCustomLogResponse, _err error) {
5161 runtime := &dara.RuntimeOptions{}
5162 _result = &CreateSiteCustomLogResponse{}
5163 _body, _err := CreateSiteCustomLogWithOptions(client,request, runtime)
5164 if _err != nil {
5165 return _result, _err
5166 }
5167 _result = _body
5168 return _result, _err
5169 }
5170
5171 // Summary:
5172 //
5173 // Creates a real-time log delivery task.
5174 //
5175 // @param tmpReq - CreateSiteDeliveryTaskRequest
5176 //
5177 // @param runtime - runtime options for this request RuntimeOptions
5178 //
5179 // @return CreateSiteDeliveryTaskResponse
5180 func CreateSiteDeliveryTaskWithOptions(client *Client, tmpReq *CreateSiteDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *CreateSiteDeliveryTaskResponse, _err error) {
5181 if dara.BoolValue(client.EnableValidate) == true {
5182 _err = tmpReq.Validate()
5183 if _err != nil {
5184 return _result, _err
5185 }
5186 }
5187 request := &CreateSiteDeliveryTaskShrinkRequest{}
5188 openapiutil.Convert(tmpReq, request)
5189 if !dara.IsNil(tmpReq.HttpDelivery) {
5190 request.HttpDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.HttpDelivery, dara.String("HttpDelivery"), dara.String("json"))
5191 }
5192
5193 if !dara.IsNil(tmpReq.KafkaDelivery) {
5194 request.KafkaDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.KafkaDelivery, dara.String("KafkaDelivery"), dara.String("json"))
5195 }
5196
5197 if !dara.IsNil(tmpReq.OssDelivery) {
5198 request.OssDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.OssDelivery, dara.String("OssDelivery"), dara.String("json"))
5199 }
5200
5201 if !dara.IsNil(tmpReq.S3Delivery) {
5202 request.S3DeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.S3Delivery, dara.String("S3Delivery"), dara.String("json"))
5203 }
5204
5205 if !dara.IsNil(tmpReq.SlsDelivery) {
5206 request.SlsDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.SlsDelivery, dara.String("SlsDelivery"), dara.String("json"))
5207 }
5208
5209 body := map[string]interface{}{}
5210 if !dara.IsNil(request.BusinessType) {
5211 body["BusinessType"] = request.BusinessType
5212 }
5213
5214 if !dara.IsNil(request.DataCenter) {
5215 body["DataCenter"] = request.DataCenter
5216 }
5217
5218 if !dara.IsNil(request.DeliveryType) {
5219 body["DeliveryType"] = request.DeliveryType
5220 }
5221
5222 if !dara.IsNil(request.DiscardRate) {
5223 body["DiscardRate"] = request.DiscardRate
5224 }
5225
5226 if !dara.IsNil(request.FieldName) {
5227 body["FieldName"] = request.FieldName
5228 }
5229
5230 if !dara.IsNil(request.FilterVer) {
5231 body["FilterVer"] = request.FilterVer
5232 }
5233
5234 if !dara.IsNil(request.HttpDeliveryShrink) {
5235 body["HttpDelivery"] = request.HttpDeliveryShrink
5236 }
5237
5238 if !dara.IsNil(request.KafkaDeliveryShrink) {
5239 body["KafkaDelivery"] = request.KafkaDeliveryShrink
5240 }
5241
5242 if !dara.IsNil(request.OssDeliveryShrink) {
5243 body["OssDelivery"] = request.OssDeliveryShrink
5244 }
5245
5246 if !dara.IsNil(request.S3DeliveryShrink) {
5247 body["S3Delivery"] = request.S3DeliveryShrink
5248 }
5249
5250 if !dara.IsNil(request.SiteId) {
5251 body["SiteId"] = request.SiteId
5252 }
5253
5254 if !dara.IsNil(request.SlsDeliveryShrink) {
5255 body["SlsDelivery"] = request.SlsDeliveryShrink
5256 }
5257
5258 if !dara.IsNil(request.TaskName) {
5259 body["TaskName"] = request.TaskName
5260 }
5261
5262 req := &openapiutil.OpenApiRequest{
5263 Body: openapiutil.ParseToMap(body),
5264 }
5265 params := &openapiutil.Params{
5266 Action: dara.String("CreateSiteDeliveryTask"),
5267 Version: dara.String("2024-09-10"),
5268 Protocol: dara.String("HTTPS"),
5269 Pathname: dara.String("/"),
5270 Method: dara.String("POST"),
5271 AuthType: dara.String("AK"),
5272 Style: dara.String("RPC"),
5273 ReqBodyType: dara.String("formData"),
5274 BodyType: dara.String("json"),
5275 }
5276 _result = &CreateSiteDeliveryTaskResponse{}
5277 _body, _err := client.CallApi(params, req, runtime)
5278 if _err != nil {
5279 return _result, _err
5280 }
5281 _err = dara.Convert(_body, &_result)
5282 return _result, _err
5283 }
5284
5285 // Summary:
5286 //
5287 // Creates a real-time log delivery task.
5288 //
5289 // @param request - CreateSiteDeliveryTaskRequest
5290 //
5291 // @return CreateSiteDeliveryTaskResponse
5292 func CreateSiteDeliveryTask(client *Client, request *CreateSiteDeliveryTaskRequest) (_result *CreateSiteDeliveryTaskResponse, _err error) {
5293 runtime := &dara.RuntimeOptions{}
5294 _result = &CreateSiteDeliveryTaskResponse{}
5295 _body, _err := CreateSiteDeliveryTaskWithOptions(client,request, runtime)
5296 if _err != nil {
5297 return _result, _err
5298 }
5299 _result = _body
5300 return _result, _err
5301 }
5302
5303 // Summary:
5304 //
5305 // 创建一个实时日志slr角色
5306 //
5307 // @param request - CreateSlrRoleForRealtimeLogRequest
5308 //
5309 // @param runtime - runtime options for this request RuntimeOptions
5310 //
5311 // @return CreateSlrRoleForRealtimeLogResponse
5312 func CreateSlrRoleForRealtimeLogWithOptions(client *Client, runtime *dara.RuntimeOptions) (_result *CreateSlrRoleForRealtimeLogResponse, _err error) {
5313 req := &openapiutil.OpenApiRequest{}
5314 params := &openapiutil.Params{
5315 Action: dara.String("CreateSlrRoleForRealtimeLog"),
5316 Version: dara.String("2024-09-10"),
5317 Protocol: dara.String("HTTPS"),
5318 Pathname: dara.String("/"),
5319 Method: dara.String("POST"),
5320 AuthType: dara.String("AK"),
5321 Style: dara.String("RPC"),
5322 ReqBodyType: dara.String("formData"),
5323 BodyType: dara.String("json"),
5324 }
5325 _result = &CreateSlrRoleForRealtimeLogResponse{}
5326 _body, _err := client.CallApi(params, req, runtime)
5327 if _err != nil {
5328 return _result, _err
5329 }
5330 _err = dara.Convert(_body, &_result)
5331 return _result, _err
5332 }
5333
5334 // Summary:
5335 //
5336 // 创建一个实时日志slr角色
5337 //
5338 // @return CreateSlrRoleForRealtimeLogResponse
5339 func CreateSlrRoleForRealtimeLog(client *Client, ) (_result *CreateSlrRoleForRealtimeLogResponse, _err error) {
5340 runtime := &dara.RuntimeOptions{}
5341 _result = &CreateSlrRoleForRealtimeLogResponse{}
5342 _body, _err := CreateSlrRoleForRealtimeLogWithOptions(client,runtime)
5343 if _err != nil {
5344 return _result, _err
5345 }
5346 _result = _body
5347 return _result, _err
5348 }
5349
5350 // Summary:
5351 //
5352 // # Create Transport Layer Application
5353 //
5354 // @param tmpReq - CreateTransportLayerApplicationRequest
5355 //
5356 // @param runtime - runtime options for this request RuntimeOptions
5357 //
5358 // @return CreateTransportLayerApplicationResponse
5359 func CreateTransportLayerApplicationWithOptions(client *Client, tmpReq *CreateTransportLayerApplicationRequest, runtime *dara.RuntimeOptions) (_result *CreateTransportLayerApplicationResponse, _err error) {
5360 if dara.BoolValue(client.EnableValidate) == true {
5361 _err = tmpReq.Validate()
5362 if _err != nil {
5363 return _result, _err
5364 }
5365 }
5366 request := &CreateTransportLayerApplicationShrinkRequest{}
5367 openapiutil.Convert(tmpReq, request)
5368 if !dara.IsNil(tmpReq.Rules) {
5369 request.RulesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Rules, dara.String("Rules"), dara.String("json"))
5370 }
5371
5372 query := map[string]interface{}{}
5373 if !dara.IsNil(request.CrossBorderOptimization) {
5374 query["CrossBorderOptimization"] = request.CrossBorderOptimization
5375 }
5376
5377 if !dara.IsNil(request.IpAccessRule) {
5378 query["IpAccessRule"] = request.IpAccessRule
5379 }
5380
5381 if !dara.IsNil(request.Ipv6) {
5382 query["Ipv6"] = request.Ipv6
5383 }
5384
5385 if !dara.IsNil(request.RecordName) {
5386 query["RecordName"] = request.RecordName
5387 }
5388
5389 if !dara.IsNil(request.RulesShrink) {
5390 query["Rules"] = request.RulesShrink
5391 }
5392
5393 if !dara.IsNil(request.SiteId) {
5394 query["SiteId"] = request.SiteId
5395 }
5396
5397 if !dara.IsNil(request.StaticIp) {
5398 query["StaticIp"] = request.StaticIp
5399 }
5400
5401 req := &openapiutil.OpenApiRequest{
5402 Query: openapiutil.Query(query),
5403 }
5404 params := &openapiutil.Params{
5405 Action: dara.String("CreateTransportLayerApplication"),
5406 Version: dara.String("2024-09-10"),
5407 Protocol: dara.String("HTTPS"),
5408 Pathname: dara.String("/"),
5409 Method: dara.String("POST"),
5410 AuthType: dara.String("AK"),
5411 Style: dara.String("RPC"),
5412 ReqBodyType: dara.String("formData"),
5413 BodyType: dara.String("json"),
5414 }
5415 _result = &CreateTransportLayerApplicationResponse{}
5416 _body, _err := client.CallApi(params, req, runtime)
5417 if _err != nil {
5418 return _result, _err
5419 }
5420 _err = dara.Convert(_body, &_result)
5421 return _result, _err
5422 }
5423
5424 // Summary:
5425 //
5426 // # Create Transport Layer Application
5427 //
5428 // @param request - CreateTransportLayerApplicationRequest
5429 //
5430 // @return CreateTransportLayerApplicationResponse
5431 func CreateTransportLayerApplication(client *Client, request *CreateTransportLayerApplicationRequest) (_result *CreateTransportLayerApplicationResponse, _err error) {
5432 runtime := &dara.RuntimeOptions{}
5433 _result = &CreateTransportLayerApplicationResponse{}
5434 _body, _err := CreateTransportLayerApplicationWithOptions(client,request, runtime)
5435 if _err != nil {
5436 return _result, _err
5437 }
5438 _result = _body
5439 return _result, _err
5440 }
5441
5442 // Summary:
5443 //
5444 // Create a web page monitoring configuration.
5445 //
5446 // @param request - CreateUrlObservationRequest
5447 //
5448 // @param runtime - runtime options for this request RuntimeOptions
5449 //
5450 // @return CreateUrlObservationResponse
5451 func CreateUrlObservationWithOptions(client *Client, request *CreateUrlObservationRequest, runtime *dara.RuntimeOptions) (_result *CreateUrlObservationResponse, _err error) {
5452 if dara.BoolValue(client.EnableValidate) == true {
5453 _err = request.Validate()
5454 if _err != nil {
5455 return _result, _err
5456 }
5457 }
5458 query := map[string]interface{}{}
5459 if !dara.IsNil(request.SdkType) {
5460 query["SdkType"] = request.SdkType
5461 }
5462
5463 if !dara.IsNil(request.SiteId) {
5464 query["SiteId"] = request.SiteId
5465 }
5466
5467 if !dara.IsNil(request.Url) {
5468 query["Url"] = request.Url
5469 }
5470
5471 req := &openapiutil.OpenApiRequest{
5472 Query: openapiutil.Query(query),
5473 }
5474 params := &openapiutil.Params{
5475 Action: dara.String("CreateUrlObservation"),
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 = &CreateUrlObservationResponse{}
5486 _body, _err := client.CallApi(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 // Create a web page monitoring configuration.
5497 //
5498 // @param request - CreateUrlObservationRequest
5499 //
5500 // @return CreateUrlObservationResponse
5501 func CreateUrlObservation(client *Client, request *CreateUrlObservationRequest) (_result *CreateUrlObservationResponse, _err error) {
5502 runtime := &dara.RuntimeOptions{}
5503 _result = &CreateUrlObservationResponse{}
5504 _body, _err := CreateUrlObservationWithOptions(client,request, runtime)
5505 if _err != nil {
5506 return _result, _err
5507 }
5508 _result = _body
5509 return _result, _err
5510 }
5511
5512 // Summary:
5513 //
5514 // Creates a log delivery task to ship logs to the specified destination.
5515 //
5516 // Description:
5517 //
5518 // 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.
5519 //
5520 // - **Field filtering**: Use the `FieldName` parameter to specify log fields to deliver.
5521 //
5522 // - **Filtering rules**: Use the `FilterRules` parameter to pre-process and filter log data.
5523 //
5524 // - **Diverse delivery destinations**: Logs can be delivered to different destinations. Configuration parameters vary with delivery destinations.
5525 //
5526 // ## [](#)Precautions
5527 //
5528 // - Make sure that you have sufficient permissions to perform delivery tasks.
5529 //
5530 // - If you enable encryption or authentication, properly configure corresponding parameters.
5531 //
5532 // - Verify the syntax of `FilterRules` to make sure that filtering logic works as expected.
5533 //
5534 // - Specify advanced settings such as the number of retries and timeout period based on your needs to have optimal delivery efficiency and stability.
5535 //
5536 // @param tmpReq - CreateUserDeliveryTaskRequest
5537 //
5538 // @param runtime - runtime options for this request RuntimeOptions
5539 //
5540 // @return CreateUserDeliveryTaskResponse
5541 func CreateUserDeliveryTaskWithOptions(client *Client, tmpReq *CreateUserDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *CreateUserDeliveryTaskResponse, _err error) {
5542 if dara.BoolValue(client.EnableValidate) == true {
5543 _err = tmpReq.Validate()
5544 if _err != nil {
5545 return _result, _err
5546 }
5547 }
5548 request := &CreateUserDeliveryTaskShrinkRequest{}
5549 openapiutil.Convert(tmpReq, request)
5550 if !dara.IsNil(tmpReq.HttpDelivery) {
5551 request.HttpDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.HttpDelivery, dara.String("HttpDelivery"), dara.String("json"))
5552 }
5553
5554 if !dara.IsNil(tmpReq.KafkaDelivery) {
5555 request.KafkaDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.KafkaDelivery, dara.String("KafkaDelivery"), dara.String("json"))
5556 }
5557
5558 if !dara.IsNil(tmpReq.OssDelivery) {
5559 request.OssDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.OssDelivery, dara.String("OssDelivery"), dara.String("json"))
5560 }
5561
5562 if !dara.IsNil(tmpReq.S3Delivery) {
5563 request.S3DeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.S3Delivery, dara.String("S3Delivery"), dara.String("json"))
5564 }
5565
5566 if !dara.IsNil(tmpReq.SlsDelivery) {
5567 request.SlsDeliveryShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.SlsDelivery, dara.String("SlsDelivery"), dara.String("json"))
5568 }
5569
5570 body := map[string]interface{}{}
5571 if !dara.IsNil(request.BusinessType) {
5572 body["BusinessType"] = request.BusinessType
5573 }
5574
5575 if !dara.IsNil(request.DataCenter) {
5576 body["DataCenter"] = request.DataCenter
5577 }
5578
5579 if !dara.IsNil(request.DeliveryType) {
5580 body["DeliveryType"] = request.DeliveryType
5581 }
5582
5583 if !dara.IsNil(request.Details) {
5584 body["Details"] = request.Details
5585 }
5586
5587 if !dara.IsNil(request.DiscardRate) {
5588 body["DiscardRate"] = request.DiscardRate
5589 }
5590
5591 if !dara.IsNil(request.FieldName) {
5592 body["FieldName"] = request.FieldName
5593 }
5594
5595 if !dara.IsNil(request.FilterVer) {
5596 body["FilterVer"] = request.FilterVer
5597 }
5598
5599 if !dara.IsNil(request.HttpDeliveryShrink) {
5600 body["HttpDelivery"] = request.HttpDeliveryShrink
5601 }
5602
5603 if !dara.IsNil(request.KafkaDeliveryShrink) {
5604 body["KafkaDelivery"] = request.KafkaDeliveryShrink
5605 }
5606
5607 if !dara.IsNil(request.OssDeliveryShrink) {
5608 body["OssDelivery"] = request.OssDeliveryShrink
5609 }
5610
5611 if !dara.IsNil(request.S3DeliveryShrink) {
5612 body["S3Delivery"] = request.S3DeliveryShrink
5613 }
5614
5615 if !dara.IsNil(request.SlsDeliveryShrink) {
5616 body["SlsDelivery"] = request.SlsDeliveryShrink
5617 }
5618
5619 if !dara.IsNil(request.TaskName) {
5620 body["TaskName"] = request.TaskName
5621 }
5622
5623 req := &openapiutil.OpenApiRequest{
5624 Body: openapiutil.ParseToMap(body),
5625 }
5626 params := &openapiutil.Params{
5627 Action: dara.String("CreateUserDeliveryTask"),
5628 Version: dara.String("2024-09-10"),
5629 Protocol: dara.String("HTTPS"),
5630 Pathname: dara.String("/"),
5631 Method: dara.String("POST"),
5632 AuthType: dara.String("AK"),
5633 Style: dara.String("RPC"),
5634 ReqBodyType: dara.String("formData"),
5635 BodyType: dara.String("json"),
5636 }
5637 _result = &CreateUserDeliveryTaskResponse{}
5638 _body, _err := client.CallApi(params, req, runtime)
5639 if _err != nil {
5640 return _result, _err
5641 }
5642 _err = dara.Convert(_body, &_result)
5643 return _result, _err
5644 }
5645
5646 // Summary:
5647 //
5648 // Creates a log delivery task to ship logs to the specified destination.
5649 //
5650 // Description:
5651 //
5652 // 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.
5653 //
5654 // - **Field filtering**: Use the `FieldName` parameter to specify log fields to deliver.
5655 //
5656 // - **Filtering rules**: Use the `FilterRules` parameter to pre-process and filter log data.
5657 //
5658 // - **Diverse delivery destinations**: Logs can be delivered to different destinations. Configuration parameters vary with delivery destinations.
5659 //
5660 // ## [](#)Precautions
5661 //
5662 // - Make sure that you have sufficient permissions to perform delivery tasks.
5663 //
5664 // - If you enable encryption or authentication, properly configure corresponding parameters.
5665 //
5666 // - Verify the syntax of `FilterRules` to make sure that filtering logic works as expected.
5667 //
5668 // - Specify advanced settings such as the number of retries and timeout period based on your needs to have optimal delivery efficiency and stability.
5669 //
5670 // @param request - CreateUserDeliveryTaskRequest
5671 //
5672 // @return CreateUserDeliveryTaskResponse
5673 func CreateUserDeliveryTask(client *Client, request *CreateUserDeliveryTaskRequest) (_result *CreateUserDeliveryTaskResponse, _err error) {
5674 runtime := &dara.RuntimeOptions{}
5675 _result = &CreateUserDeliveryTaskResponse{}
5676 _body, _err := CreateUserDeliveryTaskWithOptions(client,request, runtime)
5677 if _err != nil {
5678 return _result, _err
5679 }
5680 _result = _body
5681 return _result, _err
5682 }
5683
5684 // Summary:
5685 //
5686 // 用于创建实例级别的Web应用防火墙规则集，支持多种类型的防护规则。
5687 //
5688 // Description:
5689 //
5690 // ## 请求说明
5691 //
5692 // - 本API允许用户为指定实例创建新的WAF（Web Application Firewall）规则集。
5693 //
5694 // - `InstanceId` 是必需参数，指定了要为其创建规则集的具体实例。
5695 //
5696 // - `Phase` 参数定义了规则集的应用阶段，例如自定义规则、频次控制等。
5697 //
5698 // - `Name` 和 `Expression` 是必填项，分别代表规则集的名字和具体的匹配表达式。
5699 //
5700 // - 可选参数 `Description` 提供了对规则集功能或用途的文字描述。
5701 //
5702 // - `Status` 控制着规则集是否立即生效 (`on`) 或者处于关闭状态 (`off`)。
5703 //
5704 // - 通过 `Rules` 参数可以进一步配置更详细的规则列表，每个规则都包含名称、位置、表达式及动作等属性。
5705 //
5706 // - 成功响应将返回新创建规则集的唯一标识符 `Id` 以及所有关联规则的ID列表 `RuleIds`。
5707 //
5708 // @param tmpReq - CreateUserWafRulesetRequest
5709 //
5710 // @param runtime - runtime options for this request RuntimeOptions
5711 //
5712 // @return CreateUserWafRulesetResponse
5713 func CreateUserWafRulesetWithOptions(client *Client, tmpReq *CreateUserWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *CreateUserWafRulesetResponse, _err error) {
5714 if dara.BoolValue(client.EnableValidate) == true {
5715 _err = tmpReq.Validate()
5716 if _err != nil {
5717 return _result, _err
5718 }
5719 }
5720 request := &CreateUserWafRulesetShrinkRequest{}
5721 openapiutil.Convert(tmpReq, request)
5722 if !dara.IsNil(tmpReq.Rules) {
5723 request.RulesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Rules, dara.String("Rules"), dara.String("json"))
5724 }
5725
5726 if !dara.IsNil(tmpReq.Shared) {
5727 request.SharedShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Shared, dara.String("Shared"), dara.String("json"))
5728 }
5729
5730 query := map[string]interface{}{}
5731 if !dara.IsNil(request.InstanceId) {
5732 query["InstanceId"] = request.InstanceId
5733 }
5734
5735 body := map[string]interface{}{}
5736 if !dara.IsNil(request.Description) {
5737 body["Description"] = request.Description
5738 }
5739
5740 if !dara.IsNil(request.Expression) {
5741 body["Expression"] = request.Expression
5742 }
5743
5744 if !dara.IsNil(request.Name) {
5745 body["Name"] = request.Name
5746 }
5747
5748 if !dara.IsNil(request.Phase) {
5749 body["Phase"] = request.Phase
5750 }
5751
5752 if !dara.IsNil(request.RulesShrink) {
5753 body["Rules"] = request.RulesShrink
5754 }
5755
5756 if !dara.IsNil(request.SharedShrink) {
5757 body["Shared"] = request.SharedShrink
5758 }
5759
5760 if !dara.IsNil(request.Status) {
5761 body["Status"] = request.Status
5762 }
5763
5764 req := &openapiutil.OpenApiRequest{
5765 Query: openapiutil.Query(query),
5766 Body: openapiutil.ParseToMap(body),
5767 }
5768 params := &openapiutil.Params{
5769 Action: dara.String("CreateUserWafRuleset"),
5770 Version: dara.String("2024-09-10"),
5771 Protocol: dara.String("HTTPS"),
5772 Pathname: dara.String("/"),
5773 Method: dara.String("POST"),
5774 AuthType: dara.String("AK"),
5775 Style: dara.String("RPC"),
5776 ReqBodyType: dara.String("formData"),
5777 BodyType: dara.String("json"),
5778 }
5779 _result = &CreateUserWafRulesetResponse{}
5780 _body, _err := client.CallApi(params, req, runtime)
5781 if _err != nil {
5782 return _result, _err
5783 }
5784 _err = dara.Convert(_body, &_result)
5785 return _result, _err
5786 }
5787
5788 // Summary:
5789 //
5790 // 用于创建实例级别的Web应用防火墙规则集，支持多种类型的防护规则。
5791 //
5792 // Description:
5793 //
5794 // ## 请求说明
5795 //
5796 // - 本API允许用户为指定实例创建新的WAF（Web Application Firewall）规则集。
5797 //
5798 // - `InstanceId` 是必需参数，指定了要为其创建规则集的具体实例。
5799 //
5800 // - `Phase` 参数定义了规则集的应用阶段，例如自定义规则、频次控制等。
5801 //
5802 // - `Name` 和 `Expression` 是必填项，分别代表规则集的名字和具体的匹配表达式。
5803 //
5804 // - 可选参数 `Description` 提供了对规则集功能或用途的文字描述。
5805 //
5806 // - `Status` 控制着规则集是否立即生效 (`on`) 或者处于关闭状态 (`off`)。
5807 //
5808 // - 通过 `Rules` 参数可以进一步配置更详细的规则列表，每个规则都包含名称、位置、表达式及动作等属性。
5809 //
5810 // - 成功响应将返回新创建规则集的唯一标识符 `Id` 以及所有关联规则的ID列表 `RuleIds`。
5811 //
5812 // @param request - CreateUserWafRulesetRequest
5813 //
5814 // @return CreateUserWafRulesetResponse
5815 func CreateUserWafRuleset(client *Client, request *CreateUserWafRulesetRequest) (_result *CreateUserWafRulesetResponse, _err error) {
5816 runtime := &dara.RuntimeOptions{}
5817 _result = &CreateUserWafRulesetResponse{}
5818 _body, _err := CreateUserWafRulesetWithOptions(client,request, runtime)
5819 if _err != nil {
5820 return _result, _err
5821 }
5822 _result = _body
5823 return _result, _err
5824 }
5825
5826 // Summary:
5827 //
5828 // Add video processing configurations for a website.
5829 //
5830 // @param request - CreateVideoProcessingRequest
5831 //
5832 // @param runtime - runtime options for this request RuntimeOptions
5833 //
5834 // @return CreateVideoProcessingResponse
5835 func CreateVideoProcessingWithOptions(client *Client, request *CreateVideoProcessingRequest, runtime *dara.RuntimeOptions) (_result *CreateVideoProcessingResponse, _err error) {
5836 if dara.BoolValue(client.EnableValidate) == true {
5837 _err = request.Validate()
5838 if _err != nil {
5839 return _result, _err
5840 }
5841 }
5842 query := map[string]interface{}{}
5843 if !dara.IsNil(request.FlvSeekEnd) {
5844 query["FlvSeekEnd"] = request.FlvSeekEnd
5845 }
5846
5847 if !dara.IsNil(request.FlvSeekStart) {
5848 query["FlvSeekStart"] = request.FlvSeekStart
5849 }
5850
5851 if !dara.IsNil(request.FlvVideoSeekMode) {
5852 query["FlvVideoSeekMode"] = request.FlvVideoSeekMode
5853 }
5854
5855 if !dara.IsNil(request.Mp4SeekEnd) {
5856 query["Mp4SeekEnd"] = request.Mp4SeekEnd
5857 }
5858
5859 if !dara.IsNil(request.Mp4SeekStart) {
5860 query["Mp4SeekStart"] = request.Mp4SeekStart
5861 }
5862
5863 if !dara.IsNil(request.Rule) {
5864 query["Rule"] = request.Rule
5865 }
5866
5867 if !dara.IsNil(request.RuleEnable) {
5868 query["RuleEnable"] = request.RuleEnable
5869 }
5870
5871 if !dara.IsNil(request.RuleName) {
5872 query["RuleName"] = request.RuleName
5873 }
5874
5875 if !dara.IsNil(request.Sequence) {
5876 query["Sequence"] = request.Sequence
5877 }
5878
5879 if !dara.IsNil(request.SiteId) {
5880 query["SiteId"] = request.SiteId
5881 }
5882
5883 if !dara.IsNil(request.SiteVersion) {
5884 query["SiteVersion"] = request.SiteVersion
5885 }
5886
5887 if !dara.IsNil(request.VideoSeekEnable) {
5888 query["VideoSeekEnable"] = request.VideoSeekEnable
5889 }
5890
5891 req := &openapiutil.OpenApiRequest{
5892 Query: openapiutil.Query(query),
5893 }
5894 params := &openapiutil.Params{
5895 Action: dara.String("CreateVideoProcessing"),
5896 Version: dara.String("2024-09-10"),
5897 Protocol: dara.String("HTTPS"),
5898 Pathname: dara.String("/"),
5899 Method: dara.String("POST"),
5900 AuthType: dara.String("AK"),
5901 Style: dara.String("RPC"),
5902 ReqBodyType: dara.String("formData"),
5903 BodyType: dara.String("json"),
5904 }
5905 _result = &CreateVideoProcessingResponse{}
5906 _body, _err := client.CallApi(params, req, runtime)
5907 if _err != nil {
5908 return _result, _err
5909 }
5910 _err = dara.Convert(_body, &_result)
5911 return _result, _err
5912 }
5913
5914 // Summary:
5915 //
5916 // Add video processing configurations for a website.
5917 //
5918 // @param request - CreateVideoProcessingRequest
5919 //
5920 // @return CreateVideoProcessingResponse
5921 func CreateVideoProcessing(client *Client, request *CreateVideoProcessingRequest) (_result *CreateVideoProcessingResponse, _err error) {
5922 runtime := &dara.RuntimeOptions{}
5923 _result = &CreateVideoProcessingResponse{}
5924 _body, _err := CreateVideoProcessingWithOptions(client,request, runtime)
5925 if _err != nil {
5926 return _result, _err
5927 }
5928 _result = _body
5929 return _result, _err
5930 }
5931
5932 // Summary:
5933 //
5934 // # Create WAF Rule
5935 //
5936 // @param tmpReq - CreateWafRuleRequest
5937 //
5938 // @param runtime - runtime options for this request RuntimeOptions
5939 //
5940 // @return CreateWafRuleResponse
5941 func CreateWafRuleWithOptions(client *Client, tmpReq *CreateWafRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateWafRuleResponse, _err error) {
5942 if dara.BoolValue(client.EnableValidate) == true {
5943 _err = tmpReq.Validate()
5944 if _err != nil {
5945 return _result, _err
5946 }
5947 }
5948 request := &CreateWafRuleShrinkRequest{}
5949 openapiutil.Convert(tmpReq, request)
5950 if !dara.IsNil(tmpReq.Config) {
5951 request.ConfigShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Config, dara.String("Config"), dara.String("json"))
5952 }
5953
5954 query := map[string]interface{}{}
5955 if !dara.IsNil(request.SiteId) {
5956 query["SiteId"] = request.SiteId
5957 }
5958
5959 if !dara.IsNil(request.SiteVersion) {
5960 query["SiteVersion"] = request.SiteVersion
5961 }
5962
5963 body := map[string]interface{}{}
5964 if !dara.IsNil(request.ConfigShrink) {
5965 body["Config"] = request.ConfigShrink
5966 }
5967
5968 if !dara.IsNil(request.Phase) {
5969 body["Phase"] = request.Phase
5970 }
5971
5972 if !dara.IsNil(request.RulesetId) {
5973 body["RulesetId"] = request.RulesetId
5974 }
5975
5976 req := &openapiutil.OpenApiRequest{
5977 Query: openapiutil.Query(query),
5978 Body: openapiutil.ParseToMap(body),
5979 }
5980 params := &openapiutil.Params{
5981 Action: dara.String("CreateWafRule"),
5982 Version: dara.String("2024-09-10"),
5983 Protocol: dara.String("HTTPS"),
5984 Pathname: dara.String("/"),
5985 Method: dara.String("POST"),
5986 AuthType: dara.String("AK"),
5987 Style: dara.String("RPC"),
5988 ReqBodyType: dara.String("formData"),
5989 BodyType: dara.String("json"),
5990 }
5991 _result = &CreateWafRuleResponse{}
5992 _body, _err := client.CallApi(params, req, runtime)
5993 if _err != nil {
5994 return _result, _err
5995 }
5996 _err = dara.Convert(_body, &_result)
5997 return _result, _err
5998 }
5999
6000 // Summary:
6001 //
6002 // # Create WAF Rule
6003 //
6004 // @param request - CreateWafRuleRequest
6005 //
6006 // @return CreateWafRuleResponse
6007 func CreateWafRule(client *Client, request *CreateWafRuleRequest) (_result *CreateWafRuleResponse, _err error) {
6008 runtime := &dara.RuntimeOptions{}
6009 _result = &CreateWafRuleResponse{}
6010 _body, _err := CreateWafRuleWithOptions(client,request, runtime)
6011 if _err != nil {
6012 return _result, _err
6013 }
6014 _result = _body
6015 return _result, _err
6016 }
6017
6018 // Summary:
6019 //
6020 // # Create WAF Ruleset
6021 //
6022 // @param request - CreateWafRulesetRequest
6023 //
6024 // @param runtime - runtime options for this request RuntimeOptions
6025 //
6026 // @return CreateWafRulesetResponse
6027 func CreateWafRulesetWithOptions(client *Client, request *CreateWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *CreateWafRulesetResponse, _err error) {
6028 if dara.BoolValue(client.EnableValidate) == true {
6029 _err = request.Validate()
6030 if _err != nil {
6031 return _result, _err
6032 }
6033 }
6034 query := map[string]interface{}{}
6035 if !dara.IsNil(request.SiteId) {
6036 query["SiteId"] = request.SiteId
6037 }
6038
6039 if !dara.IsNil(request.SiteVersion) {
6040 query["SiteVersion"] = request.SiteVersion
6041 }
6042
6043 body := map[string]interface{}{}
6044 if !dara.IsNil(request.Name) {
6045 body["Name"] = request.Name
6046 }
6047
6048 if !dara.IsNil(request.Phase) {
6049 body["Phase"] = request.Phase
6050 }
6051
6052 req := &openapiutil.OpenApiRequest{
6053 Query: openapiutil.Query(query),
6054 Body: openapiutil.ParseToMap(body),
6055 }
6056 params := &openapiutil.Params{
6057 Action: dara.String("CreateWafRuleset"),
6058 Version: dara.String("2024-09-10"),
6059 Protocol: dara.String("HTTPS"),
6060 Pathname: dara.String("/"),
6061 Method: dara.String("POST"),
6062 AuthType: dara.String("AK"),
6063 Style: dara.String("RPC"),
6064 ReqBodyType: dara.String("formData"),
6065 BodyType: dara.String("json"),
6066 }
6067 _result = &CreateWafRulesetResponse{}
6068 _body, _err := client.CallApi(params, req, runtime)
6069 if _err != nil {
6070 return _result, _err
6071 }
6072 _err = dara.Convert(_body, &_result)
6073 return _result, _err
6074 }
6075
6076 // Summary:
6077 //
6078 // # Create WAF Ruleset
6079 //
6080 // @param request - CreateWafRulesetRequest
6081 //
6082 // @return CreateWafRulesetResponse
6083 func CreateWafRuleset(client *Client, request *CreateWafRulesetRequest) (_result *CreateWafRulesetResponse, _err error) {
6084 runtime := &dara.RuntimeOptions{}
6085 _result = &CreateWafRulesetResponse{}
6086 _body, _err := CreateWafRulesetWithOptions(client,request, runtime)
6087 if _err != nil {
6088 return _result, _err
6089 }
6090 _result = _body
6091 return _result, _err
6092 }
6093
6094 // Summary:
6095 //
6096 // Creates a waiting room for a website.
6097 //
6098 // @param tmpReq - CreateWaitingRoomRequest
6099 //
6100 // @param runtime - runtime options for this request RuntimeOptions
6101 //
6102 // @return CreateWaitingRoomResponse
6103 func CreateWaitingRoomWithOptions(client *Client, tmpReq *CreateWaitingRoomRequest, runtime *dara.RuntimeOptions) (_result *CreateWaitingRoomResponse, _err error) {
6104 if dara.BoolValue(client.EnableValidate) == true {
6105 _err = tmpReq.Validate()
6106 if _err != nil {
6107 return _result, _err
6108 }
6109 }
6110 request := &CreateWaitingRoomShrinkRequest{}
6111 openapiutil.Convert(tmpReq, request)
6112 if !dara.IsNil(tmpReq.HostNameAndPath) {
6113 request.HostNameAndPathShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.HostNameAndPath, dara.String("HostNameAndPath"), dara.String("json"))
6114 }
6115
6116 query := map[string]interface{}{}
6117 if !dara.IsNil(request.CookieName) {
6118 query["CookieName"] = request.CookieName
6119 }
6120
6121 if !dara.IsNil(request.CustomPageHtml) {
6122 query["CustomPageHtml"] = request.CustomPageHtml
6123 }
6124
6125 if !dara.IsNil(request.Description) {
6126 query["Description"] = request.Description
6127 }
6128
6129 if !dara.IsNil(request.DisableSessionRenewalEnable) {
6130 query["DisableSessionRenewalEnable"] = request.DisableSessionRenewalEnable
6131 }
6132
6133 if !dara.IsNil(request.Enable) {
6134 query["Enable"] = request.Enable
6135 }
6136
6137 if !dara.IsNil(request.HostNameAndPathShrink) {
6138 query["HostNameAndPath"] = request.HostNameAndPathShrink
6139 }
6140
6141 if !dara.IsNil(request.JsonResponseEnable) {
6142 query["JsonResponseEnable"] = request.JsonResponseEnable
6143 }
6144
6145 if !dara.IsNil(request.Language) {
6146 query["Language"] = request.Language
6147 }
6148
6149 if !dara.IsNil(request.Name) {
6150 query["Name"] = request.Name
6151 }
6152
6153 if !dara.IsNil(request.NewUsersPerMinute) {
6154 query["NewUsersPerMinute"] = request.NewUsersPerMinute
6155 }
6156
6157 if !dara.IsNil(request.QueueAllEnable) {
6158 query["QueueAllEnable"] = request.QueueAllEnable
6159 }
6160
6161 if !dara.IsNil(request.QueuingMethod) {
6162 query["QueuingMethod"] = request.QueuingMethod
6163 }
6164
6165 if !dara.IsNil(request.QueuingStatusCode) {
6166 query["QueuingStatusCode"] = request.QueuingStatusCode
6167 }
6168
6169 if !dara.IsNil(request.SessionDuration) {
6170 query["SessionDuration"] = request.SessionDuration
6171 }
6172
6173 if !dara.IsNil(request.SiteId) {
6174 query["SiteId"] = request.SiteId
6175 }
6176
6177 if !dara.IsNil(request.TotalActiveUsers) {
6178 query["TotalActiveUsers"] = request.TotalActiveUsers
6179 }
6180
6181 if !dara.IsNil(request.WaitingRoomType) {
6182 query["WaitingRoomType"] = request.WaitingRoomType
6183 }
6184
6185 req := &openapiutil.OpenApiRequest{
6186 Query: openapiutil.Query(query),
6187 }
6188 params := &openapiutil.Params{
6189 Action: dara.String("CreateWaitingRoom"),
6190 Version: dara.String("2024-09-10"),
6191 Protocol: dara.String("HTTPS"),
6192 Pathname: dara.String("/"),
6193 Method: dara.String("POST"),
6194 AuthType: dara.String("AK"),
6195 Style: dara.String("RPC"),
6196 ReqBodyType: dara.String("formData"),
6197 BodyType: dara.String("json"),
6198 }
6199 _result = &CreateWaitingRoomResponse{}
6200 _body, _err := client.CallApi(params, req, runtime)
6201 if _err != nil {
6202 return _result, _err
6203 }
6204 _err = dara.Convert(_body, &_result)
6205 return _result, _err
6206 }
6207
6208 // Summary:
6209 //
6210 // Creates a waiting room for a website.
6211 //
6212 // @param request - CreateWaitingRoomRequest
6213 //
6214 // @return CreateWaitingRoomResponse
6215 func CreateWaitingRoom(client *Client, request *CreateWaitingRoomRequest) (_result *CreateWaitingRoomResponse, _err error) {
6216 runtime := &dara.RuntimeOptions{}
6217 _result = &CreateWaitingRoomResponse{}
6218 _body, _err := CreateWaitingRoomWithOptions(client,request, runtime)
6219 if _err != nil {
6220 return _result, _err
6221 }
6222 _result = _body
6223 return _result, _err
6224 }
6225
6226 // Summary:
6227 //
6228 // Creates a waiting room event.
6229 //
6230 // @param request - CreateWaitingRoomEventRequest
6231 //
6232 // @param runtime - runtime options for this request RuntimeOptions
6233 //
6234 // @return CreateWaitingRoomEventResponse
6235 func CreateWaitingRoomEventWithOptions(client *Client, request *CreateWaitingRoomEventRequest, runtime *dara.RuntimeOptions) (_result *CreateWaitingRoomEventResponse, _err error) {
6236 if dara.BoolValue(client.EnableValidate) == true {
6237 _err = request.Validate()
6238 if _err != nil {
6239 return _result, _err
6240 }
6241 }
6242 query := map[string]interface{}{}
6243 if !dara.IsNil(request.CustomPageHtml) {
6244 query["CustomPageHtml"] = request.CustomPageHtml
6245 }
6246
6247 if !dara.IsNil(request.Description) {
6248 query["Description"] = request.Description
6249 }
6250
6251 if !dara.IsNil(request.DisableSessionRenewalEnable) {
6252 query["DisableSessionRenewalEnable"] = request.DisableSessionRenewalEnable
6253 }
6254
6255 if !dara.IsNil(request.Enable) {
6256 query["Enable"] = request.Enable
6257 }
6258
6259 if !dara.IsNil(request.EndTime) {
6260 query["EndTime"] = request.EndTime
6261 }
6262
6263 if !dara.IsNil(request.JsonResponseEnable) {
6264 query["JsonResponseEnable"] = request.JsonResponseEnable
6265 }
6266
6267 if !dara.IsNil(request.Language) {
6268 query["Language"] = request.Language
6269 }
6270
6271 if !dara.IsNil(request.Name) {
6272 query["Name"] = request.Name
6273 }
6274
6275 if !dara.IsNil(request.NewUsersPerMinute) {
6276 query["NewUsersPerMinute"] = request.NewUsersPerMinute
6277 }
6278
6279 if !dara.IsNil(request.PreQueueEnable) {
6280 query["PreQueueEnable"] = request.PreQueueEnable
6281 }
6282
6283 if !dara.IsNil(request.PreQueueStartTime) {
6284 query["PreQueueStartTime"] = request.PreQueueStartTime
6285 }
6286
6287 if !dara.IsNil(request.QueuingMethod) {
6288 query["QueuingMethod"] = request.QueuingMethod
6289 }
6290
6291 if !dara.IsNil(request.QueuingStatusCode) {
6292 query["QueuingStatusCode"] = request.QueuingStatusCode
6293 }
6294
6295 if !dara.IsNil(request.RandomPreQueueEnable) {
6296 query["RandomPreQueueEnable"] = request.RandomPreQueueEnable
6297 }
6298
6299 if !dara.IsNil(request.SessionDuration) {
6300 query["SessionDuration"] = request.SessionDuration
6301 }
6302
6303 if !dara.IsNil(request.SiteId) {
6304 query["SiteId"] = request.SiteId
6305 }
6306
6307 if !dara.IsNil(request.StartTime) {
6308 query["StartTime"] = request.StartTime
6309 }
6310
6311 if !dara.IsNil(request.TotalActiveUsers) {
6312 query["TotalActiveUsers"] = request.TotalActiveUsers
6313 }
6314
6315 if !dara.IsNil(request.WaitingRoomId) {
6316 query["WaitingRoomId"] = request.WaitingRoomId
6317 }
6318
6319 if !dara.IsNil(request.WaitingRoomType) {
6320 query["WaitingRoomType"] = request.WaitingRoomType
6321 }
6322
6323 req := &openapiutil.OpenApiRequest{
6324 Query: openapiutil.Query(query),
6325 }
6326 params := &openapiutil.Params{
6327 Action: dara.String("CreateWaitingRoomEvent"),
6328 Version: dara.String("2024-09-10"),
6329 Protocol: dara.String("HTTPS"),
6330 Pathname: dara.String("/"),
6331 Method: dara.String("POST"),
6332 AuthType: dara.String("AK"),
6333 Style: dara.String("RPC"),
6334 ReqBodyType: dara.String("formData"),
6335 BodyType: dara.String("json"),
6336 }
6337 _result = &CreateWaitingRoomEventResponse{}
6338 _body, _err := client.CallApi(params, req, runtime)
6339 if _err != nil {
6340 return _result, _err
6341 }
6342 _err = dara.Convert(_body, &_result)
6343 return _result, _err
6344 }
6345
6346 // Summary:
6347 //
6348 // Creates a waiting room event.
6349 //
6350 // @param request - CreateWaitingRoomEventRequest
6351 //
6352 // @return CreateWaitingRoomEventResponse
6353 func CreateWaitingRoomEvent(client *Client, request *CreateWaitingRoomEventRequest) (_result *CreateWaitingRoomEventResponse, _err error) {
6354 runtime := &dara.RuntimeOptions{}
6355 _result = &CreateWaitingRoomEventResponse{}
6356 _body, _err := CreateWaitingRoomEventWithOptions(client,request, runtime)
6357 if _err != nil {
6358 return _result, _err
6359 }
6360 _result = _body
6361 return _result, _err
6362 }
6363
6364 // Summary:
6365 //
6366 // # Create Waiting Room Rule
6367 //
6368 // @param request - CreateWaitingRoomRuleRequest
6369 //
6370 // @param runtime - runtime options for this request RuntimeOptions
6371 //
6372 // @return CreateWaitingRoomRuleResponse
6373 func CreateWaitingRoomRuleWithOptions(client *Client, request *CreateWaitingRoomRuleRequest, runtime *dara.RuntimeOptions) (_result *CreateWaitingRoomRuleResponse, _err error) {
6374 if dara.BoolValue(client.EnableValidate) == true {
6375 _err = request.Validate()
6376 if _err != nil {
6377 return _result, _err
6378 }
6379 }
6380 query := map[string]interface{}{}
6381 if !dara.IsNil(request.Rule) {
6382 query["Rule"] = request.Rule
6383 }
6384
6385 if !dara.IsNil(request.RuleEnable) {
6386 query["RuleEnable"] = request.RuleEnable
6387 }
6388
6389 if !dara.IsNil(request.RuleName) {
6390 query["RuleName"] = request.RuleName
6391 }
6392
6393 if !dara.IsNil(request.SiteId) {
6394 query["SiteId"] = request.SiteId
6395 }
6396
6397 if !dara.IsNil(request.WaitingRoomId) {
6398 query["WaitingRoomId"] = request.WaitingRoomId
6399 }
6400
6401 req := &openapiutil.OpenApiRequest{
6402 Query: openapiutil.Query(query),
6403 }
6404 params := &openapiutil.Params{
6405 Action: dara.String("CreateWaitingRoomRule"),
6406 Version: dara.String("2024-09-10"),
6407 Protocol: dara.String("HTTPS"),
6408 Pathname: dara.String("/"),
6409 Method: dara.String("POST"),
6410 AuthType: dara.String("AK"),
6411 Style: dara.String("RPC"),
6412 ReqBodyType: dara.String("formData"),
6413 BodyType: dara.String("json"),
6414 }
6415 _result = &CreateWaitingRoomRuleResponse{}
6416 _body, _err := client.CallApi(params, req, runtime)
6417 if _err != nil {
6418 return _result, _err
6419 }
6420 _err = dara.Convert(_body, &_result)
6421 return _result, _err
6422 }
6423
6424 // Summary:
6425 //
6426 // # Create Waiting Room Rule
6427 //
6428 // @param request - CreateWaitingRoomRuleRequest
6429 //
6430 // @return CreateWaitingRoomRuleResponse
6431 func CreateWaitingRoomRule(client *Client, request *CreateWaitingRoomRuleRequest) (_result *CreateWaitingRoomRuleResponse, _err error) {
6432 runtime := &dara.RuntimeOptions{}
6433 _result = &CreateWaitingRoomRuleResponse{}
6434 _body, _err := CreateWaitingRoomRuleWithOptions(client,request, runtime)
6435 if _err != nil {
6436 return _result, _err
6437 }
6438 _result = _body
6439 return _result, _err
6440 }
6441
6442 // Summary:
6443 //
6444 // Disables version management for a website.
6445 //
6446 // Description:
6447 //
6448 // You can disable version management only when the default environment and version 0 exist.
6449 //
6450 // @param request - DeactivateVersionManagementRequest
6451 //
6452 // @param runtime - runtime options for this request RuntimeOptions
6453 //
6454 // @return DeactivateVersionManagementResponse
6455 func DeactivateVersionManagementWithOptions(client *Client, request *DeactivateVersionManagementRequest, runtime *dara.RuntimeOptions) (_result *DeactivateVersionManagementResponse, _err error) {
6456 if dara.BoolValue(client.EnableValidate) == true {
6457 _err = request.Validate()
6458 if _err != nil {
6459 return _result, _err
6460 }
6461 }
6462 query := map[string]interface{}{}
6463 if !dara.IsNil(request.SiteId) {
6464 query["SiteId"] = request.SiteId
6465 }
6466
6467 req := &openapiutil.OpenApiRequest{
6468 Query: openapiutil.Query(query),
6469 }
6470 params := &openapiutil.Params{
6471 Action: dara.String("DeactivateVersionManagement"),
6472 Version: dara.String("2024-09-10"),
6473 Protocol: dara.String("HTTPS"),
6474 Pathname: dara.String("/"),
6475 Method: dara.String("POST"),
6476 AuthType: dara.String("AK"),
6477 Style: dara.String("RPC"),
6478 ReqBodyType: dara.String("formData"),
6479 BodyType: dara.String("json"),
6480 }
6481 _result = &DeactivateVersionManagementResponse{}
6482 _body, _err := client.CallApi(params, req, runtime)
6483 if _err != nil {
6484 return _result, _err
6485 }
6486 _err = dara.Convert(_body, &_result)
6487 return _result, _err
6488 }
6489
6490 // Summary:
6491 //
6492 // Disables version management for a website.
6493 //
6494 // Description:
6495 //
6496 // You can disable version management only when the default environment and version 0 exist.
6497 //
6498 // @param request - DeactivateVersionManagementRequest
6499 //
6500 // @return DeactivateVersionManagementResponse
6501 func DeactivateVersionManagement(client *Client, request *DeactivateVersionManagementRequest) (_result *DeactivateVersionManagementResponse, _err error) {
6502 runtime := &dara.RuntimeOptions{}
6503 _result = &DeactivateVersionManagementResponse{}
6504 _body, _err := DeactivateVersionManagementWithOptions(client,request, runtime)
6505 if _err != nil {
6506 return _result, _err
6507 }
6508 _result = _body
6509 return _result, _err
6510 }
6511
6512 // Summary:
6513 //
6514 // # Delete Cache Configuration
6515 //
6516 // @param request - DeleteCacheRuleRequest
6517 //
6518 // @param runtime - runtime options for this request RuntimeOptions
6519 //
6520 // @return DeleteCacheRuleResponse
6521 func DeleteCacheRuleWithOptions(client *Client, request *DeleteCacheRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteCacheRuleResponse, _err error) {
6522 if dara.BoolValue(client.EnableValidate) == true {
6523 _err = request.Validate()
6524 if _err != nil {
6525 return _result, _err
6526 }
6527 }
6528 query := map[string]interface{}{}
6529 if !dara.IsNil(request.ConfigId) {
6530 query["ConfigId"] = request.ConfigId
6531 }
6532
6533 if !dara.IsNil(request.SiteId) {
6534 query["SiteId"] = request.SiteId
6535 }
6536
6537 req := &openapiutil.OpenApiRequest{
6538 Query: openapiutil.Query(query),
6539 }
6540 params := &openapiutil.Params{
6541 Action: dara.String("DeleteCacheRule"),
6542 Version: dara.String("2024-09-10"),
6543 Protocol: dara.String("HTTPS"),
6544 Pathname: dara.String("/"),
6545 Method: dara.String("POST"),
6546 AuthType: dara.String("AK"),
6547 Style: dara.String("RPC"),
6548 ReqBodyType: dara.String("formData"),
6549 BodyType: dara.String("json"),
6550 }
6551 _result = &DeleteCacheRuleResponse{}
6552 _body, _err := client.CallApi(params, req, runtime)
6553 if _err != nil {
6554 return _result, _err
6555 }
6556 _err = dara.Convert(_body, &_result)
6557 return _result, _err
6558 }
6559
6560 // Summary:
6561 //
6562 // # Delete Cache Configuration
6563 //
6564 // @param request - DeleteCacheRuleRequest
6565 //
6566 // @return DeleteCacheRuleResponse
6567 func DeleteCacheRule(client *Client, request *DeleteCacheRuleRequest) (_result *DeleteCacheRuleResponse, _err error) {
6568 runtime := &dara.RuntimeOptions{}
6569 _result = &DeleteCacheRuleResponse{}
6570 _body, _err := DeleteCacheRuleWithOptions(client,request, runtime)
6571 if _err != nil {
6572 return _result, _err
6573 }
6574 _result = _body
6575 return _result, _err
6576 }
6577
6578 // Summary:
6579 //
6580 // Deletes a certificate for a website.
6581 //
6582 // @param request - DeleteCertificateRequest
6583 //
6584 // @param runtime - runtime options for this request RuntimeOptions
6585 //
6586 // @return DeleteCertificateResponse
6587 func DeleteCertificateWithOptions(client *Client, request *DeleteCertificateRequest, runtime *dara.RuntimeOptions) (_result *DeleteCertificateResponse, _err error) {
6588 if dara.BoolValue(client.EnableValidate) == true {
6589 _err = request.Validate()
6590 if _err != nil {
6591 return _result, _err
6592 }
6593 }
6594 query := openapiutil.Query(dara.ToMap(request))
6595 req := &openapiutil.OpenApiRequest{
6596 Query: openapiutil.Query(query),
6597 }
6598 params := &openapiutil.Params{
6599 Action: dara.String("DeleteCertificate"),
6600 Version: dara.String("2024-09-10"),
6601 Protocol: dara.String("HTTPS"),
6602 Pathname: dara.String("/"),
6603 Method: dara.String("GET"),
6604 AuthType: dara.String("AK"),
6605 Style: dara.String("RPC"),
6606 ReqBodyType: dara.String("formData"),
6607 BodyType: dara.String("json"),
6608 }
6609 _result = &DeleteCertificateResponse{}
6610 _body, _err := client.CallApi(params, req, runtime)
6611 if _err != nil {
6612 return _result, _err
6613 }
6614 _err = dara.Convert(_body, &_result)
6615 return _result, _err
6616 }
6617
6618 // Summary:
6619 //
6620 // Deletes a certificate for a website.
6621 //
6622 // @param request - DeleteCertificateRequest
6623 //
6624 // @return DeleteCertificateResponse
6625 func DeleteCertificate(client *Client, request *DeleteCertificateRequest) (_result *DeleteCertificateResponse, _err error) {
6626 runtime := &dara.RuntimeOptions{}
6627 _result = &DeleteCertificateResponse{}
6628 _body, _err := DeleteCertificateWithOptions(client,request, runtime)
6629 if _err != nil {
6630 return _result, _err
6631 }
6632 _result = _body
6633 return _result, _err
6634 }
6635
6636 // Summary:
6637 //
6638 // Deletes a client CA certificate.
6639 //
6640 // @param request - DeleteClientCaCertificateRequest
6641 //
6642 // @param runtime - runtime options for this request RuntimeOptions
6643 //
6644 // @return DeleteClientCaCertificateResponse
6645 func DeleteClientCaCertificateWithOptions(client *Client, request *DeleteClientCaCertificateRequest, runtime *dara.RuntimeOptions) (_result *DeleteClientCaCertificateResponse, _err error) {
6646 if dara.BoolValue(client.EnableValidate) == true {
6647 _err = request.Validate()
6648 if _err != nil {
6649 return _result, _err
6650 }
6651 }
6652 query := openapiutil.Query(dara.ToMap(request))
6653 req := &openapiutil.OpenApiRequest{
6654 Query: openapiutil.Query(query),
6655 }
6656 params := &openapiutil.Params{
6657 Action: dara.String("DeleteClientCaCertificate"),
6658 Version: dara.String("2024-09-10"),
6659 Protocol: dara.String("HTTPS"),
6660 Pathname: dara.String("/"),
6661 Method: dara.String("GET"),
6662 AuthType: dara.String("AK"),
6663 Style: dara.String("RPC"),
6664 ReqBodyType: dara.String("formData"),
6665 BodyType: dara.String("json"),
6666 }
6667 _result = &DeleteClientCaCertificateResponse{}
6668 _body, _err := client.CallApi(params, req, runtime)
6669 if _err != nil {
6670 return _result, _err
6671 }
6672 _err = dara.Convert(_body, &_result)
6673 return _result, _err
6674 }
6675
6676 // Summary:
6677 //
6678 // Deletes a client CA certificate.
6679 //
6680 // @param request - DeleteClientCaCertificateRequest
6681 //
6682 // @return DeleteClientCaCertificateResponse
6683 func DeleteClientCaCertificate(client *Client, request *DeleteClientCaCertificateRequest) (_result *DeleteClientCaCertificateResponse, _err error) {
6684 runtime := &dara.RuntimeOptions{}
6685 _result = &DeleteClientCaCertificateResponse{}
6686 _body, _err := DeleteClientCaCertificateWithOptions(client,request, runtime)
6687 if _err != nil {
6688 return _result, _err
6689 }
6690 _result = _body
6691 return _result, _err
6692 }
6693
6694 // Summary:
6695 //
6696 // Deletes a revoked client certificate.
6697 //
6698 // @param request - DeleteClientCertificateRequest
6699 //
6700 // @param runtime - runtime options for this request RuntimeOptions
6701 //
6702 // @return DeleteClientCertificateResponse
6703 func DeleteClientCertificateWithOptions(client *Client, request *DeleteClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *DeleteClientCertificateResponse, _err error) {
6704 if dara.BoolValue(client.EnableValidate) == true {
6705 _err = request.Validate()
6706 if _err != nil {
6707 return _result, _err
6708 }
6709 }
6710 query := openapiutil.Query(dara.ToMap(request))
6711 req := &openapiutil.OpenApiRequest{
6712 Query: openapiutil.Query(query),
6713 }
6714 params := &openapiutil.Params{
6715 Action: dara.String("DeleteClientCertificate"),
6716 Version: dara.String("2024-09-10"),
6717 Protocol: dara.String("HTTPS"),
6718 Pathname: dara.String("/"),
6719 Method: dara.String("GET"),
6720 AuthType: dara.String("AK"),
6721 Style: dara.String("RPC"),
6722 ReqBodyType: dara.String("formData"),
6723 BodyType: dara.String("json"),
6724 }
6725 _result = &DeleteClientCertificateResponse{}
6726 _body, _err := client.CallApi(params, req, runtime)
6727 if _err != nil {
6728 return _result, _err
6729 }
6730 _err = dara.Convert(_body, &_result)
6731 return _result, _err
6732 }
6733
6734 // Summary:
6735 //
6736 // Deletes a revoked client certificate.
6737 //
6738 // @param request - DeleteClientCertificateRequest
6739 //
6740 // @return DeleteClientCertificateResponse
6741 func DeleteClientCertificate(client *Client, request *DeleteClientCertificateRequest) (_result *DeleteClientCertificateResponse, _err error) {
6742 runtime := &dara.RuntimeOptions{}
6743 _result = &DeleteClientCertificateResponse{}
6744 _body, _err := DeleteClientCertificateWithOptions(client,request, runtime)
6745 if _err != nil {
6746 return _result, _err
6747 }
6748 _result = _body
6749 return _result, _err
6750 }
6751
6752 // Summary:
6753 //
6754 // # Delete compression rule
6755 //
6756 // @param request - DeleteCompressionRuleRequest
6757 //
6758 // @param runtime - runtime options for this request RuntimeOptions
6759 //
6760 // @return DeleteCompressionRuleResponse
6761 func DeleteCompressionRuleWithOptions(client *Client, request *DeleteCompressionRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteCompressionRuleResponse, _err error) {
6762 if dara.BoolValue(client.EnableValidate) == true {
6763 _err = request.Validate()
6764 if _err != nil {
6765 return _result, _err
6766 }
6767 }
6768 query := map[string]interface{}{}
6769 if !dara.IsNil(request.ConfigId) {
6770 query["ConfigId"] = request.ConfigId
6771 }
6772
6773 if !dara.IsNil(request.SiteId) {
6774 query["SiteId"] = request.SiteId
6775 }
6776
6777 req := &openapiutil.OpenApiRequest{
6778 Query: openapiutil.Query(query),
6779 }
6780 params := &openapiutil.Params{
6781 Action: dara.String("DeleteCompressionRule"),
6782 Version: dara.String("2024-09-10"),
6783 Protocol: dara.String("HTTPS"),
6784 Pathname: dara.String("/"),
6785 Method: dara.String("POST"),
6786 AuthType: dara.String("AK"),
6787 Style: dara.String("RPC"),
6788 ReqBodyType: dara.String("formData"),
6789 BodyType: dara.String("json"),
6790 }
6791 _result = &DeleteCompressionRuleResponse{}
6792 _body, _err := client.CallApi(params, req, runtime)
6793 if _err != nil {
6794 return _result, _err
6795 }
6796 _err = dara.Convert(_body, &_result)
6797 return _result, _err
6798 }
6799
6800 // Summary:
6801 //
6802 // # Delete compression rule
6803 //
6804 // @param request - DeleteCompressionRuleRequest
6805 //
6806 // @return DeleteCompressionRuleResponse
6807 func DeleteCompressionRule(client *Client, request *DeleteCompressionRuleRequest) (_result *DeleteCompressionRuleResponse, _err error) {
6808 runtime := &dara.RuntimeOptions{}
6809 _result = &DeleteCompressionRuleResponse{}
6810 _body, _err := DeleteCompressionRuleWithOptions(client,request, runtime)
6811 if _err != nil {
6812 return _result, _err
6813 }
6814 _result = _body
6815 return _result, _err
6816 }
6817
6818 // Summary:
6819 //
6820 // Deletes a scenario-specific custom policy.
6821 //
6822 // @param request - DeleteCustomScenePolicyRequest
6823 //
6824 // @param runtime - runtime options for this request RuntimeOptions
6825 //
6826 // @return DeleteCustomScenePolicyResponse
6827 func DeleteCustomScenePolicyWithOptions(client *Client, request *DeleteCustomScenePolicyRequest, runtime *dara.RuntimeOptions) (_result *DeleteCustomScenePolicyResponse, _err error) {
6828 if dara.BoolValue(client.EnableValidate) == true {
6829 _err = request.Validate()
6830 if _err != nil {
6831 return _result, _err
6832 }
6833 }
6834 query := map[string]interface{}{}
6835 if !dara.IsNil(request.PolicyId) {
6836 query["PolicyId"] = request.PolicyId
6837 }
6838
6839 req := &openapiutil.OpenApiRequest{
6840 Query: openapiutil.Query(query),
6841 }
6842 params := &openapiutil.Params{
6843 Action: dara.String("DeleteCustomScenePolicy"),
6844 Version: dara.String("2024-09-10"),
6845 Protocol: dara.String("HTTPS"),
6846 Pathname: dara.String("/"),
6847 Method: dara.String("POST"),
6848 AuthType: dara.String("AK"),
6849 Style: dara.String("RPC"),
6850 ReqBodyType: dara.String("formData"),
6851 BodyType: dara.String("json"),
6852 }
6853 _result = &DeleteCustomScenePolicyResponse{}
6854 _body, _err := client.CallApi(params, req, runtime)
6855 if _err != nil {
6856 return _result, _err
6857 }
6858 _err = dara.Convert(_body, &_result)
6859 return _result, _err
6860 }
6861
6862 // Summary:
6863 //
6864 // Deletes a scenario-specific custom policy.
6865 //
6866 // @param request - DeleteCustomScenePolicyRequest
6867 //
6868 // @return DeleteCustomScenePolicyResponse
6869 func DeleteCustomScenePolicy(client *Client, request *DeleteCustomScenePolicyRequest) (_result *DeleteCustomScenePolicyResponse, _err error) {
6870 runtime := &dara.RuntimeOptions{}
6871 _result = &DeleteCustomScenePolicyResponse{}
6872 _body, _err := DeleteCustomScenePolicyWithOptions(client,request, runtime)
6873 if _err != nil {
6874 return _result, _err
6875 }
6876 _result = _body
6877 return _result, _err
6878 }
6879
6880 // Summary:
6881 //
6882 // Deletes a containerized application.
6883 //
6884 // @param request - DeleteEdgeContainerAppRequest
6885 //
6886 // @param runtime - runtime options for this request RuntimeOptions
6887 //
6888 // @return DeleteEdgeContainerAppResponse
6889 func DeleteEdgeContainerAppWithOptions(client *Client, request *DeleteEdgeContainerAppRequest, runtime *dara.RuntimeOptions) (_result *DeleteEdgeContainerAppResponse, _err error) {
6890 if dara.BoolValue(client.EnableValidate) == true {
6891 _err = request.Validate()
6892 if _err != nil {
6893 return _result, _err
6894 }
6895 }
6896 query := map[string]interface{}{}
6897 if !dara.IsNil(request.AppId) {
6898 query["AppId"] = request.AppId
6899 }
6900
6901 req := &openapiutil.OpenApiRequest{
6902 Query: openapiutil.Query(query),
6903 }
6904 params := &openapiutil.Params{
6905 Action: dara.String("DeleteEdgeContainerApp"),
6906 Version: dara.String("2024-09-10"),
6907 Protocol: dara.String("HTTPS"),
6908 Pathname: dara.String("/"),
6909 Method: dara.String("POST"),
6910 AuthType: dara.String("AK"),
6911 Style: dara.String("RPC"),
6912 ReqBodyType: dara.String("formData"),
6913 BodyType: dara.String("json"),
6914 }
6915 _result = &DeleteEdgeContainerAppResponse{}
6916 _body, _err := client.CallApi(params, req, runtime)
6917 if _err != nil {
6918 return _result, _err
6919 }
6920 _err = dara.Convert(_body, &_result)
6921 return _result, _err
6922 }
6923
6924 // Summary:
6925 //
6926 // Deletes a containerized application.
6927 //
6928 // @param request - DeleteEdgeContainerAppRequest
6929 //
6930 // @return DeleteEdgeContainerAppResponse
6931 func DeleteEdgeContainerApp(client *Client, request *DeleteEdgeContainerAppRequest) (_result *DeleteEdgeContainerAppResponse, _err error) {
6932 runtime := &dara.RuntimeOptions{}
6933 _result = &DeleteEdgeContainerAppResponse{}
6934 _body, _err := DeleteEdgeContainerAppWithOptions(client,request, runtime)
6935 if _err != nil {
6936 return _result, _err
6937 }
6938 _result = _body
6939 return _result, _err
6940 }
6941
6942 // Summary:
6943 //
6944 // 删除边缘容器应用的镜像秘钥
6945 //
6946 // @param request - DeleteEdgeContainerAppImageSecretRequest
6947 //
6948 // @param runtime - runtime options for this request RuntimeOptions
6949 //
6950 // @return DeleteEdgeContainerAppImageSecretResponse
6951 func DeleteEdgeContainerAppImageSecretWithOptions(client *Client, request *DeleteEdgeContainerAppImageSecretRequest, runtime *dara.RuntimeOptions) (_result *DeleteEdgeContainerAppImageSecretResponse, _err error) {
6952 if dara.BoolValue(client.EnableValidate) == true {
6953 _err = request.Validate()
6954 if _err != nil {
6955 return _result, _err
6956 }
6957 }
6958 query := map[string]interface{}{}
6959 if !dara.IsNil(request.AppId) {
6960 query["AppId"] = request.AppId
6961 }
6962
6963 if !dara.IsNil(request.Name) {
6964 query["Name"] = request.Name
6965 }
6966
6967 req := &openapiutil.OpenApiRequest{
6968 Query: openapiutil.Query(query),
6969 }
6970 params := &openapiutil.Params{
6971 Action: dara.String("DeleteEdgeContainerAppImageSecret"),
6972 Version: dara.String("2024-09-10"),
6973 Protocol: dara.String("HTTPS"),
6974 Pathname: dara.String("/"),
6975 Method: dara.String("POST"),
6976 AuthType: dara.String("AK"),
6977 Style: dara.String("RPC"),
6978 ReqBodyType: dara.String("formData"),
6979 BodyType: dara.String("json"),
6980 }
6981 _result = &DeleteEdgeContainerAppImageSecretResponse{}
6982 _body, _err := client.CallApi(params, req, runtime)
6983 if _err != nil {
6984 return _result, _err
6985 }
6986 _err = dara.Convert(_body, &_result)
6987 return _result, _err
6988 }
6989
6990 // Summary:
6991 //
6992 // 删除边缘容器应用的镜像秘钥
6993 //
6994 // @param request - DeleteEdgeContainerAppImageSecretRequest
6995 //
6996 // @return DeleteEdgeContainerAppImageSecretResponse
6997 func DeleteEdgeContainerAppImageSecret(client *Client, request *DeleteEdgeContainerAppImageSecretRequest) (_result *DeleteEdgeContainerAppImageSecretResponse, _err error) {
6998 runtime := &dara.RuntimeOptions{}
6999 _result = &DeleteEdgeContainerAppImageSecretResponse{}
7000 _body, _err := DeleteEdgeContainerAppImageSecretWithOptions(client,request, runtime)
7001 if _err != nil {
7002 return _result, _err
7003 }
7004 _result = _body
7005 return _result, _err
7006 }
7007
7008 // Summary:
7009 //
7010 // Disassociates a domain name from a containerized application. After the dissociation, you can no longer use the domain name to access the containerized application.
7011 //
7012 // @param request - DeleteEdgeContainerAppRecordRequest
7013 //
7014 // @param runtime - runtime options for this request RuntimeOptions
7015 //
7016 // @return DeleteEdgeContainerAppRecordResponse
7017 func DeleteEdgeContainerAppRecordWithOptions(client *Client, request *DeleteEdgeContainerAppRecordRequest, runtime *dara.RuntimeOptions) (_result *DeleteEdgeContainerAppRecordResponse, _err error) {
7018 if dara.BoolValue(client.EnableValidate) == true {
7019 _err = request.Validate()
7020 if _err != nil {
7021 return _result, _err
7022 }
7023 }
7024 body := map[string]interface{}{}
7025 if !dara.IsNil(request.AppId) {
7026 body["AppId"] = request.AppId
7027 }
7028
7029 if !dara.IsNil(request.RecordName) {
7030 body["RecordName"] = request.RecordName
7031 }
7032
7033 if !dara.IsNil(request.SiteId) {
7034 body["SiteId"] = request.SiteId
7035 }
7036
7037 req := &openapiutil.OpenApiRequest{
7038 Body: openapiutil.ParseToMap(body),
7039 }
7040 params := &openapiutil.Params{
7041 Action: dara.String("DeleteEdgeContainerAppRecord"),
7042 Version: dara.String("2024-09-10"),
7043 Protocol: dara.String("HTTPS"),
7044 Pathname: dara.String("/"),
7045 Method: dara.String("POST"),
7046 AuthType: dara.String("AK"),
7047 Style: dara.String("RPC"),
7048 ReqBodyType: dara.String("formData"),
7049 BodyType: dara.String("json"),
7050 }
7051 _result = &DeleteEdgeContainerAppRecordResponse{}
7052 _body, _err := client.CallApi(params, req, runtime)
7053 if _err != nil {
7054 return _result, _err
7055 }
7056 _err = dara.Convert(_body, &_result)
7057 return _result, _err
7058 }
7059
7060 // Summary:
7061 //
7062 // Disassociates a domain name from a containerized application. After the dissociation, you can no longer use the domain name to access the containerized application.
7063 //
7064 // @param request - DeleteEdgeContainerAppRecordRequest
7065 //
7066 // @return DeleteEdgeContainerAppRecordResponse
7067 func DeleteEdgeContainerAppRecord(client *Client, request *DeleteEdgeContainerAppRecordRequest) (_result *DeleteEdgeContainerAppRecordResponse, _err error) {
7068 runtime := &dara.RuntimeOptions{}
7069 _result = &DeleteEdgeContainerAppRecordResponse{}
7070 _body, _err := DeleteEdgeContainerAppRecordWithOptions(client,request, runtime)
7071 if _err != nil {
7072 return _result, _err
7073 }
7074 _result = _body
7075 return _result, _err
7076 }
7077
7078 // Summary:
7079 //
7080 // Deletes a version of a containerized application.
7081 //
7082 // @param request - DeleteEdgeContainerAppVersionRequest
7083 //
7084 // @param runtime - runtime options for this request RuntimeOptions
7085 //
7086 // @return DeleteEdgeContainerAppVersionResponse
7087 func DeleteEdgeContainerAppVersionWithOptions(client *Client, request *DeleteEdgeContainerAppVersionRequest, runtime *dara.RuntimeOptions) (_result *DeleteEdgeContainerAppVersionResponse, _err error) {
7088 if dara.BoolValue(client.EnableValidate) == true {
7089 _err = request.Validate()
7090 if _err != nil {
7091 return _result, _err
7092 }
7093 }
7094 query := map[string]interface{}{}
7095 if !dara.IsNil(request.AppId) {
7096 query["AppId"] = request.AppId
7097 }
7098
7099 if !dara.IsNil(request.VersionId) {
7100 query["VersionId"] = request.VersionId
7101 }
7102
7103 req := &openapiutil.OpenApiRequest{
7104 Query: openapiutil.Query(query),
7105 }
7106 params := &openapiutil.Params{
7107 Action: dara.String("DeleteEdgeContainerAppVersion"),
7108 Version: dara.String("2024-09-10"),
7109 Protocol: dara.String("HTTPS"),
7110 Pathname: dara.String("/"),
7111 Method: dara.String("POST"),
7112 AuthType: dara.String("AK"),
7113 Style: dara.String("RPC"),
7114 ReqBodyType: dara.String("formData"),
7115 BodyType: dara.String("json"),
7116 }
7117 _result = &DeleteEdgeContainerAppVersionResponse{}
7118 _body, _err := client.CallApi(params, req, runtime)
7119 if _err != nil {
7120 return _result, _err
7121 }
7122 _err = dara.Convert(_body, &_result)
7123 return _result, _err
7124 }
7125
7126 // Summary:
7127 //
7128 // Deletes a version of a containerized application.
7129 //
7130 // @param request - DeleteEdgeContainerAppVersionRequest
7131 //
7132 // @return DeleteEdgeContainerAppVersionResponse
7133 func DeleteEdgeContainerAppVersion(client *Client, request *DeleteEdgeContainerAppVersionRequest) (_result *DeleteEdgeContainerAppVersionResponse, _err error) {
7134 runtime := &dara.RuntimeOptions{}
7135 _result = &DeleteEdgeContainerAppVersionResponse{}
7136 _body, _err := DeleteEdgeContainerAppVersionWithOptions(client,request, runtime)
7137 if _err != nil {
7138 return _result, _err
7139 }
7140 _result = _body
7141 return _result, _err
7142 }
7143
7144 // Summary:
7145 //
7146 // 删除深度学习和防护下发的规则
7147 //
7148 // @param request - DeleteHttpDDoSIntelligentRuleRequest
7149 //
7150 // @param runtime - runtime options for this request RuntimeOptions
7151 //
7152 // @return DeleteHttpDDoSIntelligentRuleResponse
7153 func DeleteHttpDDoSIntelligentRuleWithOptions(client *Client, request *DeleteHttpDDoSIntelligentRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpDDoSIntelligentRuleResponse, _err error) {
7154 if dara.BoolValue(client.EnableValidate) == true {
7155 _err = request.Validate()
7156 if _err != nil {
7157 return _result, _err
7158 }
7159 }
7160 query := map[string]interface{}{}
7161 if !dara.IsNil(request.RecordName) {
7162 query["RecordName"] = request.RecordName
7163 }
7164
7165 if !dara.IsNil(request.RuleId) {
7166 query["RuleId"] = request.RuleId
7167 }
7168
7169 if !dara.IsNil(request.SiteId) {
7170 query["SiteId"] = request.SiteId
7171 }
7172
7173 req := &openapiutil.OpenApiRequest{
7174 Query: openapiutil.Query(query),
7175 }
7176 params := &openapiutil.Params{
7177 Action: dara.String("DeleteHttpDDoSIntelligentRule"),
7178 Version: dara.String("2024-09-10"),
7179 Protocol: dara.String("HTTPS"),
7180 Pathname: dara.String("/"),
7181 Method: dara.String("POST"),
7182 AuthType: dara.String("AK"),
7183 Style: dara.String("RPC"),
7184 ReqBodyType: dara.String("formData"),
7185 BodyType: dara.String("json"),
7186 }
7187 _result = &DeleteHttpDDoSIntelligentRuleResponse{}
7188 _body, _err := client.CallApi(params, req, runtime)
7189 if _err != nil {
7190 return _result, _err
7191 }
7192 _err = dara.Convert(_body, &_result)
7193 return _result, _err
7194 }
7195
7196 // Summary:
7197 //
7198 // 删除深度学习和防护下发的规则
7199 //
7200 // @param request - DeleteHttpDDoSIntelligentRuleRequest
7201 //
7202 // @return DeleteHttpDDoSIntelligentRuleResponse
7203 func DeleteHttpDDoSIntelligentRule(client *Client, request *DeleteHttpDDoSIntelligentRuleRequest) (_result *DeleteHttpDDoSIntelligentRuleResponse, _err error) {
7204 runtime := &dara.RuntimeOptions{}
7205 _result = &DeleteHttpDDoSIntelligentRuleResponse{}
7206 _body, _err := DeleteHttpDDoSIntelligentRuleWithOptions(client,request, runtime)
7207 if _err != nil {
7208 return _result, _err
7209 }
7210 _result = _body
7211 return _result, _err
7212 }
7213
7214 // Summary:
7215 //
7216 // Deletes the configuration of modifying incoming HTTP request headers for a website.
7217 //
7218 // @param request - DeleteHttpIncomingRequestHeaderModificationRuleRequest
7219 //
7220 // @param runtime - runtime options for this request RuntimeOptions
7221 //
7222 // @return DeleteHttpIncomingRequestHeaderModificationRuleResponse
7223 func DeleteHttpIncomingRequestHeaderModificationRuleWithOptions(client *Client, request *DeleteHttpIncomingRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpIncomingRequestHeaderModificationRuleResponse, _err error) {
7224 if dara.BoolValue(client.EnableValidate) == true {
7225 _err = request.Validate()
7226 if _err != nil {
7227 return _result, _err
7228 }
7229 }
7230 query := map[string]interface{}{}
7231 if !dara.IsNil(request.ConfigId) {
7232 query["ConfigId"] = request.ConfigId
7233 }
7234
7235 if !dara.IsNil(request.SiteId) {
7236 query["SiteId"] = request.SiteId
7237 }
7238
7239 req := &openapiutil.OpenApiRequest{
7240 Query: openapiutil.Query(query),
7241 }
7242 params := &openapiutil.Params{
7243 Action: dara.String("DeleteHttpIncomingRequestHeaderModificationRule"),
7244 Version: dara.String("2024-09-10"),
7245 Protocol: dara.String("HTTPS"),
7246 Pathname: dara.String("/"),
7247 Method: dara.String("POST"),
7248 AuthType: dara.String("AK"),
7249 Style: dara.String("RPC"),
7250 ReqBodyType: dara.String("formData"),
7251 BodyType: dara.String("json"),
7252 }
7253 _result = &DeleteHttpIncomingRequestHeaderModificationRuleResponse{}
7254 _body, _err := client.CallApi(params, req, runtime)
7255 if _err != nil {
7256 return _result, _err
7257 }
7258 _err = dara.Convert(_body, &_result)
7259 return _result, _err
7260 }
7261
7262 // Summary:
7263 //
7264 // Deletes the configuration of modifying incoming HTTP request headers for a website.
7265 //
7266 // @param request - DeleteHttpIncomingRequestHeaderModificationRuleRequest
7267 //
7268 // @return DeleteHttpIncomingRequestHeaderModificationRuleResponse
7269 func DeleteHttpIncomingRequestHeaderModificationRule(client *Client, request *DeleteHttpIncomingRequestHeaderModificationRuleRequest) (_result *DeleteHttpIncomingRequestHeaderModificationRuleResponse, _err error) {
7270 runtime := &dara.RuntimeOptions{}
7271 _result = &DeleteHttpIncomingRequestHeaderModificationRuleResponse{}
7272 _body, _err := DeleteHttpIncomingRequestHeaderModificationRuleWithOptions(client,request, runtime)
7273 if _err != nil {
7274 return _result, _err
7275 }
7276 _result = _body
7277 return _result, _err
7278 }
7279
7280 // Summary:
7281 //
7282 // Deletes the configuration of modifying HTTP response headers for a website.
7283 //
7284 // @param request - DeleteHttpIncomingResponseHeaderModificationRuleRequest
7285 //
7286 // @param runtime - runtime options for this request RuntimeOptions
7287 //
7288 // @return DeleteHttpIncomingResponseHeaderModificationRuleResponse
7289 func DeleteHttpIncomingResponseHeaderModificationRuleWithOptions(client *Client, request *DeleteHttpIncomingResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpIncomingResponseHeaderModificationRuleResponse, _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.ConfigId) {
7298 query["ConfigId"] = request.ConfigId
7299 }
7300
7301 if !dara.IsNil(request.SiteId) {
7302 query["SiteId"] = request.SiteId
7303 }
7304
7305 req := &openapiutil.OpenApiRequest{
7306 Query: openapiutil.Query(query),
7307 }
7308 params := &openapiutil.Params{
7309 Action: dara.String("DeleteHttpIncomingResponseHeaderModificationRule"),
7310 Version: dara.String("2024-09-10"),
7311 Protocol: dara.String("HTTPS"),
7312 Pathname: dara.String("/"),
7313 Method: dara.String("POST"),
7314 AuthType: dara.String("AK"),
7315 Style: dara.String("RPC"),
7316 ReqBodyType: dara.String("formData"),
7317 BodyType: dara.String("json"),
7318 }
7319 _result = &DeleteHttpIncomingResponseHeaderModificationRuleResponse{}
7320 _body, _err := client.CallApi(params, req, runtime)
7321 if _err != nil {
7322 return _result, _err
7323 }
7324 _err = dara.Convert(_body, &_result)
7325 return _result, _err
7326 }
7327
7328 // Summary:
7329 //
7330 // Deletes the configuration of modifying HTTP response headers for a website.
7331 //
7332 // @param request - DeleteHttpIncomingResponseHeaderModificationRuleRequest
7333 //
7334 // @return DeleteHttpIncomingResponseHeaderModificationRuleResponse
7335 func DeleteHttpIncomingResponseHeaderModificationRule(client *Client, request *DeleteHttpIncomingResponseHeaderModificationRuleRequest) (_result *DeleteHttpIncomingResponseHeaderModificationRuleResponse, _err error) {
7336 runtime := &dara.RuntimeOptions{}
7337 _result = &DeleteHttpIncomingResponseHeaderModificationRuleResponse{}
7338 _body, _err := DeleteHttpIncomingResponseHeaderModificationRuleWithOptions(client,request, runtime)
7339 if _err != nil {
7340 return _result, _err
7341 }
7342 _result = _body
7343 return _result, _err
7344 }
7345
7346 // Summary:
7347 //
7348 // Deletes the configuration of modifying HTTP request headers for a website.
7349 //
7350 // @param request - DeleteHttpRequestHeaderModificationRuleRequest
7351 //
7352 // @param runtime - runtime options for this request RuntimeOptions
7353 //
7354 // @return DeleteHttpRequestHeaderModificationRuleResponse
7355 func DeleteHttpRequestHeaderModificationRuleWithOptions(client *Client, request *DeleteHttpRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpRequestHeaderModificationRuleResponse, _err error) {
7356 if dara.BoolValue(client.EnableValidate) == true {
7357 _err = request.Validate()
7358 if _err != nil {
7359 return _result, _err
7360 }
7361 }
7362 query := map[string]interface{}{}
7363 if !dara.IsNil(request.ConfigId) {
7364 query["ConfigId"] = request.ConfigId
7365 }
7366
7367 if !dara.IsNil(request.SiteId) {
7368 query["SiteId"] = request.SiteId
7369 }
7370
7371 req := &openapiutil.OpenApiRequest{
7372 Query: openapiutil.Query(query),
7373 }
7374 params := &openapiutil.Params{
7375 Action: dara.String("DeleteHttpRequestHeaderModificationRule"),
7376 Version: dara.String("2024-09-10"),
7377 Protocol: dara.String("HTTPS"),
7378 Pathname: dara.String("/"),
7379 Method: dara.String("POST"),
7380 AuthType: dara.String("AK"),
7381 Style: dara.String("RPC"),
7382 ReqBodyType: dara.String("formData"),
7383 BodyType: dara.String("json"),
7384 }
7385 _result = &DeleteHttpRequestHeaderModificationRuleResponse{}
7386 _body, _err := client.CallApi(params, req, runtime)
7387 if _err != nil {
7388 return _result, _err
7389 }
7390 _err = dara.Convert(_body, &_result)
7391 return _result, _err
7392 }
7393
7394 // Summary:
7395 //
7396 // Deletes the configuration of modifying HTTP request headers for a website.
7397 //
7398 // @param request - DeleteHttpRequestHeaderModificationRuleRequest
7399 //
7400 // @return DeleteHttpRequestHeaderModificationRuleResponse
7401 func DeleteHttpRequestHeaderModificationRule(client *Client, request *DeleteHttpRequestHeaderModificationRuleRequest) (_result *DeleteHttpRequestHeaderModificationRuleResponse, _err error) {
7402 runtime := &dara.RuntimeOptions{}
7403 _result = &DeleteHttpRequestHeaderModificationRuleResponse{}
7404 _body, _err := DeleteHttpRequestHeaderModificationRuleWithOptions(client,request, runtime)
7405 if _err != nil {
7406 return _result, _err
7407 }
7408 _result = _body
7409 return _result, _err
7410 }
7411
7412 // Summary:
7413 //
7414 // Deletes the configuration of modifying HTTP response headers for a website.
7415 //
7416 // @param request - DeleteHttpResponseHeaderModificationRuleRequest
7417 //
7418 // @param runtime - runtime options for this request RuntimeOptions
7419 //
7420 // @return DeleteHttpResponseHeaderModificationRuleResponse
7421 func DeleteHttpResponseHeaderModificationRuleWithOptions(client *Client, request *DeleteHttpResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpResponseHeaderModificationRuleResponse, _err error) {
7422 if dara.BoolValue(client.EnableValidate) == true {
7423 _err = request.Validate()
7424 if _err != nil {
7425 return _result, _err
7426 }
7427 }
7428 query := map[string]interface{}{}
7429 if !dara.IsNil(request.ConfigId) {
7430 query["ConfigId"] = request.ConfigId
7431 }
7432
7433 if !dara.IsNil(request.SiteId) {
7434 query["SiteId"] = request.SiteId
7435 }
7436
7437 req := &openapiutil.OpenApiRequest{
7438 Query: openapiutil.Query(query),
7439 }
7440 params := &openapiutil.Params{
7441 Action: dara.String("DeleteHttpResponseHeaderModificationRule"),
7442 Version: dara.String("2024-09-10"),
7443 Protocol: dara.String("HTTPS"),
7444 Pathname: dara.String("/"),
7445 Method: dara.String("POST"),
7446 AuthType: dara.String("AK"),
7447 Style: dara.String("RPC"),
7448 ReqBodyType: dara.String("formData"),
7449 BodyType: dara.String("json"),
7450 }
7451 _result = &DeleteHttpResponseHeaderModificationRuleResponse{}
7452 _body, _err := client.CallApi(params, req, runtime)
7453 if _err != nil {
7454 return _result, _err
7455 }
7456 _err = dara.Convert(_body, &_result)
7457 return _result, _err
7458 }
7459
7460 // Summary:
7461 //
7462 // Deletes the configuration of modifying HTTP response headers for a website.
7463 //
7464 // @param request - DeleteHttpResponseHeaderModificationRuleRequest
7465 //
7466 // @return DeleteHttpResponseHeaderModificationRuleResponse
7467 func DeleteHttpResponseHeaderModificationRule(client *Client, request *DeleteHttpResponseHeaderModificationRuleRequest) (_result *DeleteHttpResponseHeaderModificationRuleResponse, _err error) {
7468 runtime := &dara.RuntimeOptions{}
7469 _result = &DeleteHttpResponseHeaderModificationRuleResponse{}
7470 _body, _err := DeleteHttpResponseHeaderModificationRuleWithOptions(client,request, runtime)
7471 if _err != nil {
7472 return _result, _err
7473 }
7474 _result = _body
7475 return _result, _err
7476 }
7477
7478 // Summary:
7479 //
7480 // # Delete HTTPS Application Configuration
7481 //
7482 // @param request - DeleteHttpsApplicationConfigurationRequest
7483 //
7484 // @param runtime - runtime options for this request RuntimeOptions
7485 //
7486 // @return DeleteHttpsApplicationConfigurationResponse
7487 func DeleteHttpsApplicationConfigurationWithOptions(client *Client, request *DeleteHttpsApplicationConfigurationRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpsApplicationConfigurationResponse, _err error) {
7488 if dara.BoolValue(client.EnableValidate) == true {
7489 _err = request.Validate()
7490 if _err != nil {
7491 return _result, _err
7492 }
7493 }
7494 query := map[string]interface{}{}
7495 if !dara.IsNil(request.ConfigId) {
7496 query["ConfigId"] = request.ConfigId
7497 }
7498
7499 if !dara.IsNil(request.SiteId) {
7500 query["SiteId"] = request.SiteId
7501 }
7502
7503 req := &openapiutil.OpenApiRequest{
7504 Query: openapiutil.Query(query),
7505 }
7506 params := &openapiutil.Params{
7507 Action: dara.String("DeleteHttpsApplicationConfiguration"),
7508 Version: dara.String("2024-09-10"),
7509 Protocol: dara.String("HTTPS"),
7510 Pathname: dara.String("/"),
7511 Method: dara.String("POST"),
7512 AuthType: dara.String("AK"),
7513 Style: dara.String("RPC"),
7514 ReqBodyType: dara.String("formData"),
7515 BodyType: dara.String("json"),
7516 }
7517 _result = &DeleteHttpsApplicationConfigurationResponse{}
7518 _body, _err := client.CallApi(params, req, runtime)
7519 if _err != nil {
7520 return _result, _err
7521 }
7522 _err = dara.Convert(_body, &_result)
7523 return _result, _err
7524 }
7525
7526 // Summary:
7527 //
7528 // # Delete HTTPS Application Configuration
7529 //
7530 // @param request - DeleteHttpsApplicationConfigurationRequest
7531 //
7532 // @return DeleteHttpsApplicationConfigurationResponse
7533 func DeleteHttpsApplicationConfiguration(client *Client, request *DeleteHttpsApplicationConfigurationRequest) (_result *DeleteHttpsApplicationConfigurationResponse, _err error) {
7534 runtime := &dara.RuntimeOptions{}
7535 _result = &DeleteHttpsApplicationConfigurationResponse{}
7536 _body, _err := DeleteHttpsApplicationConfigurationWithOptions(client,request, runtime)
7537 if _err != nil {
7538 return _result, _err
7539 }
7540 _result = _body
7541 return _result, _err
7542 }
7543
7544 // Summary:
7545 //
7546 // # Delete HTTPS Basic Configuration
7547 //
7548 // @param request - DeleteHttpsBasicConfigurationRequest
7549 //
7550 // @param runtime - runtime options for this request RuntimeOptions
7551 //
7552 // @return DeleteHttpsBasicConfigurationResponse
7553 func DeleteHttpsBasicConfigurationWithOptions(client *Client, request *DeleteHttpsBasicConfigurationRequest, runtime *dara.RuntimeOptions) (_result *DeleteHttpsBasicConfigurationResponse, _err error) {
7554 if dara.BoolValue(client.EnableValidate) == true {
7555 _err = request.Validate()
7556 if _err != nil {
7557 return _result, _err
7558 }
7559 }
7560 query := map[string]interface{}{}
7561 if !dara.IsNil(request.ConfigId) {
7562 query["ConfigId"] = request.ConfigId
7563 }
7564
7565 if !dara.IsNil(request.SiteId) {
7566 query["SiteId"] = request.SiteId
7567 }
7568
7569 req := &openapiutil.OpenApiRequest{
7570 Query: openapiutil.Query(query),
7571 }
7572 params := &openapiutil.Params{
7573 Action: dara.String("DeleteHttpsBasicConfiguration"),
7574 Version: dara.String("2024-09-10"),
7575 Protocol: dara.String("HTTPS"),
7576 Pathname: dara.String("/"),
7577 Method: dara.String("POST"),
7578 AuthType: dara.String("AK"),
7579 Style: dara.String("RPC"),
7580 ReqBodyType: dara.String("formData"),
7581 BodyType: dara.String("json"),
7582 }
7583 _result = &DeleteHttpsBasicConfigurationResponse{}
7584 _body, _err := client.CallApi(params, req, runtime)
7585 if _err != nil {
7586 return _result, _err
7587 }
7588 _err = dara.Convert(_body, &_result)
7589 return _result, _err
7590 }
7591
7592 // Summary:
7593 //
7594 // # Delete HTTPS Basic Configuration
7595 //
7596 // @param request - DeleteHttpsBasicConfigurationRequest
7597 //
7598 // @return DeleteHttpsBasicConfigurationResponse
7599 func DeleteHttpsBasicConfiguration(client *Client, request *DeleteHttpsBasicConfigurationRequest) (_result *DeleteHttpsBasicConfigurationResponse, _err error) {
7600 runtime := &dara.RuntimeOptions{}
7601 _result = &DeleteHttpsBasicConfigurationResponse{}
7602 _body, _err := DeleteHttpsBasicConfigurationWithOptions(client,request, runtime)
7603 if _err != nil {
7604 return _result, _err
7605 }
7606 _result = _body
7607 return _result, _err
7608 }
7609
7610 // Summary:
7611 //
7612 // # Delete Site Image Transformation Configuration
7613 //
7614 // @param request - DeleteImageTransformRequest
7615 //
7616 // @param runtime - runtime options for this request RuntimeOptions
7617 //
7618 // @return DeleteImageTransformResponse
7619 func DeleteImageTransformWithOptions(client *Client, request *DeleteImageTransformRequest, runtime *dara.RuntimeOptions) (_result *DeleteImageTransformResponse, _err error) {
7620 if dara.BoolValue(client.EnableValidate) == true {
7621 _err = request.Validate()
7622 if _err != nil {
7623 return _result, _err
7624 }
7625 }
7626 query := map[string]interface{}{}
7627 if !dara.IsNil(request.ConfigId) {
7628 query["ConfigId"] = request.ConfigId
7629 }
7630
7631 if !dara.IsNil(request.SiteId) {
7632 query["SiteId"] = request.SiteId
7633 }
7634
7635 req := &openapiutil.OpenApiRequest{
7636 Query: openapiutil.Query(query),
7637 }
7638 params := &openapiutil.Params{
7639 Action: dara.String("DeleteImageTransform"),
7640 Version: dara.String("2024-09-10"),
7641 Protocol: dara.String("HTTPS"),
7642 Pathname: dara.String("/"),
7643 Method: dara.String("POST"),
7644 AuthType: dara.String("AK"),
7645 Style: dara.String("RPC"),
7646 ReqBodyType: dara.String("formData"),
7647 BodyType: dara.String("json"),
7648 }
7649 _result = &DeleteImageTransformResponse{}
7650 _body, _err := client.CallApi(params, req, runtime)
7651 if _err != nil {
7652 return _result, _err
7653 }
7654 _err = dara.Convert(_body, &_result)
7655 return _result, _err
7656 }
7657
7658 // Summary:
7659 //
7660 // # Delete Site Image Transformation Configuration
7661 //
7662 // @param request - DeleteImageTransformRequest
7663 //
7664 // @return DeleteImageTransformResponse
7665 func DeleteImageTransform(client *Client, request *DeleteImageTransformRequest) (_result *DeleteImageTransformResponse, _err error) {
7666 runtime := &dara.RuntimeOptions{}
7667 _result = &DeleteImageTransformResponse{}
7668 _body, _err := DeleteImageTransformWithOptions(client,request, runtime)
7669 if _err != nil {
7670 return _result, _err
7671 }
7672 _result = _body
7673 return _result, _err
7674 }
7675
7676 // Summary:
7677 //
7678 // Deletes a key-value pair from a namespace.
7679 //
7680 // @param request - DeleteKvRequest
7681 //
7682 // @param runtime - runtime options for this request RuntimeOptions
7683 //
7684 // @return DeleteKvResponse
7685 func DeleteKvWithOptions(client *Client, request *DeleteKvRequest, runtime *dara.RuntimeOptions) (_result *DeleteKvResponse, _err error) {
7686 if dara.BoolValue(client.EnableValidate) == true {
7687 _err = request.Validate()
7688 if _err != nil {
7689 return _result, _err
7690 }
7691 }
7692 query := openapiutil.Query(dara.ToMap(request))
7693 req := &openapiutil.OpenApiRequest{
7694 Query: openapiutil.Query(query),
7695 }
7696 params := &openapiutil.Params{
7697 Action: dara.String("DeleteKv"),
7698 Version: dara.String("2024-09-10"),
7699 Protocol: dara.String("HTTPS"),
7700 Pathname: dara.String("/"),
7701 Method: dara.String("GET"),
7702 AuthType: dara.String("AK"),
7703 Style: dara.String("RPC"),
7704 ReqBodyType: dara.String("formData"),
7705 BodyType: dara.String("json"),
7706 }
7707 _result = &DeleteKvResponse{}
7708 _body, _err := client.CallApi(params, req, runtime)
7709 if _err != nil {
7710 return _result, _err
7711 }
7712 _err = dara.Convert(_body, &_result)
7713 return _result, _err
7714 }
7715
7716 // Summary:
7717 //
7718 // Deletes a key-value pair from a namespace.
7719 //
7720 // @param request - DeleteKvRequest
7721 //
7722 // @return DeleteKvResponse
7723 func DeleteKv(client *Client, request *DeleteKvRequest) (_result *DeleteKvResponse, _err error) {
7724 runtime := &dara.RuntimeOptions{}
7725 _result = &DeleteKvResponse{}
7726 _body, _err := DeleteKvWithOptions(client,request, runtime)
7727 if _err != nil {
7728 return _result, _err
7729 }
7730 _result = _body
7731 return _result, _err
7732 }
7733
7734 // Summary:
7735 //
7736 // Deletes a namespace from an Alibaba Cloud account.
7737 //
7738 // @param request - DeleteKvNamespaceRequest
7739 //
7740 // @param runtime - runtime options for this request RuntimeOptions
7741 //
7742 // @return DeleteKvNamespaceResponse
7743 func DeleteKvNamespaceWithOptions(client *Client, request *DeleteKvNamespaceRequest, runtime *dara.RuntimeOptions) (_result *DeleteKvNamespaceResponse, _err error) {
7744 if dara.BoolValue(client.EnableValidate) == true {
7745 _err = request.Validate()
7746 if _err != nil {
7747 return _result, _err
7748 }
7749 }
7750 query := map[string]interface{}{}
7751 if !dara.IsNil(request.Namespace) {
7752 query["Namespace"] = request.Namespace
7753 }
7754
7755 req := &openapiutil.OpenApiRequest{
7756 Query: openapiutil.Query(query),
7757 }
7758 params := &openapiutil.Params{
7759 Action: dara.String("DeleteKvNamespace"),
7760 Version: dara.String("2024-09-10"),
7761 Protocol: dara.String("HTTPS"),
7762 Pathname: dara.String("/"),
7763 Method: dara.String("POST"),
7764 AuthType: dara.String("AK"),
7765 Style: dara.String("RPC"),
7766 ReqBodyType: dara.String("formData"),
7767 BodyType: dara.String("json"),
7768 }
7769 _result = &DeleteKvNamespaceResponse{}
7770 _body, _err := client.CallApi(params, req, runtime)
7771 if _err != nil {
7772 return _result, _err
7773 }
7774 _err = dara.Convert(_body, &_result)
7775 return _result, _err
7776 }
7777
7778 // Summary:
7779 //
7780 // Deletes a namespace from an Alibaba Cloud account.
7781 //
7782 // @param request - DeleteKvNamespaceRequest
7783 //
7784 // @return DeleteKvNamespaceResponse
7785 func DeleteKvNamespace(client *Client, request *DeleteKvNamespaceRequest) (_result *DeleteKvNamespaceResponse, _err error) {
7786 runtime := &dara.RuntimeOptions{}
7787 _result = &DeleteKvNamespaceResponse{}
7788 _body, _err := DeleteKvNamespaceWithOptions(client,request, runtime)
7789 if _err != nil {
7790 return _result, _err
7791 }
7792 _result = _body
7793 return _result, _err
7794 }
7795
7796 // Summary:
7797 //
7798 // Deletes a custom list that is no longer needed.
7799 //
7800 // @param request - DeleteListRequest
7801 //
7802 // @param runtime - runtime options for this request RuntimeOptions
7803 //
7804 // @return DeleteListResponse
7805 func DeleteListWithOptions(client *Client, request *DeleteListRequest, runtime *dara.RuntimeOptions) (_result *DeleteListResponse, _err error) {
7806 if dara.BoolValue(client.EnableValidate) == true {
7807 _err = request.Validate()
7808 if _err != nil {
7809 return _result, _err
7810 }
7811 }
7812 body := map[string]interface{}{}
7813 if !dara.IsNil(request.Id) {
7814 body["Id"] = request.Id
7815 }
7816
7817 req := &openapiutil.OpenApiRequest{
7818 Body: openapiutil.ParseToMap(body),
7819 }
7820 params := &openapiutil.Params{
7821 Action: dara.String("DeleteList"),
7822 Version: dara.String("2024-09-10"),
7823 Protocol: dara.String("HTTPS"),
7824 Pathname: dara.String("/"),
7825 Method: dara.String("POST"),
7826 AuthType: dara.String("AK"),
7827 Style: dara.String("RPC"),
7828 ReqBodyType: dara.String("formData"),
7829 BodyType: dara.String("json"),
7830 }
7831 _result = &DeleteListResponse{}
7832 _body, _err := client.CallApi(params, req, runtime)
7833 if _err != nil {
7834 return _result, _err
7835 }
7836 _err = dara.Convert(_body, &_result)
7837 return _result, _err
7838 }
7839
7840 // Summary:
7841 //
7842 // Deletes a custom list that is no longer needed.
7843 //
7844 // @param request - DeleteListRequest
7845 //
7846 // @return DeleteListResponse
7847 func DeleteList(client *Client, request *DeleteListRequest) (_result *DeleteListResponse, _err error) {
7848 runtime := &dara.RuntimeOptions{}
7849 _result = &DeleteListResponse{}
7850 _body, _err := DeleteListWithOptions(client,request, runtime)
7851 if _err != nil {
7852 return _result, _err
7853 }
7854 _result = _body
7855 return _result, _err
7856 }
7857
7858 // Summary:
7859 //
7860 // # Delete Load Balancer
7861 //
7862 // Description:
7863 //
7864 // Delete a load balancer by its ID, only one can be deleted at a time.
7865 //
7866 // @param request - DeleteLoadBalancerRequest
7867 //
7868 // @param runtime - runtime options for this request RuntimeOptions
7869 //
7870 // @return DeleteLoadBalancerResponse
7871 func DeleteLoadBalancerWithOptions(client *Client, request *DeleteLoadBalancerRequest, runtime *dara.RuntimeOptions) (_result *DeleteLoadBalancerResponse, _err error) {
7872 if dara.BoolValue(client.EnableValidate) == true {
7873 _err = request.Validate()
7874 if _err != nil {
7875 return _result, _err
7876 }
7877 }
7878 query := map[string]interface{}{}
7879 if !dara.IsNil(request.Id) {
7880 query["Id"] = request.Id
7881 }
7882
7883 if !dara.IsNil(request.SiteId) {
7884 query["SiteId"] = request.SiteId
7885 }
7886
7887 req := &openapiutil.OpenApiRequest{
7888 Query: openapiutil.Query(query),
7889 }
7890 params := &openapiutil.Params{
7891 Action: dara.String("DeleteLoadBalancer"),
7892 Version: dara.String("2024-09-10"),
7893 Protocol: dara.String("HTTPS"),
7894 Pathname: dara.String("/"),
7895 Method: dara.String("POST"),
7896 AuthType: dara.String("AK"),
7897 Style: dara.String("RPC"),
7898 ReqBodyType: dara.String("formData"),
7899 BodyType: dara.String("json"),
7900 }
7901 _result = &DeleteLoadBalancerResponse{}
7902 _body, _err := client.CallApi(params, req, runtime)
7903 if _err != nil {
7904 return _result, _err
7905 }
7906 _err = dara.Convert(_body, &_result)
7907 return _result, _err
7908 }
7909
7910 // Summary:
7911 //
7912 // # Delete Load Balancer
7913 //
7914 // Description:
7915 //
7916 // Delete a load balancer by its ID, only one can be deleted at a time.
7917 //
7918 // @param request - DeleteLoadBalancerRequest
7919 //
7920 // @return DeleteLoadBalancerResponse
7921 func DeleteLoadBalancer(client *Client, request *DeleteLoadBalancerRequest) (_result *DeleteLoadBalancerResponse, _err error) {
7922 runtime := &dara.RuntimeOptions{}
7923 _result = &DeleteLoadBalancerResponse{}
7924 _body, _err := DeleteLoadBalancerWithOptions(client,request, runtime)
7925 if _err != nil {
7926 return _result, _err
7927 }
7928 _result = _body
7929 return _result, _err
7930 }
7931
7932 // Summary:
7933 //
7934 // # Delete Network Optimization Configuration
7935 //
7936 // @param request - DeleteNetworkOptimizationRequest
7937 //
7938 // @param runtime - runtime options for this request RuntimeOptions
7939 //
7940 // @return DeleteNetworkOptimizationResponse
7941 func DeleteNetworkOptimizationWithOptions(client *Client, request *DeleteNetworkOptimizationRequest, runtime *dara.RuntimeOptions) (_result *DeleteNetworkOptimizationResponse, _err error) {
7942 if dara.BoolValue(client.EnableValidate) == true {
7943 _err = request.Validate()
7944 if _err != nil {
7945 return _result, _err
7946 }
7947 }
7948 query := map[string]interface{}{}
7949 if !dara.IsNil(request.ConfigId) {
7950 query["ConfigId"] = request.ConfigId
7951 }
7952
7953 if !dara.IsNil(request.SiteId) {
7954 query["SiteId"] = request.SiteId
7955 }
7956
7957 req := &openapiutil.OpenApiRequest{
7958 Query: openapiutil.Query(query),
7959 }
7960 params := &openapiutil.Params{
7961 Action: dara.String("DeleteNetworkOptimization"),
7962 Version: dara.String("2024-09-10"),
7963 Protocol: dara.String("HTTPS"),
7964 Pathname: dara.String("/"),
7965 Method: dara.String("POST"),
7966 AuthType: dara.String("AK"),
7967 Style: dara.String("RPC"),
7968 ReqBodyType: dara.String("formData"),
7969 BodyType: dara.String("json"),
7970 }
7971 _result = &DeleteNetworkOptimizationResponse{}
7972 _body, _err := client.CallApi(params, req, runtime)
7973 if _err != nil {
7974 return _result, _err
7975 }
7976 _err = dara.Convert(_body, &_result)
7977 return _result, _err
7978 }
7979
7980 // Summary:
7981 //
7982 // # Delete Network Optimization Configuration
7983 //
7984 // @param request - DeleteNetworkOptimizationRequest
7985 //
7986 // @return DeleteNetworkOptimizationResponse
7987 func DeleteNetworkOptimization(client *Client, request *DeleteNetworkOptimizationRequest) (_result *DeleteNetworkOptimizationResponse, _err error) {
7988 runtime := &dara.RuntimeOptions{}
7989 _result = &DeleteNetworkOptimizationResponse{}
7990 _body, _err := DeleteNetworkOptimizationWithOptions(client,request, runtime)
7991 if _err != nil {
7992 return _result, _err
7993 }
7994 _result = _body
7995 return _result, _err
7996 }
7997
7998 // Summary:
7999 //
8000 // 删除源服务器CA证书
8001 //
8002 // @param request - DeleteOriginCaCertificateRequest
8003 //
8004 // @param runtime - runtime options for this request RuntimeOptions
8005 //
8006 // @return DeleteOriginCaCertificateResponse
8007 func DeleteOriginCaCertificateWithOptions(client *Client, request *DeleteOriginCaCertificateRequest, runtime *dara.RuntimeOptions) (_result *DeleteOriginCaCertificateResponse, _err error) {
8008 if dara.BoolValue(client.EnableValidate) == true {
8009 _err = request.Validate()
8010 if _err != nil {
8011 return _result, _err
8012 }
8013 }
8014 query := openapiutil.Query(dara.ToMap(request))
8015 req := &openapiutil.OpenApiRequest{
8016 Query: openapiutil.Query(query),
8017 }
8018 params := &openapiutil.Params{
8019 Action: dara.String("DeleteOriginCaCertificate"),
8020 Version: dara.String("2024-09-10"),
8021 Protocol: dara.String("HTTPS"),
8022 Pathname: dara.String("/"),
8023 Method: dara.String("GET"),
8024 AuthType: dara.String("AK"),
8025 Style: dara.String("RPC"),
8026 ReqBodyType: dara.String("formData"),
8027 BodyType: dara.String("json"),
8028 }
8029 _result = &DeleteOriginCaCertificateResponse{}
8030 _body, _err := client.CallApi(params, req, runtime)
8031 if _err != nil {
8032 return _result, _err
8033 }
8034 _err = dara.Convert(_body, &_result)
8035 return _result, _err
8036 }
8037
8038 // Summary:
8039 //
8040 // 删除源服务器CA证书
8041 //
8042 // @param request - DeleteOriginCaCertificateRequest
8043 //
8044 // @return DeleteOriginCaCertificateResponse
8045 func DeleteOriginCaCertificate(client *Client, request *DeleteOriginCaCertificateRequest) (_result *DeleteOriginCaCertificateResponse, _err error) {
8046 runtime := &dara.RuntimeOptions{}
8047 _result = &DeleteOriginCaCertificateResponse{}
8048 _body, _err := DeleteOriginCaCertificateWithOptions(client,request, runtime)
8049 if _err != nil {
8050 return _result, _err
8051 }
8052 _result = _body
8053 return _result, _err
8054 }
8055
8056 // Summary:
8057 //
8058 // 删除域名回源客户端证书
8059 //
8060 // @param request - DeleteOriginClientCertificateRequest
8061 //
8062 // @param runtime - runtime options for this request RuntimeOptions
8063 //
8064 // @return DeleteOriginClientCertificateResponse
8065 func DeleteOriginClientCertificateWithOptions(client *Client, request *DeleteOriginClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *DeleteOriginClientCertificateResponse, _err error) {
8066 if dara.BoolValue(client.EnableValidate) == true {
8067 _err = request.Validate()
8068 if _err != nil {
8069 return _result, _err
8070 }
8071 }
8072 query := openapiutil.Query(dara.ToMap(request))
8073 req := &openapiutil.OpenApiRequest{
8074 Query: openapiutil.Query(query),
8075 }
8076 params := &openapiutil.Params{
8077 Action: dara.String("DeleteOriginClientCertificate"),
8078 Version: dara.String("2024-09-10"),
8079 Protocol: dara.String("HTTPS"),
8080 Pathname: dara.String("/"),
8081 Method: dara.String("GET"),
8082 AuthType: dara.String("AK"),
8083 Style: dara.String("RPC"),
8084 ReqBodyType: dara.String("formData"),
8085 BodyType: dara.String("json"),
8086 }
8087 _result = &DeleteOriginClientCertificateResponse{}
8088 _body, _err := client.CallApi(params, req, runtime)
8089 if _err != nil {
8090 return _result, _err
8091 }
8092 _err = dara.Convert(_body, &_result)
8093 return _result, _err
8094 }
8095
8096 // Summary:
8097 //
8098 // 删除域名回源客户端证书
8099 //
8100 // @param request - DeleteOriginClientCertificateRequest
8101 //
8102 // @return DeleteOriginClientCertificateResponse
8103 func DeleteOriginClientCertificate(client *Client, request *DeleteOriginClientCertificateRequest) (_result *DeleteOriginClientCertificateResponse, _err error) {
8104 runtime := &dara.RuntimeOptions{}
8105 _result = &DeleteOriginClientCertificateResponse{}
8106 _body, _err := DeleteOriginClientCertificateWithOptions(client,request, runtime)
8107 if _err != nil {
8108 return _result, _err
8109 }
8110 _result = _body
8111 return _result, _err
8112 }
8113
8114 // Summary:
8115 //
8116 // # Delete Origin Address Pool
8117 //
8118 // @param request - DeleteOriginPoolRequest
8119 //
8120 // @param runtime - runtime options for this request RuntimeOptions
8121 //
8122 // @return DeleteOriginPoolResponse
8123 func DeleteOriginPoolWithOptions(client *Client, request *DeleteOriginPoolRequest, runtime *dara.RuntimeOptions) (_result *DeleteOriginPoolResponse, _err error) {
8124 if dara.BoolValue(client.EnableValidate) == true {
8125 _err = request.Validate()
8126 if _err != nil {
8127 return _result, _err
8128 }
8129 }
8130 query := map[string]interface{}{}
8131 if !dara.IsNil(request.Id) {
8132 query["Id"] = request.Id
8133 }
8134
8135 if !dara.IsNil(request.SiteId) {
8136 query["SiteId"] = request.SiteId
8137 }
8138
8139 req := &openapiutil.OpenApiRequest{
8140 Query: openapiutil.Query(query),
8141 }
8142 params := &openapiutil.Params{
8143 Action: dara.String("DeleteOriginPool"),
8144 Version: dara.String("2024-09-10"),
8145 Protocol: dara.String("HTTPS"),
8146 Pathname: dara.String("/"),
8147 Method: dara.String("POST"),
8148 AuthType: dara.String("AK"),
8149 Style: dara.String("RPC"),
8150 ReqBodyType: dara.String("formData"),
8151 BodyType: dara.String("json"),
8152 }
8153 _result = &DeleteOriginPoolResponse{}
8154 _body, _err := client.CallApi(params, req, runtime)
8155 if _err != nil {
8156 return _result, _err
8157 }
8158 _err = dara.Convert(_body, &_result)
8159 return _result, _err
8160 }
8161
8162 // Summary:
8163 //
8164 // # Delete Origin Address Pool
8165 //
8166 // @param request - DeleteOriginPoolRequest
8167 //
8168 // @return DeleteOriginPoolResponse
8169 func DeleteOriginPool(client *Client, request *DeleteOriginPoolRequest) (_result *DeleteOriginPoolResponse, _err error) {
8170 runtime := &dara.RuntimeOptions{}
8171 _result = &DeleteOriginPoolResponse{}
8172 _body, _err := DeleteOriginPoolWithOptions(client,request, runtime)
8173 if _err != nil {
8174 return _result, _err
8175 }
8176 _result = _body
8177 return _result, _err
8178 }
8179
8180 // Summary:
8181 //
8182 // Disables origin protection.
8183 //
8184 // @param request - DeleteOriginProtectionRequest
8185 //
8186 // @param runtime - runtime options for this request RuntimeOptions
8187 //
8188 // @return DeleteOriginProtectionResponse
8189 func DeleteOriginProtectionWithOptions(client *Client, request *DeleteOriginProtectionRequest, runtime *dara.RuntimeOptions) (_result *DeleteOriginProtectionResponse, _err error) {
8190 if dara.BoolValue(client.EnableValidate) == true {
8191 _err = request.Validate()
8192 if _err != nil {
8193 return _result, _err
8194 }
8195 }
8196 query := map[string]interface{}{}
8197 if !dara.IsNil(request.SiteId) {
8198 query["SiteId"] = request.SiteId
8199 }
8200
8201 req := &openapiutil.OpenApiRequest{
8202 Query: openapiutil.Query(query),
8203 }
8204 params := &openapiutil.Params{
8205 Action: dara.String("DeleteOriginProtection"),
8206 Version: dara.String("2024-09-10"),
8207 Protocol: dara.String("HTTPS"),
8208 Pathname: dara.String("/"),
8209 Method: dara.String("POST"),
8210 AuthType: dara.String("AK"),
8211 Style: dara.String("RPC"),
8212 ReqBodyType: dara.String("formData"),
8213 BodyType: dara.String("json"),
8214 }
8215 _result = &DeleteOriginProtectionResponse{}
8216 _body, _err := client.CallApi(params, req, runtime)
8217 if _err != nil {
8218 return _result, _err
8219 }
8220 _err = dara.Convert(_body, &_result)
8221 return _result, _err
8222 }
8223
8224 // Summary:
8225 //
8226 // Disables origin protection.
8227 //
8228 // @param request - DeleteOriginProtectionRequest
8229 //
8230 // @return DeleteOriginProtectionResponse
8231 func DeleteOriginProtection(client *Client, request *DeleteOriginProtectionRequest) (_result *DeleteOriginProtectionResponse, _err error) {
8232 runtime := &dara.RuntimeOptions{}
8233 _result = &DeleteOriginProtectionResponse{}
8234 _body, _err := DeleteOriginProtectionWithOptions(client,request, runtime)
8235 if _err != nil {
8236 return _result, _err
8237 }
8238 _result = _body
8239 return _result, _err
8240 }
8241
8242 // Summary:
8243 //
8244 // # Delete Origin Rule Configuration
8245 //
8246 // @param request - DeleteOriginRuleRequest
8247 //
8248 // @param runtime - runtime options for this request RuntimeOptions
8249 //
8250 // @return DeleteOriginRuleResponse
8251 func DeleteOriginRuleWithOptions(client *Client, request *DeleteOriginRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteOriginRuleResponse, _err error) {
8252 if dara.BoolValue(client.EnableValidate) == true {
8253 _err = request.Validate()
8254 if _err != nil {
8255 return _result, _err
8256 }
8257 }
8258 query := map[string]interface{}{}
8259 if !dara.IsNil(request.ConfigId) {
8260 query["ConfigId"] = request.ConfigId
8261 }
8262
8263 if !dara.IsNil(request.SiteId) {
8264 query["SiteId"] = request.SiteId
8265 }
8266
8267 req := &openapiutil.OpenApiRequest{
8268 Query: openapiutil.Query(query),
8269 }
8270 params := &openapiutil.Params{
8271 Action: dara.String("DeleteOriginRule"),
8272 Version: dara.String("2024-09-10"),
8273 Protocol: dara.String("HTTPS"),
8274 Pathname: dara.String("/"),
8275 Method: dara.String("POST"),
8276 AuthType: dara.String("AK"),
8277 Style: dara.String("RPC"),
8278 ReqBodyType: dara.String("formData"),
8279 BodyType: dara.String("json"),
8280 }
8281 _result = &DeleteOriginRuleResponse{}
8282 _body, _err := client.CallApi(params, req, runtime)
8283 if _err != nil {
8284 return _result, _err
8285 }
8286 _err = dara.Convert(_body, &_result)
8287 return _result, _err
8288 }
8289
8290 // Summary:
8291 //
8292 // # Delete Origin Rule Configuration
8293 //
8294 // @param request - DeleteOriginRuleRequest
8295 //
8296 // @return DeleteOriginRuleResponse
8297 func DeleteOriginRule(client *Client, request *DeleteOriginRuleRequest) (_result *DeleteOriginRuleResponse, _err error) {
8298 runtime := &dara.RuntimeOptions{}
8299 _result = &DeleteOriginRuleResponse{}
8300 _body, _err := DeleteOriginRuleWithOptions(client,request, runtime)
8301 if _err != nil {
8302 return _result, _err
8303 }
8304 _result = _body
8305 return _result, _err
8306 }
8307
8308 // Summary:
8309 //
8310 // Deletes a custom error page that is no longer needed.
8311 //
8312 // @param request - DeletePageRequest
8313 //
8314 // @param runtime - runtime options for this request RuntimeOptions
8315 //
8316 // @return DeletePageResponse
8317 func DeletePageWithOptions(client *Client, request *DeletePageRequest, runtime *dara.RuntimeOptions) (_result *DeletePageResponse, _err error) {
8318 if dara.BoolValue(client.EnableValidate) == true {
8319 _err = request.Validate()
8320 if _err != nil {
8321 return _result, _err
8322 }
8323 }
8324 body := map[string]interface{}{}
8325 if !dara.IsNil(request.Id) {
8326 body["Id"] = request.Id
8327 }
8328
8329 req := &openapiutil.OpenApiRequest{
8330 Body: openapiutil.ParseToMap(body),
8331 }
8332 params := &openapiutil.Params{
8333 Action: dara.String("DeletePage"),
8334 Version: dara.String("2024-09-10"),
8335 Protocol: dara.String("HTTPS"),
8336 Pathname: dara.String("/"),
8337 Method: dara.String("POST"),
8338 AuthType: dara.String("AK"),
8339 Style: dara.String("RPC"),
8340 ReqBodyType: dara.String("formData"),
8341 BodyType: dara.String("json"),
8342 }
8343 _result = &DeletePageResponse{}
8344 _body, _err := client.CallApi(params, req, runtime)
8345 if _err != nil {
8346 return _result, _err
8347 }
8348 _err = dara.Convert(_body, &_result)
8349 return _result, _err
8350 }
8351
8352 // Summary:
8353 //
8354 // Deletes a custom error page that is no longer needed.
8355 //
8356 // @param request - DeletePageRequest
8357 //
8358 // @return DeletePageResponse
8359 func DeletePage(client *Client, request *DeletePageRequest) (_result *DeletePageResponse, _err error) {
8360 runtime := &dara.RuntimeOptions{}
8361 _result = &DeletePageResponse{}
8362 _body, _err := DeletePageWithOptions(client,request, runtime)
8363 if _err != nil {
8364 return _result, _err
8365 }
8366 _result = _body
8367 return _result, _err
8368 }
8369
8370 // Summary:
8371 //
8372 // Deletes a DNS record of a website based on the specified RecordId.
8373 //
8374 // @param request - DeleteRecordRequest
8375 //
8376 // @param runtime - runtime options for this request RuntimeOptions
8377 //
8378 // @return DeleteRecordResponse
8379 func DeleteRecordWithOptions(client *Client, request *DeleteRecordRequest, runtime *dara.RuntimeOptions) (_result *DeleteRecordResponse, _err error) {
8380 if dara.BoolValue(client.EnableValidate) == true {
8381 _err = request.Validate()
8382 if _err != nil {
8383 return _result, _err
8384 }
8385 }
8386 query := map[string]interface{}{}
8387 if !dara.IsNil(request.RecordId) {
8388 query["RecordId"] = request.RecordId
8389 }
8390
8391 if !dara.IsNil(request.SecurityToken) {
8392 query["SecurityToken"] = request.SecurityToken
8393 }
8394
8395 req := &openapiutil.OpenApiRequest{
8396 Query: openapiutil.Query(query),
8397 }
8398 params := &openapiutil.Params{
8399 Action: dara.String("DeleteRecord"),
8400 Version: dara.String("2024-09-10"),
8401 Protocol: dara.String("HTTPS"),
8402 Pathname: dara.String("/"),
8403 Method: dara.String("POST"),
8404 AuthType: dara.String("AK"),
8405 Style: dara.String("RPC"),
8406 ReqBodyType: dara.String("formData"),
8407 BodyType: dara.String("json"),
8408 }
8409 _result = &DeleteRecordResponse{}
8410 _body, _err := client.CallApi(params, req, runtime)
8411 if _err != nil {
8412 return _result, _err
8413 }
8414 _err = dara.Convert(_body, &_result)
8415 return _result, _err
8416 }
8417
8418 // Summary:
8419 //
8420 // Deletes a DNS record of a website based on the specified RecordId.
8421 //
8422 // @param request - DeleteRecordRequest
8423 //
8424 // @return DeleteRecordResponse
8425 func DeleteRecord(client *Client, request *DeleteRecordRequest) (_result *DeleteRecordResponse, _err error) {
8426 runtime := &dara.RuntimeOptions{}
8427 _result = &DeleteRecordResponse{}
8428 _body, _err := DeleteRecordWithOptions(client,request, runtime)
8429 if _err != nil {
8430 return _result, _err
8431 }
8432 _result = _body
8433 return _result, _err
8434 }
8435
8436 // Summary:
8437 //
8438 // Deletes a URL redirect rule for a website.
8439 //
8440 // @param request - DeleteRedirectRuleRequest
8441 //
8442 // @param runtime - runtime options for this request RuntimeOptions
8443 //
8444 // @return DeleteRedirectRuleResponse
8445 func DeleteRedirectRuleWithOptions(client *Client, request *DeleteRedirectRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteRedirectRuleResponse, _err error) {
8446 if dara.BoolValue(client.EnableValidate) == true {
8447 _err = request.Validate()
8448 if _err != nil {
8449 return _result, _err
8450 }
8451 }
8452 query := map[string]interface{}{}
8453 if !dara.IsNil(request.ConfigId) {
8454 query["ConfigId"] = request.ConfigId
8455 }
8456
8457 if !dara.IsNil(request.SiteId) {
8458 query["SiteId"] = request.SiteId
8459 }
8460
8461 req := &openapiutil.OpenApiRequest{
8462 Query: openapiutil.Query(query),
8463 }
8464 params := &openapiutil.Params{
8465 Action: dara.String("DeleteRedirectRule"),
8466 Version: dara.String("2024-09-10"),
8467 Protocol: dara.String("HTTPS"),
8468 Pathname: dara.String("/"),
8469 Method: dara.String("POST"),
8470 AuthType: dara.String("AK"),
8471 Style: dara.String("RPC"),
8472 ReqBodyType: dara.String("formData"),
8473 BodyType: dara.String("json"),
8474 }
8475 _result = &DeleteRedirectRuleResponse{}
8476 _body, _err := client.CallApi(params, req, runtime)
8477 if _err != nil {
8478 return _result, _err
8479 }
8480 _err = dara.Convert(_body, &_result)
8481 return _result, _err
8482 }
8483
8484 // Summary:
8485 //
8486 // Deletes a URL redirect rule for a website.
8487 //
8488 // @param request - DeleteRedirectRuleRequest
8489 //
8490 // @return DeleteRedirectRuleResponse
8491 func DeleteRedirectRule(client *Client, request *DeleteRedirectRuleRequest) (_result *DeleteRedirectRuleResponse, _err error) {
8492 runtime := &dara.RuntimeOptions{}
8493 _result = &DeleteRedirectRuleResponse{}
8494 _body, _err := DeleteRedirectRuleWithOptions(client,request, runtime)
8495 if _err != nil {
8496 return _result, _err
8497 }
8498 _result = _body
8499 return _result, _err
8500 }
8501
8502 // Summary:
8503 //
8504 // Deletes a URL rewrite rule for a website.
8505 //
8506 // @param request - DeleteRewriteUrlRuleRequest
8507 //
8508 // @param runtime - runtime options for this request RuntimeOptions
8509 //
8510 // @return DeleteRewriteUrlRuleResponse
8511 func DeleteRewriteUrlRuleWithOptions(client *Client, request *DeleteRewriteUrlRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteRewriteUrlRuleResponse, _err error) {
8512 if dara.BoolValue(client.EnableValidate) == true {
8513 _err = request.Validate()
8514 if _err != nil {
8515 return _result, _err
8516 }
8517 }
8518 query := map[string]interface{}{}
8519 if !dara.IsNil(request.ConfigId) {
8520 query["ConfigId"] = request.ConfigId
8521 }
8522
8523 if !dara.IsNil(request.SiteId) {
8524 query["SiteId"] = request.SiteId
8525 }
8526
8527 req := &openapiutil.OpenApiRequest{
8528 Query: openapiutil.Query(query),
8529 }
8530 params := &openapiutil.Params{
8531 Action: dara.String("DeleteRewriteUrlRule"),
8532 Version: dara.String("2024-09-10"),
8533 Protocol: dara.String("HTTPS"),
8534 Pathname: dara.String("/"),
8535 Method: dara.String("POST"),
8536 AuthType: dara.String("AK"),
8537 Style: dara.String("RPC"),
8538 ReqBodyType: dara.String("formData"),
8539 BodyType: dara.String("json"),
8540 }
8541 _result = &DeleteRewriteUrlRuleResponse{}
8542 _body, _err := client.CallApi(params, req, runtime)
8543 if _err != nil {
8544 return _result, _err
8545 }
8546 _err = dara.Convert(_body, &_result)
8547 return _result, _err
8548 }
8549
8550 // Summary:
8551 //
8552 // Deletes a URL rewrite rule for a website.
8553 //
8554 // @param request - DeleteRewriteUrlRuleRequest
8555 //
8556 // @return DeleteRewriteUrlRuleResponse
8557 func DeleteRewriteUrlRule(client *Client, request *DeleteRewriteUrlRuleRequest) (_result *DeleteRewriteUrlRuleResponse, _err error) {
8558 runtime := &dara.RuntimeOptions{}
8559 _result = &DeleteRewriteUrlRuleResponse{}
8560 _body, _err := DeleteRewriteUrlRuleWithOptions(client,request, runtime)
8561 if _err != nil {
8562 return _result, _err
8563 }
8564 _result = _body
8565 return _result, _err
8566 }
8567
8568 // Summary:
8569 //
8570 // Deletes a routine in Edge Routine.
8571 //
8572 // @param request - DeleteRoutineRequest
8573 //
8574 // @param runtime - runtime options for this request RuntimeOptions
8575 //
8576 // @return DeleteRoutineResponse
8577 func DeleteRoutineWithOptions(client *Client, request *DeleteRoutineRequest, runtime *dara.RuntimeOptions) (_result *DeleteRoutineResponse, _err error) {
8578 if dara.BoolValue(client.EnableValidate) == true {
8579 _err = request.Validate()
8580 if _err != nil {
8581 return _result, _err
8582 }
8583 }
8584 body := map[string]interface{}{}
8585 if !dara.IsNil(request.Name) {
8586 body["Name"] = request.Name
8587 }
8588
8589 req := &openapiutil.OpenApiRequest{
8590 Body: openapiutil.ParseToMap(body),
8591 }
8592 params := &openapiutil.Params{
8593 Action: dara.String("DeleteRoutine"),
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 = &DeleteRoutineResponse{}
8604 _body, _err := client.CallApi(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 // Deletes a routine in Edge Routine.
8615 //
8616 // @param request - DeleteRoutineRequest
8617 //
8618 // @return DeleteRoutineResponse
8619 func DeleteRoutine(client *Client, request *DeleteRoutineRequest) (_result *DeleteRoutineResponse, _err error) {
8620 runtime := &dara.RuntimeOptions{}
8621 _result = &DeleteRoutineResponse{}
8622 _body, _err := DeleteRoutineWithOptions(client,request, runtime)
8623 if _err != nil {
8624 return _result, _err
8625 }
8626 _result = _body
8627 return _result, _err
8628 }
8629
8630 // Summary:
8631 //
8632 // Deletes a code version of a routine.
8633 //
8634 // @param request - DeleteRoutineCodeVersionRequest
8635 //
8636 // @param runtime - runtime options for this request RuntimeOptions
8637 //
8638 // @return DeleteRoutineCodeVersionResponse
8639 func DeleteRoutineCodeVersionWithOptions(client *Client, request *DeleteRoutineCodeVersionRequest, runtime *dara.RuntimeOptions) (_result *DeleteRoutineCodeVersionResponse, _err error) {
8640 if dara.BoolValue(client.EnableValidate) == true {
8641 _err = request.Validate()
8642 if _err != nil {
8643 return _result, _err
8644 }
8645 }
8646 body := map[string]interface{}{}
8647 if !dara.IsNil(request.CodeVersion) {
8648 body["CodeVersion"] = request.CodeVersion
8649 }
8650
8651 if !dara.IsNil(request.Name) {
8652 body["Name"] = request.Name
8653 }
8654
8655 req := &openapiutil.OpenApiRequest{
8656 Body: openapiutil.ParseToMap(body),
8657 }
8658 params := &openapiutil.Params{
8659 Action: dara.String("DeleteRoutineCodeVersion"),
8660 Version: dara.String("2024-09-10"),
8661 Protocol: dara.String("HTTPS"),
8662 Pathname: dara.String("/"),
8663 Method: dara.String("POST"),
8664 AuthType: dara.String("AK"),
8665 Style: dara.String("RPC"),
8666 ReqBodyType: dara.String("formData"),
8667 BodyType: dara.String("json"),
8668 }
8669 _result = &DeleteRoutineCodeVersionResponse{}
8670 _body, _err := client.CallApi(params, req, runtime)
8671 if _err != nil {
8672 return _result, _err
8673 }
8674 _err = dara.Convert(_body, &_result)
8675 return _result, _err
8676 }
8677
8678 // Summary:
8679 //
8680 // Deletes a code version of a routine.
8681 //
8682 // @param request - DeleteRoutineCodeVersionRequest
8683 //
8684 // @return DeleteRoutineCodeVersionResponse
8685 func DeleteRoutineCodeVersion(client *Client, request *DeleteRoutineCodeVersionRequest) (_result *DeleteRoutineCodeVersionResponse, _err error) {
8686 runtime := &dara.RuntimeOptions{}
8687 _result = &DeleteRoutineCodeVersionResponse{}
8688 _body, _err := DeleteRoutineCodeVersionWithOptions(client,request, runtime)
8689 if _err != nil {
8690 return _result, _err
8691 }
8692 _result = _body
8693 return _result, _err
8694 }
8695
8696 // Summary:
8697 //
8698 // Deletes a record that is associated with a routine.
8699 //
8700 // @param request - DeleteRoutineRelatedRecordRequest
8701 //
8702 // @param runtime - runtime options for this request RuntimeOptions
8703 //
8704 // @return DeleteRoutineRelatedRecordResponse
8705 func DeleteRoutineRelatedRecordWithOptions(client *Client, request *DeleteRoutineRelatedRecordRequest, runtime *dara.RuntimeOptions) (_result *DeleteRoutineRelatedRecordResponse, _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.SiteId) {
8714 query["SiteId"] = request.SiteId
8715 }
8716
8717 body := map[string]interface{}{}
8718 if !dara.IsNil(request.Name) {
8719 body["Name"] = request.Name
8720 }
8721
8722 if !dara.IsNil(request.RecordId) {
8723 body["RecordId"] = request.RecordId
8724 }
8725
8726 if !dara.IsNil(request.RecordName) {
8727 body["RecordName"] = request.RecordName
8728 }
8729
8730 req := &openapiutil.OpenApiRequest{
8731 Query: openapiutil.Query(query),
8732 Body: openapiutil.ParseToMap(body),
8733 }
8734 params := &openapiutil.Params{
8735 Action: dara.String("DeleteRoutineRelatedRecord"),
8736 Version: dara.String("2024-09-10"),
8737 Protocol: dara.String("HTTPS"),
8738 Pathname: dara.String("/"),
8739 Method: dara.String("POST"),
8740 AuthType: dara.String("AK"),
8741 Style: dara.String("RPC"),
8742 ReqBodyType: dara.String("formData"),
8743 BodyType: dara.String("json"),
8744 }
8745 _result = &DeleteRoutineRelatedRecordResponse{}
8746 _body, _err := client.CallApi(params, req, runtime)
8747 if _err != nil {
8748 return _result, _err
8749 }
8750 _err = dara.Convert(_body, &_result)
8751 return _result, _err
8752 }
8753
8754 // Summary:
8755 //
8756 // Deletes a record that is associated with a routine.
8757 //
8758 // @param request - DeleteRoutineRelatedRecordRequest
8759 //
8760 // @return DeleteRoutineRelatedRecordResponse
8761 func DeleteRoutineRelatedRecord(client *Client, request *DeleteRoutineRelatedRecordRequest) (_result *DeleteRoutineRelatedRecordResponse, _err error) {
8762 runtime := &dara.RuntimeOptions{}
8763 _result = &DeleteRoutineRelatedRecordResponse{}
8764 _body, _err := DeleteRoutineRelatedRecordWithOptions(client,request, runtime)
8765 if _err != nil {
8766 return _result, _err
8767 }
8768 _result = _body
8769 return _result, _err
8770 }
8771
8772 // Summary:
8773 //
8774 // Deletes the route configuration of an edge function.
8775 //
8776 // @param request - DeleteRoutineRouteRequest
8777 //
8778 // @param runtime - runtime options for this request RuntimeOptions
8779 //
8780 // @return DeleteRoutineRouteResponse
8781 func DeleteRoutineRouteWithOptions(client *Client, request *DeleteRoutineRouteRequest, runtime *dara.RuntimeOptions) (_result *DeleteRoutineRouteResponse, _err error) {
8782 if dara.BoolValue(client.EnableValidate) == true {
8783 _err = request.Validate()
8784 if _err != nil {
8785 return _result, _err
8786 }
8787 }
8788 query := map[string]interface{}{}
8789 if !dara.IsNil(request.ConfigId) {
8790 query["ConfigId"] = request.ConfigId
8791 }
8792
8793 if !dara.IsNil(request.SiteId) {
8794 query["SiteId"] = request.SiteId
8795 }
8796
8797 req := &openapiutil.OpenApiRequest{
8798 Query: openapiutil.Query(query),
8799 }
8800 params := &openapiutil.Params{
8801 Action: dara.String("DeleteRoutineRoute"),
8802 Version: dara.String("2024-09-10"),
8803 Protocol: dara.String("HTTPS"),
8804 Pathname: dara.String("/"),
8805 Method: dara.String("POST"),
8806 AuthType: dara.String("AK"),
8807 Style: dara.String("RPC"),
8808 ReqBodyType: dara.String("formData"),
8809 BodyType: dara.String("json"),
8810 }
8811 _result = &DeleteRoutineRouteResponse{}
8812 _body, _err := client.CallApi(params, req, runtime)
8813 if _err != nil {
8814 return _result, _err
8815 }
8816 _err = dara.Convert(_body, &_result)
8817 return _result, _err
8818 }
8819
8820 // Summary:
8821 //
8822 // Deletes the route configuration of an edge function.
8823 //
8824 // @param request - DeleteRoutineRouteRequest
8825 //
8826 // @return DeleteRoutineRouteResponse
8827 func DeleteRoutineRoute(client *Client, request *DeleteRoutineRouteRequest) (_result *DeleteRoutineRouteResponse, _err error) {
8828 runtime := &dara.RuntimeOptions{}
8829 _result = &DeleteRoutineRouteResponse{}
8830 _body, _err := DeleteRoutineRouteWithOptions(client,request, runtime)
8831 if _err != nil {
8832 return _result, _err
8833 }
8834 _result = _body
8835 return _result, _err
8836 }
8837
8838 // Summary:
8839 //
8840 // Deletes a scheduled prefetch plan based on the plan ID.
8841 //
8842 // @param request - DeleteScheduledPreloadExecutionRequest
8843 //
8844 // @param runtime - runtime options for this request RuntimeOptions
8845 //
8846 // @return DeleteScheduledPreloadExecutionResponse
8847 func DeleteScheduledPreloadExecutionWithOptions(client *Client, request *DeleteScheduledPreloadExecutionRequest, runtime *dara.RuntimeOptions) (_result *DeleteScheduledPreloadExecutionResponse, _err error) {
8848 if dara.BoolValue(client.EnableValidate) == true {
8849 _err = request.Validate()
8850 if _err != nil {
8851 return _result, _err
8852 }
8853 }
8854 query := map[string]interface{}{}
8855 if !dara.IsNil(request.Id) {
8856 query["Id"] = request.Id
8857 }
8858
8859 req := &openapiutil.OpenApiRequest{
8860 Query: openapiutil.Query(query),
8861 }
8862 params := &openapiutil.Params{
8863 Action: dara.String("DeleteScheduledPreloadExecution"),
8864 Version: dara.String("2024-09-10"),
8865 Protocol: dara.String("HTTPS"),
8866 Pathname: dara.String("/"),
8867 Method: dara.String("POST"),
8868 AuthType: dara.String("AK"),
8869 Style: dara.String("RPC"),
8870 ReqBodyType: dara.String("formData"),
8871 BodyType: dara.String("json"),
8872 }
8873 _result = &DeleteScheduledPreloadExecutionResponse{}
8874 _body, _err := client.CallApi(params, req, runtime)
8875 if _err != nil {
8876 return _result, _err
8877 }
8878 _err = dara.Convert(_body, &_result)
8879 return _result, _err
8880 }
8881
8882 // Summary:
8883 //
8884 // Deletes a scheduled prefetch plan based on the plan ID.
8885 //
8886 // @param request - DeleteScheduledPreloadExecutionRequest
8887 //
8888 // @return DeleteScheduledPreloadExecutionResponse
8889 func DeleteScheduledPreloadExecution(client *Client, request *DeleteScheduledPreloadExecutionRequest) (_result *DeleteScheduledPreloadExecutionResponse, _err error) {
8890 runtime := &dara.RuntimeOptions{}
8891 _result = &DeleteScheduledPreloadExecutionResponse{}
8892 _body, _err := DeleteScheduledPreloadExecutionWithOptions(client,request, runtime)
8893 if _err != nil {
8894 return _result, _err
8895 }
8896 _result = _body
8897 return _result, _err
8898 }
8899
8900 // Summary:
8901 //
8902 // Deletes a specified scheduled prefetch task based on the task ID.
8903 //
8904 // @param request - DeleteScheduledPreloadJobRequest
8905 //
8906 // @param runtime - runtime options for this request RuntimeOptions
8907 //
8908 // @return DeleteScheduledPreloadJobResponse
8909 func DeleteScheduledPreloadJobWithOptions(client *Client, request *DeleteScheduledPreloadJobRequest, runtime *dara.RuntimeOptions) (_result *DeleteScheduledPreloadJobResponse, _err error) {
8910 if dara.BoolValue(client.EnableValidate) == true {
8911 _err = request.Validate()
8912 if _err != nil {
8913 return _result, _err
8914 }
8915 }
8916 query := map[string]interface{}{}
8917 if !dara.IsNil(request.Id) {
8918 query["Id"] = request.Id
8919 }
8920
8921 req := &openapiutil.OpenApiRequest{
8922 Query: openapiutil.Query(query),
8923 }
8924 params := &openapiutil.Params{
8925 Action: dara.String("DeleteScheduledPreloadJob"),
8926 Version: dara.String("2024-09-10"),
8927 Protocol: dara.String("HTTPS"),
8928 Pathname: dara.String("/"),
8929 Method: dara.String("POST"),
8930 AuthType: dara.String("AK"),
8931 Style: dara.String("RPC"),
8932 ReqBodyType: dara.String("formData"),
8933 BodyType: dara.String("json"),
8934 }
8935 _result = &DeleteScheduledPreloadJobResponse{}
8936 _body, _err := client.CallApi(params, req, runtime)
8937 if _err != nil {
8938 return _result, _err
8939 }
8940 _err = dara.Convert(_body, &_result)
8941 return _result, _err
8942 }
8943
8944 // Summary:
8945 //
8946 // Deletes a specified scheduled prefetch task based on the task ID.
8947 //
8948 // @param request - DeleteScheduledPreloadJobRequest
8949 //
8950 // @return DeleteScheduledPreloadJobResponse
8951 func DeleteScheduledPreloadJob(client *Client, request *DeleteScheduledPreloadJobRequest) (_result *DeleteScheduledPreloadJobResponse, _err error) {
8952 runtime := &dara.RuntimeOptions{}
8953 _result = &DeleteScheduledPreloadJobResponse{}
8954 _body, _err := DeleteScheduledPreloadJobWithOptions(client,request, runtime)
8955 if _err != nil {
8956 return _result, _err
8957 }
8958 _result = _body
8959 return _result, _err
8960 }
8961
8962 // Summary:
8963 //
8964 // Deletes a website based on the specified website ID.
8965 //
8966 // @param request - DeleteSiteRequest
8967 //
8968 // @param runtime - runtime options for this request RuntimeOptions
8969 //
8970 // @return DeleteSiteResponse
8971 func DeleteSiteWithOptions(client *Client, request *DeleteSiteRequest, runtime *dara.RuntimeOptions) (_result *DeleteSiteResponse, _err error) {
8972 if dara.BoolValue(client.EnableValidate) == true {
8973 _err = request.Validate()
8974 if _err != nil {
8975 return _result, _err
8976 }
8977 }
8978 query := map[string]interface{}{}
8979 if !dara.IsNil(request.OwnerId) {
8980 query["OwnerId"] = request.OwnerId
8981 }
8982
8983 if !dara.IsNil(request.SecurityToken) {
8984 query["SecurityToken"] = request.SecurityToken
8985 }
8986
8987 if !dara.IsNil(request.SiteId) {
8988 query["SiteId"] = request.SiteId
8989 }
8990
8991 req := &openapiutil.OpenApiRequest{
8992 Query: openapiutil.Query(query),
8993 }
8994 params := &openapiutil.Params{
8995 Action: dara.String("DeleteSite"),
8996 Version: dara.String("2024-09-10"),
8997 Protocol: dara.String("HTTPS"),
8998 Pathname: dara.String("/"),
8999 Method: dara.String("POST"),
9000 AuthType: dara.String("AK"),
9001 Style: dara.String("RPC"),
9002 ReqBodyType: dara.String("formData"),
9003 BodyType: dara.String("json"),
9004 }
9005 _result = &DeleteSiteResponse{}
9006 _body, _err := client.CallApi(params, req, runtime)
9007 if _err != nil {
9008 return _result, _err
9009 }
9010 _err = dara.Convert(_body, &_result)
9011 return _result, _err
9012 }
9013
9014 // Summary:
9015 //
9016 // Deletes a website based on the specified website ID.
9017 //
9018 // @param request - DeleteSiteRequest
9019 //
9020 // @return DeleteSiteResponse
9021 func DeleteSite(client *Client, request *DeleteSiteRequest) (_result *DeleteSiteResponse, _err error) {
9022 runtime := &dara.RuntimeOptions{}
9023 _result = &DeleteSiteResponse{}
9024 _body, _err := DeleteSiteWithOptions(client,request, runtime)
9025 if _err != nil {
9026 return _result, _err
9027 }
9028 _result = _body
9029 return _result, _err
9030 }
9031
9032 // Summary:
9033 //
9034 // Deletes a real-time log delivery task.
9035 //
9036 // @param request - DeleteSiteDeliveryTaskRequest
9037 //
9038 // @param runtime - runtime options for this request RuntimeOptions
9039 //
9040 // @return DeleteSiteDeliveryTaskResponse
9041 func DeleteSiteDeliveryTaskWithOptions(client *Client, request *DeleteSiteDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *DeleteSiteDeliveryTaskResponse, _err error) {
9042 if dara.BoolValue(client.EnableValidate) == true {
9043 _err = request.Validate()
9044 if _err != nil {
9045 return _result, _err
9046 }
9047 }
9048 body := map[string]interface{}{}
9049 if !dara.IsNil(request.SiteId) {
9050 body["SiteId"] = request.SiteId
9051 }
9052
9053 if !dara.IsNil(request.TaskName) {
9054 body["TaskName"] = request.TaskName
9055 }
9056
9057 req := &openapiutil.OpenApiRequest{
9058 Body: openapiutil.ParseToMap(body),
9059 }
9060 params := &openapiutil.Params{
9061 Action: dara.String("DeleteSiteDeliveryTask"),
9062 Version: dara.String("2024-09-10"),
9063 Protocol: dara.String("HTTPS"),
9064 Pathname: dara.String("/"),
9065 Method: dara.String("POST"),
9066 AuthType: dara.String("AK"),
9067 Style: dara.String("RPC"),
9068 ReqBodyType: dara.String("formData"),
9069 BodyType: dara.String("json"),
9070 }
9071 _result = &DeleteSiteDeliveryTaskResponse{}
9072 _body, _err := client.CallApi(params, req, runtime)
9073 if _err != nil {
9074 return _result, _err
9075 }
9076 _err = dara.Convert(_body, &_result)
9077 return _result, _err
9078 }
9079
9080 // Summary:
9081 //
9082 // Deletes a real-time log delivery task.
9083 //
9084 // @param request - DeleteSiteDeliveryTaskRequest
9085 //
9086 // @return DeleteSiteDeliveryTaskResponse
9087 func DeleteSiteDeliveryTask(client *Client, request *DeleteSiteDeliveryTaskRequest) (_result *DeleteSiteDeliveryTaskResponse, _err error) {
9088 runtime := &dara.RuntimeOptions{}
9089 _result = &DeleteSiteDeliveryTaskResponse{}
9090 _body, _err := DeleteSiteDeliveryTaskWithOptions(client,request, runtime)
9091 if _err != nil {
9092 return _result, _err
9093 }
9094 _result = _body
9095 return _result, _err
9096 }
9097
9098 // Summary:
9099 //
9100 // 删除站点回源客户端证书
9101 //
9102 // @param request - DeleteSiteOriginClientCertificateRequest
9103 //
9104 // @param runtime - runtime options for this request RuntimeOptions
9105 //
9106 // @return DeleteSiteOriginClientCertificateResponse
9107 func DeleteSiteOriginClientCertificateWithOptions(client *Client, request *DeleteSiteOriginClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *DeleteSiteOriginClientCertificateResponse, _err error) {
9108 if dara.BoolValue(client.EnableValidate) == true {
9109 _err = request.Validate()
9110 if _err != nil {
9111 return _result, _err
9112 }
9113 }
9114 query := openapiutil.Query(dara.ToMap(request))
9115 req := &openapiutil.OpenApiRequest{
9116 Query: openapiutil.Query(query),
9117 }
9118 params := &openapiutil.Params{
9119 Action: dara.String("DeleteSiteOriginClientCertificate"),
9120 Version: dara.String("2024-09-10"),
9121 Protocol: dara.String("HTTPS"),
9122 Pathname: dara.String("/"),
9123 Method: dara.String("GET"),
9124 AuthType: dara.String("AK"),
9125 Style: dara.String("RPC"),
9126 ReqBodyType: dara.String("formData"),
9127 BodyType: dara.String("json"),
9128 }
9129 _result = &DeleteSiteOriginClientCertificateResponse{}
9130 _body, _err := client.CallApi(params, req, runtime)
9131 if _err != nil {
9132 return _result, _err
9133 }
9134 _err = dara.Convert(_body, &_result)
9135 return _result, _err
9136 }
9137
9138 // Summary:
9139 //
9140 // 删除站点回源客户端证书
9141 //
9142 // @param request - DeleteSiteOriginClientCertificateRequest
9143 //
9144 // @return DeleteSiteOriginClientCertificateResponse
9145 func DeleteSiteOriginClientCertificate(client *Client, request *DeleteSiteOriginClientCertificateRequest) (_result *DeleteSiteOriginClientCertificateResponse, _err error) {
9146 runtime := &dara.RuntimeOptions{}
9147 _result = &DeleteSiteOriginClientCertificateResponse{}
9148 _body, _err := DeleteSiteOriginClientCertificateWithOptions(client,request, runtime)
9149 if _err != nil {
9150 return _result, _err
9151 }
9152 _result = _body
9153 return _result, _err
9154 }
9155
9156 // Summary:
9157 //
9158 // # Delete Transport Layer Application
9159 //
9160 // @param request - DeleteTransportLayerApplicationRequest
9161 //
9162 // @param runtime - runtime options for this request RuntimeOptions
9163 //
9164 // @return DeleteTransportLayerApplicationResponse
9165 func DeleteTransportLayerApplicationWithOptions(client *Client, request *DeleteTransportLayerApplicationRequest, runtime *dara.RuntimeOptions) (_result *DeleteTransportLayerApplicationResponse, _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 := map[string]interface{}{}
9173 if !dara.IsNil(request.ApplicationId) {
9174 query["ApplicationId"] = request.ApplicationId
9175 }
9176
9177 if !dara.IsNil(request.SiteId) {
9178 query["SiteId"] = request.SiteId
9179 }
9180
9181 req := &openapiutil.OpenApiRequest{
9182 Query: openapiutil.Query(query),
9183 }
9184 params := &openapiutil.Params{
9185 Action: dara.String("DeleteTransportLayerApplication"),
9186 Version: dara.String("2024-09-10"),
9187 Protocol: dara.String("HTTPS"),
9188 Pathname: dara.String("/"),
9189 Method: dara.String("POST"),
9190 AuthType: dara.String("AK"),
9191 Style: dara.String("RPC"),
9192 ReqBodyType: dara.String("formData"),
9193 BodyType: dara.String("json"),
9194 }
9195 _result = &DeleteTransportLayerApplicationResponse{}
9196 _body, _err := client.CallApi(params, req, runtime)
9197 if _err != nil {
9198 return _result, _err
9199 }
9200 _err = dara.Convert(_body, &_result)
9201 return _result, _err
9202 }
9203
9204 // Summary:
9205 //
9206 // # Delete Transport Layer Application
9207 //
9208 // @param request - DeleteTransportLayerApplicationRequest
9209 //
9210 // @return DeleteTransportLayerApplicationResponse
9211 func DeleteTransportLayerApplication(client *Client, request *DeleteTransportLayerApplicationRequest) (_result *DeleteTransportLayerApplicationResponse, _err error) {
9212 runtime := &dara.RuntimeOptions{}
9213 _result = &DeleteTransportLayerApplicationResponse{}
9214 _body, _err := DeleteTransportLayerApplicationWithOptions(client,request, runtime)
9215 if _err != nil {
9216 return _result, _err
9217 }
9218 _result = _body
9219 return _result, _err
9220 }
9221
9222 // Summary:
9223 //
9224 // Deletes page monitoring configurations.
9225 //
9226 // @param request - DeleteUrlObservationRequest
9227 //
9228 // @param runtime - runtime options for this request RuntimeOptions
9229 //
9230 // @return DeleteUrlObservationResponse
9231 func DeleteUrlObservationWithOptions(client *Client, request *DeleteUrlObservationRequest, runtime *dara.RuntimeOptions) (_result *DeleteUrlObservationResponse, _err error) {
9232 if dara.BoolValue(client.EnableValidate) == true {
9233 _err = request.Validate()
9234 if _err != nil {
9235 return _result, _err
9236 }
9237 }
9238 query := map[string]interface{}{}
9239 if !dara.IsNil(request.ConfigId) {
9240 query["ConfigId"] = request.ConfigId
9241 }
9242
9243 if !dara.IsNil(request.SiteId) {
9244 query["SiteId"] = request.SiteId
9245 }
9246
9247 req := &openapiutil.OpenApiRequest{
9248 Query: openapiutil.Query(query),
9249 }
9250 params := &openapiutil.Params{
9251 Action: dara.String("DeleteUrlObservation"),
9252 Version: dara.String("2024-09-10"),
9253 Protocol: dara.String("HTTPS"),
9254 Pathname: dara.String("/"),
9255 Method: dara.String("POST"),
9256 AuthType: dara.String("AK"),
9257 Style: dara.String("RPC"),
9258 ReqBodyType: dara.String("formData"),
9259 BodyType: dara.String("json"),
9260 }
9261 _result = &DeleteUrlObservationResponse{}
9262 _body, _err := client.CallApi(params, req, runtime)
9263 if _err != nil {
9264 return _result, _err
9265 }
9266 _err = dara.Convert(_body, &_result)
9267 return _result, _err
9268 }
9269
9270 // Summary:
9271 //
9272 // Deletes page monitoring configurations.
9273 //
9274 // @param request - DeleteUrlObservationRequest
9275 //
9276 // @return DeleteUrlObservationResponse
9277 func DeleteUrlObservation(client *Client, request *DeleteUrlObservationRequest) (_result *DeleteUrlObservationResponse, _err error) {
9278 runtime := &dara.RuntimeOptions{}
9279 _result = &DeleteUrlObservationResponse{}
9280 _body, _err := DeleteUrlObservationWithOptions(client,request, runtime)
9281 if _err != nil {
9282 return _result, _err
9283 }
9284 _result = _body
9285 return _result, _err
9286 }
9287
9288 // Summary:
9289 //
9290 // Deletes a log delivery task from your Alibaba Cloud account.
9291 //
9292 // Description:
9293 //
9294 // *****>
9295 //
9296 // - Deleted tasks cannot be restored. Proceed with caution.
9297 //
9298 // - To call this operation, you must have an account that has the required permissions.
9299 //
9300 // - The returned `RequestId` value can be used to track the request processing progress and troubleshoot issues.
9301 //
9302 // @param request - DeleteUserDeliveryTaskRequest
9303 //
9304 // @param runtime - runtime options for this request RuntimeOptions
9305 //
9306 // @return DeleteUserDeliveryTaskResponse
9307 func DeleteUserDeliveryTaskWithOptions(client *Client, request *DeleteUserDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *DeleteUserDeliveryTaskResponse, _err error) {
9308 if dara.BoolValue(client.EnableValidate) == true {
9309 _err = request.Validate()
9310 if _err != nil {
9311 return _result, _err
9312 }
9313 }
9314 body := map[string]interface{}{}
9315 if !dara.IsNil(request.TaskName) {
9316 body["TaskName"] = request.TaskName
9317 }
9318
9319 req := &openapiutil.OpenApiRequest{
9320 Body: openapiutil.ParseToMap(body),
9321 }
9322 params := &openapiutil.Params{
9323 Action: dara.String("DeleteUserDeliveryTask"),
9324 Version: dara.String("2024-09-10"),
9325 Protocol: dara.String("HTTPS"),
9326 Pathname: dara.String("/"),
9327 Method: dara.String("POST"),
9328 AuthType: dara.String("AK"),
9329 Style: dara.String("RPC"),
9330 ReqBodyType: dara.String("formData"),
9331 BodyType: dara.String("json"),
9332 }
9333 _result = &DeleteUserDeliveryTaskResponse{}
9334 _body, _err := client.CallApi(params, req, runtime)
9335 if _err != nil {
9336 return _result, _err
9337 }
9338 _err = dara.Convert(_body, &_result)
9339 return _result, _err
9340 }
9341
9342 // Summary:
9343 //
9344 // Deletes a log delivery task from your Alibaba Cloud account.
9345 //
9346 // Description:
9347 //
9348 // *****>
9349 //
9350 // - Deleted tasks cannot be restored. Proceed with caution.
9351 //
9352 // - To call this operation, you must have an account that has the required permissions.
9353 //
9354 // - The returned `RequestId` value can be used to track the request processing progress and troubleshoot issues.
9355 //
9356 // @param request - DeleteUserDeliveryTaskRequest
9357 //
9358 // @return DeleteUserDeliveryTaskResponse
9359 func DeleteUserDeliveryTask(client *Client, request *DeleteUserDeliveryTaskRequest) (_result *DeleteUserDeliveryTaskResponse, _err error) {
9360 runtime := &dara.RuntimeOptions{}
9361 _result = &DeleteUserDeliveryTaskResponse{}
9362 _body, _err := DeleteUserDeliveryTaskWithOptions(client,request, runtime)
9363 if _err != nil {
9364 return _result, _err
9365 }
9366 _result = _body
9367 return _result, _err
9368 }
9369
9370 // Summary:
9371 //
9372 // 用于删除实例级别的Web应用防火墙规则集。
9373 //
9374 // Description:
9375 //
9376 // ## 请求说明
9377 //
9378 // - 本API允许用户为指定实例创建新的WAF（Web Application Firewall）规则集。
9379 //
9380 // - `InstanceId` 是必需参数，指定了要为其创建规则集的具体实例。
9381 //
9382 // - `Phase` 参数定义了规则集的应用阶段，例如自定义规则、频次控制等。
9383 //
9384 // - `Name` 和 `Expression` 是必填项，分别代表规则集的名字和具体的匹配表达式。
9385 //
9386 // - 可选参数 `Description` 提供了对规则集功能或用途的文字描述。
9387 //
9388 // - `Status` 控制着规则集是否立即生效 (`on`) 或者处于关闭状态 (`off`)。
9389 //
9390 // - 通过 `Rules` 参数可以进一步配置更详细的规则列表，每个规则都包含名称、位置、表达式及动作等属性。
9391 //
9392 // - 成功响应将返回新创建规则集的唯一标识符 `Id` 以及所有关联规则的ID列表 `RuleIds`。
9393 //
9394 // @param request - DeleteUserWafRulesetRequest
9395 //
9396 // @param runtime - runtime options for this request RuntimeOptions
9397 //
9398 // @return DeleteUserWafRulesetResponse
9399 func DeleteUserWafRulesetWithOptions(client *Client, request *DeleteUserWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *DeleteUserWafRulesetResponse, _err error) {
9400 if dara.BoolValue(client.EnableValidate) == true {
9401 _err = request.Validate()
9402 if _err != nil {
9403 return _result, _err
9404 }
9405 }
9406 query := map[string]interface{}{}
9407 if !dara.IsNil(request.InstanceId) {
9408 query["InstanceId"] = request.InstanceId
9409 }
9410
9411 body := map[string]interface{}{}
9412 if !dara.IsNil(request.Id) {
9413 body["Id"] = request.Id
9414 }
9415
9416 req := &openapiutil.OpenApiRequest{
9417 Query: openapiutil.Query(query),
9418 Body: openapiutil.ParseToMap(body),
9419 }
9420 params := &openapiutil.Params{
9421 Action: dara.String("DeleteUserWafRuleset"),
9422 Version: dara.String("2024-09-10"),
9423 Protocol: dara.String("HTTPS"),
9424 Pathname: dara.String("/"),
9425 Method: dara.String("POST"),
9426 AuthType: dara.String("AK"),
9427 Style: dara.String("RPC"),
9428 ReqBodyType: dara.String("formData"),
9429 BodyType: dara.String("json"),
9430 }
9431 _result = &DeleteUserWafRulesetResponse{}
9432 _body, _err := client.CallApi(params, req, runtime)
9433 if _err != nil {
9434 return _result, _err
9435 }
9436 _err = dara.Convert(_body, &_result)
9437 return _result, _err
9438 }
9439
9440 // Summary:
9441 //
9442 // 用于删除实例级别的Web应用防火墙规则集。
9443 //
9444 // Description:
9445 //
9446 // ## 请求说明
9447 //
9448 // - 本API允许用户为指定实例创建新的WAF（Web Application Firewall）规则集。
9449 //
9450 // - `InstanceId` 是必需参数，指定了要为其创建规则集的具体实例。
9451 //
9452 // - `Phase` 参数定义了规则集的应用阶段，例如自定义规则、频次控制等。
9453 //
9454 // - `Name` 和 `Expression` 是必填项，分别代表规则集的名字和具体的匹配表达式。
9455 //
9456 // - 可选参数 `Description` 提供了对规则集功能或用途的文字描述。
9457 //
9458 // - `Status` 控制着规则集是否立即生效 (`on`) 或者处于关闭状态 (`off`)。
9459 //
9460 // - 通过 `Rules` 参数可以进一步配置更详细的规则列表，每个规则都包含名称、位置、表达式及动作等属性。
9461 //
9462 // - 成功响应将返回新创建规则集的唯一标识符 `Id` 以及所有关联规则的ID列表 `RuleIds`。
9463 //
9464 // @param request - DeleteUserWafRulesetRequest
9465 //
9466 // @return DeleteUserWafRulesetResponse
9467 func DeleteUserWafRuleset(client *Client, request *DeleteUserWafRulesetRequest) (_result *DeleteUserWafRulesetResponse, _err error) {
9468 runtime := &dara.RuntimeOptions{}
9469 _result = &DeleteUserWafRulesetResponse{}
9470 _body, _err := DeleteUserWafRulesetWithOptions(client,request, runtime)
9471 if _err != nil {
9472 return _result, _err
9473 }
9474 _result = _body
9475 return _result, _err
9476 }
9477
9478 // Summary:
9479 //
9480 // Deletes a video processing configuration.
9481 //
9482 // @param request - DeleteVideoProcessingRequest
9483 //
9484 // @param runtime - runtime options for this request RuntimeOptions
9485 //
9486 // @return DeleteVideoProcessingResponse
9487 func DeleteVideoProcessingWithOptions(client *Client, request *DeleteVideoProcessingRequest, runtime *dara.RuntimeOptions) (_result *DeleteVideoProcessingResponse, _err error) {
9488 if dara.BoolValue(client.EnableValidate) == true {
9489 _err = request.Validate()
9490 if _err != nil {
9491 return _result, _err
9492 }
9493 }
9494 query := map[string]interface{}{}
9495 if !dara.IsNil(request.ConfigId) {
9496 query["ConfigId"] = request.ConfigId
9497 }
9498
9499 if !dara.IsNil(request.SiteId) {
9500 query["SiteId"] = request.SiteId
9501 }
9502
9503 req := &openapiutil.OpenApiRequest{
9504 Query: openapiutil.Query(query),
9505 }
9506 params := &openapiutil.Params{
9507 Action: dara.String("DeleteVideoProcessing"),
9508 Version: dara.String("2024-09-10"),
9509 Protocol: dara.String("HTTPS"),
9510 Pathname: dara.String("/"),
9511 Method: dara.String("POST"),
9512 AuthType: dara.String("AK"),
9513 Style: dara.String("RPC"),
9514 ReqBodyType: dara.String("formData"),
9515 BodyType: dara.String("json"),
9516 }
9517 _result = &DeleteVideoProcessingResponse{}
9518 _body, _err := client.CallApi(params, req, runtime)
9519 if _err != nil {
9520 return _result, _err
9521 }
9522 _err = dara.Convert(_body, &_result)
9523 return _result, _err
9524 }
9525
9526 // Summary:
9527 //
9528 // Deletes a video processing configuration.
9529 //
9530 // @param request - DeleteVideoProcessingRequest
9531 //
9532 // @return DeleteVideoProcessingResponse
9533 func DeleteVideoProcessing(client *Client, request *DeleteVideoProcessingRequest) (_result *DeleteVideoProcessingResponse, _err error) {
9534 runtime := &dara.RuntimeOptions{}
9535 _result = &DeleteVideoProcessingResponse{}
9536 _body, _err := DeleteVideoProcessingWithOptions(client,request, runtime)
9537 if _err != nil {
9538 return _result, _err
9539 }
9540 _result = _body
9541 return _result, _err
9542 }
9543
9544 // Summary:
9545 //
9546 // # Delete WAF Rule
9547 //
9548 // @param request - DeleteWafRuleRequest
9549 //
9550 // @param runtime - runtime options for this request RuntimeOptions
9551 //
9552 // @return DeleteWafRuleResponse
9553 func DeleteWafRuleWithOptions(client *Client, request *DeleteWafRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteWafRuleResponse, _err error) {
9554 if dara.BoolValue(client.EnableValidate) == true {
9555 _err = request.Validate()
9556 if _err != nil {
9557 return _result, _err
9558 }
9559 }
9560 query := map[string]interface{}{}
9561 if !dara.IsNil(request.SiteId) {
9562 query["SiteId"] = request.SiteId
9563 }
9564
9565 if !dara.IsNil(request.SiteVersion) {
9566 query["SiteVersion"] = request.SiteVersion
9567 }
9568
9569 body := map[string]interface{}{}
9570 if !dara.IsNil(request.Id) {
9571 body["Id"] = request.Id
9572 }
9573
9574 req := &openapiutil.OpenApiRequest{
9575 Query: openapiutil.Query(query),
9576 Body: openapiutil.ParseToMap(body),
9577 }
9578 params := &openapiutil.Params{
9579 Action: dara.String("DeleteWafRule"),
9580 Version: dara.String("2024-09-10"),
9581 Protocol: dara.String("HTTPS"),
9582 Pathname: dara.String("/"),
9583 Method: dara.String("POST"),
9584 AuthType: dara.String("AK"),
9585 Style: dara.String("RPC"),
9586 ReqBodyType: dara.String("formData"),
9587 BodyType: dara.String("json"),
9588 }
9589 _result = &DeleteWafRuleResponse{}
9590 _body, _err := client.CallApi(params, req, runtime)
9591 if _err != nil {
9592 return _result, _err
9593 }
9594 _err = dara.Convert(_body, &_result)
9595 return _result, _err
9596 }
9597
9598 // Summary:
9599 //
9600 // # Delete WAF Rule
9601 //
9602 // @param request - DeleteWafRuleRequest
9603 //
9604 // @return DeleteWafRuleResponse
9605 func DeleteWafRule(client *Client, request *DeleteWafRuleRequest) (_result *DeleteWafRuleResponse, _err error) {
9606 runtime := &dara.RuntimeOptions{}
9607 _result = &DeleteWafRuleResponse{}
9608 _body, _err := DeleteWafRuleWithOptions(client,request, runtime)
9609 if _err != nil {
9610 return _result, _err
9611 }
9612 _result = _body
9613 return _result, _err
9614 }
9615
9616 // Summary:
9617 //
9618 // # Delete WAF Ruleset
9619 //
9620 // @param request - DeleteWafRulesetRequest
9621 //
9622 // @param runtime - runtime options for this request RuntimeOptions
9623 //
9624 // @return DeleteWafRulesetResponse
9625 func DeleteWafRulesetWithOptions(client *Client, request *DeleteWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *DeleteWafRulesetResponse, _err error) {
9626 if dara.BoolValue(client.EnableValidate) == true {
9627 _err = request.Validate()
9628 if _err != nil {
9629 return _result, _err
9630 }
9631 }
9632 query := map[string]interface{}{}
9633 if !dara.IsNil(request.SiteId) {
9634 query["SiteId"] = request.SiteId
9635 }
9636
9637 if !dara.IsNil(request.SiteVersion) {
9638 query["SiteVersion"] = request.SiteVersion
9639 }
9640
9641 body := map[string]interface{}{}
9642 if !dara.IsNil(request.Id) {
9643 body["Id"] = request.Id
9644 }
9645
9646 req := &openapiutil.OpenApiRequest{
9647 Query: openapiutil.Query(query),
9648 Body: openapiutil.ParseToMap(body),
9649 }
9650 params := &openapiutil.Params{
9651 Action: dara.String("DeleteWafRuleset"),
9652 Version: dara.String("2024-09-10"),
9653 Protocol: dara.String("HTTPS"),
9654 Pathname: dara.String("/"),
9655 Method: dara.String("POST"),
9656 AuthType: dara.String("AK"),
9657 Style: dara.String("RPC"),
9658 ReqBodyType: dara.String("formData"),
9659 BodyType: dara.String("json"),
9660 }
9661 _result = &DeleteWafRulesetResponse{}
9662 _body, _err := client.CallApi(params, req, runtime)
9663 if _err != nil {
9664 return _result, _err
9665 }
9666 _err = dara.Convert(_body, &_result)
9667 return _result, _err
9668 }
9669
9670 // Summary:
9671 //
9672 // # Delete WAF Ruleset
9673 //
9674 // @param request - DeleteWafRulesetRequest
9675 //
9676 // @return DeleteWafRulesetResponse
9677 func DeleteWafRuleset(client *Client, request *DeleteWafRulesetRequest) (_result *DeleteWafRulesetResponse, _err error) {
9678 runtime := &dara.RuntimeOptions{}
9679 _result = &DeleteWafRulesetResponse{}
9680 _body, _err := DeleteWafRulesetWithOptions(client,request, runtime)
9681 if _err != nil {
9682 return _result, _err
9683 }
9684 _result = _body
9685 return _result, _err
9686 }
9687
9688 // Summary:
9689 //
9690 // Deletes a waiting room.
9691 //
9692 // @param request - DeleteWaitingRoomRequest
9693 //
9694 // @param runtime - runtime options for this request RuntimeOptions
9695 //
9696 // @return DeleteWaitingRoomResponse
9697 func DeleteWaitingRoomWithOptions(client *Client, request *DeleteWaitingRoomRequest, runtime *dara.RuntimeOptions) (_result *DeleteWaitingRoomResponse, _err error) {
9698 if dara.BoolValue(client.EnableValidate) == true {
9699 _err = request.Validate()
9700 if _err != nil {
9701 return _result, _err
9702 }
9703 }
9704 query := map[string]interface{}{}
9705 if !dara.IsNil(request.SiteId) {
9706 query["SiteId"] = request.SiteId
9707 }
9708
9709 if !dara.IsNil(request.WaitingRoomId) {
9710 query["WaitingRoomId"] = request.WaitingRoomId
9711 }
9712
9713 req := &openapiutil.OpenApiRequest{
9714 Query: openapiutil.Query(query),
9715 }
9716 params := &openapiutil.Params{
9717 Action: dara.String("DeleteWaitingRoom"),
9718 Version: dara.String("2024-09-10"),
9719 Protocol: dara.String("HTTPS"),
9720 Pathname: dara.String("/"),
9721 Method: dara.String("POST"),
9722 AuthType: dara.String("AK"),
9723 Style: dara.String("RPC"),
9724 ReqBodyType: dara.String("formData"),
9725 BodyType: dara.String("json"),
9726 }
9727 _result = &DeleteWaitingRoomResponse{}
9728 _body, _err := client.CallApi(params, req, runtime)
9729 if _err != nil {
9730 return _result, _err
9731 }
9732 _err = dara.Convert(_body, &_result)
9733 return _result, _err
9734 }
9735
9736 // Summary:
9737 //
9738 // Deletes a waiting room.
9739 //
9740 // @param request - DeleteWaitingRoomRequest
9741 //
9742 // @return DeleteWaitingRoomResponse
9743 func DeleteWaitingRoom(client *Client, request *DeleteWaitingRoomRequest) (_result *DeleteWaitingRoomResponse, _err error) {
9744 runtime := &dara.RuntimeOptions{}
9745 _result = &DeleteWaitingRoomResponse{}
9746 _body, _err := DeleteWaitingRoomWithOptions(client,request, runtime)
9747 if _err != nil {
9748 return _result, _err
9749 }
9750 _result = _body
9751 return _result, _err
9752 }
9753
9754 // Summary:
9755 //
9756 // Deletes a waiting room event.
9757 //
9758 // @param request - DeleteWaitingRoomEventRequest
9759 //
9760 // @param runtime - runtime options for this request RuntimeOptions
9761 //
9762 // @return DeleteWaitingRoomEventResponse
9763 func DeleteWaitingRoomEventWithOptions(client *Client, request *DeleteWaitingRoomEventRequest, runtime *dara.RuntimeOptions) (_result *DeleteWaitingRoomEventResponse, _err error) {
9764 if dara.BoolValue(client.EnableValidate) == true {
9765 _err = request.Validate()
9766 if _err != nil {
9767 return _result, _err
9768 }
9769 }
9770 query := map[string]interface{}{}
9771 if !dara.IsNil(request.SiteId) {
9772 query["SiteId"] = request.SiteId
9773 }
9774
9775 if !dara.IsNil(request.WaitingRoomEventId) {
9776 query["WaitingRoomEventId"] = request.WaitingRoomEventId
9777 }
9778
9779 req := &openapiutil.OpenApiRequest{
9780 Query: openapiutil.Query(query),
9781 }
9782 params := &openapiutil.Params{
9783 Action: dara.String("DeleteWaitingRoomEvent"),
9784 Version: dara.String("2024-09-10"),
9785 Protocol: dara.String("HTTPS"),
9786 Pathname: dara.String("/"),
9787 Method: dara.String("POST"),
9788 AuthType: dara.String("AK"),
9789 Style: dara.String("RPC"),
9790 ReqBodyType: dara.String("formData"),
9791 BodyType: dara.String("json"),
9792 }
9793 _result = &DeleteWaitingRoomEventResponse{}
9794 _body, _err := client.CallApi(params, req, runtime)
9795 if _err != nil {
9796 return _result, _err
9797 }
9798 _err = dara.Convert(_body, &_result)
9799 return _result, _err
9800 }
9801
9802 // Summary:
9803 //
9804 // Deletes a waiting room event.
9805 //
9806 // @param request - DeleteWaitingRoomEventRequest
9807 //
9808 // @return DeleteWaitingRoomEventResponse
9809 func DeleteWaitingRoomEvent(client *Client, request *DeleteWaitingRoomEventRequest) (_result *DeleteWaitingRoomEventResponse, _err error) {
9810 runtime := &dara.RuntimeOptions{}
9811 _result = &DeleteWaitingRoomEventResponse{}
9812 _body, _err := DeleteWaitingRoomEventWithOptions(client,request, runtime)
9813 if _err != nil {
9814 return _result, _err
9815 }
9816 _result = _body
9817 return _result, _err
9818 }
9819
9820 // Summary:
9821 //
9822 // Deletes a waiting room bypass rule.
9823 //
9824 // @param request - DeleteWaitingRoomRuleRequest
9825 //
9826 // @param runtime - runtime options for this request RuntimeOptions
9827 //
9828 // @return DeleteWaitingRoomRuleResponse
9829 func DeleteWaitingRoomRuleWithOptions(client *Client, request *DeleteWaitingRoomRuleRequest, runtime *dara.RuntimeOptions) (_result *DeleteWaitingRoomRuleResponse, _err error) {
9830 if dara.BoolValue(client.EnableValidate) == true {
9831 _err = request.Validate()
9832 if _err != nil {
9833 return _result, _err
9834 }
9835 }
9836 query := map[string]interface{}{}
9837 if !dara.IsNil(request.SiteId) {
9838 query["SiteId"] = request.SiteId
9839 }
9840
9841 if !dara.IsNil(request.WaitingRoomRuleId) {
9842 query["WaitingRoomRuleId"] = request.WaitingRoomRuleId
9843 }
9844
9845 req := &openapiutil.OpenApiRequest{
9846 Query: openapiutil.Query(query),
9847 }
9848 params := &openapiutil.Params{
9849 Action: dara.String("DeleteWaitingRoomRule"),
9850 Version: dara.String("2024-09-10"),
9851 Protocol: dara.String("HTTPS"),
9852 Pathname: dara.String("/"),
9853 Method: dara.String("POST"),
9854 AuthType: dara.String("AK"),
9855 Style: dara.String("RPC"),
9856 ReqBodyType: dara.String("formData"),
9857 BodyType: dara.String("json"),
9858 }
9859 _result = &DeleteWaitingRoomRuleResponse{}
9860 _body, _err := client.CallApi(params, req, runtime)
9861 if _err != nil {
9862 return _result, _err
9863 }
9864 _err = dara.Convert(_body, &_result)
9865 return _result, _err
9866 }
9867
9868 // Summary:
9869 //
9870 // Deletes a waiting room bypass rule.
9871 //
9872 // @param request - DeleteWaitingRoomRuleRequest
9873 //
9874 // @return DeleteWaitingRoomRuleResponse
9875 func DeleteWaitingRoomRule(client *Client, request *DeleteWaitingRoomRuleRequest) (_result *DeleteWaitingRoomRuleResponse, _err error) {
9876 runtime := &dara.RuntimeOptions{}
9877 _result = &DeleteWaitingRoomRuleResponse{}
9878 _body, _err := DeleteWaitingRoomRuleWithOptions(client,request, runtime)
9879 if _err != nil {
9880 return _result, _err
9881 }
9882 _result = _body
9883 return _result, _err
9884 }
9885
9886 // Summary:
9887 //
9888 // Queries the configurations of a scenario-specific policy.
9889 //
9890 // @param request - DescribeCustomScenePoliciesRequest
9891 //
9892 // @param runtime - runtime options for this request RuntimeOptions
9893 //
9894 // @return DescribeCustomScenePoliciesResponse
9895 func DescribeCustomScenePoliciesWithOptions(client *Client, request *DescribeCustomScenePoliciesRequest, runtime *dara.RuntimeOptions) (_result *DescribeCustomScenePoliciesResponse, _err error) {
9896 if dara.BoolValue(client.EnableValidate) == true {
9897 _err = request.Validate()
9898 if _err != nil {
9899 return _result, _err
9900 }
9901 }
9902 query := map[string]interface{}{}
9903 if !dara.IsNil(request.PageNumber) {
9904 query["PageNumber"] = request.PageNumber
9905 }
9906
9907 if !dara.IsNil(request.PageSize) {
9908 query["PageSize"] = request.PageSize
9909 }
9910
9911 if !dara.IsNil(request.PolicyId) {
9912 query["PolicyId"] = request.PolicyId
9913 }
9914
9915 req := &openapiutil.OpenApiRequest{
9916 Query: openapiutil.Query(query),
9917 }
9918 params := &openapiutil.Params{
9919 Action: dara.String("DescribeCustomScenePolicies"),
9920 Version: dara.String("2024-09-10"),
9921 Protocol: dara.String("HTTPS"),
9922 Pathname: dara.String("/"),
9923 Method: dara.String("POST"),
9924 AuthType: dara.String("AK"),
9925 Style: dara.String("RPC"),
9926 ReqBodyType: dara.String("formData"),
9927 BodyType: dara.String("json"),
9928 }
9929 _result = &DescribeCustomScenePoliciesResponse{}
9930 _body, _err := client.CallApi(params, req, runtime)
9931 if _err != nil {
9932 return _result, _err
9933 }
9934 _err = dara.Convert(_body, &_result)
9935 return _result, _err
9936 }
9937
9938 // Summary:
9939 //
9940 // Queries the configurations of a scenario-specific policy.
9941 //
9942 // @param request - DescribeCustomScenePoliciesRequest
9943 //
9944 // @return DescribeCustomScenePoliciesResponse
9945 func DescribeCustomScenePolicies(client *Client, request *DescribeCustomScenePoliciesRequest) (_result *DescribeCustomScenePoliciesResponse, _err error) {
9946 runtime := &dara.RuntimeOptions{}
9947 _result = &DescribeCustomScenePoliciesResponse{}
9948 _body, _err := DescribeCustomScenePoliciesWithOptions(client,request, runtime)
9949 if _err != nil {
9950 return _result, _err
9951 }
9952 _result = _body
9953 return _result, _err
9954 }
9955
9956 // Summary:
9957 //
9958 // Queries DDoS attack events.
9959 //
9960 // @param request - DescribeDDoSAllEventListRequest
9961 //
9962 // @param runtime - runtime options for this request RuntimeOptions
9963 //
9964 // @return DescribeDDoSAllEventListResponse
9965 func DescribeDDoSAllEventListWithOptions(client *Client, request *DescribeDDoSAllEventListRequest, runtime *dara.RuntimeOptions) (_result *DescribeDDoSAllEventListResponse, _err error) {
9966 if dara.BoolValue(client.EnableValidate) == true {
9967 _err = request.Validate()
9968 if _err != nil {
9969 return _result, _err
9970 }
9971 }
9972 query := map[string]interface{}{}
9973 if !dara.IsNil(request.EndTime) {
9974 query["EndTime"] = request.EndTime
9975 }
9976
9977 if !dara.IsNil(request.EventType) {
9978 query["EventType"] = request.EventType
9979 }
9980
9981 if !dara.IsNil(request.PageNumber) {
9982 query["PageNumber"] = request.PageNumber
9983 }
9984
9985 if !dara.IsNil(request.PageSize) {
9986 query["PageSize"] = request.PageSize
9987 }
9988
9989 if !dara.IsNil(request.SiteId) {
9990 query["SiteId"] = request.SiteId
9991 }
9992
9993 if !dara.IsNil(request.StartTime) {
9994 query["StartTime"] = request.StartTime
9995 }
9996
9997 req := &openapiutil.OpenApiRequest{
9998 Query: openapiutil.Query(query),
9999 }
10000 params := &openapiutil.Params{
10001 Action: dara.String("DescribeDDoSAllEventList"),
10002 Version: dara.String("2024-09-10"),
10003 Protocol: dara.String("HTTPS"),
10004 Pathname: dara.String("/"),
10005 Method: dara.String("POST"),
10006 AuthType: dara.String("AK"),
10007 Style: dara.String("RPC"),
10008 ReqBodyType: dara.String("formData"),
10009 BodyType: dara.String("json"),
10010 }
10011 _result = &DescribeDDoSAllEventListResponse{}
10012 _body, _err := client.CallApi(params, req, runtime)
10013 if _err != nil {
10014 return _result, _err
10015 }
10016 _err = dara.Convert(_body, &_result)
10017 return _result, _err
10018 }
10019
10020 // Summary:
10021 //
10022 // Queries DDoS attack events.
10023 //
10024 // @param request - DescribeDDoSAllEventListRequest
10025 //
10026 // @return DescribeDDoSAllEventListResponse
10027 func DescribeDDoSAllEventList(client *Client, request *DescribeDDoSAllEventListRequest) (_result *DescribeDDoSAllEventListResponse, _err error) {
10028 runtime := &dara.RuntimeOptions{}
10029 _result = &DescribeDDoSAllEventListResponse{}
10030 _body, _err := DescribeDDoSAllEventListWithOptions(client,request, runtime)
10031 if _err != nil {
10032 return _result, _err
10033 }
10034 _result = _body
10035 return _result, _err
10036 }
10037
10038 // Summary:
10039 //
10040 // # Query DCDN DDoS user bps and pps data
10041 //
10042 // @param request - DescribeDDoSBpsListRequest
10043 //
10044 // @param runtime - runtime options for this request RuntimeOptions
10045 //
10046 // @return DescribeDDoSBpsListResponse
10047 func DescribeDDoSBpsListWithOptions(client *Client, request *DescribeDDoSBpsListRequest, runtime *dara.RuntimeOptions) (_result *DescribeDDoSBpsListResponse, _err error) {
10048 if dara.BoolValue(client.EnableValidate) == true {
10049 _err = request.Validate()
10050 if _err != nil {
10051 return _result, _err
10052 }
10053 }
10054 query := openapiutil.Query(dara.ToMap(request))
10055 req := &openapiutil.OpenApiRequest{
10056 Query: openapiutil.Query(query),
10057 }
10058 params := &openapiutil.Params{
10059 Action: dara.String("DescribeDDoSBpsList"),
10060 Version: dara.String("2024-09-10"),
10061 Protocol: dara.String("HTTPS"),
10062 Pathname: dara.String("/"),
10063 Method: dara.String("GET"),
10064 AuthType: dara.String("AK"),
10065 Style: dara.String("RPC"),
10066 ReqBodyType: dara.String("formData"),
10067 BodyType: dara.String("json"),
10068 }
10069 _result = &DescribeDDoSBpsListResponse{}
10070 _body, _err := client.CallApi(params, req, runtime)
10071 if _err != nil {
10072 return _result, _err
10073 }
10074 _err = dara.Convert(_body, &_result)
10075 return _result, _err
10076 }
10077
10078 // Summary:
10079 //
10080 // # Query DCDN DDoS user bps and pps data
10081 //
10082 // @param request - DescribeDDoSBpsListRequest
10083 //
10084 // @return DescribeDDoSBpsListResponse
10085 func DescribeDDoSBpsList(client *Client, request *DescribeDDoSBpsListRequest) (_result *DescribeDDoSBpsListResponse, _err error) {
10086 runtime := &dara.RuntimeOptions{}
10087 _result = &DescribeDDoSBpsListResponse{}
10088 _body, _err := DescribeDDoSBpsListWithOptions(client,request, runtime)
10089 if _err != nil {
10090 return _result, _err
10091 }
10092 _result = _body
10093 return _result, _err
10094 }
10095
10096 // Summary:
10097 //
10098 // # DDoS Analysis Layer 7 QPS Trend Chart API
10099 //
10100 // @param request - DescribeDDoSL7QpsListRequest
10101 //
10102 // @param runtime - runtime options for this request RuntimeOptions
10103 //
10104 // @return DescribeDDoSL7QpsListResponse
10105 func DescribeDDoSL7QpsListWithOptions(client *Client, request *DescribeDDoSL7QpsListRequest, runtime *dara.RuntimeOptions) (_result *DescribeDDoSL7QpsListResponse, _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 := map[string]interface{}{}
10113 if !dara.IsNil(request.EndTime) {
10114 query["EndTime"] = request.EndTime
10115 }
10116
10117 if !dara.IsNil(request.Interval) {
10118 query["Interval"] = request.Interval
10119 }
10120
10121 if !dara.IsNil(request.RecordId) {
10122 query["RecordId"] = request.RecordId
10123 }
10124
10125 if !dara.IsNil(request.SiteId) {
10126 query["SiteId"] = request.SiteId
10127 }
10128
10129 if !dara.IsNil(request.StartTime) {
10130 query["StartTime"] = request.StartTime
10131 }
10132
10133 req := &openapiutil.OpenApiRequest{
10134 Query: openapiutil.Query(query),
10135 }
10136 params := &openapiutil.Params{
10137 Action: dara.String("DescribeDDoSL7QpsList"),
10138 Version: dara.String("2024-09-10"),
10139 Protocol: dara.String("HTTPS"),
10140 Pathname: dara.String("/"),
10141 Method: dara.String("POST"),
10142 AuthType: dara.String("AK"),
10143 Style: dara.String("RPC"),
10144 ReqBodyType: dara.String("formData"),
10145 BodyType: dara.String("json"),
10146 }
10147 _result = &DescribeDDoSL7QpsListResponse{}
10148 _body, _err := client.CallApi(params, req, runtime)
10149 if _err != nil {
10150 return _result, _err
10151 }
10152 _err = dara.Convert(_body, &_result)
10153 return _result, _err
10154 }
10155
10156 // Summary:
10157 //
10158 // # DDoS Analysis Layer 7 QPS Trend Chart API
10159 //
10160 // @param request - DescribeDDoSL7QpsListRequest
10161 //
10162 // @return DescribeDDoSL7QpsListResponse
10163 func DescribeDDoSL7QpsList(client *Client, request *DescribeDDoSL7QpsListRequest) (_result *DescribeDDoSL7QpsListResponse, _err error) {
10164 runtime := &dara.RuntimeOptions{}
10165 _result = &DescribeDDoSL7QpsListResponse{}
10166 _body, _err := DescribeDDoSL7QpsListWithOptions(client,request, runtime)
10167 if _err != nil {
10168 return _result, _err
10169 }
10170 _result = _body
10171 return _result, _err
10172 }
10173
10174 // Summary:
10175 //
10176 // Provides monitoring data for metrics of ESA edge containers.
10177 //
10178 // @param request - DescribeEdgeContainerAppStatsRequest
10179 //
10180 // @param runtime - runtime options for this request RuntimeOptions
10181 //
10182 // @return DescribeEdgeContainerAppStatsResponse
10183 func DescribeEdgeContainerAppStatsWithOptions(client *Client, request *DescribeEdgeContainerAppStatsRequest, runtime *dara.RuntimeOptions) (_result *DescribeEdgeContainerAppStatsResponse, _err error) {
10184 if dara.BoolValue(client.EnableValidate) == true {
10185 _err = request.Validate()
10186 if _err != nil {
10187 return _result, _err
10188 }
10189 }
10190 query := openapiutil.Query(dara.ToMap(request))
10191 req := &openapiutil.OpenApiRequest{
10192 Query: openapiutil.Query(query),
10193 }
10194 params := &openapiutil.Params{
10195 Action: dara.String("DescribeEdgeContainerAppStats"),
10196 Version: dara.String("2024-09-10"),
10197 Protocol: dara.String("HTTPS"),
10198 Pathname: dara.String("/"),
10199 Method: dara.String("GET"),
10200 AuthType: dara.String("AK"),
10201 Style: dara.String("RPC"),
10202 ReqBodyType: dara.String("formData"),
10203 BodyType: dara.String("json"),
10204 }
10205 _result = &DescribeEdgeContainerAppStatsResponse{}
10206 _body, _err := client.CallApi(params, req, runtime)
10207 if _err != nil {
10208 return _result, _err
10209 }
10210 _err = dara.Convert(_body, &_result)
10211 return _result, _err
10212 }
10213
10214 // Summary:
10215 //
10216 // Provides monitoring data for metrics of ESA edge containers.
10217 //
10218 // @param request - DescribeEdgeContainerAppStatsRequest
10219 //
10220 // @return DescribeEdgeContainerAppStatsResponse
10221 func DescribeEdgeContainerAppStats(client *Client, request *DescribeEdgeContainerAppStatsRequest) (_result *DescribeEdgeContainerAppStatsResponse, _err error) {
10222 runtime := &dara.RuntimeOptions{}
10223 _result = &DescribeEdgeContainerAppStatsResponse{}
10224 _body, _err := DescribeEdgeContainerAppStatsWithOptions(client,request, runtime)
10225 if _err != nil {
10226 return _result, _err
10227 }
10228 _result = _body
10229 return _result, _err
10230 }
10231
10232 // Summary:
10233 //
10234 // Queries the configuration of smart HTTP DDoS protection for a website.
10235 //
10236 // @param request - DescribeHttpDDoSAttackIntelligentProtectionRequest
10237 //
10238 // @param runtime - runtime options for this request RuntimeOptions
10239 //
10240 // @return DescribeHttpDDoSAttackIntelligentProtectionResponse
10241 func DescribeHttpDDoSAttackIntelligentProtectionWithOptions(client *Client, request *DescribeHttpDDoSAttackIntelligentProtectionRequest, runtime *dara.RuntimeOptions) (_result *DescribeHttpDDoSAttackIntelligentProtectionResponse, _err error) {
10242 if dara.BoolValue(client.EnableValidate) == true {
10243 _err = request.Validate()
10244 if _err != nil {
10245 return _result, _err
10246 }
10247 }
10248 query := map[string]interface{}{}
10249 if !dara.IsNil(request.SiteId) {
10250 query["SiteId"] = request.SiteId
10251 }
10252
10253 req := &openapiutil.OpenApiRequest{
10254 Query: openapiutil.Query(query),
10255 }
10256 params := &openapiutil.Params{
10257 Action: dara.String("DescribeHttpDDoSAttackIntelligentProtection"),
10258 Version: dara.String("2024-09-10"),
10259 Protocol: dara.String("HTTPS"),
10260 Pathname: dara.String("/"),
10261 Method: dara.String("POST"),
10262 AuthType: dara.String("AK"),
10263 Style: dara.String("RPC"),
10264 ReqBodyType: dara.String("formData"),
10265 BodyType: dara.String("json"),
10266 }
10267 _result = &DescribeHttpDDoSAttackIntelligentProtectionResponse{}
10268 _body, _err := client.CallApi(params, req, runtime)
10269 if _err != nil {
10270 return _result, _err
10271 }
10272 _err = dara.Convert(_body, &_result)
10273 return _result, _err
10274 }
10275
10276 // Summary:
10277 //
10278 // Queries the configuration of smart HTTP DDoS protection for a website.
10279 //
10280 // @param request - DescribeHttpDDoSAttackIntelligentProtectionRequest
10281 //
10282 // @return DescribeHttpDDoSAttackIntelligentProtectionResponse
10283 func DescribeHttpDDoSAttackIntelligentProtection(client *Client, request *DescribeHttpDDoSAttackIntelligentProtectionRequest) (_result *DescribeHttpDDoSAttackIntelligentProtectionResponse, _err error) {
10284 runtime := &dara.RuntimeOptions{}
10285 _result = &DescribeHttpDDoSAttackIntelligentProtectionResponse{}
10286 _body, _err := DescribeHttpDDoSAttackIntelligentProtectionWithOptions(client,request, runtime)
10287 if _err != nil {
10288 return _result, _err
10289 }
10290 _result = _body
10291 return _result, _err
10292 }
10293
10294 // Summary:
10295 //
10296 // Queries the configurations of HTTP DDoS attack protection.
10297 //
10298 // @param request - DescribeHttpDDoSAttackProtectionRequest
10299 //
10300 // @param runtime - runtime options for this request RuntimeOptions
10301 //
10302 // @return DescribeHttpDDoSAttackProtectionResponse
10303 func DescribeHttpDDoSAttackProtectionWithOptions(client *Client, request *DescribeHttpDDoSAttackProtectionRequest, runtime *dara.RuntimeOptions) (_result *DescribeHttpDDoSAttackProtectionResponse, _err error) {
10304 if dara.BoolValue(client.EnableValidate) == true {
10305 _err = request.Validate()
10306 if _err != nil {
10307 return _result, _err
10308 }
10309 }
10310 query := map[string]interface{}{}
10311 if !dara.IsNil(request.SiteId) {
10312 query["SiteId"] = request.SiteId
10313 }
10314
10315 req := &openapiutil.OpenApiRequest{
10316 Query: openapiutil.Query(query),
10317 }
10318 params := &openapiutil.Params{
10319 Action: dara.String("DescribeHttpDDoSAttackProtection"),
10320 Version: dara.String("2024-09-10"),
10321 Protocol: dara.String("HTTPS"),
10322 Pathname: dara.String("/"),
10323 Method: dara.String("POST"),
10324 AuthType: dara.String("AK"),
10325 Style: dara.String("RPC"),
10326 ReqBodyType: dara.String("formData"),
10327 BodyType: dara.String("json"),
10328 }
10329 _result = &DescribeHttpDDoSAttackProtectionResponse{}
10330 _body, _err := client.CallApi(params, req, runtime)
10331 if _err != nil {
10332 return _result, _err
10333 }
10334 _err = dara.Convert(_body, &_result)
10335 return _result, _err
10336 }
10337
10338 // Summary:
10339 //
10340 // Queries the configurations of HTTP DDoS attack protection.
10341 //
10342 // @param request - DescribeHttpDDoSAttackProtectionRequest
10343 //
10344 // @return DescribeHttpDDoSAttackProtectionResponse
10345 func DescribeHttpDDoSAttackProtection(client *Client, request *DescribeHttpDDoSAttackProtectionRequest) (_result *DescribeHttpDDoSAttackProtectionResponse, _err error) {
10346 runtime := &dara.RuntimeOptions{}
10347 _result = &DescribeHttpDDoSAttackProtectionResponse{}
10348 _body, _err := DescribeHttpDDoSAttackProtectionWithOptions(client,request, runtime)
10349 if _err != nil {
10350 return _result, _err
10351 }
10352 _result = _body
10353 return _result, _err
10354 }
10355
10356 // Summary:
10357 //
10358 // Queries whether Edge KV is activated in your Alibaba Cloud account.
10359 //
10360 // @param request - DescribeKvAccountStatusRequest
10361 //
10362 // @param runtime - runtime options for this request RuntimeOptions
10363 //
10364 // @return DescribeKvAccountStatusResponse
10365 func DescribeKvAccountStatusWithOptions(client *Client, runtime *dara.RuntimeOptions) (_result *DescribeKvAccountStatusResponse, _err error) {
10366 req := &openapiutil.OpenApiRequest{}
10367 params := &openapiutil.Params{
10368 Action: dara.String("DescribeKvAccountStatus"),
10369 Version: dara.String("2024-09-10"),
10370 Protocol: dara.String("HTTPS"),
10371 Pathname: dara.String("/"),
10372 Method: dara.String("GET"),
10373 AuthType: dara.String("AK"),
10374 Style: dara.String("RPC"),
10375 ReqBodyType: dara.String("formData"),
10376 BodyType: dara.String("json"),
10377 }
10378 _result = &DescribeKvAccountStatusResponse{}
10379 _body, _err := client.CallApi(params, req, runtime)
10380 if _err != nil {
10381 return _result, _err
10382 }
10383 _err = dara.Convert(_body, &_result)
10384 return _result, _err
10385 }
10386
10387 // Summary:
10388 //
10389 // Queries whether Edge KV is activated in your Alibaba Cloud account.
10390 //
10391 // @return DescribeKvAccountStatusResponse
10392 func DescribeKvAccountStatus(client *Client, ) (_result *DescribeKvAccountStatusResponse, _err error) {
10393 runtime := &dara.RuntimeOptions{}
10394 _result = &DescribeKvAccountStatusResponse{}
10395 _body, _err := DescribeKvAccountStatusWithOptions(client,runtime)
10396 if _err != nil {
10397 return _result, _err
10398 }
10399 _result = _body
10400 return _result, _err
10401 }
10402
10403 // Summary:
10404 //
10405 // Queries the details of prefetch tasks by time, task status, or prefetch URL.
10406 //
10407 // @param request - DescribePreloadTasksRequest
10408 //
10409 // @param runtime - runtime options for this request RuntimeOptions
10410 //
10411 // @return DescribePreloadTasksResponse
10412 func DescribePreloadTasksWithOptions(client *Client, request *DescribePreloadTasksRequest, runtime *dara.RuntimeOptions) (_result *DescribePreloadTasksResponse, _err error) {
10413 if dara.BoolValue(client.EnableValidate) == true {
10414 _err = request.Validate()
10415 if _err != nil {
10416 return _result, _err
10417 }
10418 }
10419 query := openapiutil.Query(dara.ToMap(request))
10420 req := &openapiutil.OpenApiRequest{
10421 Query: openapiutil.Query(query),
10422 }
10423 params := &openapiutil.Params{
10424 Action: dara.String("DescribePreloadTasks"),
10425 Version: dara.String("2024-09-10"),
10426 Protocol: dara.String("HTTPS"),
10427 Pathname: dara.String("/"),
10428 Method: dara.String("GET"),
10429 AuthType: dara.String("AK"),
10430 Style: dara.String("RPC"),
10431 ReqBodyType: dara.String("formData"),
10432 BodyType: dara.String("json"),
10433 }
10434 _result = &DescribePreloadTasksResponse{}
10435 _body, _err := client.CallApi(params, req, runtime)
10436 if _err != nil {
10437 return _result, _err
10438 }
10439 _err = dara.Convert(_body, &_result)
10440 return _result, _err
10441 }
10442
10443 // Summary:
10444 //
10445 // Queries the details of prefetch tasks by time, task status, or prefetch URL.
10446 //
10447 // @param request - DescribePreloadTasksRequest
10448 //
10449 // @return DescribePreloadTasksResponse
10450 func DescribePreloadTasks(client *Client, request *DescribePreloadTasksRequest) (_result *DescribePreloadTasksResponse, _err error) {
10451 runtime := &dara.RuntimeOptions{}
10452 _result = &DescribePreloadTasksResponse{}
10453 _body, _err := DescribePreloadTasksWithOptions(client,request, runtime)
10454 if _err != nil {
10455 return _result, _err
10456 }
10457 _result = _body
10458 return _result, _err
10459 }
10460
10461 // Summary:
10462 //
10463 // Queries the details of purge tasks.
10464 //
10465 // @param request - DescribePurgeTasksRequest
10466 //
10467 // @param runtime - runtime options for this request RuntimeOptions
10468 //
10469 // @return DescribePurgeTasksResponse
10470 func DescribePurgeTasksWithOptions(client *Client, request *DescribePurgeTasksRequest, runtime *dara.RuntimeOptions) (_result *DescribePurgeTasksResponse, _err error) {
10471 if dara.BoolValue(client.EnableValidate) == true {
10472 _err = request.Validate()
10473 if _err != nil {
10474 return _result, _err
10475 }
10476 }
10477 query := openapiutil.Query(dara.ToMap(request))
10478 req := &openapiutil.OpenApiRequest{
10479 Query: openapiutil.Query(query),
10480 }
10481 params := &openapiutil.Params{
10482 Action: dara.String("DescribePurgeTasks"),
10483 Version: dara.String("2024-09-10"),
10484 Protocol: dara.String("HTTPS"),
10485 Pathname: dara.String("/"),
10486 Method: dara.String("GET"),
10487 AuthType: dara.String("AK"),
10488 Style: dara.String("RPC"),
10489 ReqBodyType: dara.String("formData"),
10490 BodyType: dara.String("json"),
10491 }
10492 _result = &DescribePurgeTasksResponse{}
10493 _body, _err := client.CallApi(params, req, runtime)
10494 if _err != nil {
10495 return _result, _err
10496 }
10497 _err = dara.Convert(_body, &_result)
10498 return _result, _err
10499 }
10500
10501 // Summary:
10502 //
10503 // Queries the details of purge tasks.
10504 //
10505 // @param request - DescribePurgeTasksRequest
10506 //
10507 // @return DescribePurgeTasksResponse
10508 func DescribePurgeTasks(client *Client, request *DescribePurgeTasksRequest) (_result *DescribePurgeTasksResponse, _err error) {
10509 runtime := &dara.RuntimeOptions{}
10510 _result = &DescribePurgeTasksResponse{}
10511 _body, _err := DescribePurgeTasksWithOptions(client,request, runtime)
10512 if _err != nil {
10513 return _result, _err
10514 }
10515 _result = _body
10516 return _result, _err
10517 }
10518
10519 // Summary:
10520 //
10521 // Queries the status of an instance that uses a plan.
10522 //
10523 // Description:
10524 //
10525 // You can query the status of an instance after you purchase a plan for the instance.
10526 //
10527 // @param request - DescribeRatePlanInstanceStatusRequest
10528 //
10529 // @param runtime - runtime options for this request RuntimeOptions
10530 //
10531 // @return DescribeRatePlanInstanceStatusResponse
10532 func DescribeRatePlanInstanceStatusWithOptions(client *Client, request *DescribeRatePlanInstanceStatusRequest, runtime *dara.RuntimeOptions) (_result *DescribeRatePlanInstanceStatusResponse, _err error) {
10533 if dara.BoolValue(client.EnableValidate) == true {
10534 _err = request.Validate()
10535 if _err != nil {
10536 return _result, _err
10537 }
10538 }
10539 query := map[string]interface{}{}
10540 if !dara.IsNil(request.InstanceId) {
10541 query["InstanceId"] = request.InstanceId
10542 }
10543
10544 req := &openapiutil.OpenApiRequest{
10545 Query: openapiutil.Query(query),
10546 }
10547 params := &openapiutil.Params{
10548 Action: dara.String("DescribeRatePlanInstanceStatus"),
10549 Version: dara.String("2024-09-10"),
10550 Protocol: dara.String("HTTPS"),
10551 Pathname: dara.String("/"),
10552 Method: dara.String("POST"),
10553 AuthType: dara.String("AK"),
10554 Style: dara.String("RPC"),
10555 ReqBodyType: dara.String("formData"),
10556 BodyType: dara.String("json"),
10557 }
10558 _result = &DescribeRatePlanInstanceStatusResponse{}
10559 _body, _err := client.CallApi(params, req, runtime)
10560 if _err != nil {
10561 return _result, _err
10562 }
10563 _err = dara.Convert(_body, &_result)
10564 return _result, _err
10565 }
10566
10567 // Summary:
10568 //
10569 // Queries the status of an instance that uses a plan.
10570 //
10571 // Description:
10572 //
10573 // You can query the status of an instance after you purchase a plan for the instance.
10574 //
10575 // @param request - DescribeRatePlanInstanceStatusRequest
10576 //
10577 // @return DescribeRatePlanInstanceStatusResponse
10578 func DescribeRatePlanInstanceStatus(client *Client, request *DescribeRatePlanInstanceStatusRequest) (_result *DescribeRatePlanInstanceStatusResponse, _err error) {
10579 runtime := &dara.RuntimeOptions{}
10580 _result = &DescribeRatePlanInstanceStatusResponse{}
10581 _body, _err := DescribeRatePlanInstanceStatusWithOptions(client,request, runtime)
10582 if _err != nil {
10583 return _result, _err
10584 }
10585 _result = _body
10586 return _result, _err
10587 }
10588
10589 // Summary:
10590 //
10591 // Queries the URLs from which you can download the raw access logs of a website.
10592 //
10593 // Description:
10594 //
10595 // 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.
10596 //
10597 // - The log data is collected every hour.
10598 //
10599 // - You can call this operation up to 50 times per second per account.
10600 //
10601 // - You can query only logs in the last month. The time range cannot exceed 31 days.
10602 //
10603 // @param request - DescribeSiteLogsRequest
10604 //
10605 // @param runtime - runtime options for this request RuntimeOptions
10606 //
10607 // @return DescribeSiteLogsResponse
10608 func DescribeSiteLogsWithOptions(client *Client, request *DescribeSiteLogsRequest, runtime *dara.RuntimeOptions) (_result *DescribeSiteLogsResponse, _err error) {
10609 if dara.BoolValue(client.EnableValidate) == true {
10610 _err = request.Validate()
10611 if _err != nil {
10612 return _result, _err
10613 }
10614 }
10615 query := map[string]interface{}{}
10616 if !dara.IsNil(request.EndTime) {
10617 query["EndTime"] = request.EndTime
10618 }
10619
10620 if !dara.IsNil(request.PageNumber) {
10621 query["PageNumber"] = request.PageNumber
10622 }
10623
10624 if !dara.IsNil(request.PageSize) {
10625 query["PageSize"] = request.PageSize
10626 }
10627
10628 if !dara.IsNil(request.SiteId) {
10629 query["SiteId"] = request.SiteId
10630 }
10631
10632 if !dara.IsNil(request.StartTime) {
10633 query["StartTime"] = request.StartTime
10634 }
10635
10636 req := &openapiutil.OpenApiRequest{
10637 Query: openapiutil.Query(query),
10638 }
10639 params := &openapiutil.Params{
10640 Action: dara.String("DescribeSiteLogs"),
10641 Version: dara.String("2024-09-10"),
10642 Protocol: dara.String("HTTPS"),
10643 Pathname: dara.String("/"),
10644 Method: dara.String("POST"),
10645 AuthType: dara.String("AK"),
10646 Style: dara.String("RPC"),
10647 ReqBodyType: dara.String("formData"),
10648 BodyType: dara.String("json"),
10649 }
10650 _result = &DescribeSiteLogsResponse{}
10651 _body, _err := client.CallApi(params, req, runtime)
10652 if _err != nil {
10653 return _result, _err
10654 }
10655 _err = dara.Convert(_body, &_result)
10656 return _result, _err
10657 }
10658
10659 // Summary:
10660 //
10661 // Queries the URLs from which you can download the raw access logs of a website.
10662 //
10663 // Description:
10664 //
10665 // 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.
10666 //
10667 // - The log data is collected every hour.
10668 //
10669 // - You can call this operation up to 50 times per second per account.
10670 //
10671 // - You can query only logs in the last month. The time range cannot exceed 31 days.
10672 //
10673 // @param request - DescribeSiteLogsRequest
10674 //
10675 // @return DescribeSiteLogsResponse
10676 func DescribeSiteLogs(client *Client, request *DescribeSiteLogsRequest) (_result *DescribeSiteLogsResponse, _err error) {
10677 runtime := &dara.RuntimeOptions{}
10678 _result = &DescribeSiteLogsResponse{}
10679 _body, _err := DescribeSiteLogsWithOptions(client,request, runtime)
10680 if _err != nil {
10681 return _result, _err
10682 }
10683 _result = _body
10684 return _result, _err
10685 }
10686
10687 // Summary:
10688 //
10689 // # Query traffic analysis time series data
10690 //
10691 // Description:
10692 //
10693 // - 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.
10694 //
10695 // - The API returns different time granularities based on the span between `StartTime` and `EndTime`.
10696 //
10697 // - For a span of 3 hours or less, it returns 1-minute granularity data.
10698 //
10699 // - For a span greater than 3 hours but no more than 12 hours, it returns 5-minute granularity data.
10700 //
10701 // - For a span greater than 12 hours but no more than 1 day, it returns 15-minute granularity data.
10702 //
10703 // - For a span greater than 1 day but no more than 10 days, it returns hourly granularity data.
10704 //
10705 // - For a span greater than 10 days but no more than 31 days, it returns daily granularity data.
10706 //
10707 // - Due to the high number of accesses during the query period, the data analysis may be sampled.
10708 //
10709 // @param tmpReq - DescribeSiteTimeSeriesDataRequest
10710 //
10711 // @param runtime - runtime options for this request RuntimeOptions
10712 //
10713 // @return DescribeSiteTimeSeriesDataResponse
10714 func DescribeSiteTimeSeriesDataWithOptions(client *Client, tmpReq *DescribeSiteTimeSeriesDataRequest, runtime *dara.RuntimeOptions) (_result *DescribeSiteTimeSeriesDataResponse, _err error) {
10715 if dara.BoolValue(client.EnableValidate) == true {
10716 _err = tmpReq.Validate()
10717 if _err != nil {
10718 return _result, _err
10719 }
10720 }
10721 request := &DescribeSiteTimeSeriesDataShrinkRequest{}
10722 openapiutil.Convert(tmpReq, request)
10723 if !dara.IsNil(tmpReq.Fields) {
10724 request.FieldsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Fields, dara.String("Fields"), dara.String("json"))
10725 }
10726
10727 query := map[string]interface{}{}
10728 if !dara.IsNil(request.EndTime) {
10729 query["EndTime"] = request.EndTime
10730 }
10731
10732 if !dara.IsNil(request.FieldsShrink) {
10733 query["Fields"] = request.FieldsShrink
10734 }
10735
10736 if !dara.IsNil(request.Interval) {
10737 query["Interval"] = request.Interval
10738 }
10739
10740 if !dara.IsNil(request.SiteId) {
10741 query["SiteId"] = request.SiteId
10742 }
10743
10744 if !dara.IsNil(request.StartTime) {
10745 query["StartTime"] = request.StartTime
10746 }
10747
10748 req := &openapiutil.OpenApiRequest{
10749 Query: openapiutil.Query(query),
10750 }
10751 params := &openapiutil.Params{
10752 Action: dara.String("DescribeSiteTimeSeriesData"),
10753 Version: dara.String("2024-09-10"),
10754 Protocol: dara.String("HTTPS"),
10755 Pathname: dara.String("/"),
10756 Method: dara.String("POST"),
10757 AuthType: dara.String("AK"),
10758 Style: dara.String("RPC"),
10759 ReqBodyType: dara.String("formData"),
10760 BodyType: dara.String("json"),
10761 }
10762 _result = &DescribeSiteTimeSeriesDataResponse{}
10763 _body, _err := client.CallApi(params, req, runtime)
10764 if _err != nil {
10765 return _result, _err
10766 }
10767 _err = dara.Convert(_body, &_result)
10768 return _result, _err
10769 }
10770
10771 // Summary:
10772 //
10773 // # Query traffic analysis time series data
10774 //
10775 // Description:
10776 //
10777 // - 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.
10778 //
10779 // - The API returns different time granularities based on the span between `StartTime` and `EndTime`.
10780 //
10781 // - For a span of 3 hours or less, it returns 1-minute granularity data.
10782 //
10783 // - For a span greater than 3 hours but no more than 12 hours, it returns 5-minute granularity data.
10784 //
10785 // - For a span greater than 12 hours but no more than 1 day, it returns 15-minute granularity data.
10786 //
10787 // - For a span greater than 1 day but no more than 10 days, it returns hourly granularity data.
10788 //
10789 // - For a span greater than 10 days but no more than 31 days, it returns daily granularity data.
10790 //
10791 // - Due to the high number of accesses during the query period, the data analysis may be sampled.
10792 //
10793 // @param request - DescribeSiteTimeSeriesDataRequest
10794 //
10795 // @return DescribeSiteTimeSeriesDataResponse
10796 func DescribeSiteTimeSeriesData(client *Client, request *DescribeSiteTimeSeriesDataRequest) (_result *DescribeSiteTimeSeriesDataResponse, _err error) {
10797 runtime := &dara.RuntimeOptions{}
10798 _result = &DescribeSiteTimeSeriesDataResponse{}
10799 _body, _err := DescribeSiteTimeSeriesDataWithOptions(client,request, runtime)
10800 if _err != nil {
10801 return _result, _err
10802 }
10803 _result = _body
10804 return _result, _err
10805 }
10806
10807 // Summary:
10808 //
10809 // Queries the top-ranking records in a traffic analytics report by website or Alibaba Cloud account.
10810 //
10811 // Description:
10812 //
10813 // 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.
10814 //
10815 // @param tmpReq - DescribeSiteTopDataRequest
10816 //
10817 // @param runtime - runtime options for this request RuntimeOptions
10818 //
10819 // @return DescribeSiteTopDataResponse
10820 func DescribeSiteTopDataWithOptions(client *Client, tmpReq *DescribeSiteTopDataRequest, runtime *dara.RuntimeOptions) (_result *DescribeSiteTopDataResponse, _err error) {
10821 if dara.BoolValue(client.EnableValidate) == true {
10822 _err = tmpReq.Validate()
10823 if _err != nil {
10824 return _result, _err
10825 }
10826 }
10827 request := &DescribeSiteTopDataShrinkRequest{}
10828 openapiutil.Convert(tmpReq, request)
10829 if !dara.IsNil(tmpReq.Fields) {
10830 request.FieldsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Fields, dara.String("Fields"), dara.String("json"))
10831 }
10832
10833 query := map[string]interface{}{}
10834 if !dara.IsNil(request.EndTime) {
10835 query["EndTime"] = request.EndTime
10836 }
10837
10838 if !dara.IsNil(request.FieldsShrink) {
10839 query["Fields"] = request.FieldsShrink
10840 }
10841
10842 if !dara.IsNil(request.Interval) {
10843 query["Interval"] = request.Interval
10844 }
10845
10846 if !dara.IsNil(request.Limit) {
10847 query["Limit"] = request.Limit
10848 }
10849
10850 if !dara.IsNil(request.SiteId) {
10851 query["SiteId"] = request.SiteId
10852 }
10853
10854 if !dara.IsNil(request.StartTime) {
10855 query["StartTime"] = request.StartTime
10856 }
10857
10858 req := &openapiutil.OpenApiRequest{
10859 Query: openapiutil.Query(query),
10860 }
10861 params := &openapiutil.Params{
10862 Action: dara.String("DescribeSiteTopData"),
10863 Version: dara.String("2024-09-10"),
10864 Protocol: dara.String("HTTPS"),
10865 Pathname: dara.String("/"),
10866 Method: dara.String("POST"),
10867 AuthType: dara.String("AK"),
10868 Style: dara.String("RPC"),
10869 ReqBodyType: dara.String("formData"),
10870 BodyType: dara.String("json"),
10871 }
10872 _result = &DescribeSiteTopDataResponse{}
10873 _body, _err := client.CallApi(params, req, runtime)
10874 if _err != nil {
10875 return _result, _err
10876 }
10877 _err = dara.Convert(_body, &_result)
10878 return _result, _err
10879 }
10880
10881 // Summary:
10882 //
10883 // Queries the top-ranking records in a traffic analytics report by website or Alibaba Cloud account.
10884 //
10885 // Description:
10886 //
10887 // 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.
10888 //
10889 // @param request - DescribeSiteTopDataRequest
10890 //
10891 // @return DescribeSiteTopDataResponse
10892 func DescribeSiteTopData(client *Client, request *DescribeSiteTopDataRequest) (_result *DescribeSiteTopDataResponse, _err error) {
10893 runtime := &dara.RuntimeOptions{}
10894 _result = &DescribeSiteTopDataResponse{}
10895 _body, _err := DescribeSiteTopDataWithOptions(client,request, runtime)
10896 if _err != nil {
10897 return _result, _err
10898 }
10899 _result = _body
10900 return _result, _err
10901 }
10902
10903 // Summary:
10904 //
10905 // Queries the page monitoring data.
10906 //
10907 // Description:
10908 //
10909 // 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.
10910 //
10911 // @param request - DescribeUrlObservationDataRequest
10912 //
10913 // @param runtime - runtime options for this request RuntimeOptions
10914 //
10915 // @return DescribeUrlObservationDataResponse
10916 func DescribeUrlObservationDataWithOptions(client *Client, request *DescribeUrlObservationDataRequest, runtime *dara.RuntimeOptions) (_result *DescribeUrlObservationDataResponse, _err error) {
10917 if dara.BoolValue(client.EnableValidate) == true {
10918 _err = request.Validate()
10919 if _err != nil {
10920 return _result, _err
10921 }
10922 }
10923 query := map[string]interface{}{}
10924 if !dara.IsNil(request.ClientPlatform) {
10925 query["ClientPlatform"] = request.ClientPlatform
10926 }
10927
10928 if !dara.IsNil(request.EndTime) {
10929 query["EndTime"] = request.EndTime
10930 }
10931
10932 if !dara.IsNil(request.Metric) {
10933 query["Metric"] = request.Metric
10934 }
10935
10936 if !dara.IsNil(request.SiteId) {
10937 query["SiteId"] = request.SiteId
10938 }
10939
10940 if !dara.IsNil(request.StartTime) {
10941 query["StartTime"] = request.StartTime
10942 }
10943
10944 if !dara.IsNil(request.Url) {
10945 query["Url"] = request.Url
10946 }
10947
10948 req := &openapiutil.OpenApiRequest{
10949 Query: openapiutil.Query(query),
10950 }
10951 params := &openapiutil.Params{
10952 Action: dara.String("DescribeUrlObservationData"),
10953 Version: dara.String("2024-09-10"),
10954 Protocol: dara.String("HTTPS"),
10955 Pathname: dara.String("/"),
10956 Method: dara.String("POST"),
10957 AuthType: dara.String("AK"),
10958 Style: dara.String("RPC"),
10959 ReqBodyType: dara.String("formData"),
10960 BodyType: dara.String("json"),
10961 }
10962 _result = &DescribeUrlObservationDataResponse{}
10963 _body, _err := client.CallApi(params, req, runtime)
10964 if _err != nil {
10965 return _result, _err
10966 }
10967 _err = dara.Convert(_body, &_result)
10968 return _result, _err
10969 }
10970
10971 // Summary:
10972 //
10973 // Queries the page monitoring data.
10974 //
10975 // Description:
10976 //
10977 // 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.
10978 //
10979 // @param request - DescribeUrlObservationDataRequest
10980 //
10981 // @return DescribeUrlObservationDataResponse
10982 func DescribeUrlObservationData(client *Client, request *DescribeUrlObservationDataRequest) (_result *DescribeUrlObservationDataResponse, _err error) {
10983 runtime := &dara.RuntimeOptions{}
10984 _result = &DescribeUrlObservationDataResponse{}
10985 _body, _err := DescribeUrlObservationDataWithOptions(client,request, runtime)
10986 if _err != nil {
10987 return _result, _err
10988 }
10989 _result = _body
10990 return _result, _err
10991 }
10992
10993 // Summary:
10994 //
10995 // Disables a scenario-specific policy.
10996 //
10997 // @param request - DisableCustomScenePolicyRequest
10998 //
10999 // @param runtime - runtime options for this request RuntimeOptions
11000 //
11001 // @return DisableCustomScenePolicyResponse
11002 func DisableCustomScenePolicyWithOptions(client *Client, request *DisableCustomScenePolicyRequest, runtime *dara.RuntimeOptions) (_result *DisableCustomScenePolicyResponse, _err error) {
11003 if dara.BoolValue(client.EnableValidate) == true {
11004 _err = request.Validate()
11005 if _err != nil {
11006 return _result, _err
11007 }
11008 }
11009 query := map[string]interface{}{}
11010 if !dara.IsNil(request.PolicyId) {
11011 query["PolicyId"] = request.PolicyId
11012 }
11013
11014 req := &openapiutil.OpenApiRequest{
11015 Query: openapiutil.Query(query),
11016 }
11017 params := &openapiutil.Params{
11018 Action: dara.String("DisableCustomScenePolicy"),
11019 Version: dara.String("2024-09-10"),
11020 Protocol: dara.String("HTTPS"),
11021 Pathname: dara.String("/"),
11022 Method: dara.String("POST"),
11023 AuthType: dara.String("AK"),
11024 Style: dara.String("RPC"),
11025 ReqBodyType: dara.String("formData"),
11026 BodyType: dara.String("json"),
11027 }
11028 _result = &DisableCustomScenePolicyResponse{}
11029 _body, _err := client.CallApi(params, req, runtime)
11030 if _err != nil {
11031 return _result, _err
11032 }
11033 _err = dara.Convert(_body, &_result)
11034 return _result, _err
11035 }
11036
11037 // Summary:
11038 //
11039 // Disables a scenario-specific policy.
11040 //
11041 // @param request - DisableCustomScenePolicyRequest
11042 //
11043 // @return DisableCustomScenePolicyResponse
11044 func DisableCustomScenePolicy(client *Client, request *DisableCustomScenePolicyRequest) (_result *DisableCustomScenePolicyResponse, _err error) {
11045 runtime := &dara.RuntimeOptions{}
11046 _result = &DisableCustomScenePolicyResponse{}
11047 _body, _err := DisableCustomScenePolicyWithOptions(client,request, runtime)
11048 if _err != nil {
11049 return _result, _err
11050 }
11051 _result = _body
11052 return _result, _err
11053 }
11054
11055 // Summary:
11056 //
11057 // # Edit WAF Configuration for a Site
11058 //
11059 // @param tmpReq - EditSiteWafSettingsRequest
11060 //
11061 // @param runtime - runtime options for this request RuntimeOptions
11062 //
11063 // @return EditSiteWafSettingsResponse
11064 func EditSiteWafSettingsWithOptions(client *Client, tmpReq *EditSiteWafSettingsRequest, runtime *dara.RuntimeOptions) (_result *EditSiteWafSettingsResponse, _err error) {
11065 if dara.BoolValue(client.EnableValidate) == true {
11066 _err = tmpReq.Validate()
11067 if _err != nil {
11068 return _result, _err
11069 }
11070 }
11071 request := &EditSiteWafSettingsShrinkRequest{}
11072 openapiutil.Convert(tmpReq, request)
11073 if !dara.IsNil(tmpReq.Settings) {
11074 request.SettingsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Settings, dara.String("Settings"), dara.String("json"))
11075 }
11076
11077 query := map[string]interface{}{}
11078 if !dara.IsNil(request.SiteId) {
11079 query["SiteId"] = request.SiteId
11080 }
11081
11082 if !dara.IsNil(request.SiteVersion) {
11083 query["SiteVersion"] = request.SiteVersion
11084 }
11085
11086 body := map[string]interface{}{}
11087 if !dara.IsNil(request.SettingsShrink) {
11088 body["Settings"] = request.SettingsShrink
11089 }
11090
11091 req := &openapiutil.OpenApiRequest{
11092 Query: openapiutil.Query(query),
11093 Body: openapiutil.ParseToMap(body),
11094 }
11095 params := &openapiutil.Params{
11096 Action: dara.String("EditSiteWafSettings"),
11097 Version: dara.String("2024-09-10"),
11098 Protocol: dara.String("HTTPS"),
11099 Pathname: dara.String("/"),
11100 Method: dara.String("POST"),
11101 AuthType: dara.String("AK"),
11102 Style: dara.String("RPC"),
11103 ReqBodyType: dara.String("formData"),
11104 BodyType: dara.String("json"),
11105 }
11106 _result = &EditSiteWafSettingsResponse{}
11107 _body, _err := client.CallApi(params, req, runtime)
11108 if _err != nil {
11109 return _result, _err
11110 }
11111 _err = dara.Convert(_body, &_result)
11112 return _result, _err
11113 }
11114
11115 // Summary:
11116 //
11117 // # Edit WAF Configuration for a Site
11118 //
11119 // @param request - EditSiteWafSettingsRequest
11120 //
11121 // @return EditSiteWafSettingsResponse
11122 func EditSiteWafSettings(client *Client, request *EditSiteWafSettingsRequest) (_result *EditSiteWafSettingsResponse, _err error) {
11123 runtime := &dara.RuntimeOptions{}
11124 _result = &EditSiteWafSettingsResponse{}
11125 _body, _err := EditSiteWafSettingsWithOptions(client,request, runtime)
11126 if _err != nil {
11127 return _result, _err
11128 }
11129 _result = _body
11130 return _result, _err
11131 }
11132
11133 // Summary:
11134 //
11135 // Enables a scenario-specific policy.
11136 //
11137 // @param request - EnableCustomScenePolicyRequest
11138 //
11139 // @param runtime - runtime options for this request RuntimeOptions
11140 //
11141 // @return EnableCustomScenePolicyResponse
11142 func EnableCustomScenePolicyWithOptions(client *Client, request *EnableCustomScenePolicyRequest, runtime *dara.RuntimeOptions) (_result *EnableCustomScenePolicyResponse, _err error) {
11143 if dara.BoolValue(client.EnableValidate) == true {
11144 _err = request.Validate()
11145 if _err != nil {
11146 return _result, _err
11147 }
11148 }
11149 query := map[string]interface{}{}
11150 if !dara.IsNil(request.PolicyId) {
11151 query["PolicyId"] = request.PolicyId
11152 }
11153
11154 req := &openapiutil.OpenApiRequest{
11155 Query: openapiutil.Query(query),
11156 }
11157 params := &openapiutil.Params{
11158 Action: dara.String("EnableCustomScenePolicy"),
11159 Version: dara.String("2024-09-10"),
11160 Protocol: dara.String("HTTPS"),
11161 Pathname: dara.String("/"),
11162 Method: dara.String("POST"),
11163 AuthType: dara.String("AK"),
11164 Style: dara.String("RPC"),
11165 ReqBodyType: dara.String("formData"),
11166 BodyType: dara.String("json"),
11167 }
11168 _result = &EnableCustomScenePolicyResponse{}
11169 _body, _err := client.CallApi(params, req, runtime)
11170 if _err != nil {
11171 return _result, _err
11172 }
11173 _err = dara.Convert(_body, &_result)
11174 return _result, _err
11175 }
11176
11177 // Summary:
11178 //
11179 // Enables a scenario-specific policy.
11180 //
11181 // @param request - EnableCustomScenePolicyRequest
11182 //
11183 // @return EnableCustomScenePolicyResponse
11184 func EnableCustomScenePolicy(client *Client, request *EnableCustomScenePolicyRequest) (_result *EnableCustomScenePolicyResponse, _err error) {
11185 runtime := &dara.RuntimeOptions{}
11186 _result = &EnableCustomScenePolicyResponse{}
11187 _body, _err := EnableCustomScenePolicyWithOptions(client,request, runtime)
11188 if _err != nil {
11189 return _result, _err
11190 }
11191 _result = _body
11192 return _result, _err
11193 }
11194
11195 // Summary:
11196 //
11197 // Exports all DNS records of a website domain as a TXT file.
11198 //
11199 // @param request - ExportRecordsRequest
11200 //
11201 // @param runtime - runtime options for this request RuntimeOptions
11202 //
11203 // @return ExportRecordsResponse
11204 func ExportRecordsWithOptions(client *Client, request *ExportRecordsRequest, runtime *dara.RuntimeOptions) (_result *ExportRecordsResponse, _err error) {
11205 if dara.BoolValue(client.EnableValidate) == true {
11206 _err = request.Validate()
11207 if _err != nil {
11208 return _result, _err
11209 }
11210 }
11211 query := openapiutil.Query(dara.ToMap(request))
11212 req := &openapiutil.OpenApiRequest{
11213 Query: openapiutil.Query(query),
11214 }
11215 params := &openapiutil.Params{
11216 Action: dara.String("ExportRecords"),
11217 Version: dara.String("2024-09-10"),
11218 Protocol: dara.String("HTTPS"),
11219 Pathname: dara.String("/"),
11220 Method: dara.String("GET"),
11221 AuthType: dara.String("AK"),
11222 Style: dara.String("RPC"),
11223 ReqBodyType: dara.String("formData"),
11224 BodyType: dara.String("json"),
11225 }
11226 _result = &ExportRecordsResponse{}
11227 _body, _err := client.CallApi(params, req, runtime)
11228 if _err != nil {
11229 return _result, _err
11230 }
11231 _err = dara.Convert(_body, &_result)
11232 return _result, _err
11233 }
11234
11235 // Summary:
11236 //
11237 // Exports all DNS records of a website domain as a TXT file.
11238 //
11239 // @param request - ExportRecordsRequest
11240 //
11241 // @return ExportRecordsResponse
11242 func ExportRecords(client *Client, request *ExportRecordsRequest) (_result *ExportRecordsResponse, _err error) {
11243 runtime := &dara.RuntimeOptions{}
11244 _result = &ExportRecordsResponse{}
11245 _body, _err := ExportRecordsWithOptions(client,request, runtime)
11246 if _err != nil {
11247 return _result, _err
11248 }
11249 _result = _body
11250 return _result, _err
11251 }
11252
11253 // Summary:
11254 //
11255 // Queries the usage of the upload file quota for API security schema verification.
11256 //
11257 // @param request - GetApiSchemaUsageRequest
11258 //
11259 // @param runtime - runtime options for this request RuntimeOptions
11260 //
11261 // @return GetApiSchemaUsageResponse
11262 func GetApiSchemaUsageWithOptions(client *Client, request *GetApiSchemaUsageRequest, runtime *dara.RuntimeOptions) (_result *GetApiSchemaUsageResponse, _err error) {
11263 if dara.BoolValue(client.EnableValidate) == true {
11264 _err = request.Validate()
11265 if _err != nil {
11266 return _result, _err
11267 }
11268 }
11269 query := map[string]interface{}{}
11270 if !dara.IsNil(request.SiteId) {
11271 query["SiteId"] = request.SiteId
11272 }
11273
11274 if !dara.IsNil(request.SiteVersion) {
11275 query["SiteVersion"] = request.SiteVersion
11276 }
11277
11278 req := &openapiutil.OpenApiRequest{
11279 Query: openapiutil.Query(query),
11280 }
11281 params := &openapiutil.Params{
11282 Action: dara.String("GetApiSchemaUsage"),
11283 Version: dara.String("2024-09-10"),
11284 Protocol: dara.String("HTTPS"),
11285 Pathname: dara.String("/"),
11286 Method: dara.String("POST"),
11287 AuthType: dara.String("AK"),
11288 Style: dara.String("RPC"),
11289 ReqBodyType: dara.String("formData"),
11290 BodyType: dara.String("json"),
11291 }
11292 _result = &GetApiSchemaUsageResponse{}
11293 _body, _err := client.CallApi(params, req, runtime)
11294 if _err != nil {
11295 return _result, _err
11296 }
11297 _err = dara.Convert(_body, &_result)
11298 return _result, _err
11299 }
11300
11301 // Summary:
11302 //
11303 // Queries the usage of the upload file quota for API security schema verification.
11304 //
11305 // @param request - GetApiSchemaUsageRequest
11306 //
11307 // @return GetApiSchemaUsageResponse
11308 func GetApiSchemaUsage(client *Client, request *GetApiSchemaUsageRequest) (_result *GetApiSchemaUsageResponse, _err error) {
11309 runtime := &dara.RuntimeOptions{}
11310 _result = &GetApiSchemaUsageResponse{}
11311 _body, _err := GetApiSchemaUsageWithOptions(client,request, runtime)
11312 if _err != nil {
11313 return _result, _err
11314 }
11315 _result = _body
11316 return _result, _err
11317 }
11318
11319 // Summary:
11320 //
11321 // Queries the available specifications of cache reserve instances.
11322 //
11323 // @param request - GetCacheReserveSpecificationRequest
11324 //
11325 // @param runtime - runtime options for this request RuntimeOptions
11326 //
11327 // @return GetCacheReserveSpecificationResponse
11328 func GetCacheReserveSpecificationWithOptions(client *Client, runtime *dara.RuntimeOptions) (_result *GetCacheReserveSpecificationResponse, _err error) {
11329 req := &openapiutil.OpenApiRequest{}
11330 params := &openapiutil.Params{
11331 Action: dara.String("GetCacheReserveSpecification"),
11332 Version: dara.String("2024-09-10"),
11333 Protocol: dara.String("HTTPS"),
11334 Pathname: dara.String("/"),
11335 Method: dara.String("GET"),
11336 AuthType: dara.String("AK"),
11337 Style: dara.String("RPC"),
11338 ReqBodyType: dara.String("formData"),
11339 BodyType: dara.String("json"),
11340 }
11341 _result = &GetCacheReserveSpecificationResponse{}
11342 _body, _err := client.CallApi(params, req, runtime)
11343 if _err != nil {
11344 return _result, _err
11345 }
11346 _err = dara.Convert(_body, &_result)
11347 return _result, _err
11348 }
11349
11350 // Summary:
11351 //
11352 // Queries the available specifications of cache reserve instances.
11353 //
11354 // @return GetCacheReserveSpecificationResponse
11355 func GetCacheReserveSpecification(client *Client, ) (_result *GetCacheReserveSpecificationResponse, _err error) {
11356 runtime := &dara.RuntimeOptions{}
11357 _result = &GetCacheReserveSpecificationResponse{}
11358 _body, _err := GetCacheReserveSpecificationWithOptions(client,runtime)
11359 if _err != nil {
11360 return _result, _err
11361 }
11362 _result = _body
11363 return _result, _err
11364 }
11365
11366 // Summary:
11367 //
11368 // # Query a single cache configuration
11369 //
11370 // @param request - GetCacheRuleRequest
11371 //
11372 // @param runtime - runtime options for this request RuntimeOptions
11373 //
11374 // @return GetCacheRuleResponse
11375 func GetCacheRuleWithOptions(client *Client, request *GetCacheRuleRequest, runtime *dara.RuntimeOptions) (_result *GetCacheRuleResponse, _err error) {
11376 if dara.BoolValue(client.EnableValidate) == true {
11377 _err = request.Validate()
11378 if _err != nil {
11379 return _result, _err
11380 }
11381 }
11382 query := openapiutil.Query(dara.ToMap(request))
11383 req := &openapiutil.OpenApiRequest{
11384 Query: openapiutil.Query(query),
11385 }
11386 params := &openapiutil.Params{
11387 Action: dara.String("GetCacheRule"),
11388 Version: dara.String("2024-09-10"),
11389 Protocol: dara.String("HTTPS"),
11390 Pathname: dara.String("/"),
11391 Method: dara.String("GET"),
11392 AuthType: dara.String("AK"),
11393 Style: dara.String("RPC"),
11394 ReqBodyType: dara.String("formData"),
11395 BodyType: dara.String("json"),
11396 }
11397 _result = &GetCacheRuleResponse{}
11398 _body, _err := client.CallApi(params, req, runtime)
11399 if _err != nil {
11400 return _result, _err
11401 }
11402 _err = dara.Convert(_body, &_result)
11403 return _result, _err
11404 }
11405
11406 // Summary:
11407 //
11408 // # Query a single cache configuration
11409 //
11410 // @param request - GetCacheRuleRequest
11411 //
11412 // @return GetCacheRuleResponse
11413 func GetCacheRule(client *Client, request *GetCacheRuleRequest) (_result *GetCacheRuleResponse, _err error) {
11414 runtime := &dara.RuntimeOptions{}
11415 _result = &GetCacheRuleResponse{}
11416 _body, _err := GetCacheRuleWithOptions(client,request, runtime)
11417 if _err != nil {
11418 return _result, _err
11419 }
11420 _result = _body
11421 return _result, _err
11422 }
11423
11424 // Summary:
11425 //
11426 // # Query Site Cache Tag Configuration
11427 //
11428 // @param request - GetCacheTagRequest
11429 //
11430 // @param runtime - runtime options for this request RuntimeOptions
11431 //
11432 // @return GetCacheTagResponse
11433 func GetCacheTagWithOptions(client *Client, request *GetCacheTagRequest, runtime *dara.RuntimeOptions) (_result *GetCacheTagResponse, _err error) {
11434 if dara.BoolValue(client.EnableValidate) == true {
11435 _err = request.Validate()
11436 if _err != nil {
11437 return _result, _err
11438 }
11439 }
11440 query := openapiutil.Query(dara.ToMap(request))
11441 req := &openapiutil.OpenApiRequest{
11442 Query: openapiutil.Query(query),
11443 }
11444 params := &openapiutil.Params{
11445 Action: dara.String("GetCacheTag"),
11446 Version: dara.String("2024-09-10"),
11447 Protocol: dara.String("HTTPS"),
11448 Pathname: dara.String("/"),
11449 Method: dara.String("GET"),
11450 AuthType: dara.String("AK"),
11451 Style: dara.String("RPC"),
11452 ReqBodyType: dara.String("formData"),
11453 BodyType: dara.String("json"),
11454 }
11455 _result = &GetCacheTagResponse{}
11456 _body, _err := client.CallApi(params, req, runtime)
11457 if _err != nil {
11458 return _result, _err
11459 }
11460 _err = dara.Convert(_body, &_result)
11461 return _result, _err
11462 }
11463
11464 // Summary:
11465 //
11466 // # Query Site Cache Tag Configuration
11467 //
11468 // @param request - GetCacheTagRequest
11469 //
11470 // @return GetCacheTagResponse
11471 func GetCacheTag(client *Client, request *GetCacheTagRequest) (_result *GetCacheTagResponse, _err error) {
11472 runtime := &dara.RuntimeOptions{}
11473 _result = &GetCacheTagResponse{}
11474 _body, _err := GetCacheTagWithOptions(client,request, runtime)
11475 if _err != nil {
11476 return _result, _err
11477 }
11478 _result = _body
11479 return _result, _err
11480 }
11481
11482 // Summary:
11483 //
11484 // # Retrieve the certificate, private key, and certificate information
11485 //
11486 // @param request - GetCertificateRequest
11487 //
11488 // @param runtime - runtime options for this request RuntimeOptions
11489 //
11490 // @return GetCertificateResponse
11491 func GetCertificateWithOptions(client *Client, request *GetCertificateRequest, runtime *dara.RuntimeOptions) (_result *GetCertificateResponse, _err error) {
11492 if dara.BoolValue(client.EnableValidate) == true {
11493 _err = request.Validate()
11494 if _err != nil {
11495 return _result, _err
11496 }
11497 }
11498 query := openapiutil.Query(dara.ToMap(request))
11499 req := &openapiutil.OpenApiRequest{
11500 Query: openapiutil.Query(query),
11501 }
11502 params := &openapiutil.Params{
11503 Action: dara.String("GetCertificate"),
11504 Version: dara.String("2024-09-10"),
11505 Protocol: dara.String("HTTPS"),
11506 Pathname: dara.String("/"),
11507 Method: dara.String("GET"),
11508 AuthType: dara.String("AK"),
11509 Style: dara.String("RPC"),
11510 ReqBodyType: dara.String("formData"),
11511 BodyType: dara.String("json"),
11512 }
11513 _result = &GetCertificateResponse{}
11514 _body, _err := client.CallApi(params, req, runtime)
11515 if _err != nil {
11516 return _result, _err
11517 }
11518 _err = dara.Convert(_body, &_result)
11519 return _result, _err
11520 }
11521
11522 // Summary:
11523 //
11524 // # Retrieve the certificate, private key, and certificate information
11525 //
11526 // @param request - GetCertificateRequest
11527 //
11528 // @return GetCertificateResponse
11529 func GetCertificate(client *Client, request *GetCertificateRequest) (_result *GetCertificateResponse, _err error) {
11530 runtime := &dara.RuntimeOptions{}
11531 _result = &GetCertificateResponse{}
11532 _body, _err := GetCertificateWithOptions(client,request, runtime)
11533 if _err != nil {
11534 return _result, _err
11535 }
11536 _result = _body
11537 return _result, _err
11538 }
11539
11540 // Summary:
11541 //
11542 // # Query certificate quota and usage
11543 //
11544 // @param request - GetCertificateQuotaRequest
11545 //
11546 // @param runtime - runtime options for this request RuntimeOptions
11547 //
11548 // @return GetCertificateQuotaResponse
11549 func GetCertificateQuotaWithOptions(client *Client, request *GetCertificateQuotaRequest, runtime *dara.RuntimeOptions) (_result *GetCertificateQuotaResponse, _err error) {
11550 if dara.BoolValue(client.EnableValidate) == true {
11551 _err = request.Validate()
11552 if _err != nil {
11553 return _result, _err
11554 }
11555 }
11556 query := openapiutil.Query(dara.ToMap(request))
11557 req := &openapiutil.OpenApiRequest{
11558 Query: openapiutil.Query(query),
11559 }
11560 params := &openapiutil.Params{
11561 Action: dara.String("GetCertificateQuota"),
11562 Version: dara.String("2024-09-10"),
11563 Protocol: dara.String("HTTPS"),
11564 Pathname: dara.String("/"),
11565 Method: dara.String("GET"),
11566 AuthType: dara.String("AK"),
11567 Style: dara.String("RPC"),
11568 ReqBodyType: dara.String("formData"),
11569 BodyType: dara.String("json"),
11570 }
11571 _result = &GetCertificateQuotaResponse{}
11572 _body, _err := client.CallApi(params, req, runtime)
11573 if _err != nil {
11574 return _result, _err
11575 }
11576 _err = dara.Convert(_body, &_result)
11577 return _result, _err
11578 }
11579
11580 // Summary:
11581 //
11582 // # Query certificate quota and usage
11583 //
11584 // @param request - GetCertificateQuotaRequest
11585 //
11586 // @return GetCertificateQuotaResponse
11587 func GetCertificateQuota(client *Client, request *GetCertificateQuotaRequest) (_result *GetCertificateQuotaResponse, _err error) {
11588 runtime := &dara.RuntimeOptions{}
11589 _result = &GetCertificateQuotaResponse{}
11590 _body, _err := GetCertificateQuotaWithOptions(client,request, runtime)
11591 if _err != nil {
11592 return _result, _err
11593 }
11594 _result = _body
11595 return _result, _err
11596 }
11597
11598 // Summary:
11599 //
11600 // Queries a client CA certificate.
11601 //
11602 // @param request - GetClientCaCertificateRequest
11603 //
11604 // @param runtime - runtime options for this request RuntimeOptions
11605 //
11606 // @return GetClientCaCertificateResponse
11607 func GetClientCaCertificateWithOptions(client *Client, request *GetClientCaCertificateRequest, runtime *dara.RuntimeOptions) (_result *GetClientCaCertificateResponse, _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("GetClientCaCertificate"),
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 = &GetClientCaCertificateResponse{}
11630 _body, _err := client.CallApi(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 a client CA certificate.
11641 //
11642 // @param request - GetClientCaCertificateRequest
11643 //
11644 // @return GetClientCaCertificateResponse
11645 func GetClientCaCertificate(client *Client, request *GetClientCaCertificateRequest) (_result *GetClientCaCertificateResponse, _err error) {
11646 runtime := &dara.RuntimeOptions{}
11647 _result = &GetClientCaCertificateResponse{}
11648 _body, _err := GetClientCaCertificateWithOptions(client,request, runtime)
11649 if _err != nil {
11650 return _result, _err
11651 }
11652 _result = _body
11653 return _result, _err
11654 }
11655
11656 // Summary:
11657 //
11658 // Queries information about a client certificate.
11659 //
11660 // @param request - GetClientCertificateRequest
11661 //
11662 // @param runtime - runtime options for this request RuntimeOptions
11663 //
11664 // @return GetClientCertificateResponse
11665 func GetClientCertificateWithOptions(client *Client, request *GetClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *GetClientCertificateResponse, _err error) {
11666 if dara.BoolValue(client.EnableValidate) == true {
11667 _err = request.Validate()
11668 if _err != nil {
11669 return _result, _err
11670 }
11671 }
11672 query := openapiutil.Query(dara.ToMap(request))
11673 req := &openapiutil.OpenApiRequest{
11674 Query: openapiutil.Query(query),
11675 }
11676 params := &openapiutil.Params{
11677 Action: dara.String("GetClientCertificate"),
11678 Version: dara.String("2024-09-10"),
11679 Protocol: dara.String("HTTPS"),
11680 Pathname: dara.String("/"),
11681 Method: dara.String("GET"),
11682 AuthType: dara.String("AK"),
11683 Style: dara.String("RPC"),
11684 ReqBodyType: dara.String("formData"),
11685 BodyType: dara.String("json"),
11686 }
11687 _result = &GetClientCertificateResponse{}
11688 _body, _err := client.CallApi(params, req, runtime)
11689 if _err != nil {
11690 return _result, _err
11691 }
11692 _err = dara.Convert(_body, &_result)
11693 return _result, _err
11694 }
11695
11696 // Summary:
11697 //
11698 // Queries information about a client certificate.
11699 //
11700 // @param request - GetClientCertificateRequest
11701 //
11702 // @return GetClientCertificateResponse
11703 func GetClientCertificate(client *Client, request *GetClientCertificateRequest) (_result *GetClientCertificateResponse, _err error) {
11704 runtime := &dara.RuntimeOptions{}
11705 _result = &GetClientCertificateResponse{}
11706 _body, _err := GetClientCertificateWithOptions(client,request, runtime)
11707 if _err != nil {
11708 return _result, _err
11709 }
11710 _result = _body
11711 return _result, _err
11712 }
11713
11714 // Summary:
11715 //
11716 // 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.
11717 //
11718 // @param request - GetClientCertificateHostnamesRequest
11719 //
11720 // @param runtime - runtime options for this request RuntimeOptions
11721 //
11722 // @return GetClientCertificateHostnamesResponse
11723 func GetClientCertificateHostnamesWithOptions(client *Client, request *GetClientCertificateHostnamesRequest, runtime *dara.RuntimeOptions) (_result *GetClientCertificateHostnamesResponse, _err error) {
11724 if dara.BoolValue(client.EnableValidate) == true {
11725 _err = request.Validate()
11726 if _err != nil {
11727 return _result, _err
11728 }
11729 }
11730 query := openapiutil.Query(dara.ToMap(request))
11731 req := &openapiutil.OpenApiRequest{
11732 Query: openapiutil.Query(query),
11733 }
11734 params := &openapiutil.Params{
11735 Action: dara.String("GetClientCertificateHostnames"),
11736 Version: dara.String("2024-09-10"),
11737 Protocol: dara.String("HTTPS"),
11738 Pathname: dara.String("/"),
11739 Method: dara.String("GET"),
11740 AuthType: dara.String("AK"),
11741 Style: dara.String("RPC"),
11742 ReqBodyType: dara.String("formData"),
11743 BodyType: dara.String("json"),
11744 }
11745 _result = &GetClientCertificateHostnamesResponse{}
11746 _body, _err := client.CallApi(params, req, runtime)
11747 if _err != nil {
11748 return _result, _err
11749 }
11750 _err = dara.Convert(_body, &_result)
11751 return _result, _err
11752 }
11753
11754 // Summary:
11755 //
11756 // 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.
11757 //
11758 // @param request - GetClientCertificateHostnamesRequest
11759 //
11760 // @return GetClientCertificateHostnamesResponse
11761 func GetClientCertificateHostnames(client *Client, request *GetClientCertificateHostnamesRequest) (_result *GetClientCertificateHostnamesResponse, _err error) {
11762 runtime := &dara.RuntimeOptions{}
11763 _result = &GetClientCertificateHostnamesResponse{}
11764 _body, _err := GetClientCertificateHostnamesWithOptions(client,request, runtime)
11765 if _err != nil {
11766 return _result, _err
11767 }
11768 _result = _body
11769 return _result, _err
11770 }
11771
11772 // Summary:
11773 //
11774 // # Queries the CNAME flattening configuration of a website
11775 //
11776 // @param request - GetCnameFlatteningRequest
11777 //
11778 // @param runtime - runtime options for this request RuntimeOptions
11779 //
11780 // @return GetCnameFlatteningResponse
11781 func GetCnameFlatteningWithOptions(client *Client, request *GetCnameFlatteningRequest, runtime *dara.RuntimeOptions) (_result *GetCnameFlatteningResponse, _err error) {
11782 if dara.BoolValue(client.EnableValidate) == true {
11783 _err = request.Validate()
11784 if _err != nil {
11785 return _result, _err
11786 }
11787 }
11788 query := openapiutil.Query(dara.ToMap(request))
11789 req := &openapiutil.OpenApiRequest{
11790 Query: openapiutil.Query(query),
11791 }
11792 params := &openapiutil.Params{
11793 Action: dara.String("GetCnameFlattening"),
11794 Version: dara.String("2024-09-10"),
11795 Protocol: dara.String("HTTPS"),
11796 Pathname: dara.String("/"),
11797 Method: dara.String("GET"),
11798 AuthType: dara.String("AK"),
11799 Style: dara.String("RPC"),
11800 ReqBodyType: dara.String("formData"),
11801 BodyType: dara.String("json"),
11802 }
11803 _result = &GetCnameFlatteningResponse{}
11804 _body, _err := client.CallApi(params, req, runtime)
11805 if _err != nil {
11806 return _result, _err
11807 }
11808 _err = dara.Convert(_body, &_result)
11809 return _result, _err
11810 }
11811
11812 // Summary:
11813 //
11814 // # Queries the CNAME flattening configuration of a website
11815 //
11816 // @param request - GetCnameFlatteningRequest
11817 //
11818 // @return GetCnameFlatteningResponse
11819 func GetCnameFlattening(client *Client, request *GetCnameFlatteningRequest) (_result *GetCnameFlatteningResponse, _err error) {
11820 runtime := &dara.RuntimeOptions{}
11821 _result = &GetCnameFlatteningResponse{}
11822 _body, _err := GetCnameFlatteningWithOptions(client,request, runtime)
11823 if _err != nil {
11824 return _result, _err
11825 }
11826 _result = _body
11827 return _result, _err
11828 }
11829
11830 // Summary:
11831 //
11832 // # Query Compression Rule Details
11833 //
11834 // @param request - GetCompressionRuleRequest
11835 //
11836 // @param runtime - runtime options for this request RuntimeOptions
11837 //
11838 // @return GetCompressionRuleResponse
11839 func GetCompressionRuleWithOptions(client *Client, request *GetCompressionRuleRequest, runtime *dara.RuntimeOptions) (_result *GetCompressionRuleResponse, _err error) {
11840 if dara.BoolValue(client.EnableValidate) == true {
11841 _err = request.Validate()
11842 if _err != nil {
11843 return _result, _err
11844 }
11845 }
11846 query := openapiutil.Query(dara.ToMap(request))
11847 req := &openapiutil.OpenApiRequest{
11848 Query: openapiutil.Query(query),
11849 }
11850 params := &openapiutil.Params{
11851 Action: dara.String("GetCompressionRule"),
11852 Version: dara.String("2024-09-10"),
11853 Protocol: dara.String("HTTPS"),
11854 Pathname: dara.String("/"),
11855 Method: dara.String("GET"),
11856 AuthType: dara.String("AK"),
11857 Style: dara.String("RPC"),
11858 ReqBodyType: dara.String("formData"),
11859 BodyType: dara.String("json"),
11860 }
11861 _result = &GetCompressionRuleResponse{}
11862 _body, _err := client.CallApi(params, req, runtime)
11863 if _err != nil {
11864 return _result, _err
11865 }
11866 _err = dara.Convert(_body, &_result)
11867 return _result, _err
11868 }
11869
11870 // Summary:
11871 //
11872 // # Query Compression Rule Details
11873 //
11874 // @param request - GetCompressionRuleRequest
11875 //
11876 // @return GetCompressionRuleResponse
11877 func GetCompressionRule(client *Client, request *GetCompressionRuleRequest) (_result *GetCompressionRuleResponse, _err error) {
11878 runtime := &dara.RuntimeOptions{}
11879 _result = &GetCompressionRuleResponse{}
11880 _body, _err := GetCompressionRuleWithOptions(client,request, runtime)
11881 if _err != nil {
11882 return _result, _err
11883 }
11884 _result = _body
11885 return _result, _err
11886 }
11887
11888 // Summary:
11889 //
11890 // Queries the configuration of Chinese mainland access optimization.
11891 //
11892 // @param request - GetCrossBorderOptimizationRequest
11893 //
11894 // @param runtime - runtime options for this request RuntimeOptions
11895 //
11896 // @return GetCrossBorderOptimizationResponse
11897 func GetCrossBorderOptimizationWithOptions(client *Client, request *GetCrossBorderOptimizationRequest, runtime *dara.RuntimeOptions) (_result *GetCrossBorderOptimizationResponse, _err error) {
11898 if dara.BoolValue(client.EnableValidate) == true {
11899 _err = request.Validate()
11900 if _err != nil {
11901 return _result, _err
11902 }
11903 }
11904 query := openapiutil.Query(dara.ToMap(request))
11905 req := &openapiutil.OpenApiRequest{
11906 Query: openapiutil.Query(query),
11907 }
11908 params := &openapiutil.Params{
11909 Action: dara.String("GetCrossBorderOptimization"),
11910 Version: dara.String("2024-09-10"),
11911 Protocol: dara.String("HTTPS"),
11912 Pathname: dara.String("/"),
11913 Method: dara.String("GET"),
11914 AuthType: dara.String("AK"),
11915 Style: dara.String("RPC"),
11916 ReqBodyType: dara.String("formData"),
11917 BodyType: dara.String("json"),
11918 }
11919 _result = &GetCrossBorderOptimizationResponse{}
11920 _body, _err := client.CallApi(params, req, runtime)
11921 if _err != nil {
11922 return _result, _err
11923 }
11924 _err = dara.Convert(_body, &_result)
11925 return _result, _err
11926 }
11927
11928 // Summary:
11929 //
11930 // Queries the configuration of Chinese mainland access optimization.
11931 //
11932 // @param request - GetCrossBorderOptimizationRequest
11933 //
11934 // @return GetCrossBorderOptimizationResponse
11935 func GetCrossBorderOptimization(client *Client, request *GetCrossBorderOptimizationRequest) (_result *GetCrossBorderOptimizationResponse, _err error) {
11936 runtime := &dara.RuntimeOptions{}
11937 _result = &GetCrossBorderOptimizationResponse{}
11938 _body, _err := GetCrossBorderOptimizationWithOptions(client,request, runtime)
11939 if _err != nil {
11940 return _result, _err
11941 }
11942 _result = _body
11943 return _result, _err
11944 }
11945
11946 // Summary:
11947 //
11948 // # Query Site Developer Mode Configuration
11949 //
11950 // @param request - GetDevelopmentModeRequest
11951 //
11952 // @param runtime - runtime options for this request RuntimeOptions
11953 //
11954 // @return GetDevelopmentModeResponse
11955 func GetDevelopmentModeWithOptions(client *Client, request *GetDevelopmentModeRequest, runtime *dara.RuntimeOptions) (_result *GetDevelopmentModeResponse, _err error) {
11956 if dara.BoolValue(client.EnableValidate) == true {
11957 _err = request.Validate()
11958 if _err != nil {
11959 return _result, _err
11960 }
11961 }
11962 query := openapiutil.Query(dara.ToMap(request))
11963 req := &openapiutil.OpenApiRequest{
11964 Query: openapiutil.Query(query),
11965 }
11966 params := &openapiutil.Params{
11967 Action: dara.String("GetDevelopmentMode"),
11968 Version: dara.String("2024-09-10"),
11969 Protocol: dara.String("HTTPS"),
11970 Pathname: dara.String("/"),
11971 Method: dara.String("GET"),
11972 AuthType: dara.String("AK"),
11973 Style: dara.String("RPC"),
11974 ReqBodyType: dara.String("formData"),
11975 BodyType: dara.String("json"),
11976 }
11977 _result = &GetDevelopmentModeResponse{}
11978 _body, _err := client.CallApi(params, req, runtime)
11979 if _err != nil {
11980 return _result, _err
11981 }
11982 _err = dara.Convert(_body, &_result)
11983 return _result, _err
11984 }
11985
11986 // Summary:
11987 //
11988 // # Query Site Developer Mode Configuration
11989 //
11990 // @param request - GetDevelopmentModeRequest
11991 //
11992 // @return GetDevelopmentModeResponse
11993 func GetDevelopmentMode(client *Client, request *GetDevelopmentModeRequest) (_result *GetDevelopmentModeResponse, _err error) {
11994 runtime := &dara.RuntimeOptions{}
11995 _result = &GetDevelopmentModeResponse{}
11996 _body, _err := GetDevelopmentModeWithOptions(client,request, runtime)
11997 if _err != nil {
11998 return _result, _err
11999 }
12000 _result = _body
12001 return _result, _err
12002 }
12003
12004 // Summary:
12005 //
12006 // Queries the information about a containerized application, including basic application configurations and health check configurations.
12007 //
12008 // @param request - GetEdgeContainerAppRequest
12009 //
12010 // @param runtime - runtime options for this request RuntimeOptions
12011 //
12012 // @return GetEdgeContainerAppResponse
12013 func GetEdgeContainerAppWithOptions(client *Client, request *GetEdgeContainerAppRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppResponse, _err error) {
12014 if dara.BoolValue(client.EnableValidate) == true {
12015 _err = request.Validate()
12016 if _err != nil {
12017 return _result, _err
12018 }
12019 }
12020 query := map[string]interface{}{}
12021 if !dara.IsNil(request.AppId) {
12022 query["AppId"] = request.AppId
12023 }
12024
12025 req := &openapiutil.OpenApiRequest{
12026 Query: openapiutil.Query(query),
12027 }
12028 params := &openapiutil.Params{
12029 Action: dara.String("GetEdgeContainerApp"),
12030 Version: dara.String("2024-09-10"),
12031 Protocol: dara.String("HTTPS"),
12032 Pathname: dara.String("/"),
12033 Method: dara.String("POST"),
12034 AuthType: dara.String("AK"),
12035 Style: dara.String("RPC"),
12036 ReqBodyType: dara.String("formData"),
12037 BodyType: dara.String("json"),
12038 }
12039 _result = &GetEdgeContainerAppResponse{}
12040 _body, _err := client.CallApi(params, req, runtime)
12041 if _err != nil {
12042 return _result, _err
12043 }
12044 _err = dara.Convert(_body, &_result)
12045 return _result, _err
12046 }
12047
12048 // Summary:
12049 //
12050 // Queries the information about a containerized application, including basic application configurations and health check configurations.
12051 //
12052 // @param request - GetEdgeContainerAppRequest
12053 //
12054 // @return GetEdgeContainerAppResponse
12055 func GetEdgeContainerApp(client *Client, request *GetEdgeContainerAppRequest) (_result *GetEdgeContainerAppResponse, _err error) {
12056 runtime := &dara.RuntimeOptions{}
12057 _result = &GetEdgeContainerAppResponse{}
12058 _body, _err := GetEdgeContainerAppWithOptions(client,request, runtime)
12059 if _err != nil {
12060 return _result, _err
12061 }
12062 _result = _body
12063 return _result, _err
12064 }
12065
12066 // Summary:
12067 //
12068 // Queries the log collection configuration of a containerized application.
12069 //
12070 // @param request - GetEdgeContainerAppLogRiverRequest
12071 //
12072 // @param runtime - runtime options for this request RuntimeOptions
12073 //
12074 // @return GetEdgeContainerAppLogRiverResponse
12075 func GetEdgeContainerAppLogRiverWithOptions(client *Client, request *GetEdgeContainerAppLogRiverRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppLogRiverResponse, _err error) {
12076 if dara.BoolValue(client.EnableValidate) == true {
12077 _err = request.Validate()
12078 if _err != nil {
12079 return _result, _err
12080 }
12081 }
12082 query := openapiutil.Query(dara.ToMap(request))
12083 req := &openapiutil.OpenApiRequest{
12084 Query: openapiutil.Query(query),
12085 }
12086 params := &openapiutil.Params{
12087 Action: dara.String("GetEdgeContainerAppLogRiver"),
12088 Version: dara.String("2024-09-10"),
12089 Protocol: dara.String("HTTPS"),
12090 Pathname: dara.String("/"),
12091 Method: dara.String("GET"),
12092 AuthType: dara.String("AK"),
12093 Style: dara.String("RPC"),
12094 ReqBodyType: dara.String("formData"),
12095 BodyType: dara.String("json"),
12096 }
12097 _result = &GetEdgeContainerAppLogRiverResponse{}
12098 _body, _err := client.CallApi(params, req, runtime)
12099 if _err != nil {
12100 return _result, _err
12101 }
12102 _err = dara.Convert(_body, &_result)
12103 return _result, _err
12104 }
12105
12106 // Summary:
12107 //
12108 // Queries the log collection configuration of a containerized application.
12109 //
12110 // @param request - GetEdgeContainerAppLogRiverRequest
12111 //
12112 // @return GetEdgeContainerAppLogRiverResponse
12113 func GetEdgeContainerAppLogRiver(client *Client, request *GetEdgeContainerAppLogRiverRequest) (_result *GetEdgeContainerAppLogRiverResponse, _err error) {
12114 runtime := &dara.RuntimeOptions{}
12115 _result = &GetEdgeContainerAppLogRiverResponse{}
12116 _body, _err := GetEdgeContainerAppLogRiverWithOptions(client,request, runtime)
12117 if _err != nil {
12118 return _result, _err
12119 }
12120 _result = _body
12121 return _result, _err
12122 }
12123
12124 // Summary:
12125 //
12126 // 获取边缘容器应用的资源容量
12127 //
12128 // @param request - GetEdgeContainerAppResourceCapacityRequest
12129 //
12130 // @param runtime - runtime options for this request RuntimeOptions
12131 //
12132 // @return GetEdgeContainerAppResourceCapacityResponse
12133 func GetEdgeContainerAppResourceCapacityWithOptions(client *Client, request *GetEdgeContainerAppResourceCapacityRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppResourceCapacityResponse, _err error) {
12134 if dara.BoolValue(client.EnableValidate) == true {
12135 _err = request.Validate()
12136 if _err != nil {
12137 return _result, _err
12138 }
12139 }
12140 query := map[string]interface{}{}
12141 if !dara.IsNil(request.AppId) {
12142 query["AppId"] = request.AppId
12143 }
12144
12145 req := &openapiutil.OpenApiRequest{
12146 Query: openapiutil.Query(query),
12147 }
12148 params := &openapiutil.Params{
12149 Action: dara.String("GetEdgeContainerAppResourceCapacity"),
12150 Version: dara.String("2024-09-10"),
12151 Protocol: dara.String("HTTPS"),
12152 Pathname: dara.String("/"),
12153 Method: dara.String("POST"),
12154 AuthType: dara.String("AK"),
12155 Style: dara.String("RPC"),
12156 ReqBodyType: dara.String("formData"),
12157 BodyType: dara.String("json"),
12158 }
12159 _result = &GetEdgeContainerAppResourceCapacityResponse{}
12160 _body, _err := client.CallApi(params, req, runtime)
12161 if _err != nil {
12162 return _result, _err
12163 }
12164 _err = dara.Convert(_body, &_result)
12165 return _result, _err
12166 }
12167
12168 // Summary:
12169 //
12170 // 获取边缘容器应用的资源容量
12171 //
12172 // @param request - GetEdgeContainerAppResourceCapacityRequest
12173 //
12174 // @return GetEdgeContainerAppResourceCapacityResponse
12175 func GetEdgeContainerAppResourceCapacity(client *Client, request *GetEdgeContainerAppResourceCapacityRequest) (_result *GetEdgeContainerAppResourceCapacityResponse, _err error) {
12176 runtime := &dara.RuntimeOptions{}
12177 _result = &GetEdgeContainerAppResourceCapacityResponse{}
12178 _body, _err := GetEdgeContainerAppResourceCapacityWithOptions(client,request, runtime)
12179 if _err != nil {
12180 return _result, _err
12181 }
12182 _result = _body
12183 return _result, _err
12184 }
12185
12186 // Summary:
12187 //
12188 // Obtain the resource reservation configuration of the edge container.
12189 //
12190 // @param request - GetEdgeContainerAppResourceReserveRequest
12191 //
12192 // @param runtime - runtime options for this request RuntimeOptions
12193 //
12194 // @return GetEdgeContainerAppResourceReserveResponse
12195 func GetEdgeContainerAppResourceReserveWithOptions(client *Client, request *GetEdgeContainerAppResourceReserveRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppResourceReserveResponse, _err error) {
12196 if dara.BoolValue(client.EnableValidate) == true {
12197 _err = request.Validate()
12198 if _err != nil {
12199 return _result, _err
12200 }
12201 }
12202 query := map[string]interface{}{}
12203 if !dara.IsNil(request.AppId) {
12204 query["AppId"] = request.AppId
12205 }
12206
12207 req := &openapiutil.OpenApiRequest{
12208 Query: openapiutil.Query(query),
12209 }
12210 params := &openapiutil.Params{
12211 Action: dara.String("GetEdgeContainerAppResourceReserve"),
12212 Version: dara.String("2024-09-10"),
12213 Protocol: dara.String("HTTPS"),
12214 Pathname: dara.String("/"),
12215 Method: dara.String("POST"),
12216 AuthType: dara.String("AK"),
12217 Style: dara.String("RPC"),
12218 ReqBodyType: dara.String("formData"),
12219 BodyType: dara.String("json"),
12220 }
12221 _result = &GetEdgeContainerAppResourceReserveResponse{}
12222 _body, _err := client.CallApi(params, req, runtime)
12223 if _err != nil {
12224 return _result, _err
12225 }
12226 _err = dara.Convert(_body, &_result)
12227 return _result, _err
12228 }
12229
12230 // Summary:
12231 //
12232 // Obtain the resource reservation configuration of the edge container.
12233 //
12234 // @param request - GetEdgeContainerAppResourceReserveRequest
12235 //
12236 // @return GetEdgeContainerAppResourceReserveResponse
12237 func GetEdgeContainerAppResourceReserve(client *Client, request *GetEdgeContainerAppResourceReserveRequest) (_result *GetEdgeContainerAppResourceReserveResponse, _err error) {
12238 runtime := &dara.RuntimeOptions{}
12239 _result = &GetEdgeContainerAppResourceReserveResponse{}
12240 _body, _err := GetEdgeContainerAppResourceReserveWithOptions(client,request, runtime)
12241 if _err != nil {
12242 return _result, _err
12243 }
12244 _result = _body
12245 return _result, _err
12246 }
12247
12248 // Summary:
12249 //
12250 // Obtains the distribution of edge container application resources.
12251 //
12252 // @param request - GetEdgeContainerAppResourceStatusRequest
12253 //
12254 // @param runtime - runtime options for this request RuntimeOptions
12255 //
12256 // @return GetEdgeContainerAppResourceStatusResponse
12257 func GetEdgeContainerAppResourceStatusWithOptions(client *Client, request *GetEdgeContainerAppResourceStatusRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppResourceStatusResponse, _err error) {
12258 if dara.BoolValue(client.EnableValidate) == true {
12259 _err = request.Validate()
12260 if _err != nil {
12261 return _result, _err
12262 }
12263 }
12264 query := map[string]interface{}{}
12265 if !dara.IsNil(request.AppId) {
12266 query["AppId"] = request.AppId
12267 }
12268
12269 req := &openapiutil.OpenApiRequest{
12270 Query: openapiutil.Query(query),
12271 }
12272 params := &openapiutil.Params{
12273 Action: dara.String("GetEdgeContainerAppResourceStatus"),
12274 Version: dara.String("2024-09-10"),
12275 Protocol: dara.String("HTTPS"),
12276 Pathname: dara.String("/"),
12277 Method: dara.String("POST"),
12278 AuthType: dara.String("AK"),
12279 Style: dara.String("RPC"),
12280 ReqBodyType: dara.String("formData"),
12281 BodyType: dara.String("json"),
12282 }
12283 _result = &GetEdgeContainerAppResourceStatusResponse{}
12284 _body, _err := client.CallApi(params, req, runtime)
12285 if _err != nil {
12286 return _result, _err
12287 }
12288 _err = dara.Convert(_body, &_result)
12289 return _result, _err
12290 }
12291
12292 // Summary:
12293 //
12294 // Obtains the distribution of edge container application resources.
12295 //
12296 // @param request - GetEdgeContainerAppResourceStatusRequest
12297 //
12298 // @return GetEdgeContainerAppResourceStatusResponse
12299 func GetEdgeContainerAppResourceStatus(client *Client, request *GetEdgeContainerAppResourceStatusRequest) (_result *GetEdgeContainerAppResourceStatusResponse, _err error) {
12300 runtime := &dara.RuntimeOptions{}
12301 _result = &GetEdgeContainerAppResourceStatusResponse{}
12302 _body, _err := GetEdgeContainerAppResourceStatusWithOptions(client,request, runtime)
12303 if _err != nil {
12304 return _result, _err
12305 }
12306 _result = _body
12307 return _result, _err
12308 }
12309
12310 // Summary:
12311 //
12312 // Queries the status information about a containerized application, including the deployment, release, and rollback of the application.
12313 //
12314 // @param request - GetEdgeContainerAppStatusRequest
12315 //
12316 // @param runtime - runtime options for this request RuntimeOptions
12317 //
12318 // @return GetEdgeContainerAppStatusResponse
12319 func GetEdgeContainerAppStatusWithOptions(client *Client, request *GetEdgeContainerAppStatusRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppStatusResponse, _err error) {
12320 if dara.BoolValue(client.EnableValidate) == true {
12321 _err = request.Validate()
12322 if _err != nil {
12323 return _result, _err
12324 }
12325 }
12326 query := map[string]interface{}{}
12327 if !dara.IsNil(request.AppId) {
12328 query["AppId"] = request.AppId
12329 }
12330
12331 if !dara.IsNil(request.PublishEnv) {
12332 query["PublishEnv"] = request.PublishEnv
12333 }
12334
12335 req := &openapiutil.OpenApiRequest{
12336 Query: openapiutil.Query(query),
12337 }
12338 params := &openapiutil.Params{
12339 Action: dara.String("GetEdgeContainerAppStatus"),
12340 Version: dara.String("2024-09-10"),
12341 Protocol: dara.String("HTTPS"),
12342 Pathname: dara.String("/"),
12343 Method: dara.String("POST"),
12344 AuthType: dara.String("AK"),
12345 Style: dara.String("RPC"),
12346 ReqBodyType: dara.String("formData"),
12347 BodyType: dara.String("json"),
12348 }
12349 _result = &GetEdgeContainerAppStatusResponse{}
12350 _body, _err := client.CallApi(params, req, runtime)
12351 if _err != nil {
12352 return _result, _err
12353 }
12354 _err = dara.Convert(_body, &_result)
12355 return _result, _err
12356 }
12357
12358 // Summary:
12359 //
12360 // Queries the status information about a containerized application, including the deployment, release, and rollback of the application.
12361 //
12362 // @param request - GetEdgeContainerAppStatusRequest
12363 //
12364 // @return GetEdgeContainerAppStatusResponse
12365 func GetEdgeContainerAppStatus(client *Client, request *GetEdgeContainerAppStatusRequest) (_result *GetEdgeContainerAppStatusResponse, _err error) {
12366 runtime := &dara.RuntimeOptions{}
12367 _result = &GetEdgeContainerAppStatusResponse{}
12368 _body, _err := GetEdgeContainerAppStatusWithOptions(client,request, runtime)
12369 if _err != nil {
12370 return _result, _err
12371 }
12372 _result = _body
12373 return _result, _err
12374 }
12375
12376 // Summary:
12377 //
12378 // Queries the information about a version of a containerized application. You can select an application version to release based on the version information.
12379 //
12380 // @param request - GetEdgeContainerAppVersionRequest
12381 //
12382 // @param runtime - runtime options for this request RuntimeOptions
12383 //
12384 // @return GetEdgeContainerAppVersionResponse
12385 func GetEdgeContainerAppVersionWithOptions(client *Client, request *GetEdgeContainerAppVersionRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerAppVersionResponse, _err error) {
12386 if dara.BoolValue(client.EnableValidate) == true {
12387 _err = request.Validate()
12388 if _err != nil {
12389 return _result, _err
12390 }
12391 }
12392 query := openapiutil.Query(dara.ToMap(request))
12393 req := &openapiutil.OpenApiRequest{
12394 Query: openapiutil.Query(query),
12395 }
12396 params := &openapiutil.Params{
12397 Action: dara.String("GetEdgeContainerAppVersion"),
12398 Version: dara.String("2024-09-10"),
12399 Protocol: dara.String("HTTPS"),
12400 Pathname: dara.String("/"),
12401 Method: dara.String("GET"),
12402 AuthType: dara.String("AK"),
12403 Style: dara.String("RPC"),
12404 ReqBodyType: dara.String("formData"),
12405 BodyType: dara.String("json"),
12406 }
12407 _result = &GetEdgeContainerAppVersionResponse{}
12408 _body, _err := client.CallApi(params, req, runtime)
12409 if _err != nil {
12410 return _result, _err
12411 }
12412 _err = dara.Convert(_body, &_result)
12413 return _result, _err
12414 }
12415
12416 // Summary:
12417 //
12418 // Queries the information about a version of a containerized application. You can select an application version to release based on the version information.
12419 //
12420 // @param request - GetEdgeContainerAppVersionRequest
12421 //
12422 // @return GetEdgeContainerAppVersionResponse
12423 func GetEdgeContainerAppVersion(client *Client, request *GetEdgeContainerAppVersionRequest) (_result *GetEdgeContainerAppVersionResponse, _err error) {
12424 runtime := &dara.RuntimeOptions{}
12425 _result = &GetEdgeContainerAppVersionResponse{}
12426 _body, _err := GetEdgeContainerAppVersionWithOptions(client,request, runtime)
12427 if _err != nil {
12428 return _result, _err
12429 }
12430 _result = _body
12431 return _result, _err
12432 }
12433
12434 // Summary:
12435 //
12436 // Queries regions where a containerized application is deployed based on the application ID.
12437 //
12438 // @param request - GetEdgeContainerDeployRegionsRequest
12439 //
12440 // @param runtime - runtime options for this request RuntimeOptions
12441 //
12442 // @return GetEdgeContainerDeployRegionsResponse
12443 func GetEdgeContainerDeployRegionsWithOptions(client *Client, request *GetEdgeContainerDeployRegionsRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerDeployRegionsResponse, _err error) {
12444 if dara.BoolValue(client.EnableValidate) == true {
12445 _err = request.Validate()
12446 if _err != nil {
12447 return _result, _err
12448 }
12449 }
12450 query := openapiutil.Query(dara.ToMap(request))
12451 req := &openapiutil.OpenApiRequest{
12452 Query: openapiutil.Query(query),
12453 }
12454 params := &openapiutil.Params{
12455 Action: dara.String("GetEdgeContainerDeployRegions"),
12456 Version: dara.String("2024-09-10"),
12457 Protocol: dara.String("HTTPS"),
12458 Pathname: dara.String("/"),
12459 Method: dara.String("GET"),
12460 AuthType: dara.String("AK"),
12461 Style: dara.String("RPC"),
12462 ReqBodyType: dara.String("formData"),
12463 BodyType: dara.String("json"),
12464 }
12465 _result = &GetEdgeContainerDeployRegionsResponse{}
12466 _body, _err := client.CallApi(params, req, runtime)
12467 if _err != nil {
12468 return _result, _err
12469 }
12470 _err = dara.Convert(_body, &_result)
12471 return _result, _err
12472 }
12473
12474 // Summary:
12475 //
12476 // Queries regions where a containerized application is deployed based on the application ID.
12477 //
12478 // @param request - GetEdgeContainerDeployRegionsRequest
12479 //
12480 // @return GetEdgeContainerDeployRegionsResponse
12481 func GetEdgeContainerDeployRegions(client *Client, request *GetEdgeContainerDeployRegionsRequest) (_result *GetEdgeContainerDeployRegionsResponse, _err error) {
12482 runtime := &dara.RuntimeOptions{}
12483 _result = &GetEdgeContainerDeployRegionsResponse{}
12484 _body, _err := GetEdgeContainerDeployRegionsWithOptions(client,request, runtime)
12485 if _err != nil {
12486 return _result, _err
12487 }
12488 _result = _body
12489 return _result, _err
12490 }
12491
12492 // Summary:
12493 //
12494 // Queries Edge Container logs.
12495 //
12496 // @param request - GetEdgeContainerLogsRequest
12497 //
12498 // @param runtime - runtime options for this request RuntimeOptions
12499 //
12500 // @return GetEdgeContainerLogsResponse
12501 func GetEdgeContainerLogsWithOptions(client *Client, request *GetEdgeContainerLogsRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerLogsResponse, _err error) {
12502 if dara.BoolValue(client.EnableValidate) == true {
12503 _err = request.Validate()
12504 if _err != nil {
12505 return _result, _err
12506 }
12507 }
12508 query := openapiutil.Query(dara.ToMap(request))
12509 req := &openapiutil.OpenApiRequest{
12510 Query: openapiutil.Query(query),
12511 }
12512 params := &openapiutil.Params{
12513 Action: dara.String("GetEdgeContainerLogs"),
12514 Version: dara.String("2024-09-10"),
12515 Protocol: dara.String("HTTPS"),
12516 Pathname: dara.String("/"),
12517 Method: dara.String("GET"),
12518 AuthType: dara.String("AK"),
12519 Style: dara.String("RPC"),
12520 ReqBodyType: dara.String("formData"),
12521 BodyType: dara.String("json"),
12522 }
12523 _result = &GetEdgeContainerLogsResponse{}
12524 _body, _err := client.CallApi(params, req, runtime)
12525 if _err != nil {
12526 return _result, _err
12527 }
12528 _err = dara.Convert(_body, &_result)
12529 return _result, _err
12530 }
12531
12532 // Summary:
12533 //
12534 // Queries Edge Container logs.
12535 //
12536 // @param request - GetEdgeContainerLogsRequest
12537 //
12538 // @return GetEdgeContainerLogsResponse
12539 func GetEdgeContainerLogs(client *Client, request *GetEdgeContainerLogsRequest) (_result *GetEdgeContainerLogsResponse, _err error) {
12540 runtime := &dara.RuntimeOptions{}
12541 _result = &GetEdgeContainerLogsResponse{}
12542 _body, _err := GetEdgeContainerLogsWithOptions(client,request, runtime)
12543 if _err != nil {
12544 return _result, _err
12545 }
12546 _result = _body
12547 return _result, _err
12548 }
12549
12550 // Summary:
12551 //
12552 // Queries the deployment status of an application in the staging environment by using the application ID.
12553 //
12554 // @param request - GetEdgeContainerStagingDeployStatusRequest
12555 //
12556 // @param runtime - runtime options for this request RuntimeOptions
12557 //
12558 // @return GetEdgeContainerStagingDeployStatusResponse
12559 func GetEdgeContainerStagingDeployStatusWithOptions(client *Client, request *GetEdgeContainerStagingDeployStatusRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerStagingDeployStatusResponse, _err error) {
12560 if dara.BoolValue(client.EnableValidate) == true {
12561 _err = request.Validate()
12562 if _err != nil {
12563 return _result, _err
12564 }
12565 }
12566 query := openapiutil.Query(dara.ToMap(request))
12567 req := &openapiutil.OpenApiRequest{
12568 Query: openapiutil.Query(query),
12569 }
12570 params := &openapiutil.Params{
12571 Action: dara.String("GetEdgeContainerStagingDeployStatus"),
12572 Version: dara.String("2024-09-10"),
12573 Protocol: dara.String("HTTPS"),
12574 Pathname: dara.String("/"),
12575 Method: dara.String("GET"),
12576 AuthType: dara.String("AK"),
12577 Style: dara.String("RPC"),
12578 ReqBodyType: dara.String("formData"),
12579 BodyType: dara.String("json"),
12580 }
12581 _result = &GetEdgeContainerStagingDeployStatusResponse{}
12582 _body, _err := client.CallApi(params, req, runtime)
12583 if _err != nil {
12584 return _result, _err
12585 }
12586 _err = dara.Convert(_body, &_result)
12587 return _result, _err
12588 }
12589
12590 // Summary:
12591 //
12592 // Queries the deployment status of an application in the staging environment by using the application ID.
12593 //
12594 // @param request - GetEdgeContainerStagingDeployStatusRequest
12595 //
12596 // @return GetEdgeContainerStagingDeployStatusResponse
12597 func GetEdgeContainerStagingDeployStatus(client *Client, request *GetEdgeContainerStagingDeployStatusRequest) (_result *GetEdgeContainerStagingDeployStatusResponse, _err error) {
12598 runtime := &dara.RuntimeOptions{}
12599 _result = &GetEdgeContainerStagingDeployStatusResponse{}
12600 _body, _err := GetEdgeContainerStagingDeployStatusWithOptions(client,request, runtime)
12601 if _err != nil {
12602 return _result, _err
12603 }
12604 _result = _body
12605 return _result, _err
12606 }
12607
12608 // Summary:
12609 //
12610 // Queries the terminal information of a containerized application.
12611 //
12612 // @param request - GetEdgeContainerTerminalRequest
12613 //
12614 // @param runtime - runtime options for this request RuntimeOptions
12615 //
12616 // @return GetEdgeContainerTerminalResponse
12617 func GetEdgeContainerTerminalWithOptions(client *Client, request *GetEdgeContainerTerminalRequest, runtime *dara.RuntimeOptions) (_result *GetEdgeContainerTerminalResponse, _err error) {
12618 if dara.BoolValue(client.EnableValidate) == true {
12619 _err = request.Validate()
12620 if _err != nil {
12621 return _result, _err
12622 }
12623 }
12624 query := map[string]interface{}{}
12625 if !dara.IsNil(request.AppId) {
12626 query["AppId"] = request.AppId
12627 }
12628
12629 req := &openapiutil.OpenApiRequest{
12630 Query: openapiutil.Query(query),
12631 }
12632 params := &openapiutil.Params{
12633 Action: dara.String("GetEdgeContainerTerminal"),
12634 Version: dara.String("2024-09-10"),
12635 Protocol: dara.String("HTTPS"),
12636 Pathname: dara.String("/"),
12637 Method: dara.String("POST"),
12638 AuthType: dara.String("AK"),
12639 Style: dara.String("RPC"),
12640 ReqBodyType: dara.String("formData"),
12641 BodyType: dara.String("json"),
12642 }
12643 _result = &GetEdgeContainerTerminalResponse{}
12644 _body, _err := client.CallApi(params, req, runtime)
12645 if _err != nil {
12646 return _result, _err
12647 }
12648 _err = dara.Convert(_body, &_result)
12649 return _result, _err
12650 }
12651
12652 // Summary:
12653 //
12654 // Queries the terminal information of a containerized application.
12655 //
12656 // @param request - GetEdgeContainerTerminalRequest
12657 //
12658 // @return GetEdgeContainerTerminalResponse
12659 func GetEdgeContainerTerminal(client *Client, request *GetEdgeContainerTerminalRequest) (_result *GetEdgeContainerTerminalResponse, _err error) {
12660 runtime := &dara.RuntimeOptions{}
12661 _result = &GetEdgeContainerTerminalResponse{}
12662 _body, _err := GetEdgeContainerTerminalWithOptions(client,request, runtime)
12663 if _err != nil {
12664 return _result, _err
12665 }
12666 _result = _body
12667 return _result, _err
12668 }
12669
12670 // Summary:
12671 //
12672 // Checks the status of Edge Routine.
12673 //
12674 // @param request - GetErServiceRequest
12675 //
12676 // @param runtime - runtime options for this request RuntimeOptions
12677 //
12678 // @return GetErServiceResponse
12679 func GetErServiceWithOptions(client *Client, request *GetErServiceRequest, runtime *dara.RuntimeOptions) (_result *GetErServiceResponse, _err error) {
12680 if dara.BoolValue(client.EnableValidate) == true {
12681 _err = request.Validate()
12682 if _err != nil {
12683 return _result, _err
12684 }
12685 }
12686 query := openapiutil.Query(dara.ToMap(request))
12687 req := &openapiutil.OpenApiRequest{
12688 Query: openapiutil.Query(query),
12689 }
12690 params := &openapiutil.Params{
12691 Action: dara.String("GetErService"),
12692 Version: dara.String("2024-09-10"),
12693 Protocol: dara.String("HTTPS"),
12694 Pathname: dara.String("/"),
12695 Method: dara.String("GET"),
12696 AuthType: dara.String("AK"),
12697 Style: dara.String("RPC"),
12698 ReqBodyType: dara.String("formData"),
12699 BodyType: dara.String("json"),
12700 }
12701 _result = &GetErServiceResponse{}
12702 _body, _err := client.CallApi(params, req, runtime)
12703 if _err != nil {
12704 return _result, _err
12705 }
12706 _err = dara.Convert(_body, &_result)
12707 return _result, _err
12708 }
12709
12710 // Summary:
12711 //
12712 // Checks the status of Edge Routine.
12713 //
12714 // @param request - GetErServiceRequest
12715 //
12716 // @return GetErServiceResponse
12717 func GetErService(client *Client, request *GetErServiceRequest) (_result *GetErServiceResponse, _err error) {
12718 runtime := &dara.RuntimeOptions{}
12719 _result = &GetErServiceResponse{}
12720 _body, _err := GetErServiceWithOptions(client,request, runtime)
12721 if _err != nil {
12722 return _result, _err
12723 }
12724 _result = _body
12725 return _result, _err
12726 }
12727
12728 // Summary:
12729 //
12730 // Queries the configuration details of an HTTP request header modification rule for a website.
12731 //
12732 // @param request - GetHttpIncomingRequestHeaderModificationRuleRequest
12733 //
12734 // @param runtime - runtime options for this request RuntimeOptions
12735 //
12736 // @return GetHttpIncomingRequestHeaderModificationRuleResponse
12737 func GetHttpIncomingRequestHeaderModificationRuleWithOptions(client *Client, request *GetHttpIncomingRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *GetHttpIncomingRequestHeaderModificationRuleResponse, _err error) {
12738 if dara.BoolValue(client.EnableValidate) == true {
12739 _err = request.Validate()
12740 if _err != nil {
12741 return _result, _err
12742 }
12743 }
12744 query := openapiutil.Query(dara.ToMap(request))
12745 req := &openapiutil.OpenApiRequest{
12746 Query: openapiutil.Query(query),
12747 }
12748 params := &openapiutil.Params{
12749 Action: dara.String("GetHttpIncomingRequestHeaderModificationRule"),
12750 Version: dara.String("2024-09-10"),
12751 Protocol: dara.String("HTTPS"),
12752 Pathname: dara.String("/"),
12753 Method: dara.String("GET"),
12754 AuthType: dara.String("AK"),
12755 Style: dara.String("RPC"),
12756 ReqBodyType: dara.String("formData"),
12757 BodyType: dara.String("json"),
12758 }
12759 _result = &GetHttpIncomingRequestHeaderModificationRuleResponse{}
12760 _body, _err := client.CallApi(params, req, runtime)
12761 if _err != nil {
12762 return _result, _err
12763 }
12764 _err = dara.Convert(_body, &_result)
12765 return _result, _err
12766 }
12767
12768 // Summary:
12769 //
12770 // Queries the configuration details of an HTTP request header modification rule for a website.
12771 //
12772 // @param request - GetHttpIncomingRequestHeaderModificationRuleRequest
12773 //
12774 // @return GetHttpIncomingRequestHeaderModificationRuleResponse
12775 func GetHttpIncomingRequestHeaderModificationRule(client *Client, request *GetHttpIncomingRequestHeaderModificationRuleRequest) (_result *GetHttpIncomingRequestHeaderModificationRuleResponse, _err error) {
12776 runtime := &dara.RuntimeOptions{}
12777 _result = &GetHttpIncomingRequestHeaderModificationRuleResponse{}
12778 _body, _err := GetHttpIncomingRequestHeaderModificationRuleWithOptions(client,request, runtime)
12779 if _err != nil {
12780 return _result, _err
12781 }
12782 _result = _body
12783 return _result, _err
12784 }
12785
12786 // Summary:
12787 //
12788 // Queries the configuration details of an incoming HTTP response header modification rule for a website.
12789 //
12790 // @param request - GetHttpIncomingResponseHeaderModificationRuleRequest
12791 //
12792 // @param runtime - runtime options for this request RuntimeOptions
12793 //
12794 // @return GetHttpIncomingResponseHeaderModificationRuleResponse
12795 func GetHttpIncomingResponseHeaderModificationRuleWithOptions(client *Client, request *GetHttpIncomingResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *GetHttpIncomingResponseHeaderModificationRuleResponse, _err error) {
12796 if dara.BoolValue(client.EnableValidate) == true {
12797 _err = request.Validate()
12798 if _err != nil {
12799 return _result, _err
12800 }
12801 }
12802 query := openapiutil.Query(dara.ToMap(request))
12803 req := &openapiutil.OpenApiRequest{
12804 Query: openapiutil.Query(query),
12805 }
12806 params := &openapiutil.Params{
12807 Action: dara.String("GetHttpIncomingResponseHeaderModificationRule"),
12808 Version: dara.String("2024-09-10"),
12809 Protocol: dara.String("HTTPS"),
12810 Pathname: dara.String("/"),
12811 Method: dara.String("GET"),
12812 AuthType: dara.String("AK"),
12813 Style: dara.String("RPC"),
12814 ReqBodyType: dara.String("formData"),
12815 BodyType: dara.String("json"),
12816 }
12817 _result = &GetHttpIncomingResponseHeaderModificationRuleResponse{}
12818 _body, _err := client.CallApi(params, req, runtime)
12819 if _err != nil {
12820 return _result, _err
12821 }
12822 _err = dara.Convert(_body, &_result)
12823 return _result, _err
12824 }
12825
12826 // Summary:
12827 //
12828 // Queries the configuration details of an incoming HTTP response header modification rule for a website.
12829 //
12830 // @param request - GetHttpIncomingResponseHeaderModificationRuleRequest
12831 //
12832 // @return GetHttpIncomingResponseHeaderModificationRuleResponse
12833 func GetHttpIncomingResponseHeaderModificationRule(client *Client, request *GetHttpIncomingResponseHeaderModificationRuleRequest) (_result *GetHttpIncomingResponseHeaderModificationRuleResponse, _err error) {
12834 runtime := &dara.RuntimeOptions{}
12835 _result = &GetHttpIncomingResponseHeaderModificationRuleResponse{}
12836 _body, _err := GetHttpIncomingResponseHeaderModificationRuleWithOptions(client,request, runtime)
12837 if _err != nil {
12838 return _result, _err
12839 }
12840 _result = _body
12841 return _result, _err
12842 }
12843
12844 // Summary:
12845 //
12846 // # Query HTTP Request Header Rule Details
12847 //
12848 // @param request - GetHttpRequestHeaderModificationRuleRequest
12849 //
12850 // @param runtime - runtime options for this request RuntimeOptions
12851 //
12852 // @return GetHttpRequestHeaderModificationRuleResponse
12853 func GetHttpRequestHeaderModificationRuleWithOptions(client *Client, request *GetHttpRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *GetHttpRequestHeaderModificationRuleResponse, _err error) {
12854 if dara.BoolValue(client.EnableValidate) == true {
12855 _err = request.Validate()
12856 if _err != nil {
12857 return _result, _err
12858 }
12859 }
12860 query := openapiutil.Query(dara.ToMap(request))
12861 req := &openapiutil.OpenApiRequest{
12862 Query: openapiutil.Query(query),
12863 }
12864 params := &openapiutil.Params{
12865 Action: dara.String("GetHttpRequestHeaderModificationRule"),
12866 Version: dara.String("2024-09-10"),
12867 Protocol: dara.String("HTTPS"),
12868 Pathname: dara.String("/"),
12869 Method: dara.String("GET"),
12870 AuthType: dara.String("AK"),
12871 Style: dara.String("RPC"),
12872 ReqBodyType: dara.String("formData"),
12873 BodyType: dara.String("json"),
12874 }
12875 _result = &GetHttpRequestHeaderModificationRuleResponse{}
12876 _body, _err := client.CallApi(params, req, runtime)
12877 if _err != nil {
12878 return _result, _err
12879 }
12880 _err = dara.Convert(_body, &_result)
12881 return _result, _err
12882 }
12883
12884 // Summary:
12885 //
12886 // # Query HTTP Request Header Rule Details
12887 //
12888 // @param request - GetHttpRequestHeaderModificationRuleRequest
12889 //
12890 // @return GetHttpRequestHeaderModificationRuleResponse
12891 func GetHttpRequestHeaderModificationRule(client *Client, request *GetHttpRequestHeaderModificationRuleRequest) (_result *GetHttpRequestHeaderModificationRuleResponse, _err error) {
12892 runtime := &dara.RuntimeOptions{}
12893 _result = &GetHttpRequestHeaderModificationRuleResponse{}
12894 _body, _err := GetHttpRequestHeaderModificationRuleWithOptions(client,request, runtime)
12895 if _err != nil {
12896 return _result, _err
12897 }
12898 _result = _body
12899 return _result, _err
12900 }
12901
12902 // Summary:
12903 //
12904 // # Query HTTP Response Header Rules
12905 //
12906 // @param request - GetHttpResponseHeaderModificationRuleRequest
12907 //
12908 // @param runtime - runtime options for this request RuntimeOptions
12909 //
12910 // @return GetHttpResponseHeaderModificationRuleResponse
12911 func GetHttpResponseHeaderModificationRuleWithOptions(client *Client, request *GetHttpResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *GetHttpResponseHeaderModificationRuleResponse, _err error) {
12912 if dara.BoolValue(client.EnableValidate) == true {
12913 _err = request.Validate()
12914 if _err != nil {
12915 return _result, _err
12916 }
12917 }
12918 query := openapiutil.Query(dara.ToMap(request))
12919 req := &openapiutil.OpenApiRequest{
12920 Query: openapiutil.Query(query),
12921 }
12922 params := &openapiutil.Params{
12923 Action: dara.String("GetHttpResponseHeaderModificationRule"),
12924 Version: dara.String("2024-09-10"),
12925 Protocol: dara.String("HTTPS"),
12926 Pathname: dara.String("/"),
12927 Method: dara.String("GET"),
12928 AuthType: dara.String("AK"),
12929 Style: dara.String("RPC"),
12930 ReqBodyType: dara.String("formData"),
12931 BodyType: dara.String("json"),
12932 }
12933 _result = &GetHttpResponseHeaderModificationRuleResponse{}
12934 _body, _err := client.CallApi(params, req, runtime)
12935 if _err != nil {
12936 return _result, _err
12937 }
12938 _err = dara.Convert(_body, &_result)
12939 return _result, _err
12940 }
12941
12942 // Summary:
12943 //
12944 // # Query HTTP Response Header Rules
12945 //
12946 // @param request - GetHttpResponseHeaderModificationRuleRequest
12947 //
12948 // @return GetHttpResponseHeaderModificationRuleResponse
12949 func GetHttpResponseHeaderModificationRule(client *Client, request *GetHttpResponseHeaderModificationRuleRequest) (_result *GetHttpResponseHeaderModificationRuleResponse, _err error) {
12950 runtime := &dara.RuntimeOptions{}
12951 _result = &GetHttpResponseHeaderModificationRuleResponse{}
12952 _body, _err := GetHttpResponseHeaderModificationRuleWithOptions(client,request, runtime)
12953 if _err != nil {
12954 return _result, _err
12955 }
12956 _result = _body
12957 return _result, _err
12958 }
12959
12960 // Summary:
12961 //
12962 // # Query a Single HTTPS Application Configuration
12963 //
12964 // @param request - GetHttpsApplicationConfigurationRequest
12965 //
12966 // @param runtime - runtime options for this request RuntimeOptions
12967 //
12968 // @return GetHttpsApplicationConfigurationResponse
12969 func GetHttpsApplicationConfigurationWithOptions(client *Client, request *GetHttpsApplicationConfigurationRequest, runtime *dara.RuntimeOptions) (_result *GetHttpsApplicationConfigurationResponse, _err error) {
12970 if dara.BoolValue(client.EnableValidate) == true {
12971 _err = request.Validate()
12972 if _err != nil {
12973 return _result, _err
12974 }
12975 }
12976 query := openapiutil.Query(dara.ToMap(request))
12977 req := &openapiutil.OpenApiRequest{
12978 Query: openapiutil.Query(query),
12979 }
12980 params := &openapiutil.Params{
12981 Action: dara.String("GetHttpsApplicationConfiguration"),
12982 Version: dara.String("2024-09-10"),
12983 Protocol: dara.String("HTTPS"),
12984 Pathname: dara.String("/"),
12985 Method: dara.String("GET"),
12986 AuthType: dara.String("AK"),
12987 Style: dara.String("RPC"),
12988 ReqBodyType: dara.String("formData"),
12989 BodyType: dara.String("json"),
12990 }
12991 _result = &GetHttpsApplicationConfigurationResponse{}
12992 _body, _err := client.CallApi(params, req, runtime)
12993 if _err != nil {
12994 return _result, _err
12995 }
12996 _err = dara.Convert(_body, &_result)
12997 return _result, _err
12998 }
12999
13000 // Summary:
13001 //
13002 // # Query a Single HTTPS Application Configuration
13003 //
13004 // @param request - GetHttpsApplicationConfigurationRequest
13005 //
13006 // @return GetHttpsApplicationConfigurationResponse
13007 func GetHttpsApplicationConfiguration(client *Client, request *GetHttpsApplicationConfigurationRequest) (_result *GetHttpsApplicationConfigurationResponse, _err error) {
13008 runtime := &dara.RuntimeOptions{}
13009 _result = &GetHttpsApplicationConfigurationResponse{}
13010 _body, _err := GetHttpsApplicationConfigurationWithOptions(client,request, runtime)
13011 if _err != nil {
13012 return _result, _err
13013 }
13014 _result = _body
13015 return _result, _err
13016 }
13017
13018 // Summary:
13019 //
13020 // # Query a Single HTTPS Basic Configuration
13021 //
13022 // @param request - GetHttpsBasicConfigurationRequest
13023 //
13024 // @param runtime - runtime options for this request RuntimeOptions
13025 //
13026 // @return GetHttpsBasicConfigurationResponse
13027 func GetHttpsBasicConfigurationWithOptions(client *Client, request *GetHttpsBasicConfigurationRequest, runtime *dara.RuntimeOptions) (_result *GetHttpsBasicConfigurationResponse, _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("GetHttpsBasicConfiguration"),
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 = &GetHttpsBasicConfigurationResponse{}
13050 _body, _err := client.CallApi(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 // # Query a Single HTTPS Basic Configuration
13061 //
13062 // @param request - GetHttpsBasicConfigurationRequest
13063 //
13064 // @return GetHttpsBasicConfigurationResponse
13065 func GetHttpsBasicConfiguration(client *Client, request *GetHttpsBasicConfigurationRequest) (_result *GetHttpsBasicConfigurationResponse, _err error) {
13066 runtime := &dara.RuntimeOptions{}
13067 _result = &GetHttpsBasicConfigurationResponse{}
13068 _body, _err := GetHttpsBasicConfigurationWithOptions(client,request, runtime)
13069 if _err != nil {
13070 return _result, _err
13071 }
13072 _result = _body
13073 return _result, _err
13074 }
13075
13076 // Summary:
13077 //
13078 // Queries the IPv6 configuration of a website.
13079 //
13080 // @param request - GetIPv6Request
13081 //
13082 // @param runtime - runtime options for this request RuntimeOptions
13083 //
13084 // @return GetIPv6Response
13085 func GetIPv6WithOptions(client *Client, request *GetIPv6Request, runtime *dara.RuntimeOptions) (_result *GetIPv6Response, _err error) {
13086 if dara.BoolValue(client.EnableValidate) == true {
13087 _err = request.Validate()
13088 if _err != nil {
13089 return _result, _err
13090 }
13091 }
13092 query := openapiutil.Query(dara.ToMap(request))
13093 req := &openapiutil.OpenApiRequest{
13094 Query: openapiutil.Query(query),
13095 }
13096 params := &openapiutil.Params{
13097 Action: dara.String("GetIPv6"),
13098 Version: dara.String("2024-09-10"),
13099 Protocol: dara.String("HTTPS"),
13100 Pathname: dara.String("/"),
13101 Method: dara.String("GET"),
13102 AuthType: dara.String("AK"),
13103 Style: dara.String("RPC"),
13104 ReqBodyType: dara.String("formData"),
13105 BodyType: dara.String("json"),
13106 }
13107 _result = &GetIPv6Response{}
13108 _body, _err := client.CallApi(params, req, runtime)
13109 if _err != nil {
13110 return _result, _err
13111 }
13112 _err = dara.Convert(_body, &_result)
13113 return _result, _err
13114 }
13115
13116 // Summary:
13117 //
13118 // Queries the IPv6 configuration of a website.
13119 //
13120 // @param request - GetIPv6Request
13121 //
13122 // @return GetIPv6Response
13123 func GetIPv6(client *Client, request *GetIPv6Request) (_result *GetIPv6Response, _err error) {
13124 runtime := &dara.RuntimeOptions{}
13125 _result = &GetIPv6Response{}
13126 _body, _err := GetIPv6WithOptions(client,request, runtime)
13127 if _err != nil {
13128 return _result, _err
13129 }
13130 _result = _body
13131 return _result, _err
13132 }
13133
13134 // Summary:
13135 //
13136 // # Query Single Site Image Transformation Configuration
13137 //
13138 // @param request - GetImageTransformRequest
13139 //
13140 // @param runtime - runtime options for this request RuntimeOptions
13141 //
13142 // @return GetImageTransformResponse
13143 func GetImageTransformWithOptions(client *Client, request *GetImageTransformRequest, runtime *dara.RuntimeOptions) (_result *GetImageTransformResponse, _err error) {
13144 if dara.BoolValue(client.EnableValidate) == true {
13145 _err = request.Validate()
13146 if _err != nil {
13147 return _result, _err
13148 }
13149 }
13150 query := openapiutil.Query(dara.ToMap(request))
13151 req := &openapiutil.OpenApiRequest{
13152 Query: openapiutil.Query(query),
13153 }
13154 params := &openapiutil.Params{
13155 Action: dara.String("GetImageTransform"),
13156 Version: dara.String("2024-09-10"),
13157 Protocol: dara.String("HTTPS"),
13158 Pathname: dara.String("/"),
13159 Method: dara.String("GET"),
13160 AuthType: dara.String("AK"),
13161 Style: dara.String("RPC"),
13162 ReqBodyType: dara.String("formData"),
13163 BodyType: dara.String("json"),
13164 }
13165 _result = &GetImageTransformResponse{}
13166 _body, _err := client.CallApi(params, req, runtime)
13167 if _err != nil {
13168 return _result, _err
13169 }
13170 _err = dara.Convert(_body, &_result)
13171 return _result, _err
13172 }
13173
13174 // Summary:
13175 //
13176 // # Query Single Site Image Transformation Configuration
13177 //
13178 // @param request - GetImageTransformRequest
13179 //
13180 // @return GetImageTransformResponse
13181 func GetImageTransform(client *Client, request *GetImageTransformRequest) (_result *GetImageTransformResponse, _err error) {
13182 runtime := &dara.RuntimeOptions{}
13183 _result = &GetImageTransformResponse{}
13184 _body, _err := GetImageTransformWithOptions(client,request, runtime)
13185 if _err != nil {
13186 return _result, _err
13187 }
13188 _result = _body
13189 return _result, _err
13190 }
13191
13192 // Summary:
13193 //
13194 // Queries the value of a key in a key-value pair.
13195 //
13196 // @param request - GetKvRequest
13197 //
13198 // @param runtime - runtime options for this request RuntimeOptions
13199 //
13200 // @return GetKvResponse
13201 func GetKvWithOptions(client *Client, request *GetKvRequest, runtime *dara.RuntimeOptions) (_result *GetKvResponse, _err error) {
13202 if dara.BoolValue(client.EnableValidate) == true {
13203 _err = request.Validate()
13204 if _err != nil {
13205 return _result, _err
13206 }
13207 }
13208 query := openapiutil.Query(dara.ToMap(request))
13209 req := &openapiutil.OpenApiRequest{
13210 Query: openapiutil.Query(query),
13211 }
13212 params := &openapiutil.Params{
13213 Action: dara.String("GetKv"),
13214 Version: dara.String("2024-09-10"),
13215 Protocol: dara.String("HTTPS"),
13216 Pathname: dara.String("/"),
13217 Method: dara.String("GET"),
13218 AuthType: dara.String("AK"),
13219 Style: dara.String("RPC"),
13220 ReqBodyType: dara.String("formData"),
13221 BodyType: dara.String("json"),
13222 }
13223 _result = &GetKvResponse{}
13224 _body, _err := client.CallApi(params, req, runtime)
13225 if _err != nil {
13226 return _result, _err
13227 }
13228 _err = dara.Convert(_body, &_result)
13229 return _result, _err
13230 }
13231
13232 // Summary:
13233 //
13234 // Queries the value of a key in a key-value pair.
13235 //
13236 // @param request - GetKvRequest
13237 //
13238 // @return GetKvResponse
13239 func GetKv(client *Client, request *GetKvRequest) (_result *GetKvResponse, _err error) {
13240 runtime := &dara.RuntimeOptions{}
13241 _result = &GetKvResponse{}
13242 _body, _err := GetKvWithOptions(client,request, runtime)
13243 if _err != nil {
13244 return _result, _err
13245 }
13246 _result = _body
13247 return _result, _err
13248 }
13249
13250 // Summary:
13251 //
13252 // Queries the Edge KV usage in your Alibaba Cloud account, including the information about all namespaces.
13253 //
13254 // @param request - GetKvAccountRequest
13255 //
13256 // @param runtime - runtime options for this request RuntimeOptions
13257 //
13258 // @return GetKvAccountResponse
13259 func GetKvAccountWithOptions(client *Client, runtime *dara.RuntimeOptions) (_result *GetKvAccountResponse, _err error) {
13260 req := &openapiutil.OpenApiRequest{}
13261 params := &openapiutil.Params{
13262 Action: dara.String("GetKvAccount"),
13263 Version: dara.String("2024-09-10"),
13264 Protocol: dara.String("HTTPS"),
13265 Pathname: dara.String("/"),
13266 Method: dara.String("GET"),
13267 AuthType: dara.String("AK"),
13268 Style: dara.String("RPC"),
13269 ReqBodyType: dara.String("formData"),
13270 BodyType: dara.String("json"),
13271 }
13272 _result = &GetKvAccountResponse{}
13273 _body, _err := client.CallApi(params, req, runtime)
13274 if _err != nil {
13275 return _result, _err
13276 }
13277 _err = dara.Convert(_body, &_result)
13278 return _result, _err
13279 }
13280
13281 // Summary:
13282 //
13283 // Queries the Edge KV usage in your Alibaba Cloud account, including the information about all namespaces.
13284 //
13285 // @return GetKvAccountResponse
13286 func GetKvAccount(client *Client, ) (_result *GetKvAccountResponse, _err error) {
13287 runtime := &dara.RuntimeOptions{}
13288 _result = &GetKvAccountResponse{}
13289 _body, _err := GetKvAccountWithOptions(client,runtime)
13290 if _err != nil {
13291 return _result, _err
13292 }
13293 _result = _body
13294 return _result, _err
13295 }
13296
13297 // Summary:
13298 //
13299 // 查询Key-Value对的某个Key的详情
13300 //
13301 // @param request - GetKvDetailRequest
13302 //
13303 // @param runtime - runtime options for this request RuntimeOptions
13304 //
13305 // @return GetKvDetailResponse
13306 func GetKvDetailWithOptions(client *Client, request *GetKvDetailRequest, runtime *dara.RuntimeOptions) (_result *GetKvDetailResponse, _err error) {
13307 if dara.BoolValue(client.EnableValidate) == true {
13308 _err = request.Validate()
13309 if _err != nil {
13310 return _result, _err
13311 }
13312 }
13313 query := map[string]interface{}{}
13314 if !dara.IsNil(request.Key) {
13315 query["Key"] = request.Key
13316 }
13317
13318 if !dara.IsNil(request.Namespace) {
13319 query["Namespace"] = request.Namespace
13320 }
13321
13322 req := &openapiutil.OpenApiRequest{
13323 Query: openapiutil.Query(query),
13324 }
13325 params := &openapiutil.Params{
13326 Action: dara.String("GetKvDetail"),
13327 Version: dara.String("2024-09-10"),
13328 Protocol: dara.String("HTTPS"),
13329 Pathname: dara.String("/"),
13330 Method: dara.String("POST"),
13331 AuthType: dara.String("AK"),
13332 Style: dara.String("RPC"),
13333 ReqBodyType: dara.String("formData"),
13334 BodyType: dara.String("json"),
13335 }
13336 _result = &GetKvDetailResponse{}
13337 _body, _err := client.CallApi(params, req, runtime)
13338 if _err != nil {
13339 return _result, _err
13340 }
13341 _err = dara.Convert(_body, &_result)
13342 return _result, _err
13343 }
13344
13345 // Summary:
13346 //
13347 // 查询Key-Value对的某个Key的详情
13348 //
13349 // @param request - GetKvDetailRequest
13350 //
13351 // @return GetKvDetailResponse
13352 func GetKvDetail(client *Client, request *GetKvDetailRequest) (_result *GetKvDetailResponse, _err error) {
13353 runtime := &dara.RuntimeOptions{}
13354 _result = &GetKvDetailResponse{}
13355 _body, _err := GetKvDetailWithOptions(client,request, runtime)
13356 if _err != nil {
13357 return _result, _err
13358 }
13359 _result = _body
13360 return _result, _err
13361 }
13362
13363 // Summary:
13364 //
13365 // Queries the information about a namespace in your Alibaba Cloud account.
13366 //
13367 // @param request - GetKvNamespaceRequest
13368 //
13369 // @param runtime - runtime options for this request RuntimeOptions
13370 //
13371 // @return GetKvNamespaceResponse
13372 func GetKvNamespaceWithOptions(client *Client, request *GetKvNamespaceRequest, runtime *dara.RuntimeOptions) (_result *GetKvNamespaceResponse, _err error) {
13373 if dara.BoolValue(client.EnableValidate) == true {
13374 _err = request.Validate()
13375 if _err != nil {
13376 return _result, _err
13377 }
13378 }
13379 query := openapiutil.Query(dara.ToMap(request))
13380 req := &openapiutil.OpenApiRequest{
13381 Query: openapiutil.Query(query),
13382 }
13383 params := &openapiutil.Params{
13384 Action: dara.String("GetKvNamespace"),
13385 Version: dara.String("2024-09-10"),
13386 Protocol: dara.String("HTTPS"),
13387 Pathname: dara.String("/"),
13388 Method: dara.String("GET"),
13389 AuthType: dara.String("AK"),
13390 Style: dara.String("RPC"),
13391 ReqBodyType: dara.String("formData"),
13392 BodyType: dara.String("json"),
13393 }
13394 _result = &GetKvNamespaceResponse{}
13395 _body, _err := client.CallApi(params, req, runtime)
13396 if _err != nil {
13397 return _result, _err
13398 }
13399 _err = dara.Convert(_body, &_result)
13400 return _result, _err
13401 }
13402
13403 // Summary:
13404 //
13405 // Queries the information about a namespace in your Alibaba Cloud account.
13406 //
13407 // @param request - GetKvNamespaceRequest
13408 //
13409 // @return GetKvNamespaceResponse
13410 func GetKvNamespace(client *Client, request *GetKvNamespaceRequest) (_result *GetKvNamespaceResponse, _err error) {
13411 runtime := &dara.RuntimeOptions{}
13412 _result = &GetKvNamespaceResponse{}
13413 _body, _err := GetKvNamespaceWithOptions(client,request, runtime)
13414 if _err != nil {
13415 return _result, _err
13416 }
13417 _result = _body
13418 return _result, _err
13419 }
13420
13421 // Summary:
13422 //
13423 // Queries the details of a custom list, such as the name, description, type, and content.
13424 //
13425 // @param request - GetListRequest
13426 //
13427 // @param runtime - runtime options for this request RuntimeOptions
13428 //
13429 // @return GetListResponse
13430 func GetListWithOptions(client *Client, request *GetListRequest, runtime *dara.RuntimeOptions) (_result *GetListResponse, _err error) {
13431 if dara.BoolValue(client.EnableValidate) == true {
13432 _err = request.Validate()
13433 if _err != nil {
13434 return _result, _err
13435 }
13436 }
13437 query := map[string]interface{}{}
13438 if !dara.IsNil(request.Id) {
13439 query["Id"] = request.Id
13440 }
13441
13442 req := &openapiutil.OpenApiRequest{
13443 Query: openapiutil.Query(query),
13444 }
13445 params := &openapiutil.Params{
13446 Action: dara.String("GetList"),
13447 Version: dara.String("2024-09-10"),
13448 Protocol: dara.String("HTTPS"),
13449 Pathname: dara.String("/"),
13450 Method: dara.String("POST"),
13451 AuthType: dara.String("AK"),
13452 Style: dara.String("RPC"),
13453 ReqBodyType: dara.String("formData"),
13454 BodyType: dara.String("json"),
13455 }
13456 _result = &GetListResponse{}
13457 _body, _err := client.CallApi(params, req, runtime)
13458 if _err != nil {
13459 return _result, _err
13460 }
13461 _err = dara.Convert(_body, &_result)
13462 return _result, _err
13463 }
13464
13465 // Summary:
13466 //
13467 // Queries the details of a custom list, such as the name, description, type, and content.
13468 //
13469 // @param request - GetListRequest
13470 //
13471 // @return GetListResponse
13472 func GetList(client *Client, request *GetListRequest) (_result *GetListResponse, _err error) {
13473 runtime := &dara.RuntimeOptions{}
13474 _result = &GetListResponse{}
13475 _body, _err := GetListWithOptions(client,request, runtime)
13476 if _err != nil {
13477 return _result, _err
13478 }
13479 _result = _body
13480 return _result, _err
13481 }
13482
13483 // Summary:
13484 //
13485 // # Query a Specific Load Balancer
13486 //
13487 // Description:
13488 //
13489 // 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.
13490 //
13491 // @param request - GetLoadBalancerRequest
13492 //
13493 // @param runtime - runtime options for this request RuntimeOptions
13494 //
13495 // @return GetLoadBalancerResponse
13496 func GetLoadBalancerWithOptions(client *Client, request *GetLoadBalancerRequest, runtime *dara.RuntimeOptions) (_result *GetLoadBalancerResponse, _err error) {
13497 if dara.BoolValue(client.EnableValidate) == true {
13498 _err = request.Validate()
13499 if _err != nil {
13500 return _result, _err
13501 }
13502 }
13503 query := openapiutil.Query(dara.ToMap(request))
13504 req := &openapiutil.OpenApiRequest{
13505 Query: openapiutil.Query(query),
13506 }
13507 params := &openapiutil.Params{
13508 Action: dara.String("GetLoadBalancer"),
13509 Version: dara.String("2024-09-10"),
13510 Protocol: dara.String("HTTPS"),
13511 Pathname: dara.String("/"),
13512 Method: dara.String("GET"),
13513 AuthType: dara.String("AK"),
13514 Style: dara.String("RPC"),
13515 ReqBodyType: dara.String("formData"),
13516 BodyType: dara.String("json"),
13517 }
13518 _result = &GetLoadBalancerResponse{}
13519 _body, _err := client.CallApi(params, req, runtime)
13520 if _err != nil {
13521 return _result, _err
13522 }
13523 _err = dara.Convert(_body, &_result)
13524 return _result, _err
13525 }
13526
13527 // Summary:
13528 //
13529 // # Query a Specific Load Balancer
13530 //
13531 // Description:
13532 //
13533 // 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.
13534 //
13535 // @param request - GetLoadBalancerRequest
13536 //
13537 // @return GetLoadBalancerResponse
13538 func GetLoadBalancer(client *Client, request *GetLoadBalancerRequest) (_result *GetLoadBalancerResponse, _err error) {
13539 runtime := &dara.RuntimeOptions{}
13540 _result = &GetLoadBalancerResponse{}
13541 _body, _err := GetLoadBalancerWithOptions(client,request, runtime)
13542 if _err != nil {
13543 return _result, _err
13544 }
13545 _result = _body
13546 return _result, _err
13547 }
13548
13549 // Summary:
13550 //
13551 // # Query Managed Transform Configuration
13552 //
13553 // @param request - GetManagedTransformRequest
13554 //
13555 // @param runtime - runtime options for this request RuntimeOptions
13556 //
13557 // @return GetManagedTransformResponse
13558 func GetManagedTransformWithOptions(client *Client, request *GetManagedTransformRequest, runtime *dara.RuntimeOptions) (_result *GetManagedTransformResponse, _err error) {
13559 if dara.BoolValue(client.EnableValidate) == true {
13560 _err = request.Validate()
13561 if _err != nil {
13562 return _result, _err
13563 }
13564 }
13565 query := openapiutil.Query(dara.ToMap(request))
13566 req := &openapiutil.OpenApiRequest{
13567 Query: openapiutil.Query(query),
13568 }
13569 params := &openapiutil.Params{
13570 Action: dara.String("GetManagedTransform"),
13571 Version: dara.String("2024-09-10"),
13572 Protocol: dara.String("HTTPS"),
13573 Pathname: dara.String("/"),
13574 Method: dara.String("GET"),
13575 AuthType: dara.String("AK"),
13576 Style: dara.String("RPC"),
13577 ReqBodyType: dara.String("formData"),
13578 BodyType: dara.String("json"),
13579 }
13580 _result = &GetManagedTransformResponse{}
13581 _body, _err := client.CallApi(params, req, runtime)
13582 if _err != nil {
13583 return _result, _err
13584 }
13585 _err = dara.Convert(_body, &_result)
13586 return _result, _err
13587 }
13588
13589 // Summary:
13590 //
13591 // # Query Managed Transform Configuration
13592 //
13593 // @param request - GetManagedTransformRequest
13594 //
13595 // @return GetManagedTransformResponse
13596 func GetManagedTransform(client *Client, request *GetManagedTransformRequest) (_result *GetManagedTransformResponse, _err error) {
13597 runtime := &dara.RuntimeOptions{}
13598 _result = &GetManagedTransformResponse{}
13599 _body, _err := GetManagedTransformWithOptions(client,request, runtime)
13600 if _err != nil {
13601 return _result, _err
13602 }
13603 _result = _body
13604 return _result, _err
13605 }
13606
13607 // Summary:
13608 //
13609 // # Query a single network optimization configuration
13610 //
13611 // @param request - GetNetworkOptimizationRequest
13612 //
13613 // @param runtime - runtime options for this request RuntimeOptions
13614 //
13615 // @return GetNetworkOptimizationResponse
13616 func GetNetworkOptimizationWithOptions(client *Client, request *GetNetworkOptimizationRequest, runtime *dara.RuntimeOptions) (_result *GetNetworkOptimizationResponse, _err error) {
13617 if dara.BoolValue(client.EnableValidate) == true {
13618 _err = request.Validate()
13619 if _err != nil {
13620 return _result, _err
13621 }
13622 }
13623 query := openapiutil.Query(dara.ToMap(request))
13624 req := &openapiutil.OpenApiRequest{
13625 Query: openapiutil.Query(query),
13626 }
13627 params := &openapiutil.Params{
13628 Action: dara.String("GetNetworkOptimization"),
13629 Version: dara.String("2024-09-10"),
13630 Protocol: dara.String("HTTPS"),
13631 Pathname: dara.String("/"),
13632 Method: dara.String("GET"),
13633 AuthType: dara.String("AK"),
13634 Style: dara.String("RPC"),
13635 ReqBodyType: dara.String("formData"),
13636 BodyType: dara.String("json"),
13637 }
13638 _result = &GetNetworkOptimizationResponse{}
13639 _body, _err := client.CallApi(params, req, runtime)
13640 if _err != nil {
13641 return _result, _err
13642 }
13643 _err = dara.Convert(_body, &_result)
13644 return _result, _err
13645 }
13646
13647 // Summary:
13648 //
13649 // # Query a single network optimization configuration
13650 //
13651 // @param request - GetNetworkOptimizationRequest
13652 //
13653 // @return GetNetworkOptimizationResponse
13654 func GetNetworkOptimization(client *Client, request *GetNetworkOptimizationRequest) (_result *GetNetworkOptimizationResponse, _err error) {
13655 runtime := &dara.RuntimeOptions{}
13656 _result = &GetNetworkOptimizationResponse{}
13657 _body, _err := GetNetworkOptimizationWithOptions(client,request, runtime)
13658 if _err != nil {
13659 return _result, _err
13660 }
13661 _result = _body
13662 return _result, _err
13663 }
13664
13665 // Summary:
13666 //
13667 // 获取源服务器CA证书信息
13668 //
13669 // @param request - GetOriginCaCertificateRequest
13670 //
13671 // @param runtime - runtime options for this request RuntimeOptions
13672 //
13673 // @return GetOriginCaCertificateResponse
13674 func GetOriginCaCertificateWithOptions(client *Client, request *GetOriginCaCertificateRequest, runtime *dara.RuntimeOptions) (_result *GetOriginCaCertificateResponse, _err error) {
13675 if dara.BoolValue(client.EnableValidate) == true {
13676 _err = request.Validate()
13677 if _err != nil {
13678 return _result, _err
13679 }
13680 }
13681 query := openapiutil.Query(dara.ToMap(request))
13682 req := &openapiutil.OpenApiRequest{
13683 Query: openapiutil.Query(query),
13684 }
13685 params := &openapiutil.Params{
13686 Action: dara.String("GetOriginCaCertificate"),
13687 Version: dara.String("2024-09-10"),
13688 Protocol: dara.String("HTTPS"),
13689 Pathname: dara.String("/"),
13690 Method: dara.String("GET"),
13691 AuthType: dara.String("AK"),
13692 Style: dara.String("RPC"),
13693 ReqBodyType: dara.String("formData"),
13694 BodyType: dara.String("json"),
13695 }
13696 _result = &GetOriginCaCertificateResponse{}
13697 _body, _err := client.CallApi(params, req, runtime)
13698 if _err != nil {
13699 return _result, _err
13700 }
13701 _err = dara.Convert(_body, &_result)
13702 return _result, _err
13703 }
13704
13705 // Summary:
13706 //
13707 // 获取源服务器CA证书信息
13708 //
13709 // @param request - GetOriginCaCertificateRequest
13710 //
13711 // @return GetOriginCaCertificateResponse
13712 func GetOriginCaCertificate(client *Client, request *GetOriginCaCertificateRequest) (_result *GetOriginCaCertificateResponse, _err error) {
13713 runtime := &dara.RuntimeOptions{}
13714 _result = &GetOriginCaCertificateResponse{}
13715 _body, _err := GetOriginCaCertificateWithOptions(client,request, runtime)
13716 if _err != nil {
13717 return _result, _err
13718 }
13719 _result = _body
13720 return _result, _err
13721 }
13722
13723 // Summary:
13724 //
13725 // 获取域名回源客户端证书信息
13726 //
13727 // @param request - GetOriginClientCertificateRequest
13728 //
13729 // @param runtime - runtime options for this request RuntimeOptions
13730 //
13731 // @return GetOriginClientCertificateResponse
13732 func GetOriginClientCertificateWithOptions(client *Client, request *GetOriginClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *GetOriginClientCertificateResponse, _err error) {
13733 if dara.BoolValue(client.EnableValidate) == true {
13734 _err = request.Validate()
13735 if _err != nil {
13736 return _result, _err
13737 }
13738 }
13739 query := openapiutil.Query(dara.ToMap(request))
13740 req := &openapiutil.OpenApiRequest{
13741 Query: openapiutil.Query(query),
13742 }
13743 params := &openapiutil.Params{
13744 Action: dara.String("GetOriginClientCertificate"),
13745 Version: dara.String("2024-09-10"),
13746 Protocol: dara.String("HTTPS"),
13747 Pathname: dara.String("/"),
13748 Method: dara.String("GET"),
13749 AuthType: dara.String("AK"),
13750 Style: dara.String("RPC"),
13751 ReqBodyType: dara.String("formData"),
13752 BodyType: dara.String("json"),
13753 }
13754 _result = &GetOriginClientCertificateResponse{}
13755 _body, _err := client.CallApi(params, req, runtime)
13756 if _err != nil {
13757 return _result, _err
13758 }
13759 _err = dara.Convert(_body, &_result)
13760 return _result, _err
13761 }
13762
13763 // Summary:
13764 //
13765 // 获取域名回源客户端证书信息
13766 //
13767 // @param request - GetOriginClientCertificateRequest
13768 //
13769 // @return GetOriginClientCertificateResponse
13770 func GetOriginClientCertificate(client *Client, request *GetOriginClientCertificateRequest) (_result *GetOriginClientCertificateResponse, _err error) {
13771 runtime := &dara.RuntimeOptions{}
13772 _result = &GetOriginClientCertificateResponse{}
13773 _body, _err := GetOriginClientCertificateWithOptions(client,request, runtime)
13774 if _err != nil {
13775 return _result, _err
13776 }
13777 _result = _body
13778 return _result, _err
13779 }
13780
13781 // Summary:
13782 //
13783 // 获取域名回源客户端证书绑定的域名列表
13784 //
13785 // @param request - GetOriginClientCertificateHostnamesRequest
13786 //
13787 // @param runtime - runtime options for this request RuntimeOptions
13788 //
13789 // @return GetOriginClientCertificateHostnamesResponse
13790 func GetOriginClientCertificateHostnamesWithOptions(client *Client, request *GetOriginClientCertificateHostnamesRequest, runtime *dara.RuntimeOptions) (_result *GetOriginClientCertificateHostnamesResponse, _err error) {
13791 if dara.BoolValue(client.EnableValidate) == true {
13792 _err = request.Validate()
13793 if _err != nil {
13794 return _result, _err
13795 }
13796 }
13797 query := openapiutil.Query(dara.ToMap(request))
13798 req := &openapiutil.OpenApiRequest{
13799 Query: openapiutil.Query(query),
13800 }
13801 params := &openapiutil.Params{
13802 Action: dara.String("GetOriginClientCertificateHostnames"),
13803 Version: dara.String("2024-09-10"),
13804 Protocol: dara.String("HTTPS"),
13805 Pathname: dara.String("/"),
13806 Method: dara.String("GET"),
13807 AuthType: dara.String("AK"),
13808 Style: dara.String("RPC"),
13809 ReqBodyType: dara.String("formData"),
13810 BodyType: dara.String("json"),
13811 }
13812 _result = &GetOriginClientCertificateHostnamesResponse{}
13813 _body, _err := client.CallApi(params, req, runtime)
13814 if _err != nil {
13815 return _result, _err
13816 }
13817 _err = dara.Convert(_body, &_result)
13818 return _result, _err
13819 }
13820
13821 // Summary:
13822 //
13823 // 获取域名回源客户端证书绑定的域名列表
13824 //
13825 // @param request - GetOriginClientCertificateHostnamesRequest
13826 //
13827 // @return GetOriginClientCertificateHostnamesResponse
13828 func GetOriginClientCertificateHostnames(client *Client, request *GetOriginClientCertificateHostnamesRequest) (_result *GetOriginClientCertificateHostnamesResponse, _err error) {
13829 runtime := &dara.RuntimeOptions{}
13830 _result = &GetOriginClientCertificateHostnamesResponse{}
13831 _body, _err := GetOriginClientCertificateHostnamesWithOptions(client,request, runtime)
13832 if _err != nil {
13833 return _result, _err
13834 }
13835 _result = _body
13836 return _result, _err
13837 }
13838
13839 // Summary:
13840 //
13841 // # Query a specific origin pool
13842 //
13843 // @param request - GetOriginPoolRequest
13844 //
13845 // @param runtime - runtime options for this request RuntimeOptions
13846 //
13847 // @return GetOriginPoolResponse
13848 func GetOriginPoolWithOptions(client *Client, request *GetOriginPoolRequest, runtime *dara.RuntimeOptions) (_result *GetOriginPoolResponse, _err error) {
13849 if dara.BoolValue(client.EnableValidate) == true {
13850 _err = request.Validate()
13851 if _err != nil {
13852 return _result, _err
13853 }
13854 }
13855 query := openapiutil.Query(dara.ToMap(request))
13856 req := &openapiutil.OpenApiRequest{
13857 Query: openapiutil.Query(query),
13858 }
13859 params := &openapiutil.Params{
13860 Action: dara.String("GetOriginPool"),
13861 Version: dara.String("2024-09-10"),
13862 Protocol: dara.String("HTTPS"),
13863 Pathname: dara.String("/"),
13864 Method: dara.String("GET"),
13865 AuthType: dara.String("AK"),
13866 Style: dara.String("RPC"),
13867 ReqBodyType: dara.String("formData"),
13868 BodyType: dara.String("json"),
13869 }
13870 _result = &GetOriginPoolResponse{}
13871 _body, _err := client.CallApi(params, req, runtime)
13872 if _err != nil {
13873 return _result, _err
13874 }
13875 _err = dara.Convert(_body, &_result)
13876 return _result, _err
13877 }
13878
13879 // Summary:
13880 //
13881 // # Query a specific origin pool
13882 //
13883 // @param request - GetOriginPoolRequest
13884 //
13885 // @return GetOriginPoolResponse
13886 func GetOriginPool(client *Client, request *GetOriginPoolRequest) (_result *GetOriginPoolResponse, _err error) {
13887 runtime := &dara.RuntimeOptions{}
13888 _result = &GetOriginPoolResponse{}
13889 _body, _err := GetOriginPoolWithOptions(client,request, runtime)
13890 if _err != nil {
13891 return _result, _err
13892 }
13893 _result = _body
13894 return _result, _err
13895 }
13896
13897 // Summary:
13898 //
13899 // 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.
13900 //
13901 // @param request - GetOriginProtectionRequest
13902 //
13903 // @param runtime - runtime options for this request RuntimeOptions
13904 //
13905 // @return GetOriginProtectionResponse
13906 func GetOriginProtectionWithOptions(client *Client, request *GetOriginProtectionRequest, runtime *dara.RuntimeOptions) (_result *GetOriginProtectionResponse, _err error) {
13907 if dara.BoolValue(client.EnableValidate) == true {
13908 _err = request.Validate()
13909 if _err != nil {
13910 return _result, _err
13911 }
13912 }
13913 query := openapiutil.Query(dara.ToMap(request))
13914 req := &openapiutil.OpenApiRequest{
13915 Query: openapiutil.Query(query),
13916 }
13917 params := &openapiutil.Params{
13918 Action: dara.String("GetOriginProtection"),
13919 Version: dara.String("2024-09-10"),
13920 Protocol: dara.String("HTTPS"),
13921 Pathname: dara.String("/"),
13922 Method: dara.String("GET"),
13923 AuthType: dara.String("AK"),
13924 Style: dara.String("RPC"),
13925 ReqBodyType: dara.String("formData"),
13926 BodyType: dara.String("json"),
13927 }
13928 _result = &GetOriginProtectionResponse{}
13929 _body, _err := client.CallApi(params, req, runtime)
13930 if _err != nil {
13931 return _result, _err
13932 }
13933 _err = dara.Convert(_body, &_result)
13934 return _result, _err
13935 }
13936
13937 // Summary:
13938 //
13939 // 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.
13940 //
13941 // @param request - GetOriginProtectionRequest
13942 //
13943 // @return GetOriginProtectionResponse
13944 func GetOriginProtection(client *Client, request *GetOriginProtectionRequest) (_result *GetOriginProtectionResponse, _err error) {
13945 runtime := &dara.RuntimeOptions{}
13946 _result = &GetOriginProtectionResponse{}
13947 _body, _err := GetOriginProtectionWithOptions(client,request, runtime)
13948 if _err != nil {
13949 return _result, _err
13950 }
13951 _result = _body
13952 return _result, _err
13953 }
13954
13955 // Summary:
13956 //
13957 // Queries the configurations of a single origin rule.
13958 //
13959 // @param request - GetOriginRuleRequest
13960 //
13961 // @param runtime - runtime options for this request RuntimeOptions
13962 //
13963 // @return GetOriginRuleResponse
13964 func GetOriginRuleWithOptions(client *Client, request *GetOriginRuleRequest, runtime *dara.RuntimeOptions) (_result *GetOriginRuleResponse, _err error) {
13965 if dara.BoolValue(client.EnableValidate) == true {
13966 _err = request.Validate()
13967 if _err != nil {
13968 return _result, _err
13969 }
13970 }
13971 query := openapiutil.Query(dara.ToMap(request))
13972 req := &openapiutil.OpenApiRequest{
13973 Query: openapiutil.Query(query),
13974 }
13975 params := &openapiutil.Params{
13976 Action: dara.String("GetOriginRule"),
13977 Version: dara.String("2024-09-10"),
13978 Protocol: dara.String("HTTPS"),
13979 Pathname: dara.String("/"),
13980 Method: dara.String("GET"),
13981 AuthType: dara.String("AK"),
13982 Style: dara.String("RPC"),
13983 ReqBodyType: dara.String("formData"),
13984 BodyType: dara.String("json"),
13985 }
13986 _result = &GetOriginRuleResponse{}
13987 _body, _err := client.CallApi(params, req, runtime)
13988 if _err != nil {
13989 return _result, _err
13990 }
13991 _err = dara.Convert(_body, &_result)
13992 return _result, _err
13993 }
13994
13995 // Summary:
13996 //
13997 // Queries the configurations of a single origin rule.
13998 //
13999 // @param request - GetOriginRuleRequest
14000 //
14001 // @return GetOriginRuleResponse
14002 func GetOriginRule(client *Client, request *GetOriginRuleRequest) (_result *GetOriginRuleResponse, _err error) {
14003 runtime := &dara.RuntimeOptions{}
14004 _result = &GetOriginRuleResponse{}
14005 _body, _err := GetOriginRuleWithOptions(client,request, runtime)
14006 if _err != nil {
14007 return _result, _err
14008 }
14009 _result = _body
14010 return _result, _err
14011 }
14012
14013 // Summary:
14014 //
14015 // Queries the details of a custom error page based on the error page ID.
14016 //
14017 // @param request - GetPageRequest
14018 //
14019 // @param runtime - runtime options for this request RuntimeOptions
14020 //
14021 // @return GetPageResponse
14022 func GetPageWithOptions(client *Client, request *GetPageRequest, runtime *dara.RuntimeOptions) (_result *GetPageResponse, _err error) {
14023 if dara.BoolValue(client.EnableValidate) == true {
14024 _err = request.Validate()
14025 if _err != nil {
14026 return _result, _err
14027 }
14028 }
14029 query := map[string]interface{}{}
14030 if !dara.IsNil(request.Id) {
14031 query["Id"] = request.Id
14032 }
14033
14034 req := &openapiutil.OpenApiRequest{
14035 Query: openapiutil.Query(query),
14036 }
14037 params := &openapiutil.Params{
14038 Action: dara.String("GetPage"),
14039 Version: dara.String("2024-09-10"),
14040 Protocol: dara.String("HTTPS"),
14041 Pathname: dara.String("/"),
14042 Method: dara.String("POST"),
14043 AuthType: dara.String("AK"),
14044 Style: dara.String("RPC"),
14045 ReqBodyType: dara.String("formData"),
14046 BodyType: dara.String("json"),
14047 }
14048 _result = &GetPageResponse{}
14049 _body, _err := client.CallApi(params, req, runtime)
14050 if _err != nil {
14051 return _result, _err
14052 }
14053 _err = dara.Convert(_body, &_result)
14054 return _result, _err
14055 }
14056
14057 // Summary:
14058 //
14059 // Queries the details of a custom error page based on the error page ID.
14060 //
14061 // @param request - GetPageRequest
14062 //
14063 // @return GetPageResponse
14064 func GetPage(client *Client, request *GetPageRequest) (_result *GetPageResponse, _err error) {
14065 runtime := &dara.RuntimeOptions{}
14066 _result = &GetPageResponse{}
14067 _body, _err := GetPageWithOptions(client,request, runtime)
14068 if _err != nil {
14069 return _result, _err
14070 }
14071 _result = _body
14072 return _result, _err
14073 }
14074
14075 // Summary:
14076 //
14077 // Queries the quotas and quota usage for different cache purge options.
14078 //
14079 // @param request - GetPurgeQuotaRequest
14080 //
14081 // @param runtime - runtime options for this request RuntimeOptions
14082 //
14083 // @return GetPurgeQuotaResponse
14084 func GetPurgeQuotaWithOptions(client *Client, request *GetPurgeQuotaRequest, runtime *dara.RuntimeOptions) (_result *GetPurgeQuotaResponse, _err error) {
14085 if dara.BoolValue(client.EnableValidate) == true {
14086 _err = request.Validate()
14087 if _err != nil {
14088 return _result, _err
14089 }
14090 }
14091 query := openapiutil.Query(dara.ToMap(request))
14092 req := &openapiutil.OpenApiRequest{
14093 Query: openapiutil.Query(query),
14094 }
14095 params := &openapiutil.Params{
14096 Action: dara.String("GetPurgeQuota"),
14097 Version: dara.String("2024-09-10"),
14098 Protocol: dara.String("HTTPS"),
14099 Pathname: dara.String("/"),
14100 Method: dara.String("GET"),
14101 AuthType: dara.String("AK"),
14102 Style: dara.String("RPC"),
14103 ReqBodyType: dara.String("formData"),
14104 BodyType: dara.String("json"),
14105 }
14106 _result = &GetPurgeQuotaResponse{}
14107 _body, _err := client.CallApi(params, req, runtime)
14108 if _err != nil {
14109 return _result, _err
14110 }
14111 _err = dara.Convert(_body, &_result)
14112 return _result, _err
14113 }
14114
14115 // Summary:
14116 //
14117 // Queries the quotas and quota usage for different cache purge options.
14118 //
14119 // @param request - GetPurgeQuotaRequest
14120 //
14121 // @return GetPurgeQuotaResponse
14122 func GetPurgeQuota(client *Client, request *GetPurgeQuotaRequest) (_result *GetPurgeQuotaResponse, _err error) {
14123 runtime := &dara.RuntimeOptions{}
14124 _result = &GetPurgeQuotaResponse{}
14125 _body, _err := GetPurgeQuotaWithOptions(client,request, runtime)
14126 if _err != nil {
14127 return _result, _err
14128 }
14129 _result = _body
14130 return _result, _err
14131 }
14132
14133 // Summary:
14134 //
14135 // Queries the fields in real-time logs based on the log category.
14136 //
14137 // @param request - GetRealtimeDeliveryFieldRequest
14138 //
14139 // @param runtime - runtime options for this request RuntimeOptions
14140 //
14141 // @return GetRealtimeDeliveryFieldResponse
14142 func GetRealtimeDeliveryFieldWithOptions(client *Client, request *GetRealtimeDeliveryFieldRequest, runtime *dara.RuntimeOptions) (_result *GetRealtimeDeliveryFieldResponse, _err error) {
14143 if dara.BoolValue(client.EnableValidate) == true {
14144 _err = request.Validate()
14145 if _err != nil {
14146 return _result, _err
14147 }
14148 }
14149 query := openapiutil.Query(dara.ToMap(request))
14150 req := &openapiutil.OpenApiRequest{
14151 Query: openapiutil.Query(query),
14152 }
14153 params := &openapiutil.Params{
14154 Action: dara.String("GetRealtimeDeliveryField"),
14155 Version: dara.String("2024-09-10"),
14156 Protocol: dara.String("HTTPS"),
14157 Pathname: dara.String("/"),
14158 Method: dara.String("GET"),
14159 AuthType: dara.String("AK"),
14160 Style: dara.String("RPC"),
14161 ReqBodyType: dara.String("formData"),
14162 BodyType: dara.String("json"),
14163 }
14164 _result = &GetRealtimeDeliveryFieldResponse{}
14165 _body, _err := client.CallApi(params, req, runtime)
14166 if _err != nil {
14167 return _result, _err
14168 }
14169 _err = dara.Convert(_body, &_result)
14170 return _result, _err
14171 }
14172
14173 // Summary:
14174 //
14175 // Queries the fields in real-time logs based on the log category.
14176 //
14177 // @param request - GetRealtimeDeliveryFieldRequest
14178 //
14179 // @return GetRealtimeDeliveryFieldResponse
14180 func GetRealtimeDeliveryField(client *Client, request *GetRealtimeDeliveryFieldRequest) (_result *GetRealtimeDeliveryFieldResponse, _err error) {
14181 runtime := &dara.RuntimeOptions{}
14182 _result = &GetRealtimeDeliveryFieldResponse{}
14183 _body, _err := GetRealtimeDeliveryFieldWithOptions(client,request, runtime)
14184 if _err != nil {
14185 return _result, _err
14186 }
14187 _result = _body
14188 return _result, _err
14189 }
14190
14191 // Summary:
14192 //
14193 // Queries the configuration of a single DNS record, such as the record value, priority, and origin authentication setting (exclusive to CNAME records).
14194 //
14195 // @param request - GetRecordRequest
14196 //
14197 // @param runtime - runtime options for this request RuntimeOptions
14198 //
14199 // @return GetRecordResponse
14200 func GetRecordWithOptions(client *Client, request *GetRecordRequest, runtime *dara.RuntimeOptions) (_result *GetRecordResponse, _err error) {
14201 if dara.BoolValue(client.EnableValidate) == true {
14202 _err = request.Validate()
14203 if _err != nil {
14204 return _result, _err
14205 }
14206 }
14207 query := openapiutil.Query(dara.ToMap(request))
14208 req := &openapiutil.OpenApiRequest{
14209 Query: openapiutil.Query(query),
14210 }
14211 params := &openapiutil.Params{
14212 Action: dara.String("GetRecord"),
14213 Version: dara.String("2024-09-10"),
14214 Protocol: dara.String("HTTPS"),
14215 Pathname: dara.String("/"),
14216 Method: dara.String("GET"),
14217 AuthType: dara.String("AK"),
14218 Style: dara.String("RPC"),
14219 ReqBodyType: dara.String("formData"),
14220 BodyType: dara.String("json"),
14221 }
14222 _result = &GetRecordResponse{}
14223 _body, _err := client.CallApi(params, req, runtime)
14224 if _err != nil {
14225 return _result, _err
14226 }
14227 _err = dara.Convert(_body, &_result)
14228 return _result, _err
14229 }
14230
14231 // Summary:
14232 //
14233 // Queries the configuration of a single DNS record, such as the record value, priority, and origin authentication setting (exclusive to CNAME records).
14234 //
14235 // @param request - GetRecordRequest
14236 //
14237 // @return GetRecordResponse
14238 func GetRecord(client *Client, request *GetRecordRequest) (_result *GetRecordResponse, _err error) {
14239 runtime := &dara.RuntimeOptions{}
14240 _result = &GetRecordResponse{}
14241 _body, _err := GetRecordWithOptions(client,request, runtime)
14242 if _err != nil {
14243 return _result, _err
14244 }
14245 _result = _body
14246 return _result, _err
14247 }
14248
14249 // Summary:
14250 //
14251 // # Query Redirect Rule Details
14252 //
14253 // @param request - GetRedirectRuleRequest
14254 //
14255 // @param runtime - runtime options for this request RuntimeOptions
14256 //
14257 // @return GetRedirectRuleResponse
14258 func GetRedirectRuleWithOptions(client *Client, request *GetRedirectRuleRequest, runtime *dara.RuntimeOptions) (_result *GetRedirectRuleResponse, _err error) {
14259 if dara.BoolValue(client.EnableValidate) == true {
14260 _err = request.Validate()
14261 if _err != nil {
14262 return _result, _err
14263 }
14264 }
14265 query := openapiutil.Query(dara.ToMap(request))
14266 req := &openapiutil.OpenApiRequest{
14267 Query: openapiutil.Query(query),
14268 }
14269 params := &openapiutil.Params{
14270 Action: dara.String("GetRedirectRule"),
14271 Version: dara.String("2024-09-10"),
14272 Protocol: dara.String("HTTPS"),
14273 Pathname: dara.String("/"),
14274 Method: dara.String("GET"),
14275 AuthType: dara.String("AK"),
14276 Style: dara.String("RPC"),
14277 ReqBodyType: dara.String("formData"),
14278 BodyType: dara.String("json"),
14279 }
14280 _result = &GetRedirectRuleResponse{}
14281 _body, _err := client.CallApi(params, req, runtime)
14282 if _err != nil {
14283 return _result, _err
14284 }
14285 _err = dara.Convert(_body, &_result)
14286 return _result, _err
14287 }
14288
14289 // Summary:
14290 //
14291 // # Query Redirect Rule Details
14292 //
14293 // @param request - GetRedirectRuleRequest
14294 //
14295 // @return GetRedirectRuleResponse
14296 func GetRedirectRule(client *Client, request *GetRedirectRuleRequest) (_result *GetRedirectRuleResponse, _err error) {
14297 runtime := &dara.RuntimeOptions{}
14298 _result = &GetRedirectRuleResponse{}
14299 _body, _err := GetRedirectRuleWithOptions(client,request, runtime)
14300 if _err != nil {
14301 return _result, _err
14302 }
14303 _result = _body
14304 return _result, _err
14305 }
14306
14307 // Summary:
14308 //
14309 // # Query details of the rewrite URL rule
14310 //
14311 // @param request - GetRewriteUrlRuleRequest
14312 //
14313 // @param runtime - runtime options for this request RuntimeOptions
14314 //
14315 // @return GetRewriteUrlRuleResponse
14316 func GetRewriteUrlRuleWithOptions(client *Client, request *GetRewriteUrlRuleRequest, runtime *dara.RuntimeOptions) (_result *GetRewriteUrlRuleResponse, _err error) {
14317 if dara.BoolValue(client.EnableValidate) == true {
14318 _err = request.Validate()
14319 if _err != nil {
14320 return _result, _err
14321 }
14322 }
14323 query := openapiutil.Query(dara.ToMap(request))
14324 req := &openapiutil.OpenApiRequest{
14325 Query: openapiutil.Query(query),
14326 }
14327 params := &openapiutil.Params{
14328 Action: dara.String("GetRewriteUrlRule"),
14329 Version: dara.String("2024-09-10"),
14330 Protocol: dara.String("HTTPS"),
14331 Pathname: dara.String("/"),
14332 Method: dara.String("GET"),
14333 AuthType: dara.String("AK"),
14334 Style: dara.String("RPC"),
14335 ReqBodyType: dara.String("formData"),
14336 BodyType: dara.String("json"),
14337 }
14338 _result = &GetRewriteUrlRuleResponse{}
14339 _body, _err := client.CallApi(params, req, runtime)
14340 if _err != nil {
14341 return _result, _err
14342 }
14343 _err = dara.Convert(_body, &_result)
14344 return _result, _err
14345 }
14346
14347 // Summary:
14348 //
14349 // # Query details of the rewrite URL rule
14350 //
14351 // @param request - GetRewriteUrlRuleRequest
14352 //
14353 // @return GetRewriteUrlRuleResponse
14354 func GetRewriteUrlRule(client *Client, request *GetRewriteUrlRuleRequest) (_result *GetRewriteUrlRuleResponse, _err error) {
14355 runtime := &dara.RuntimeOptions{}
14356 _result = &GetRewriteUrlRuleResponse{}
14357 _body, _err := GetRewriteUrlRuleWithOptions(client,request, runtime)
14358 if _err != nil {
14359 return _result, _err
14360 }
14361 _result = _body
14362 return _result, _err
14363 }
14364
14365 // Summary:
14366 //
14367 // Queries the configurations of a routine, including the code versions and the configurations of the environments, associated domain names, and associated routes.
14368 //
14369 // @param request - GetRoutineRequest
14370 //
14371 // @param runtime - runtime options for this request RuntimeOptions
14372 //
14373 // @return GetRoutineResponse
14374 func GetRoutineWithOptions(client *Client, request *GetRoutineRequest, runtime *dara.RuntimeOptions) (_result *GetRoutineResponse, _err error) {
14375 if dara.BoolValue(client.EnableValidate) == true {
14376 _err = request.Validate()
14377 if _err != nil {
14378 return _result, _err
14379 }
14380 }
14381 body := map[string]interface{}{}
14382 if !dara.IsNil(request.Name) {
14383 body["Name"] = request.Name
14384 }
14385
14386 req := &openapiutil.OpenApiRequest{
14387 Body: openapiutil.ParseToMap(body),
14388 }
14389 params := &openapiutil.Params{
14390 Action: dara.String("GetRoutine"),
14391 Version: dara.String("2024-09-10"),
14392 Protocol: dara.String("HTTPS"),
14393 Pathname: dara.String("/"),
14394 Method: dara.String("POST"),
14395 AuthType: dara.String("AK"),
14396 Style: dara.String("RPC"),
14397 ReqBodyType: dara.String("formData"),
14398 BodyType: dara.String("json"),
14399 }
14400 _result = &GetRoutineResponse{}
14401 _body, _err := client.CallApi(params, req, runtime)
14402 if _err != nil {
14403 return _result, _err
14404 }
14405 _err = dara.Convert(_body, &_result)
14406 return _result, _err
14407 }
14408
14409 // Summary:
14410 //
14411 // Queries the configurations of a routine, including the code versions and the configurations of the environments, associated domain names, and associated routes.
14412 //
14413 // @param request - GetRoutineRequest
14414 //
14415 // @return GetRoutineResponse
14416 func GetRoutine(client *Client, request *GetRoutineRequest) (_result *GetRoutineResponse, _err error) {
14417 runtime := &dara.RuntimeOptions{}
14418 _result = &GetRoutineResponse{}
14419 _body, _err := GetRoutineWithOptions(client,request, runtime)
14420 if _err != nil {
14421 return _result, _err
14422 }
14423 _result = _body
14424 return _result, _err
14425 }
14426
14427 // Summary:
14428 //
14429 // 查询Routine默认访问记录访问鉴权token
14430 //
14431 // @param request - GetRoutineAccessTokenRequest
14432 //
14433 // @param runtime - runtime options for this request RuntimeOptions
14434 //
14435 // @return GetRoutineAccessTokenResponse
14436 func GetRoutineAccessTokenWithOptions(client *Client, request *GetRoutineAccessTokenRequest, runtime *dara.RuntimeOptions) (_result *GetRoutineAccessTokenResponse, _err error) {
14437 if dara.BoolValue(client.EnableValidate) == true {
14438 _err = request.Validate()
14439 if _err != nil {
14440 return _result, _err
14441 }
14442 }
14443 body := map[string]interface{}{}
14444 if !dara.IsNil(request.Name) {
14445 body["Name"] = request.Name
14446 }
14447
14448 req := &openapiutil.OpenApiRequest{
14449 Body: openapiutil.ParseToMap(body),
14450 }
14451 params := &openapiutil.Params{
14452 Action: dara.String("GetRoutineAccessToken"),
14453 Version: dara.String("2024-09-10"),
14454 Protocol: dara.String("HTTPS"),
14455 Pathname: dara.String("/"),
14456 Method: dara.String("POST"),
14457 AuthType: dara.String("AK"),
14458 Style: dara.String("RPC"),
14459 ReqBodyType: dara.String("formData"),
14460 BodyType: dara.String("json"),
14461 }
14462 _result = &GetRoutineAccessTokenResponse{}
14463 _body, _err := client.CallApi(params, req, runtime)
14464 if _err != nil {
14465 return _result, _err
14466 }
14467 _err = dara.Convert(_body, &_result)
14468 return _result, _err
14469 }
14470
14471 // Summary:
14472 //
14473 // 查询Routine默认访问记录访问鉴权token
14474 //
14475 // @param request - GetRoutineAccessTokenRequest
14476 //
14477 // @return GetRoutineAccessTokenResponse
14478 func GetRoutineAccessToken(client *Client, request *GetRoutineAccessTokenRequest) (_result *GetRoutineAccessTokenResponse, _err error) {
14479 runtime := &dara.RuntimeOptions{}
14480 _result = &GetRoutineAccessTokenResponse{}
14481 _body, _err := GetRoutineAccessTokenWithOptions(client,request, runtime)
14482 if _err != nil {
14483 return _result, _err
14484 }
14485 _result = _body
14486 return _result, _err
14487 }
14488
14489 // Summary:
14490 //
14491 // Queries information about a code version of a routine.
14492 //
14493 // @param request - GetRoutineCodeVersionRequest
14494 //
14495 // @param runtime - runtime options for this request RuntimeOptions
14496 //
14497 // @return GetRoutineCodeVersionResponse
14498 func GetRoutineCodeVersionWithOptions(client *Client, request *GetRoutineCodeVersionRequest, runtime *dara.RuntimeOptions) (_result *GetRoutineCodeVersionResponse, _err error) {
14499 if dara.BoolValue(client.EnableValidate) == true {
14500 _err = request.Validate()
14501 if _err != nil {
14502 return _result, _err
14503 }
14504 }
14505 body := map[string]interface{}{}
14506 if !dara.IsNil(request.CodeVersion) {
14507 body["CodeVersion"] = request.CodeVersion
14508 }
14509
14510 if !dara.IsNil(request.Name) {
14511 body["Name"] = request.Name
14512 }
14513
14514 req := &openapiutil.OpenApiRequest{
14515 Body: openapiutil.ParseToMap(body),
14516 }
14517 params := &openapiutil.Params{
14518 Action: dara.String("GetRoutineCodeVersion"),
14519 Version: dara.String("2024-09-10"),
14520 Protocol: dara.String("HTTPS"),
14521 Pathname: dara.String("/"),
14522 Method: dara.String("POST"),
14523 AuthType: dara.String("AK"),
14524 Style: dara.String("RPC"),
14525 ReqBodyType: dara.String("formData"),
14526 BodyType: dara.String("json"),
14527 }
14528 _result = &GetRoutineCodeVersionResponse{}
14529 _body, _err := client.CallApi(params, req, runtime)
14530 if _err != nil {
14531 return _result, _err
14532 }
14533 _err = dara.Convert(_body, &_result)
14534 return _result, _err
14535 }
14536
14537 // Summary:
14538 //
14539 // Queries information about a code version of a routine.
14540 //
14541 // @param request - GetRoutineCodeVersionRequest
14542 //
14543 // @return GetRoutineCodeVersionResponse
14544 func GetRoutineCodeVersion(client *Client, request *GetRoutineCodeVersionRequest) (_result *GetRoutineCodeVersionResponse, _err error) {
14545 runtime := &dara.RuntimeOptions{}
14546 _result = &GetRoutineCodeVersionResponse{}
14547 _body, _err := GetRoutineCodeVersionWithOptions(client,request, runtime)
14548 if _err != nil {
14549 return _result, _err
14550 }
14551 _result = _body
14552 return _result, _err
14553 }
14554
14555 // Summary:
14556 //
14557 // Queries the route configurations of a single edge function.
14558 //
14559 // @param request - GetRoutineRouteRequest
14560 //
14561 // @param runtime - runtime options for this request RuntimeOptions
14562 //
14563 // @return GetRoutineRouteResponse
14564 func GetRoutineRouteWithOptions(client *Client, request *GetRoutineRouteRequest, runtime *dara.RuntimeOptions) (_result *GetRoutineRouteResponse, _err error) {
14565 if dara.BoolValue(client.EnableValidate) == true {
14566 _err = request.Validate()
14567 if _err != nil {
14568 return _result, _err
14569 }
14570 }
14571 query := map[string]interface{}{}
14572 if !dara.IsNil(request.ConfigId) {
14573 query["ConfigId"] = request.ConfigId
14574 }
14575
14576 if !dara.IsNil(request.SiteId) {
14577 query["SiteId"] = request.SiteId
14578 }
14579
14580 req := &openapiutil.OpenApiRequest{
14581 Query: openapiutil.Query(query),
14582 }
14583 params := &openapiutil.Params{
14584 Action: dara.String("GetRoutineRoute"),
14585 Version: dara.String("2024-09-10"),
14586 Protocol: dara.String("HTTPS"),
14587 Pathname: dara.String("/"),
14588 Method: dara.String("POST"),
14589 AuthType: dara.String("AK"),
14590 Style: dara.String("RPC"),
14591 ReqBodyType: dara.String("formData"),
14592 BodyType: dara.String("json"),
14593 }
14594 _result = &GetRoutineRouteResponse{}
14595 _body, _err := client.CallApi(params, req, runtime)
14596 if _err != nil {
14597 return _result, _err
14598 }
14599 _err = dara.Convert(_body, &_result)
14600 return _result, _err
14601 }
14602
14603 // Summary:
14604 //
14605 // Queries the route configurations of a single edge function.
14606 //
14607 // @param request - GetRoutineRouteRequest
14608 //
14609 // @return GetRoutineRouteResponse
14610 func GetRoutineRoute(client *Client, request *GetRoutineRouteRequest) (_result *GetRoutineRouteResponse, _err error) {
14611 runtime := &dara.RuntimeOptions{}
14612 _result = &GetRoutineRouteResponse{}
14613 _body, _err := GetRoutineRouteWithOptions(client,request, runtime)
14614 if _err != nil {
14615 return _result, _err
14616 }
14617 _result = _body
14618 return _result, _err
14619 }
14620
14621 // Summary:
14622 //
14623 // 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).
14624 //
14625 // Description:
14626 //
14627 // Every time the code of a routine is released to the staging environment, a version number is generated. Such code is for tests only.
14628 //
14629 // - 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.
14630 //
14631 // @param request - GetRoutineStagingCodeUploadInfoRequest
14632 //
14633 // @param runtime - runtime options for this request RuntimeOptions
14634 //
14635 // @return GetRoutineStagingCodeUploadInfoResponse
14636 func GetRoutineStagingCodeUploadInfoWithOptions(client *Client, request *GetRoutineStagingCodeUploadInfoRequest, runtime *dara.RuntimeOptions) (_result *GetRoutineStagingCodeUploadInfoResponse, _err error) {
14637 if dara.BoolValue(client.EnableValidate) == true {
14638 _err = request.Validate()
14639 if _err != nil {
14640 return _result, _err
14641 }
14642 }
14643 body := map[string]interface{}{}
14644 if !dara.IsNil(request.CodeDescription) {
14645 body["CodeDescription"] = request.CodeDescription
14646 }
14647
14648 if !dara.IsNil(request.Name) {
14649 body["Name"] = request.Name
14650 }
14651
14652 req := &openapiutil.OpenApiRequest{
14653 Body: openapiutil.ParseToMap(body),
14654 }
14655 params := &openapiutil.Params{
14656 Action: dara.String("GetRoutineStagingCodeUploadInfo"),
14657 Version: dara.String("2024-09-10"),
14658 Protocol: dara.String("HTTPS"),
14659 Pathname: dara.String("/"),
14660 Method: dara.String("POST"),
14661 AuthType: dara.String("AK"),
14662 Style: dara.String("RPC"),
14663 ReqBodyType: dara.String("formData"),
14664 BodyType: dara.String("json"),
14665 }
14666 _result = &GetRoutineStagingCodeUploadInfoResponse{}
14667 _body, _err := client.CallApi(params, req, runtime)
14668 if _err != nil {
14669 return _result, _err
14670 }
14671 _err = dara.Convert(_body, &_result)
14672 return _result, _err
14673 }
14674
14675 // Summary:
14676 //
14677 // 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).
14678 //
14679 // Description:
14680 //
14681 // Every time the code of a routine is released to the staging environment, a version number is generated. Such code is for tests only.
14682 //
14683 // - 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.
14684 //
14685 // @param request - GetRoutineStagingCodeUploadInfoRequest
14686 //
14687 // @return GetRoutineStagingCodeUploadInfoResponse
14688 func GetRoutineStagingCodeUploadInfo(client *Client, request *GetRoutineStagingCodeUploadInfoRequest) (_result *GetRoutineStagingCodeUploadInfoResponse, _err error) {
14689 runtime := &dara.RuntimeOptions{}
14690 _result = &GetRoutineStagingCodeUploadInfoResponse{}
14691 _body, _err := GetRoutineStagingCodeUploadInfoWithOptions(client,request, runtime)
14692 if _err != nil {
14693 return _result, _err
14694 }
14695 _result = _body
14696 return _result, _err
14697 }
14698
14699 // Summary:
14700 //
14701 // Queries the IP addresses of staging environments for Edge Routine.
14702 //
14703 // @param request - GetRoutineStagingEnvIpRequest
14704 //
14705 // @param runtime - runtime options for this request RuntimeOptions
14706 //
14707 // @return GetRoutineStagingEnvIpResponse
14708 func GetRoutineStagingEnvIpWithOptions(client *Client, runtime *dara.RuntimeOptions) (_result *GetRoutineStagingEnvIpResponse, _err error) {
14709 req := &openapiutil.OpenApiRequest{}
14710 params := &openapiutil.Params{
14711 Action: dara.String("GetRoutineStagingEnvIp"),
14712 Version: dara.String("2024-09-10"),
14713 Protocol: dara.String("HTTPS"),
14714 Pathname: dara.String("/"),
14715 Method: dara.String("POST"),
14716 AuthType: dara.String("AK"),
14717 Style: dara.String("RPC"),
14718 ReqBodyType: dara.String("formData"),
14719 BodyType: dara.String("json"),
14720 }
14721 _result = &GetRoutineStagingEnvIpResponse{}
14722 _body, _err := client.CallApi(params, req, runtime)
14723 if _err != nil {
14724 return _result, _err
14725 }
14726 _err = dara.Convert(_body, &_result)
14727 return _result, _err
14728 }
14729
14730 // Summary:
14731 //
14732 // Queries the IP addresses of staging environments for Edge Routine.
14733 //
14734 // @return GetRoutineStagingEnvIpResponse
14735 func GetRoutineStagingEnvIp(client *Client, ) (_result *GetRoutineStagingEnvIpResponse, _err error) {
14736 runtime := &dara.RuntimeOptions{}
14737 _result = &GetRoutineStagingEnvIpResponse{}
14738 _body, _err := GetRoutineStagingEnvIpWithOptions(client,runtime)
14739 if _err != nil {
14740 return _result, _err
14741 }
14742 _result = _body
14743 return _result, _err
14744 }
14745
14746 // Summary:
14747 //
14748 // Queries the Edge Routine information in your Alibaba Cloud account, including the associated subdomain and created routines.
14749 //
14750 // @param request - GetRoutineUserInfoRequest
14751 //
14752 // @param runtime - runtime options for this request RuntimeOptions
14753 //
14754 // @return GetRoutineUserInfoResponse
14755 func GetRoutineUserInfoWithOptions(client *Client, runtime *dara.RuntimeOptions) (_result *GetRoutineUserInfoResponse, _err error) {
14756 req := &openapiutil.OpenApiRequest{}
14757 params := &openapiutil.Params{
14758 Action: dara.String("GetRoutineUserInfo"),
14759 Version: dara.String("2024-09-10"),
14760 Protocol: dara.String("HTTPS"),
14761 Pathname: dara.String("/"),
14762 Method: dara.String("POST"),
14763 AuthType: dara.String("AK"),
14764 Style: dara.String("RPC"),
14765 ReqBodyType: dara.String("formData"),
14766 BodyType: dara.String("json"),
14767 }
14768 _result = &GetRoutineUserInfoResponse{}
14769 _body, _err := client.CallApi(params, req, runtime)
14770 if _err != nil {
14771 return _result, _err
14772 }
14773 _err = dara.Convert(_body, &_result)
14774 return _result, _err
14775 }
14776
14777 // Summary:
14778 //
14779 // Queries the Edge Routine information in your Alibaba Cloud account, including the associated subdomain and created routines.
14780 //
14781 // @return GetRoutineUserInfoResponse
14782 func GetRoutineUserInfo(client *Client, ) (_result *GetRoutineUserInfoResponse, _err error) {
14783 runtime := &dara.RuntimeOptions{}
14784 _result = &GetRoutineUserInfoResponse{}
14785 _body, _err := GetRoutineUserInfoWithOptions(client,runtime)
14786 if _err != nil {
14787 return _result, _err
14788 }
14789 _result = _body
14790 return _result, _err
14791 }
14792
14793 // Summary:
14794 //
14795 // Queries a specified scheduled prefetch task based on the task ID.
14796 //
14797 // @param request - GetScheduledPreloadJobRequest
14798 //
14799 // @param runtime - runtime options for this request RuntimeOptions
14800 //
14801 // @return GetScheduledPreloadJobResponse
14802 func GetScheduledPreloadJobWithOptions(client *Client, request *GetScheduledPreloadJobRequest, runtime *dara.RuntimeOptions) (_result *GetScheduledPreloadJobResponse, _err error) {
14803 if dara.BoolValue(client.EnableValidate) == true {
14804 _err = request.Validate()
14805 if _err != nil {
14806 return _result, _err
14807 }
14808 }
14809 query := openapiutil.Query(dara.ToMap(request))
14810 req := &openapiutil.OpenApiRequest{
14811 Query: openapiutil.Query(query),
14812 }
14813 params := &openapiutil.Params{
14814 Action: dara.String("GetScheduledPreloadJob"),
14815 Version: dara.String("2024-09-10"),
14816 Protocol: dara.String("HTTPS"),
14817 Pathname: dara.String("/"),
14818 Method: dara.String("GET"),
14819 AuthType: dara.String("AK"),
14820 Style: dara.String("RPC"),
14821 ReqBodyType: dara.String("formData"),
14822 BodyType: dara.String("json"),
14823 }
14824 _result = &GetScheduledPreloadJobResponse{}
14825 _body, _err := client.CallApi(params, req, runtime)
14826 if _err != nil {
14827 return _result, _err
14828 }
14829 _err = dara.Convert(_body, &_result)
14830 return _result, _err
14831 }
14832
14833 // Summary:
14834 //
14835 // Queries a specified scheduled prefetch task based on the task ID.
14836 //
14837 // @param request - GetScheduledPreloadJobRequest
14838 //
14839 // @return GetScheduledPreloadJobResponse
14840 func GetScheduledPreloadJob(client *Client, request *GetScheduledPreloadJobRequest) (_result *GetScheduledPreloadJobResponse, _err error) {
14841 runtime := &dara.RuntimeOptions{}
14842 _result = &GetScheduledPreloadJobResponse{}
14843 _body, _err := GetScheduledPreloadJobWithOptions(client,request, runtime)
14844 if _err != nil {
14845 return _result, _err
14846 }
14847 _result = _body
14848 return _result, _err
14849 }
14850
14851 // Summary:
14852 //
14853 // Queries the configuration for search engine crawler of a website.
14854 //
14855 // @param request - GetSeoBypassRequest
14856 //
14857 // @param runtime - runtime options for this request RuntimeOptions
14858 //
14859 // @return GetSeoBypassResponse
14860 func GetSeoBypassWithOptions(client *Client, request *GetSeoBypassRequest, runtime *dara.RuntimeOptions) (_result *GetSeoBypassResponse, _err error) {
14861 if dara.BoolValue(client.EnableValidate) == true {
14862 _err = request.Validate()
14863 if _err != nil {
14864 return _result, _err
14865 }
14866 }
14867 query := openapiutil.Query(dara.ToMap(request))
14868 req := &openapiutil.OpenApiRequest{
14869 Query: openapiutil.Query(query),
14870 }
14871 params := &openapiutil.Params{
14872 Action: dara.String("GetSeoBypass"),
14873 Version: dara.String("2024-09-10"),
14874 Protocol: dara.String("HTTPS"),
14875 Pathname: dara.String("/"),
14876 Method: dara.String("GET"),
14877 AuthType: dara.String("AK"),
14878 Style: dara.String("RPC"),
14879 ReqBodyType: dara.String("formData"),
14880 BodyType: dara.String("json"),
14881 }
14882 _result = &GetSeoBypassResponse{}
14883 _body, _err := client.CallApi(params, req, runtime)
14884 if _err != nil {
14885 return _result, _err
14886 }
14887 _err = dara.Convert(_body, &_result)
14888 return _result, _err
14889 }
14890
14891 // Summary:
14892 //
14893 // Queries the configuration for search engine crawler of a website.
14894 //
14895 // @param request - GetSeoBypassRequest
14896 //
14897 // @return GetSeoBypassResponse
14898 func GetSeoBypass(client *Client, request *GetSeoBypassRequest) (_result *GetSeoBypassResponse, _err error) {
14899 runtime := &dara.RuntimeOptions{}
14900 _result = &GetSeoBypassResponse{}
14901 _body, _err := GetSeoBypassWithOptions(client,request, runtime)
14902 if _err != nil {
14903 return _result, _err
14904 }
14905 _result = _body
14906 return _result, _err
14907 }
14908
14909 // Summary:
14910 //
14911 // Queries information about a website based on the website ID.
14912 //
14913 // @param request - GetSiteRequest
14914 //
14915 // @param runtime - runtime options for this request RuntimeOptions
14916 //
14917 // @return GetSiteResponse
14918 func GetSiteWithOptions(client *Client, request *GetSiteRequest, runtime *dara.RuntimeOptions) (_result *GetSiteResponse, _err error) {
14919 if dara.BoolValue(client.EnableValidate) == true {
14920 _err = request.Validate()
14921 if _err != nil {
14922 return _result, _err
14923 }
14924 }
14925 query := openapiutil.Query(dara.ToMap(request))
14926 req := &openapiutil.OpenApiRequest{
14927 Query: openapiutil.Query(query),
14928 }
14929 params := &openapiutil.Params{
14930 Action: dara.String("GetSite"),
14931 Version: dara.String("2024-09-10"),
14932 Protocol: dara.String("HTTPS"),
14933 Pathname: dara.String("/"),
14934 Method: dara.String("GET"),
14935 AuthType: dara.String("AK"),
14936 Style: dara.String("RPC"),
14937 ReqBodyType: dara.String("formData"),
14938 BodyType: dara.String("json"),
14939 }
14940 _result = &GetSiteResponse{}
14941 _body, _err := client.CallApi(params, req, runtime)
14942 if _err != nil {
14943 return _result, _err
14944 }
14945 _err = dara.Convert(_body, &_result)
14946 return _result, _err
14947 }
14948
14949 // Summary:
14950 //
14951 // Queries information about a website based on the website ID.
14952 //
14953 // @param request - GetSiteRequest
14954 //
14955 // @return GetSiteResponse
14956 func GetSite(client *Client, request *GetSiteRequest) (_result *GetSiteResponse, _err error) {
14957 runtime := &dara.RuntimeOptions{}
14958 _result = &GetSiteResponse{}
14959 _body, _err := GetSiteWithOptions(client,request, runtime)
14960 if _err != nil {
14961 return _result, _err
14962 }
14963 _result = _body
14964 return _result, _err
14965 }
14966
14967 // Summary:
14968 //
14969 // Queries the nameservers configured for a website.
14970 //
14971 // @param request - GetSiteCurrentNSRequest
14972 //
14973 // @param runtime - runtime options for this request RuntimeOptions
14974 //
14975 // @return GetSiteCurrentNSResponse
14976 func GetSiteCurrentNSWithOptions(client *Client, request *GetSiteCurrentNSRequest, runtime *dara.RuntimeOptions) (_result *GetSiteCurrentNSResponse, _err error) {
14977 if dara.BoolValue(client.EnableValidate) == true {
14978 _err = request.Validate()
14979 if _err != nil {
14980 return _result, _err
14981 }
14982 }
14983 query := openapiutil.Query(dara.ToMap(request))
14984 req := &openapiutil.OpenApiRequest{
14985 Query: openapiutil.Query(query),
14986 }
14987 params := &openapiutil.Params{
14988 Action: dara.String("GetSiteCurrentNS"),
14989 Version: dara.String("2024-09-10"),
14990 Protocol: dara.String("HTTPS"),
14991 Pathname: dara.String("/"),
14992 Method: dara.String("GET"),
14993 AuthType: dara.String("AK"),
14994 Style: dara.String("RPC"),
14995 ReqBodyType: dara.String("formData"),
14996 BodyType: dara.String("json"),
14997 }
14998 _result = &GetSiteCurrentNSResponse{}
14999 _body, _err := client.CallApi(params, req, runtime)
15000 if _err != nil {
15001 return _result, _err
15002 }
15003 _err = dara.Convert(_body, &_result)
15004 return _result, _err
15005 }
15006
15007 // Summary:
15008 //
15009 // Queries the nameservers configured for a website.
15010 //
15011 // @param request - GetSiteCurrentNSRequest
15012 //
15013 // @return GetSiteCurrentNSResponse
15014 func GetSiteCurrentNS(client *Client, request *GetSiteCurrentNSRequest) (_result *GetSiteCurrentNSResponse, _err error) {
15015 runtime := &dara.RuntimeOptions{}
15016 _result = &GetSiteCurrentNSResponse{}
15017 _body, _err := GetSiteCurrentNSWithOptions(client,request, runtime)
15018 if _err != nil {
15019 return _result, _err
15020 }
15021 _result = _body
15022 return _result, _err
15023 }
15024
15025 // Summary:
15026 //
15027 // Queries the configuration of custom log fields for a website.
15028 //
15029 // Description:
15030 //
15031 // **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.
15032 //
15033 // - **Scenarios**: You can call this operation in scenarios where you need to obtain specific HTTP headers or cookie information for log analysis.
15034 //
15035 // - ****
15036 //
15037 // @param request - GetSiteCustomLogRequest
15038 //
15039 // @param runtime - runtime options for this request RuntimeOptions
15040 //
15041 // @return GetSiteCustomLogResponse
15042 func GetSiteCustomLogWithOptions(client *Client, request *GetSiteCustomLogRequest, runtime *dara.RuntimeOptions) (_result *GetSiteCustomLogResponse, _err error) {
15043 if dara.BoolValue(client.EnableValidate) == true {
15044 _err = request.Validate()
15045 if _err != nil {
15046 return _result, _err
15047 }
15048 }
15049 query := openapiutil.Query(dara.ToMap(request))
15050 req := &openapiutil.OpenApiRequest{
15051 Query: openapiutil.Query(query),
15052 }
15053 params := &openapiutil.Params{
15054 Action: dara.String("GetSiteCustomLog"),
15055 Version: dara.String("2024-09-10"),
15056 Protocol: dara.String("HTTPS"),
15057 Pathname: dara.String("/"),
15058 Method: dara.String("GET"),
15059 AuthType: dara.String("AK"),
15060 Style: dara.String("RPC"),
15061 ReqBodyType: dara.String("formData"),
15062 BodyType: dara.String("json"),
15063 }
15064 _result = &GetSiteCustomLogResponse{}
15065 _body, _err := client.CallApi(params, req, runtime)
15066 if _err != nil {
15067 return _result, _err
15068 }
15069 _err = dara.Convert(_body, &_result)
15070 return _result, _err
15071 }
15072
15073 // Summary:
15074 //
15075 // Queries the configuration of custom log fields for a website.
15076 //
15077 // Description:
15078 //
15079 // **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.
15080 //
15081 // - **Scenarios**: You can call this operation in scenarios where you need to obtain specific HTTP headers or cookie information for log analysis.
15082 //
15083 // - ****
15084 //
15085 // @param request - GetSiteCustomLogRequest
15086 //
15087 // @return GetSiteCustomLogResponse
15088 func GetSiteCustomLog(client *Client, request *GetSiteCustomLogRequest) (_result *GetSiteCustomLogResponse, _err error) {
15089 runtime := &dara.RuntimeOptions{}
15090 _result = &GetSiteCustomLogResponse{}
15091 _body, _err := GetSiteCustomLogWithOptions(client,request, runtime)
15092 if _err != nil {
15093 return _result, _err
15094 }
15095 _result = _body
15096 return _result, _err
15097 }
15098
15099 // Summary:
15100 //
15101 // Queries a real-time log delivery task.
15102 //
15103 // @param request - GetSiteDeliveryTaskRequest
15104 //
15105 // @param runtime - runtime options for this request RuntimeOptions
15106 //
15107 // @return GetSiteDeliveryTaskResponse
15108 func GetSiteDeliveryTaskWithOptions(client *Client, request *GetSiteDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *GetSiteDeliveryTaskResponse, _err error) {
15109 if dara.BoolValue(client.EnableValidate) == true {
15110 _err = request.Validate()
15111 if _err != nil {
15112 return _result, _err
15113 }
15114 }
15115 query := openapiutil.Query(dara.ToMap(request))
15116 req := &openapiutil.OpenApiRequest{
15117 Query: openapiutil.Query(query),
15118 }
15119 params := &openapiutil.Params{
15120 Action: dara.String("GetSiteDeliveryTask"),
15121 Version: dara.String("2024-09-10"),
15122 Protocol: dara.String("HTTPS"),
15123 Pathname: dara.String("/"),
15124 Method: dara.String("GET"),
15125 AuthType: dara.String("AK"),
15126 Style: dara.String("RPC"),
15127 ReqBodyType: dara.String("formData"),
15128 BodyType: dara.String("json"),
15129 }
15130 _result = &GetSiteDeliveryTaskResponse{}
15131 _body, _err := client.CallApi(params, req, runtime)
15132 if _err != nil {
15133 return _result, _err
15134 }
15135 _err = dara.Convert(_body, &_result)
15136 return _result, _err
15137 }
15138
15139 // Summary:
15140 //
15141 // Queries a real-time log delivery task.
15142 //
15143 // @param request - GetSiteDeliveryTaskRequest
15144 //
15145 // @return GetSiteDeliveryTaskResponse
15146 func GetSiteDeliveryTask(client *Client, request *GetSiteDeliveryTaskRequest) (_result *GetSiteDeliveryTaskResponse, _err error) {
15147 runtime := &dara.RuntimeOptions{}
15148 _result = &GetSiteDeliveryTaskResponse{}
15149 _body, _err := GetSiteDeliveryTaskWithOptions(client,request, runtime)
15150 if _err != nil {
15151 return _result, _err
15152 }
15153 _result = _body
15154 return _result, _err
15155 }
15156
15157 // Summary:
15158 //
15159 // Queries the remaining quota for delivering a specific category of real-time logs in a website.
15160 //
15161 // Description:
15162 //
15163 // 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.
15164 //
15165 // **Take note of the following parameters:**
15166 //
15167 // - “
15168 //
15169 // - `BusinessType` is required. You must specify a log category to obtain the corresponding quota information.
15170 //
15171 // - `SiteId` specifies the ID of a website, which must be a valid integer that corresponds to a website that you configured on Alibaba Cloud.
15172 //
15173 // **Response:**
15174 //
15175 // - 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.
15176 //
15177 // @param request - GetSiteLogDeliveryQuotaRequest
15178 //
15179 // @param runtime - runtime options for this request RuntimeOptions
15180 //
15181 // @return GetSiteLogDeliveryQuotaResponse
15182 func GetSiteLogDeliveryQuotaWithOptions(client *Client, request *GetSiteLogDeliveryQuotaRequest, runtime *dara.RuntimeOptions) (_result *GetSiteLogDeliveryQuotaResponse, _err error) {
15183 if dara.BoolValue(client.EnableValidate) == true {
15184 _err = request.Validate()
15185 if _err != nil {
15186 return _result, _err
15187 }
15188 }
15189 query := openapiutil.Query(dara.ToMap(request))
15190 req := &openapiutil.OpenApiRequest{
15191 Query: openapiutil.Query(query),
15192 }
15193 params := &openapiutil.Params{
15194 Action: dara.String("GetSiteLogDeliveryQuota"),
15195 Version: dara.String("2024-09-10"),
15196 Protocol: dara.String("HTTPS"),
15197 Pathname: dara.String("/"),
15198 Method: dara.String("GET"),
15199 AuthType: dara.String("AK"),
15200 Style: dara.String("RPC"),
15201 ReqBodyType: dara.String("formData"),
15202 BodyType: dara.String("json"),
15203 }
15204 _result = &GetSiteLogDeliveryQuotaResponse{}
15205 _body, _err := client.CallApi(params, req, runtime)
15206 if _err != nil {
15207 return _result, _err
15208 }
15209 _err = dara.Convert(_body, &_result)
15210 return _result, _err
15211 }
15212
15213 // Summary:
15214 //
15215 // Queries the remaining quota for delivering a specific category of real-time logs in a website.
15216 //
15217 // Description:
15218 //
15219 // 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.
15220 //
15221 // **Take note of the following parameters:**
15222 //
15223 // - “
15224 //
15225 // - `BusinessType` is required. You must specify a log category to obtain the corresponding quota information.
15226 //
15227 // - `SiteId` specifies the ID of a website, which must be a valid integer that corresponds to a website that you configured on Alibaba Cloud.
15228 //
15229 // **Response:**
15230 //
15231 // - 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.
15232 //
15233 // @param request - GetSiteLogDeliveryQuotaRequest
15234 //
15235 // @return GetSiteLogDeliveryQuotaResponse
15236 func GetSiteLogDeliveryQuota(client *Client, request *GetSiteLogDeliveryQuotaRequest) (_result *GetSiteLogDeliveryQuotaResponse, _err error) {
15237 runtime := &dara.RuntimeOptions{}
15238 _result = &GetSiteLogDeliveryQuotaResponse{}
15239 _body, _err := GetSiteLogDeliveryQuotaWithOptions(client,request, runtime)
15240 if _err != nil {
15241 return _result, _err
15242 }
15243 _result = _body
15244 return _result, _err
15245 }
15246
15247 // Summary:
15248 //
15249 // 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.
15250 //
15251 // @param request - GetSiteNameExclusiveRequest
15252 //
15253 // @param runtime - runtime options for this request RuntimeOptions
15254 //
15255 // @return GetSiteNameExclusiveResponse
15256 func GetSiteNameExclusiveWithOptions(client *Client, request *GetSiteNameExclusiveRequest, runtime *dara.RuntimeOptions) (_result *GetSiteNameExclusiveResponse, _err error) {
15257 if dara.BoolValue(client.EnableValidate) == true {
15258 _err = request.Validate()
15259 if _err != nil {
15260 return _result, _err
15261 }
15262 }
15263 query := openapiutil.Query(dara.ToMap(request))
15264 req := &openapiutil.OpenApiRequest{
15265 Query: openapiutil.Query(query),
15266 }
15267 params := &openapiutil.Params{
15268 Action: dara.String("GetSiteNameExclusive"),
15269 Version: dara.String("2024-09-10"),
15270 Protocol: dara.String("HTTPS"),
15271 Pathname: dara.String("/"),
15272 Method: dara.String("GET"),
15273 AuthType: dara.String("AK"),
15274 Style: dara.String("RPC"),
15275 ReqBodyType: dara.String("formData"),
15276 BodyType: dara.String("json"),
15277 }
15278 _result = &GetSiteNameExclusiveResponse{}
15279 _body, _err := client.CallApi(params, req, runtime)
15280 if _err != nil {
15281 return _result, _err
15282 }
15283 _err = dara.Convert(_body, &_result)
15284 return _result, _err
15285 }
15286
15287 // Summary:
15288 //
15289 // 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.
15290 //
15291 // @param request - GetSiteNameExclusiveRequest
15292 //
15293 // @return GetSiteNameExclusiveResponse
15294 func GetSiteNameExclusive(client *Client, request *GetSiteNameExclusiveRequest) (_result *GetSiteNameExclusiveResponse, _err error) {
15295 runtime := &dara.RuntimeOptions{}
15296 _result = &GetSiteNameExclusiveResponse{}
15297 _body, _err := GetSiteNameExclusiveWithOptions(client,request, runtime)
15298 if _err != nil {
15299 return _result, _err
15300 }
15301 _result = _body
15302 return _result, _err
15303 }
15304
15305 // Summary:
15306 //
15307 // 获取站点回源客户端证书信息
15308 //
15309 // @param request - GetSiteOriginClientCertificateRequest
15310 //
15311 // @param runtime - runtime options for this request RuntimeOptions
15312 //
15313 // @return GetSiteOriginClientCertificateResponse
15314 func GetSiteOriginClientCertificateWithOptions(client *Client, request *GetSiteOriginClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *GetSiteOriginClientCertificateResponse, _err error) {
15315 if dara.BoolValue(client.EnableValidate) == true {
15316 _err = request.Validate()
15317 if _err != nil {
15318 return _result, _err
15319 }
15320 }
15321 query := openapiutil.Query(dara.ToMap(request))
15322 req := &openapiutil.OpenApiRequest{
15323 Query: openapiutil.Query(query),
15324 }
15325 params := &openapiutil.Params{
15326 Action: dara.String("GetSiteOriginClientCertificate"),
15327 Version: dara.String("2024-09-10"),
15328 Protocol: dara.String("HTTPS"),
15329 Pathname: dara.String("/"),
15330 Method: dara.String("GET"),
15331 AuthType: dara.String("AK"),
15332 Style: dara.String("RPC"),
15333 ReqBodyType: dara.String("formData"),
15334 BodyType: dara.String("json"),
15335 }
15336 _result = &GetSiteOriginClientCertificateResponse{}
15337 _body, _err := client.CallApi(params, req, runtime)
15338 if _err != nil {
15339 return _result, _err
15340 }
15341 _err = dara.Convert(_body, &_result)
15342 return _result, _err
15343 }
15344
15345 // Summary:
15346 //
15347 // 获取站点回源客户端证书信息
15348 //
15349 // @param request - GetSiteOriginClientCertificateRequest
15350 //
15351 // @return GetSiteOriginClientCertificateResponse
15352 func GetSiteOriginClientCertificate(client *Client, request *GetSiteOriginClientCertificateRequest) (_result *GetSiteOriginClientCertificateResponse, _err error) {
15353 runtime := &dara.RuntimeOptions{}
15354 _result = &GetSiteOriginClientCertificateResponse{}
15355 _body, _err := GetSiteOriginClientCertificateWithOptions(client,request, runtime)
15356 if _err != nil {
15357 return _result, _err
15358 }
15359 _result = _body
15360 return _result, _err
15361 }
15362
15363 // Summary:
15364 //
15365 // Queries the ESA proxy configuration of a website.
15366 //
15367 // @param request - GetSitePauseRequest
15368 //
15369 // @param runtime - runtime options for this request RuntimeOptions
15370 //
15371 // @return GetSitePauseResponse
15372 func GetSitePauseWithOptions(client *Client, request *GetSitePauseRequest, runtime *dara.RuntimeOptions) (_result *GetSitePauseResponse, _err error) {
15373 if dara.BoolValue(client.EnableValidate) == true {
15374 _err = request.Validate()
15375 if _err != nil {
15376 return _result, _err
15377 }
15378 }
15379 query := openapiutil.Query(dara.ToMap(request))
15380 req := &openapiutil.OpenApiRequest{
15381 Query: openapiutil.Query(query),
15382 }
15383 params := &openapiutil.Params{
15384 Action: dara.String("GetSitePause"),
15385 Version: dara.String("2024-09-10"),
15386 Protocol: dara.String("HTTPS"),
15387 Pathname: dara.String("/"),
15388 Method: dara.String("GET"),
15389 AuthType: dara.String("AK"),
15390 Style: dara.String("RPC"),
15391 ReqBodyType: dara.String("formData"),
15392 BodyType: dara.String("json"),
15393 }
15394 _result = &GetSitePauseResponse{}
15395 _body, _err := client.CallApi(params, req, runtime)
15396 if _err != nil {
15397 return _result, _err
15398 }
15399 _err = dara.Convert(_body, &_result)
15400 return _result, _err
15401 }
15402
15403 // Summary:
15404 //
15405 // Queries the ESA proxy configuration of a website.
15406 //
15407 // @param request - GetSitePauseRequest
15408 //
15409 // @return GetSitePauseResponse
15410 func GetSitePause(client *Client, request *GetSitePauseRequest) (_result *GetSitePauseResponse, _err error) {
15411 runtime := &dara.RuntimeOptions{}
15412 _result = &GetSitePauseResponse{}
15413 _body, _err := GetSitePauseWithOptions(client,request, runtime)
15414 if _err != nil {
15415 return _result, _err
15416 }
15417 _result = _body
15418 return _result, _err
15419 }
15420
15421 // Summary:
15422 //
15423 // # Get WAF Configuration for a Site
15424 //
15425 // @param request - GetSiteWafSettingsRequest
15426 //
15427 // @param runtime - runtime options for this request RuntimeOptions
15428 //
15429 // @return GetSiteWafSettingsResponse
15430 func GetSiteWafSettingsWithOptions(client *Client, request *GetSiteWafSettingsRequest, runtime *dara.RuntimeOptions) (_result *GetSiteWafSettingsResponse, _err error) {
15431 if dara.BoolValue(client.EnableValidate) == true {
15432 _err = request.Validate()
15433 if _err != nil {
15434 return _result, _err
15435 }
15436 }
15437 query := map[string]interface{}{}
15438 if !dara.IsNil(request.Path) {
15439 query["Path"] = request.Path
15440 }
15441
15442 if !dara.IsNil(request.SiteId) {
15443 query["SiteId"] = request.SiteId
15444 }
15445
15446 if !dara.IsNil(request.SiteVersion) {
15447 query["SiteVersion"] = request.SiteVersion
15448 }
15449
15450 req := &openapiutil.OpenApiRequest{
15451 Query: openapiutil.Query(query),
15452 }
15453 params := &openapiutil.Params{
15454 Action: dara.String("GetSiteWafSettings"),
15455 Version: dara.String("2024-09-10"),
15456 Protocol: dara.String("HTTPS"),
15457 Pathname: dara.String("/"),
15458 Method: dara.String("POST"),
15459 AuthType: dara.String("AK"),
15460 Style: dara.String("RPC"),
15461 ReqBodyType: dara.String("formData"),
15462 BodyType: dara.String("json"),
15463 }
15464 _result = &GetSiteWafSettingsResponse{}
15465 _body, _err := client.CallApi(params, req, runtime)
15466 if _err != nil {
15467 return _result, _err
15468 }
15469 _err = dara.Convert(_body, &_result)
15470 return _result, _err
15471 }
15472
15473 // Summary:
15474 //
15475 // # Get WAF Configuration for a Site
15476 //
15477 // @param request - GetSiteWafSettingsRequest
15478 //
15479 // @return GetSiteWafSettingsResponse
15480 func GetSiteWafSettings(client *Client, request *GetSiteWafSettingsRequest) (_result *GetSiteWafSettingsResponse, _err error) {
15481 runtime := &dara.RuntimeOptions{}
15482 _result = &GetSiteWafSettingsResponse{}
15483 _body, _err := GetSiteWafSettingsWithOptions(client,request, runtime)
15484 if _err != nil {
15485 return _result, _err
15486 }
15487 _result = _body
15488 return _result, _err
15489 }
15490
15491 // Summary:
15492 //
15493 // # Query Multi-level Cache Configuration for Site
15494 //
15495 // @param request - GetTieredCacheRequest
15496 //
15497 // @param runtime - runtime options for this request RuntimeOptions
15498 //
15499 // @return GetTieredCacheResponse
15500 func GetTieredCacheWithOptions(client *Client, request *GetTieredCacheRequest, runtime *dara.RuntimeOptions) (_result *GetTieredCacheResponse, _err error) {
15501 if dara.BoolValue(client.EnableValidate) == true {
15502 _err = request.Validate()
15503 if _err != nil {
15504 return _result, _err
15505 }
15506 }
15507 query := openapiutil.Query(dara.ToMap(request))
15508 req := &openapiutil.OpenApiRequest{
15509 Query: openapiutil.Query(query),
15510 }
15511 params := &openapiutil.Params{
15512 Action: dara.String("GetTieredCache"),
15513 Version: dara.String("2024-09-10"),
15514 Protocol: dara.String("HTTPS"),
15515 Pathname: dara.String("/"),
15516 Method: dara.String("GET"),
15517 AuthType: dara.String("AK"),
15518 Style: dara.String("RPC"),
15519 ReqBodyType: dara.String("formData"),
15520 BodyType: dara.String("json"),
15521 }
15522 _result = &GetTieredCacheResponse{}
15523 _body, _err := client.CallApi(params, req, runtime)
15524 if _err != nil {
15525 return _result, _err
15526 }
15527 _err = dara.Convert(_body, &_result)
15528 return _result, _err
15529 }
15530
15531 // Summary:
15532 //
15533 // # Query Multi-level Cache Configuration for Site
15534 //
15535 // @param request - GetTieredCacheRequest
15536 //
15537 // @return GetTieredCacheResponse
15538 func GetTieredCache(client *Client, request *GetTieredCacheRequest) (_result *GetTieredCacheResponse, _err error) {
15539 runtime := &dara.RuntimeOptions{}
15540 _result = &GetTieredCacheResponse{}
15541 _body, _err := GetTieredCacheWithOptions(client,request, runtime)
15542 if _err != nil {
15543 return _result, _err
15544 }
15545 _result = _body
15546 return _result, _err
15547 }
15548
15549 // Summary:
15550 //
15551 // # Query details of the transport layer application
15552 //
15553 // @param request - GetTransportLayerApplicationRequest
15554 //
15555 // @param runtime - runtime options for this request RuntimeOptions
15556 //
15557 // @return GetTransportLayerApplicationResponse
15558 func GetTransportLayerApplicationWithOptions(client *Client, request *GetTransportLayerApplicationRequest, runtime *dara.RuntimeOptions) (_result *GetTransportLayerApplicationResponse, _err error) {
15559 if dara.BoolValue(client.EnableValidate) == true {
15560 _err = request.Validate()
15561 if _err != nil {
15562 return _result, _err
15563 }
15564 }
15565 query := openapiutil.Query(dara.ToMap(request))
15566 req := &openapiutil.OpenApiRequest{
15567 Query: openapiutil.Query(query),
15568 }
15569 params := &openapiutil.Params{
15570 Action: dara.String("GetTransportLayerApplication"),
15571 Version: dara.String("2024-09-10"),
15572 Protocol: dara.String("HTTPS"),
15573 Pathname: dara.String("/"),
15574 Method: dara.String("GET"),
15575 AuthType: dara.String("AK"),
15576 Style: dara.String("RPC"),
15577 ReqBodyType: dara.String("formData"),
15578 BodyType: dara.String("json"),
15579 }
15580 _result = &GetTransportLayerApplicationResponse{}
15581 _body, _err := client.CallApi(params, req, runtime)
15582 if _err != nil {
15583 return _result, _err
15584 }
15585 _err = dara.Convert(_body, &_result)
15586 return _result, _err
15587 }
15588
15589 // Summary:
15590 //
15591 // # Query details of the transport layer application
15592 //
15593 // @param request - GetTransportLayerApplicationRequest
15594 //
15595 // @return GetTransportLayerApplicationResponse
15596 func GetTransportLayerApplication(client *Client, request *GetTransportLayerApplicationRequest) (_result *GetTransportLayerApplicationResponse, _err error) {
15597 runtime := &dara.RuntimeOptions{}
15598 _result = &GetTransportLayerApplicationResponse{}
15599 _body, _err := GetTransportLayerApplicationWithOptions(client,request, runtime)
15600 if _err != nil {
15601 return _result, _err
15602 }
15603 _result = _body
15604 return _result, _err
15605 }
15606
15607 // Summary:
15608 //
15609 // Queries the execution status and running information of a file upload task based on the task ID.
15610 //
15611 // @param request - GetUploadTaskRequest
15612 //
15613 // @param runtime - runtime options for this request RuntimeOptions
15614 //
15615 // @return GetUploadTaskResponse
15616 func GetUploadTaskWithOptions(client *Client, request *GetUploadTaskRequest, runtime *dara.RuntimeOptions) (_result *GetUploadTaskResponse, _err error) {
15617 if dara.BoolValue(client.EnableValidate) == true {
15618 _err = request.Validate()
15619 if _err != nil {
15620 return _result, _err
15621 }
15622 }
15623 query := openapiutil.Query(dara.ToMap(request))
15624 req := &openapiutil.OpenApiRequest{
15625 Query: openapiutil.Query(query),
15626 }
15627 params := &openapiutil.Params{
15628 Action: dara.String("GetUploadTask"),
15629 Version: dara.String("2024-09-10"),
15630 Protocol: dara.String("HTTPS"),
15631 Pathname: dara.String("/"),
15632 Method: dara.String("GET"),
15633 AuthType: dara.String("AK"),
15634 Style: dara.String("RPC"),
15635 ReqBodyType: dara.String("formData"),
15636 BodyType: dara.String("json"),
15637 }
15638 _result = &GetUploadTaskResponse{}
15639 _body, _err := client.CallApi(params, req, runtime)
15640 if _err != nil {
15641 return _result, _err
15642 }
15643 _err = dara.Convert(_body, &_result)
15644 return _result, _err
15645 }
15646
15647 // Summary:
15648 //
15649 // Queries the execution status and running information of a file upload task based on the task ID.
15650 //
15651 // @param request - GetUploadTaskRequest
15652 //
15653 // @return GetUploadTaskResponse
15654 func GetUploadTask(client *Client, request *GetUploadTaskRequest) (_result *GetUploadTaskResponse, _err error) {
15655 runtime := &dara.RuntimeOptions{}
15656 _result = &GetUploadTaskResponse{}
15657 _body, _err := GetUploadTaskWithOptions(client,request, runtime)
15658 if _err != nil {
15659 return _result, _err
15660 }
15661 _result = _body
15662 return _result, _err
15663 }
15664
15665 // Summary:
15666 //
15667 // Queries the information about a log delivery task by account.
15668 //
15669 // Description:
15670 //
15671 // 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.****
15672 //
15673 // - You can call this operation to query detailed information about a log delivery task to analyze log processing efficiency or troubleshoot delivery problems.****
15674 //
15675 // - ****````
15676 //
15677 // @param request - GetUserDeliveryTaskRequest
15678 //
15679 // @param runtime - runtime options for this request RuntimeOptions
15680 //
15681 // @return GetUserDeliveryTaskResponse
15682 func GetUserDeliveryTaskWithOptions(client *Client, request *GetUserDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *GetUserDeliveryTaskResponse, _err error) {
15683 if dara.BoolValue(client.EnableValidate) == true {
15684 _err = request.Validate()
15685 if _err != nil {
15686 return _result, _err
15687 }
15688 }
15689 query := openapiutil.Query(dara.ToMap(request))
15690 req := &openapiutil.OpenApiRequest{
15691 Query: openapiutil.Query(query),
15692 }
15693 params := &openapiutil.Params{
15694 Action: dara.String("GetUserDeliveryTask"),
15695 Version: dara.String("2024-09-10"),
15696 Protocol: dara.String("HTTPS"),
15697 Pathname: dara.String("/"),
15698 Method: dara.String("GET"),
15699 AuthType: dara.String("AK"),
15700 Style: dara.String("RPC"),
15701 ReqBodyType: dara.String("formData"),
15702 BodyType: dara.String("json"),
15703 }
15704 _result = &GetUserDeliveryTaskResponse{}
15705 _body, _err := client.CallApi(params, req, runtime)
15706 if _err != nil {
15707 return _result, _err
15708 }
15709 _err = dara.Convert(_body, &_result)
15710 return _result, _err
15711 }
15712
15713 // Summary:
15714 //
15715 // Queries the information about a log delivery task by account.
15716 //
15717 // Description:
15718 //
15719 // 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.****
15720 //
15721 // - You can call this operation to query detailed information about a log delivery task to analyze log processing efficiency or troubleshoot delivery problems.****
15722 //
15723 // - ****````
15724 //
15725 // @param request - GetUserDeliveryTaskRequest
15726 //
15727 // @return GetUserDeliveryTaskResponse
15728 func GetUserDeliveryTask(client *Client, request *GetUserDeliveryTaskRequest) (_result *GetUserDeliveryTaskResponse, _err error) {
15729 runtime := &dara.RuntimeOptions{}
15730 _result = &GetUserDeliveryTaskResponse{}
15731 _body, _err := GetUserDeliveryTaskWithOptions(client,request, runtime)
15732 if _err != nil {
15733 return _result, _err
15734 }
15735 _result = _body
15736 return _result, _err
15737 }
15738
15739 // Summary:
15740 //
15741 // Queries the remaining log delivery quota of each log category in your account.
15742 //
15743 // Description:
15744 //
15745 // 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.
15746 //
15747 // @param request - GetUserLogDeliveryQuotaRequest
15748 //
15749 // @param runtime - runtime options for this request RuntimeOptions
15750 //
15751 // @return GetUserLogDeliveryQuotaResponse
15752 func GetUserLogDeliveryQuotaWithOptions(client *Client, request *GetUserLogDeliveryQuotaRequest, runtime *dara.RuntimeOptions) (_result *GetUserLogDeliveryQuotaResponse, _err error) {
15753 if dara.BoolValue(client.EnableValidate) == true {
15754 _err = request.Validate()
15755 if _err != nil {
15756 return _result, _err
15757 }
15758 }
15759 query := openapiutil.Query(dara.ToMap(request))
15760 req := &openapiutil.OpenApiRequest{
15761 Query: openapiutil.Query(query),
15762 }
15763 params := &openapiutil.Params{
15764 Action: dara.String("GetUserLogDeliveryQuota"),
15765 Version: dara.String("2024-09-10"),
15766 Protocol: dara.String("HTTPS"),
15767 Pathname: dara.String("/"),
15768 Method: dara.String("GET"),
15769 AuthType: dara.String("AK"),
15770 Style: dara.String("RPC"),
15771 ReqBodyType: dara.String("formData"),
15772 BodyType: dara.String("json"),
15773 }
15774 _result = &GetUserLogDeliveryQuotaResponse{}
15775 _body, _err := client.CallApi(params, req, runtime)
15776 if _err != nil {
15777 return _result, _err
15778 }
15779 _err = dara.Convert(_body, &_result)
15780 return _result, _err
15781 }
15782
15783 // Summary:
15784 //
15785 // Queries the remaining log delivery quota of each log category in your account.
15786 //
15787 // Description:
15788 //
15789 // 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.
15790 //
15791 // @param request - GetUserLogDeliveryQuotaRequest
15792 //
15793 // @return GetUserLogDeliveryQuotaResponse
15794 func GetUserLogDeliveryQuota(client *Client, request *GetUserLogDeliveryQuotaRequest) (_result *GetUserLogDeliveryQuotaResponse, _err error) {
15795 runtime := &dara.RuntimeOptions{}
15796 _result = &GetUserLogDeliveryQuotaResponse{}
15797 _body, _err := GetUserLogDeliveryQuotaWithOptions(client,request, runtime)
15798 if _err != nil {
15799 return _result, _err
15800 }
15801 _result = _body
15802 return _result, _err
15803 }
15804
15805 // Summary:
15806 //
15807 // 用于获取实例级别的Web应用防火墙规则集详情
15808 //
15809 // @param request - GetUserWafRulesetRequest
15810 //
15811 // @param runtime - runtime options for this request RuntimeOptions
15812 //
15813 // @return GetUserWafRulesetResponse
15814 func GetUserWafRulesetWithOptions(client *Client, request *GetUserWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *GetUserWafRulesetResponse, _err error) {
15815 if dara.BoolValue(client.EnableValidate) == true {
15816 _err = request.Validate()
15817 if _err != nil {
15818 return _result, _err
15819 }
15820 }
15821 query := map[string]interface{}{}
15822 if !dara.IsNil(request.Id) {
15823 query["Id"] = request.Id
15824 }
15825
15826 if !dara.IsNil(request.InstanceId) {
15827 query["InstanceId"] = request.InstanceId
15828 }
15829
15830 req := &openapiutil.OpenApiRequest{
15831 Query: openapiutil.Query(query),
15832 }
15833 params := &openapiutil.Params{
15834 Action: dara.String("GetUserWafRuleset"),
15835 Version: dara.String("2024-09-10"),
15836 Protocol: dara.String("HTTPS"),
15837 Pathname: dara.String("/"),
15838 Method: dara.String("POST"),
15839 AuthType: dara.String("AK"),
15840 Style: dara.String("RPC"),
15841 ReqBodyType: dara.String("formData"),
15842 BodyType: dara.String("json"),
15843 }
15844 _result = &GetUserWafRulesetResponse{}
15845 _body, _err := client.CallApi(params, req, runtime)
15846 if _err != nil {
15847 return _result, _err
15848 }
15849 _err = dara.Convert(_body, &_result)
15850 return _result, _err
15851 }
15852
15853 // Summary:
15854 //
15855 // 用于获取实例级别的Web应用防火墙规则集详情
15856 //
15857 // @param request - GetUserWafRulesetRequest
15858 //
15859 // @return GetUserWafRulesetResponse
15860 func GetUserWafRuleset(client *Client, request *GetUserWafRulesetRequest) (_result *GetUserWafRulesetResponse, _err error) {
15861 runtime := &dara.RuntimeOptions{}
15862 _result = &GetUserWafRulesetResponse{}
15863 _body, _err := GetUserWafRulesetWithOptions(client,request, runtime)
15864 if _err != nil {
15865 return _result, _err
15866 }
15867 _result = _body
15868 return _result, _err
15869 }
15870
15871 // Summary:
15872 //
15873 // Queries the video processing configuration details of a site.
15874 //
15875 // @param request - GetVideoProcessingRequest
15876 //
15877 // @param runtime - runtime options for this request RuntimeOptions
15878 //
15879 // @return GetVideoProcessingResponse
15880 func GetVideoProcessingWithOptions(client *Client, request *GetVideoProcessingRequest, runtime *dara.RuntimeOptions) (_result *GetVideoProcessingResponse, _err error) {
15881 if dara.BoolValue(client.EnableValidate) == true {
15882 _err = request.Validate()
15883 if _err != nil {
15884 return _result, _err
15885 }
15886 }
15887 query := map[string]interface{}{}
15888 if !dara.IsNil(request.ConfigId) {
15889 query["ConfigId"] = request.ConfigId
15890 }
15891
15892 if !dara.IsNil(request.SiteId) {
15893 query["SiteId"] = request.SiteId
15894 }
15895
15896 req := &openapiutil.OpenApiRequest{
15897 Query: openapiutil.Query(query),
15898 }
15899 params := &openapiutil.Params{
15900 Action: dara.String("GetVideoProcessing"),
15901 Version: dara.String("2024-09-10"),
15902 Protocol: dara.String("HTTPS"),
15903 Pathname: dara.String("/"),
15904 Method: dara.String("POST"),
15905 AuthType: dara.String("AK"),
15906 Style: dara.String("RPC"),
15907 ReqBodyType: dara.String("formData"),
15908 BodyType: dara.String("json"),
15909 }
15910 _result = &GetVideoProcessingResponse{}
15911 _body, _err := client.CallApi(params, req, runtime)
15912 if _err != nil {
15913 return _result, _err
15914 }
15915 _err = dara.Convert(_body, &_result)
15916 return _result, _err
15917 }
15918
15919 // Summary:
15920 //
15921 // Queries the video processing configuration details of a site.
15922 //
15923 // @param request - GetVideoProcessingRequest
15924 //
15925 // @return GetVideoProcessingResponse
15926 func GetVideoProcessing(client *Client, request *GetVideoProcessingRequest) (_result *GetVideoProcessingResponse, _err error) {
15927 runtime := &dara.RuntimeOptions{}
15928 _result = &GetVideoProcessingResponse{}
15929 _body, _err := GetVideoProcessingWithOptions(client,request, runtime)
15930 if _err != nil {
15931 return _result, _err
15932 }
15933 _result = _body
15934 return _result, _err
15935 }
15936
15937 // Summary:
15938 //
15939 // This interface is used to obtain the application key (AppKey) for the BOT behavior detection feature in the site\\"s Web Application Firewall (WAF). The key is typically used for authentication and data exchange with the WAF service.
15940 //
15941 // @param request - GetWafBotAppKeyRequest
15942 //
15943 // @param runtime - runtime options for this request RuntimeOptions
15944 //
15945 // @return GetWafBotAppKeyResponse
15946 func GetWafBotAppKeyWithOptions(client *Client, runtime *dara.RuntimeOptions) (_result *GetWafBotAppKeyResponse, _err error) {
15947 req := &openapiutil.OpenApiRequest{}
15948 params := &openapiutil.Params{
15949 Action: dara.String("GetWafBotAppKey"),
15950 Version: dara.String("2024-09-10"),
15951 Protocol: dara.String("HTTPS"),
15952 Pathname: dara.String("/"),
15953 Method: dara.String("POST"),
15954 AuthType: dara.String("AK"),
15955 Style: dara.String("RPC"),
15956 ReqBodyType: dara.String("formData"),
15957 BodyType: dara.String("json"),
15958 }
15959 _result = &GetWafBotAppKeyResponse{}
15960 _body, _err := client.CallApi(params, req, runtime)
15961 if _err != nil {
15962 return _result, _err
15963 }
15964 _err = dara.Convert(_body, &_result)
15965 return _result, _err
15966 }
15967
15968 // Summary:
15969 //
15970 // This interface is used to obtain the application key (AppKey) for the BOT behavior detection feature in the site\\"s Web Application Firewall (WAF). The key is typically used for authentication and data exchange with the WAF service.
15971 //
15972 // @return GetWafBotAppKeyResponse
15973 func GetWafBotAppKey(client *Client, ) (_result *GetWafBotAppKeyResponse, _err error) {
15974 runtime := &dara.RuntimeOptions{}
15975 _result = &GetWafBotAppKeyResponse{}
15976 _body, _err := GetWafBotAppKeyWithOptions(client,runtime)
15977 if _err != nil {
15978 return _result, _err
15979 }
15980 _result = _body
15981 return _result, _err
15982 }
15983
15984 // Summary:
15985 //
15986 // 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.
15987 //
15988 // @param request - GetWafFilterRequest
15989 //
15990 // @param runtime - runtime options for this request RuntimeOptions
15991 //
15992 // @return GetWafFilterResponse
15993 func GetWafFilterWithOptions(client *Client, request *GetWafFilterRequest, runtime *dara.RuntimeOptions) (_result *GetWafFilterResponse, _err error) {
15994 if dara.BoolValue(client.EnableValidate) == true {
15995 _err = request.Validate()
15996 if _err != nil {
15997 return _result, _err
15998 }
15999 }
16000 query := map[string]interface{}{}
16001 if !dara.IsNil(request.Phase) {
16002 query["Phase"] = request.Phase
16003 }
16004
16005 if !dara.IsNil(request.SiteId) {
16006 query["SiteId"] = request.SiteId
16007 }
16008
16009 if !dara.IsNil(request.Target) {
16010 query["Target"] = request.Target
16011 }
16012
16013 if !dara.IsNil(request.Type) {
16014 query["Type"] = request.Type
16015 }
16016
16017 req := &openapiutil.OpenApiRequest{
16018 Query: openapiutil.Query(query),
16019 }
16020 params := &openapiutil.Params{
16021 Action: dara.String("GetWafFilter"),
16022 Version: dara.String("2024-09-10"),
16023 Protocol: dara.String("HTTPS"),
16024 Pathname: dara.String("/"),
16025 Method: dara.String("POST"),
16026 AuthType: dara.String("AK"),
16027 Style: dara.String("RPC"),
16028 ReqBodyType: dara.String("formData"),
16029 BodyType: dara.String("json"),
16030 }
16031 _result = &GetWafFilterResponse{}
16032 _body, _err := client.CallApi(params, req, runtime)
16033 if _err != nil {
16034 return _result, _err
16035 }
16036 _err = dara.Convert(_body, &_result)
16037 return _result, _err
16038 }
16039
16040 // Summary:
16041 //
16042 // 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.
16043 //
16044 // @param request - GetWafFilterRequest
16045 //
16046 // @return GetWafFilterResponse
16047 func GetWafFilter(client *Client, request *GetWafFilterRequest) (_result *GetWafFilterResponse, _err error) {
16048 runtime := &dara.RuntimeOptions{}
16049 _result = &GetWafFilterResponse{}
16050 _body, _err := GetWafFilterWithOptions(client,request, runtime)
16051 if _err != nil {
16052 return _result, _err
16053 }
16054 _result = _body
16055 return _result, _err
16056 }
16057
16058 // Summary:
16059 //
16060 // # Get WAF Quota Details
16061 //
16062 // @param request - GetWafQuotaRequest
16063 //
16064 // @param runtime - runtime options for this request RuntimeOptions
16065 //
16066 // @return GetWafQuotaResponse
16067 func GetWafQuotaWithOptions(client *Client, request *GetWafQuotaRequest, runtime *dara.RuntimeOptions) (_result *GetWafQuotaResponse, _err error) {
16068 if dara.BoolValue(client.EnableValidate) == true {
16069 _err = request.Validate()
16070 if _err != nil {
16071 return _result, _err
16072 }
16073 }
16074 query := map[string]interface{}{}
16075 if !dara.IsNil(request.Paths) {
16076 query["Paths"] = request.Paths
16077 }
16078
16079 req := &openapiutil.OpenApiRequest{
16080 Query: openapiutil.Query(query),
16081 }
16082 params := &openapiutil.Params{
16083 Action: dara.String("GetWafQuota"),
16084 Version: dara.String("2024-09-10"),
16085 Protocol: dara.String("HTTPS"),
16086 Pathname: dara.String("/"),
16087 Method: dara.String("POST"),
16088 AuthType: dara.String("AK"),
16089 Style: dara.String("RPC"),
16090 ReqBodyType: dara.String("formData"),
16091 BodyType: dara.String("json"),
16092 }
16093 _result = &GetWafQuotaResponse{}
16094 _body, _err := client.CallApi(params, req, runtime)
16095 if _err != nil {
16096 return _result, _err
16097 }
16098 _err = dara.Convert(_body, &_result)
16099 return _result, _err
16100 }
16101
16102 // Summary:
16103 //
16104 // # Get WAF Quota Details
16105 //
16106 // @param request - GetWafQuotaRequest
16107 //
16108 // @return GetWafQuotaResponse
16109 func GetWafQuota(client *Client, request *GetWafQuotaRequest) (_result *GetWafQuotaResponse, _err error) {
16110 runtime := &dara.RuntimeOptions{}
16111 _result = &GetWafQuotaResponse{}
16112 _body, _err := GetWafQuotaWithOptions(client,request, runtime)
16113 if _err != nil {
16114 return _result, _err
16115 }
16116 _result = _body
16117 return _result, _err
16118 }
16119
16120 // Summary:
16121 //
16122 // # Get Details of a Single WAF Rule
16123 //
16124 // @param request - GetWafRuleRequest
16125 //
16126 // @param runtime - runtime options for this request RuntimeOptions
16127 //
16128 // @return GetWafRuleResponse
16129 func GetWafRuleWithOptions(client *Client, request *GetWafRuleRequest, runtime *dara.RuntimeOptions) (_result *GetWafRuleResponse, _err error) {
16130 if dara.BoolValue(client.EnableValidate) == true {
16131 _err = request.Validate()
16132 if _err != nil {
16133 return _result, _err
16134 }
16135 }
16136 query := map[string]interface{}{}
16137 if !dara.IsNil(request.Id) {
16138 query["Id"] = request.Id
16139 }
16140
16141 if !dara.IsNil(request.SiteId) {
16142 query["SiteId"] = request.SiteId
16143 }
16144
16145 req := &openapiutil.OpenApiRequest{
16146 Query: openapiutil.Query(query),
16147 }
16148 params := &openapiutil.Params{
16149 Action: dara.String("GetWafRule"),
16150 Version: dara.String("2024-09-10"),
16151 Protocol: dara.String("HTTPS"),
16152 Pathname: dara.String("/"),
16153 Method: dara.String("POST"),
16154 AuthType: dara.String("AK"),
16155 Style: dara.String("RPC"),
16156 ReqBodyType: dara.String("formData"),
16157 BodyType: dara.String("json"),
16158 }
16159 _result = &GetWafRuleResponse{}
16160 _body, _err := client.CallApi(params, req, runtime)
16161 if _err != nil {
16162 return _result, _err
16163 }
16164 _err = dara.Convert(_body, &_result)
16165 return _result, _err
16166 }
16167
16168 // Summary:
16169 //
16170 // # Get Details of a Single WAF Rule
16171 //
16172 // @param request - GetWafRuleRequest
16173 //
16174 // @return GetWafRuleResponse
16175 func GetWafRule(client *Client, request *GetWafRuleRequest) (_result *GetWafRuleResponse, _err error) {
16176 runtime := &dara.RuntimeOptions{}
16177 _result = &GetWafRuleResponse{}
16178 _body, _err := GetWafRuleWithOptions(client,request, runtime)
16179 if _err != nil {
16180 return _result, _err
16181 }
16182 _result = _body
16183 return _result, _err
16184 }
16185
16186 // Summary:
16187 //
16188 // # Get WAF Ruleset Details
16189 //
16190 // @param request - GetWafRulesetRequest
16191 //
16192 // @param runtime - runtime options for this request RuntimeOptions
16193 //
16194 // @return GetWafRulesetResponse
16195 func GetWafRulesetWithOptions(client *Client, request *GetWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *GetWafRulesetResponse, _err error) {
16196 if dara.BoolValue(client.EnableValidate) == true {
16197 _err = request.Validate()
16198 if _err != nil {
16199 return _result, _err
16200 }
16201 }
16202 query := map[string]interface{}{}
16203 if !dara.IsNil(request.Id) {
16204 query["Id"] = request.Id
16205 }
16206
16207 if !dara.IsNil(request.Phase) {
16208 query["Phase"] = request.Phase
16209 }
16210
16211 if !dara.IsNil(request.SiteId) {
16212 query["SiteId"] = request.SiteId
16213 }
16214
16215 req := &openapiutil.OpenApiRequest{
16216 Query: openapiutil.Query(query),
16217 }
16218 params := &openapiutil.Params{
16219 Action: dara.String("GetWafRuleset"),
16220 Version: dara.String("2024-09-10"),
16221 Protocol: dara.String("HTTPS"),
16222 Pathname: dara.String("/"),
16223 Method: dara.String("POST"),
16224 AuthType: dara.String("AK"),
16225 Style: dara.String("RPC"),
16226 ReqBodyType: dara.String("formData"),
16227 BodyType: dara.String("json"),
16228 }
16229 _result = &GetWafRulesetResponse{}
16230 _body, _err := client.CallApi(params, req, runtime)
16231 if _err != nil {
16232 return _result, _err
16233 }
16234 _err = dara.Convert(_body, &_result)
16235 return _result, _err
16236 }
16237
16238 // Summary:
16239 //
16240 // # Get WAF Ruleset Details
16241 //
16242 // @param request - GetWafRulesetRequest
16243 //
16244 // @return GetWafRulesetResponse
16245 func GetWafRuleset(client *Client, request *GetWafRulesetRequest) (_result *GetWafRulesetResponse, _err error) {
16246 runtime := &dara.RuntimeOptions{}
16247 _result = &GetWafRulesetResponse{}
16248 _body, _err := GetWafRulesetWithOptions(client,request, runtime)
16249 if _err != nil {
16250 return _result, _err
16251 }
16252 _result = _body
16253 return _result, _err
16254 }
16255
16256 // Summary:
16257 //
16258 // # Query Cache Reserve Instance List
16259 //
16260 // @param request - ListCacheReserveInstancesRequest
16261 //
16262 // @param runtime - runtime options for this request RuntimeOptions
16263 //
16264 // @return ListCacheReserveInstancesResponse
16265 func ListCacheReserveInstancesWithOptions(client *Client, request *ListCacheReserveInstancesRequest, runtime *dara.RuntimeOptions) (_result *ListCacheReserveInstancesResponse, _err error) {
16266 if dara.BoolValue(client.EnableValidate) == true {
16267 _err = request.Validate()
16268 if _err != nil {
16269 return _result, _err
16270 }
16271 }
16272 query := openapiutil.Query(dara.ToMap(request))
16273 req := &openapiutil.OpenApiRequest{
16274 Query: openapiutil.Query(query),
16275 }
16276 params := &openapiutil.Params{
16277 Action: dara.String("ListCacheReserveInstances"),
16278 Version: dara.String("2024-09-10"),
16279 Protocol: dara.String("HTTPS"),
16280 Pathname: dara.String("/"),
16281 Method: dara.String("GET"),
16282 AuthType: dara.String("AK"),
16283 Style: dara.String("RPC"),
16284 ReqBodyType: dara.String("formData"),
16285 BodyType: dara.String("json"),
16286 }
16287 _result = &ListCacheReserveInstancesResponse{}
16288 _body, _err := client.CallApi(params, req, runtime)
16289 if _err != nil {
16290 return _result, _err
16291 }
16292 _err = dara.Convert(_body, &_result)
16293 return _result, _err
16294 }
16295
16296 // Summary:
16297 //
16298 // # Query Cache Reserve Instance List
16299 //
16300 // @param request - ListCacheReserveInstancesRequest
16301 //
16302 // @return ListCacheReserveInstancesResponse
16303 func ListCacheReserveInstances(client *Client, request *ListCacheReserveInstancesRequest) (_result *ListCacheReserveInstancesResponse, _err error) {
16304 runtime := &dara.RuntimeOptions{}
16305 _result = &ListCacheReserveInstancesResponse{}
16306 _body, _err := ListCacheReserveInstancesWithOptions(client,request, runtime)
16307 if _err != nil {
16308 return _result, _err
16309 }
16310 _result = _body
16311 return _result, _err
16312 }
16313
16314 // Summary:
16315 //
16316 // # Query multiple cache configurations
16317 //
16318 // @param request - ListCacheRulesRequest
16319 //
16320 // @param runtime - runtime options for this request RuntimeOptions
16321 //
16322 // @return ListCacheRulesResponse
16323 func ListCacheRulesWithOptions(client *Client, request *ListCacheRulesRequest, runtime *dara.RuntimeOptions) (_result *ListCacheRulesResponse, _err error) {
16324 if dara.BoolValue(client.EnableValidate) == true {
16325 _err = request.Validate()
16326 if _err != nil {
16327 return _result, _err
16328 }
16329 }
16330 query := openapiutil.Query(dara.ToMap(request))
16331 req := &openapiutil.OpenApiRequest{
16332 Query: openapiutil.Query(query),
16333 }
16334 params := &openapiutil.Params{
16335 Action: dara.String("ListCacheRules"),
16336 Version: dara.String("2024-09-10"),
16337 Protocol: dara.String("HTTPS"),
16338 Pathname: dara.String("/"),
16339 Method: dara.String("GET"),
16340 AuthType: dara.String("AK"),
16341 Style: dara.String("RPC"),
16342 ReqBodyType: dara.String("formData"),
16343 BodyType: dara.String("json"),
16344 }
16345 _result = &ListCacheRulesResponse{}
16346 _body, _err := client.CallApi(params, req, runtime)
16347 if _err != nil {
16348 return _result, _err
16349 }
16350 _err = dara.Convert(_body, &_result)
16351 return _result, _err
16352 }
16353
16354 // Summary:
16355 //
16356 // # Query multiple cache configurations
16357 //
16358 // @param request - ListCacheRulesRequest
16359 //
16360 // @return ListCacheRulesResponse
16361 func ListCacheRules(client *Client, request *ListCacheRulesRequest) (_result *ListCacheRulesResponse, _err error) {
16362 runtime := &dara.RuntimeOptions{}
16363 _result = &ListCacheRulesResponse{}
16364 _body, _err := ListCacheRulesWithOptions(client,request, runtime)
16365 if _err != nil {
16366 return _result, _err
16367 }
16368 _result = _body
16369 return _result, _err
16370 }
16371
16372 // Summary:
16373 //
16374 // Lists certificates of a website.
16375 //
16376 // @param request - ListCertificatesRequest
16377 //
16378 // @param runtime - runtime options for this request RuntimeOptions
16379 //
16380 // @return ListCertificatesResponse
16381 func ListCertificatesWithOptions(client *Client, request *ListCertificatesRequest, runtime *dara.RuntimeOptions) (_result *ListCertificatesResponse, _err error) {
16382 if dara.BoolValue(client.EnableValidate) == true {
16383 _err = request.Validate()
16384 if _err != nil {
16385 return _result, _err
16386 }
16387 }
16388 query := openapiutil.Query(dara.ToMap(request))
16389 req := &openapiutil.OpenApiRequest{
16390 Query: openapiutil.Query(query),
16391 }
16392 params := &openapiutil.Params{
16393 Action: dara.String("ListCertificates"),
16394 Version: dara.String("2024-09-10"),
16395 Protocol: dara.String("HTTPS"),
16396 Pathname: dara.String("/"),
16397 Method: dara.String("GET"),
16398 AuthType: dara.String("AK"),
16399 Style: dara.String("RPC"),
16400 ReqBodyType: dara.String("formData"),
16401 BodyType: dara.String("json"),
16402 }
16403 _result = &ListCertificatesResponse{}
16404 _body, _err := client.CallApi(params, req, runtime)
16405 if _err != nil {
16406 return _result, _err
16407 }
16408 _err = dara.Convert(_body, &_result)
16409 return _result, _err
16410 }
16411
16412 // Summary:
16413 //
16414 // Lists certificates of a website.
16415 //
16416 // @param request - ListCertificatesRequest
16417 //
16418 // @return ListCertificatesResponse
16419 func ListCertificates(client *Client, request *ListCertificatesRequest) (_result *ListCertificatesResponse, _err error) {
16420 runtime := &dara.RuntimeOptions{}
16421 _result = &ListCertificatesResponse{}
16422 _body, _err := ListCertificatesWithOptions(client,request, runtime)
16423 if _err != nil {
16424 return _result, _err
16425 }
16426 _result = _body
16427 return _result, _err
16428 }
16429
16430 // Summary:
16431 //
16432 // Lists certificates that match specified records for a website. You can specify multiple records at a time.
16433 //
16434 // @param request - ListCertificatesByRecordRequest
16435 //
16436 // @param runtime - runtime options for this request RuntimeOptions
16437 //
16438 // @return ListCertificatesByRecordResponse
16439 func ListCertificatesByRecordWithOptions(client *Client, request *ListCertificatesByRecordRequest, runtime *dara.RuntimeOptions) (_result *ListCertificatesByRecordResponse, _err error) {
16440 if dara.BoolValue(client.EnableValidate) == true {
16441 _err = request.Validate()
16442 if _err != nil {
16443 return _result, _err
16444 }
16445 }
16446 query := openapiutil.Query(dara.ToMap(request))
16447 req := &openapiutil.OpenApiRequest{
16448 Query: openapiutil.Query(query),
16449 }
16450 params := &openapiutil.Params{
16451 Action: dara.String("ListCertificatesByRecord"),
16452 Version: dara.String("2024-09-10"),
16453 Protocol: dara.String("HTTPS"),
16454 Pathname: dara.String("/"),
16455 Method: dara.String("GET"),
16456 AuthType: dara.String("AK"),
16457 Style: dara.String("RPC"),
16458 ReqBodyType: dara.String("formData"),
16459 BodyType: dara.String("json"),
16460 }
16461 _result = &ListCertificatesByRecordResponse{}
16462 _body, _err := client.CallApi(params, req, runtime)
16463 if _err != nil {
16464 return _result, _err
16465 }
16466 _err = dara.Convert(_body, &_result)
16467 return _result, _err
16468 }
16469
16470 // Summary:
16471 //
16472 // Lists certificates that match specified records for a website. You can specify multiple records at a time.
16473 //
16474 // @param request - ListCertificatesByRecordRequest
16475 //
16476 // @return ListCertificatesByRecordResponse
16477 func ListCertificatesByRecord(client *Client, request *ListCertificatesByRecordRequest) (_result *ListCertificatesByRecordResponse, _err error) {
16478 runtime := &dara.RuntimeOptions{}
16479 _result = &ListCertificatesByRecordResponse{}
16480 _body, _err := ListCertificatesByRecordWithOptions(client,request, runtime)
16481 if _err != nil {
16482 return _result, _err
16483 }
16484 _result = _body
16485 return _result, _err
16486 }
16487
16488 // Summary:
16489 //
16490 // # Query TLS Cipher Suite List
16491 //
16492 // @param request - ListCiphersRequest
16493 //
16494 // @param runtime - runtime options for this request RuntimeOptions
16495 //
16496 // @return ListCiphersResponse
16497 func ListCiphersWithOptions(client *Client, request *ListCiphersRequest, runtime *dara.RuntimeOptions) (_result *ListCiphersResponse, _err error) {
16498 if dara.BoolValue(client.EnableValidate) == true {
16499 _err = request.Validate()
16500 if _err != nil {
16501 return _result, _err
16502 }
16503 }
16504 query := openapiutil.Query(dara.ToMap(request))
16505 req := &openapiutil.OpenApiRequest{
16506 Query: openapiutil.Query(query),
16507 }
16508 params := &openapiutil.Params{
16509 Action: dara.String("ListCiphers"),
16510 Version: dara.String("2024-09-10"),
16511 Protocol: dara.String("HTTPS"),
16512 Pathname: dara.String("/"),
16513 Method: dara.String("GET"),
16514 AuthType: dara.String("AK"),
16515 Style: dara.String("RPC"),
16516 ReqBodyType: dara.String("formData"),
16517 BodyType: dara.String("json"),
16518 }
16519 _result = &ListCiphersResponse{}
16520 _body, _err := client.CallApi(params, req, runtime)
16521 if _err != nil {
16522 return _result, _err
16523 }
16524 _err = dara.Convert(_body, &_result)
16525 return _result, _err
16526 }
16527
16528 // Summary:
16529 //
16530 // # Query TLS Cipher Suite List
16531 //
16532 // @param request - ListCiphersRequest
16533 //
16534 // @return ListCiphersResponse
16535 func ListCiphers(client *Client, request *ListCiphersRequest) (_result *ListCiphersResponse, _err error) {
16536 runtime := &dara.RuntimeOptions{}
16537 _result = &ListCiphersResponse{}
16538 _body, _err := ListCiphersWithOptions(client,request, runtime)
16539 if _err != nil {
16540 return _result, _err
16541 }
16542 _result = _body
16543 return _result, _err
16544 }
16545
16546 // Summary:
16547 //
16548 // Queries a list of client certificate authority (CA) certificates for a website.
16549 //
16550 // @param request - ListClientCaCertificatesRequest
16551 //
16552 // @param runtime - runtime options for this request RuntimeOptions
16553 //
16554 // @return ListClientCaCertificatesResponse
16555 func ListClientCaCertificatesWithOptions(client *Client, request *ListClientCaCertificatesRequest, runtime *dara.RuntimeOptions) (_result *ListClientCaCertificatesResponse, _err error) {
16556 if dara.BoolValue(client.EnableValidate) == true {
16557 _err = request.Validate()
16558 if _err != nil {
16559 return _result, _err
16560 }
16561 }
16562 query := openapiutil.Query(dara.ToMap(request))
16563 req := &openapiutil.OpenApiRequest{
16564 Query: openapiutil.Query(query),
16565 }
16566 params := &openapiutil.Params{
16567 Action: dara.String("ListClientCaCertificates"),
16568 Version: dara.String("2024-09-10"),
16569 Protocol: dara.String("HTTPS"),
16570 Pathname: dara.String("/"),
16571 Method: dara.String("GET"),
16572 AuthType: dara.String("AK"),
16573 Style: dara.String("RPC"),
16574 ReqBodyType: dara.String("formData"),
16575 BodyType: dara.String("json"),
16576 }
16577 _result = &ListClientCaCertificatesResponse{}
16578 _body, _err := client.CallApi(params, req, runtime)
16579 if _err != nil {
16580 return _result, _err
16581 }
16582 _err = dara.Convert(_body, &_result)
16583 return _result, _err
16584 }
16585
16586 // Summary:
16587 //
16588 // Queries a list of client certificate authority (CA) certificates for a website.
16589 //
16590 // @param request - ListClientCaCertificatesRequest
16591 //
16592 // @return ListClientCaCertificatesResponse
16593 func ListClientCaCertificates(client *Client, request *ListClientCaCertificatesRequest) (_result *ListClientCaCertificatesResponse, _err error) {
16594 runtime := &dara.RuntimeOptions{}
16595 _result = &ListClientCaCertificatesResponse{}
16596 _body, _err := ListClientCaCertificatesWithOptions(client,request, runtime)
16597 if _err != nil {
16598 return _result, _err
16599 }
16600 _result = _body
16601 return _result, _err
16602 }
16603
16604 // Summary:
16605 //
16606 // Queries client certificates configured for a website.
16607 //
16608 // @param request - ListClientCertificatesRequest
16609 //
16610 // @param runtime - runtime options for this request RuntimeOptions
16611 //
16612 // @return ListClientCertificatesResponse
16613 func ListClientCertificatesWithOptions(client *Client, request *ListClientCertificatesRequest, runtime *dara.RuntimeOptions) (_result *ListClientCertificatesResponse, _err error) {
16614 if dara.BoolValue(client.EnableValidate) == true {
16615 _err = request.Validate()
16616 if _err != nil {
16617 return _result, _err
16618 }
16619 }
16620 query := openapiutil.Query(dara.ToMap(request))
16621 req := &openapiutil.OpenApiRequest{
16622 Query: openapiutil.Query(query),
16623 }
16624 params := &openapiutil.Params{
16625 Action: dara.String("ListClientCertificates"),
16626 Version: dara.String("2024-09-10"),
16627 Protocol: dara.String("HTTPS"),
16628 Pathname: dara.String("/"),
16629 Method: dara.String("GET"),
16630 AuthType: dara.String("AK"),
16631 Style: dara.String("RPC"),
16632 ReqBodyType: dara.String("formData"),
16633 BodyType: dara.String("json"),
16634 }
16635 _result = &ListClientCertificatesResponse{}
16636 _body, _err := client.CallApi(params, req, runtime)
16637 if _err != nil {
16638 return _result, _err
16639 }
16640 _err = dara.Convert(_body, &_result)
16641 return _result, _err
16642 }
16643
16644 // Summary:
16645 //
16646 // Queries client certificates configured for a website.
16647 //
16648 // @param request - ListClientCertificatesRequest
16649 //
16650 // @return ListClientCertificatesResponse
16651 func ListClientCertificates(client *Client, request *ListClientCertificatesRequest) (_result *ListClientCertificatesResponse, _err error) {
16652 runtime := &dara.RuntimeOptions{}
16653 _result = &ListClientCertificatesResponse{}
16654 _body, _err := ListClientCertificatesWithOptions(client,request, runtime)
16655 if _err != nil {
16656 return _result, _err
16657 }
16658 _result = _body
16659 return _result, _err
16660 }
16661
16662 // Summary:
16663 //
16664 // # Query the list of compression rules
16665 //
16666 // @param request - ListCompressionRulesRequest
16667 //
16668 // @param runtime - runtime options for this request RuntimeOptions
16669 //
16670 // @return ListCompressionRulesResponse
16671 func ListCompressionRulesWithOptions(client *Client, request *ListCompressionRulesRequest, runtime *dara.RuntimeOptions) (_result *ListCompressionRulesResponse, _err error) {
16672 if dara.BoolValue(client.EnableValidate) == true {
16673 _err = request.Validate()
16674 if _err != nil {
16675 return _result, _err
16676 }
16677 }
16678 query := openapiutil.Query(dara.ToMap(request))
16679 req := &openapiutil.OpenApiRequest{
16680 Query: openapiutil.Query(query),
16681 }
16682 params := &openapiutil.Params{
16683 Action: dara.String("ListCompressionRules"),
16684 Version: dara.String("2024-09-10"),
16685 Protocol: dara.String("HTTPS"),
16686 Pathname: dara.String("/"),
16687 Method: dara.String("GET"),
16688 AuthType: dara.String("AK"),
16689 Style: dara.String("RPC"),
16690 ReqBodyType: dara.String("formData"),
16691 BodyType: dara.String("json"),
16692 }
16693 _result = &ListCompressionRulesResponse{}
16694 _body, _err := client.CallApi(params, req, runtime)
16695 if _err != nil {
16696 return _result, _err
16697 }
16698 _err = dara.Convert(_body, &_result)
16699 return _result, _err
16700 }
16701
16702 // Summary:
16703 //
16704 // # Query the list of compression rules
16705 //
16706 // @param request - ListCompressionRulesRequest
16707 //
16708 // @return ListCompressionRulesResponse
16709 func ListCompressionRules(client *Client, request *ListCompressionRulesRequest) (_result *ListCompressionRulesResponse, _err error) {
16710 runtime := &dara.RuntimeOptions{}
16711 _result = &ListCompressionRulesResponse{}
16712 _body, _err := ListCompressionRulesWithOptions(client,request, runtime)
16713 if _err != nil {
16714 return _result, _err
16715 }
16716 _result = _body
16717 return _result, _err
16718 }
16719
16720 // Summary:
16721 //
16722 // Batch query whether the IP address is included in the ESA resolution result.
16723 //
16724 // Description:
16725 //
16726 // This interface is used to check whether the vs_addr parameter in the vipInfo collection is vip.
16727 //
16728 // @param request - ListESAIPInfoRequest
16729 //
16730 // @param runtime - runtime options for this request RuntimeOptions
16731 //
16732 // @return ListESAIPInfoResponse
16733 func ListESAIPInfoWithOptions(client *Client, request *ListESAIPInfoRequest, runtime *dara.RuntimeOptions) (_result *ListESAIPInfoResponse, _err error) {
16734 if dara.BoolValue(client.EnableValidate) == true {
16735 _err = request.Validate()
16736 if _err != nil {
16737 return _result, _err
16738 }
16739 }
16740 query := openapiutil.Query(dara.ToMap(request))
16741 req := &openapiutil.OpenApiRequest{
16742 Query: openapiutil.Query(query),
16743 }
16744 params := &openapiutil.Params{
16745 Action: dara.String("ListESAIPInfo"),
16746 Version: dara.String("2024-09-10"),
16747 Protocol: dara.String("HTTPS"),
16748 Pathname: dara.String("/"),
16749 Method: dara.String("GET"),
16750 AuthType: dara.String("AK"),
16751 Style: dara.String("RPC"),
16752 ReqBodyType: dara.String("formData"),
16753 BodyType: dara.String("json"),
16754 }
16755 _result = &ListESAIPInfoResponse{}
16756 _body, _err := client.CallApi(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 // Batch query whether the IP address is included in the ESA resolution result.
16767 //
16768 // Description:
16769 //
16770 // This interface is used to check whether the vs_addr parameter in the vipInfo collection is vip.
16771 //
16772 // @param request - ListESAIPInfoRequest
16773 //
16774 // @return ListESAIPInfoResponse
16775 func ListESAIPInfo(client *Client, request *ListESAIPInfoRequest) (_result *ListESAIPInfoResponse, _err error) {
16776 runtime := &dara.RuntimeOptions{}
16777 _result = &ListESAIPInfoResponse{}
16778 _body, _err := ListESAIPInfoWithOptions(client,request, runtime)
16779 if _err != nil {
16780 return _result, _err
16781 }
16782 _result = _body
16783 return _result, _err
16784 }
16785
16786 // Summary:
16787 //
16788 // 获取边缘容器应用的镜像秘钥列表
16789 //
16790 // @param request - ListEdgeContainerAppImageSecretsRequest
16791 //
16792 // @param runtime - runtime options for this request RuntimeOptions
16793 //
16794 // @return ListEdgeContainerAppImageSecretsResponse
16795 func ListEdgeContainerAppImageSecretsWithOptions(client *Client, request *ListEdgeContainerAppImageSecretsRequest, runtime *dara.RuntimeOptions) (_result *ListEdgeContainerAppImageSecretsResponse, _err error) {
16796 if dara.BoolValue(client.EnableValidate) == true {
16797 _err = request.Validate()
16798 if _err != nil {
16799 return _result, _err
16800 }
16801 }
16802 query := map[string]interface{}{}
16803 if !dara.IsNil(request.AppId) {
16804 query["AppId"] = request.AppId
16805 }
16806
16807 req := &openapiutil.OpenApiRequest{
16808 Query: openapiutil.Query(query),
16809 }
16810 params := &openapiutil.Params{
16811 Action: dara.String("ListEdgeContainerAppImageSecrets"),
16812 Version: dara.String("2024-09-10"),
16813 Protocol: dara.String("HTTPS"),
16814 Pathname: dara.String("/"),
16815 Method: dara.String("POST"),
16816 AuthType: dara.String("AK"),
16817 Style: dara.String("RPC"),
16818 ReqBodyType: dara.String("formData"),
16819 BodyType: dara.String("json"),
16820 }
16821 _result = &ListEdgeContainerAppImageSecretsResponse{}
16822 _body, _err := client.CallApi(params, req, runtime)
16823 if _err != nil {
16824 return _result, _err
16825 }
16826 _err = dara.Convert(_body, &_result)
16827 return _result, _err
16828 }
16829
16830 // Summary:
16831 //
16832 // 获取边缘容器应用的镜像秘钥列表
16833 //
16834 // @param request - ListEdgeContainerAppImageSecretsRequest
16835 //
16836 // @return ListEdgeContainerAppImageSecretsResponse
16837 func ListEdgeContainerAppImageSecrets(client *Client, request *ListEdgeContainerAppImageSecretsRequest) (_result *ListEdgeContainerAppImageSecretsResponse, _err error) {
16838 runtime := &dara.RuntimeOptions{}
16839 _result = &ListEdgeContainerAppImageSecretsResponse{}
16840 _body, _err := ListEdgeContainerAppImageSecretsWithOptions(client,request, runtime)
16841 if _err != nil {
16842 return _result, _err
16843 }
16844 _result = _body
16845 return _result, _err
16846 }
16847
16848 // Summary:
16849 //
16850 // Lists domain names that are associated with a containerized application.
16851 //
16852 // @param request - ListEdgeContainerAppRecordsRequest
16853 //
16854 // @param runtime - runtime options for this request RuntimeOptions
16855 //
16856 // @return ListEdgeContainerAppRecordsResponse
16857 func ListEdgeContainerAppRecordsWithOptions(client *Client, request *ListEdgeContainerAppRecordsRequest, runtime *dara.RuntimeOptions) (_result *ListEdgeContainerAppRecordsResponse, _err error) {
16858 if dara.BoolValue(client.EnableValidate) == true {
16859 _err = request.Validate()
16860 if _err != nil {
16861 return _result, _err
16862 }
16863 }
16864 query := openapiutil.Query(dara.ToMap(request))
16865 req := &openapiutil.OpenApiRequest{
16866 Query: openapiutil.Query(query),
16867 }
16868 params := &openapiutil.Params{
16869 Action: dara.String("ListEdgeContainerAppRecords"),
16870 Version: dara.String("2024-09-10"),
16871 Protocol: dara.String("HTTPS"),
16872 Pathname: dara.String("/"),
16873 Method: dara.String("GET"),
16874 AuthType: dara.String("AK"),
16875 Style: dara.String("RPC"),
16876 ReqBodyType: dara.String("formData"),
16877 BodyType: dara.String("json"),
16878 }
16879 _result = &ListEdgeContainerAppRecordsResponse{}
16880 _body, _err := client.CallApi(params, req, runtime)
16881 if _err != nil {
16882 return _result, _err
16883 }
16884 _err = dara.Convert(_body, &_result)
16885 return _result, _err
16886 }
16887
16888 // Summary:
16889 //
16890 // Lists domain names that are associated with a containerized application.
16891 //
16892 // @param request - ListEdgeContainerAppRecordsRequest
16893 //
16894 // @return ListEdgeContainerAppRecordsResponse
16895 func ListEdgeContainerAppRecords(client *Client, request *ListEdgeContainerAppRecordsRequest) (_result *ListEdgeContainerAppRecordsResponse, _err error) {
16896 runtime := &dara.RuntimeOptions{}
16897 _result = &ListEdgeContainerAppRecordsResponse{}
16898 _body, _err := ListEdgeContainerAppRecordsWithOptions(client,request, runtime)
16899 if _err != nil {
16900 return _result, _err
16901 }
16902 _result = _body
16903 return _result, _err
16904 }
16905
16906 // Summary:
16907 //
16908 // Lists versions of all containerized applications.
16909 //
16910 // @param request - ListEdgeContainerAppVersionsRequest
16911 //
16912 // @param runtime - runtime options for this request RuntimeOptions
16913 //
16914 // @return ListEdgeContainerAppVersionsResponse
16915 func ListEdgeContainerAppVersionsWithOptions(client *Client, request *ListEdgeContainerAppVersionsRequest, runtime *dara.RuntimeOptions) (_result *ListEdgeContainerAppVersionsResponse, _err error) {
16916 if dara.BoolValue(client.EnableValidate) == true {
16917 _err = request.Validate()
16918 if _err != nil {
16919 return _result, _err
16920 }
16921 }
16922 query := openapiutil.Query(dara.ToMap(request))
16923 req := &openapiutil.OpenApiRequest{
16924 Query: openapiutil.Query(query),
16925 }
16926 params := &openapiutil.Params{
16927 Action: dara.String("ListEdgeContainerAppVersions"),
16928 Version: dara.String("2024-09-10"),
16929 Protocol: dara.String("HTTPS"),
16930 Pathname: dara.String("/"),
16931 Method: dara.String("GET"),
16932 AuthType: dara.String("AK"),
16933 Style: dara.String("RPC"),
16934 ReqBodyType: dara.String("formData"),
16935 BodyType: dara.String("json"),
16936 }
16937 _result = &ListEdgeContainerAppVersionsResponse{}
16938 _body, _err := client.CallApi(params, req, runtime)
16939 if _err != nil {
16940 return _result, _err
16941 }
16942 _err = dara.Convert(_body, &_result)
16943 return _result, _err
16944 }
16945
16946 // Summary:
16947 //
16948 // Lists versions of all containerized applications.
16949 //
16950 // @param request - ListEdgeContainerAppVersionsRequest
16951 //
16952 // @return ListEdgeContainerAppVersionsResponse
16953 func ListEdgeContainerAppVersions(client *Client, request *ListEdgeContainerAppVersionsRequest) (_result *ListEdgeContainerAppVersionsResponse, _err error) {
16954 runtime := &dara.RuntimeOptions{}
16955 _result = &ListEdgeContainerAppVersionsResponse{}
16956 _body, _err := ListEdgeContainerAppVersionsWithOptions(client,request, runtime)
16957 if _err != nil {
16958 return _result, _err
16959 }
16960 _result = _body
16961 return _result, _err
16962 }
16963
16964 // Summary:
16965 //
16966 // Queries all containerized applications in your Alibaba Cloud account.
16967 //
16968 // @param request - ListEdgeContainerAppsRequest
16969 //
16970 // @param runtime - runtime options for this request RuntimeOptions
16971 //
16972 // @return ListEdgeContainerAppsResponse
16973 func ListEdgeContainerAppsWithOptions(client *Client, request *ListEdgeContainerAppsRequest, runtime *dara.RuntimeOptions) (_result *ListEdgeContainerAppsResponse, _err error) {
16974 if dara.BoolValue(client.EnableValidate) == true {
16975 _err = request.Validate()
16976 if _err != nil {
16977 return _result, _err
16978 }
16979 }
16980 query := map[string]interface{}{}
16981 if !dara.IsNil(request.OrderKey) {
16982 query["OrderKey"] = request.OrderKey
16983 }
16984
16985 if !dara.IsNil(request.OrderType) {
16986 query["OrderType"] = request.OrderType
16987 }
16988
16989 if !dara.IsNil(request.PageNumber) {
16990 query["PageNumber"] = request.PageNumber
16991 }
16992
16993 if !dara.IsNil(request.PageSize) {
16994 query["PageSize"] = request.PageSize
16995 }
16996
16997 if !dara.IsNil(request.SearchKey) {
16998 query["SearchKey"] = request.SearchKey
16999 }
17000
17001 if !dara.IsNil(request.SearchType) {
17002 query["SearchType"] = request.SearchType
17003 }
17004
17005 req := &openapiutil.OpenApiRequest{
17006 Query: openapiutil.Query(query),
17007 }
17008 params := &openapiutil.Params{
17009 Action: dara.String("ListEdgeContainerApps"),
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 = &ListEdgeContainerAppsResponse{}
17020 _body, _err := client.CallApi(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 // Queries all containerized applications in your Alibaba Cloud account.
17031 //
17032 // @param request - ListEdgeContainerAppsRequest
17033 //
17034 // @return ListEdgeContainerAppsResponse
17035 func ListEdgeContainerApps(client *Client, request *ListEdgeContainerAppsRequest) (_result *ListEdgeContainerAppsResponse, _err error) {
17036 runtime := &dara.RuntimeOptions{}
17037 _result = &ListEdgeContainerAppsResponse{}
17038 _body, _err := ListEdgeContainerAppsWithOptions(client,request, runtime)
17039 if _err != nil {
17040 return _result, _err
17041 }
17042 _result = _body
17043 return _result, _err
17044 }
17045
17046 // Summary:
17047 //
17048 // Queries the records that are associated with Edge Container for a website.
17049 //
17050 // @param request - ListEdgeContainerRecordsRequest
17051 //
17052 // @param runtime - runtime options for this request RuntimeOptions
17053 //
17054 // @return ListEdgeContainerRecordsResponse
17055 func ListEdgeContainerRecordsWithOptions(client *Client, request *ListEdgeContainerRecordsRequest, runtime *dara.RuntimeOptions) (_result *ListEdgeContainerRecordsResponse, _err error) {
17056 if dara.BoolValue(client.EnableValidate) == true {
17057 _err = request.Validate()
17058 if _err != nil {
17059 return _result, _err
17060 }
17061 }
17062 query := openapiutil.Query(dara.ToMap(request))
17063 req := &openapiutil.OpenApiRequest{
17064 Query: openapiutil.Query(query),
17065 }
17066 params := &openapiutil.Params{
17067 Action: dara.String("ListEdgeContainerRecords"),
17068 Version: dara.String("2024-09-10"),
17069 Protocol: dara.String("HTTPS"),
17070 Pathname: dara.String("/"),
17071 Method: dara.String("GET"),
17072 AuthType: dara.String("AK"),
17073 Style: dara.String("RPC"),
17074 ReqBodyType: dara.String("formData"),
17075 BodyType: dara.String("json"),
17076 }
17077 _result = &ListEdgeContainerRecordsResponse{}
17078 _body, _err := client.CallApi(params, req, runtime)
17079 if _err != nil {
17080 return _result, _err
17081 }
17082 _err = dara.Convert(_body, &_result)
17083 return _result, _err
17084 }
17085
17086 // Summary:
17087 //
17088 // Queries the records that are associated with Edge Container for a website.
17089 //
17090 // @param request - ListEdgeContainerRecordsRequest
17091 //
17092 // @return ListEdgeContainerRecordsResponse
17093 func ListEdgeContainerRecords(client *Client, request *ListEdgeContainerRecordsRequest) (_result *ListEdgeContainerRecordsResponse, _err error) {
17094 runtime := &dara.RuntimeOptions{}
17095 _result = &ListEdgeContainerRecordsResponse{}
17096 _body, _err := ListEdgeContainerRecordsWithOptions(client,request, runtime)
17097 if _err != nil {
17098 return _result, _err
17099 }
17100 _result = _body
17101 return _result, _err
17102 }
17103
17104 // Summary:
17105 //
17106 // Queries Edge Routine plans.
17107 //
17108 // @param request - ListEdgeRoutinePlansRequest
17109 //
17110 // @param runtime - runtime options for this request RuntimeOptions
17111 //
17112 // @return ListEdgeRoutinePlansResponse
17113 func ListEdgeRoutinePlansWithOptions(client *Client, runtime *dara.RuntimeOptions) (_result *ListEdgeRoutinePlansResponse, _err error) {
17114 req := &openapiutil.OpenApiRequest{}
17115 params := &openapiutil.Params{
17116 Action: dara.String("ListEdgeRoutinePlans"),
17117 Version: dara.String("2024-09-10"),
17118 Protocol: dara.String("HTTPS"),
17119 Pathname: dara.String("/"),
17120 Method: dara.String("GET"),
17121 AuthType: dara.String("AK"),
17122 Style: dara.String("RPC"),
17123 ReqBodyType: dara.String("formData"),
17124 BodyType: dara.String("json"),
17125 }
17126 _result = &ListEdgeRoutinePlansResponse{}
17127 _body, _err := client.CallApi(params, req, runtime)
17128 if _err != nil {
17129 return _result, _err
17130 }
17131 _err = dara.Convert(_body, &_result)
17132 return _result, _err
17133 }
17134
17135 // Summary:
17136 //
17137 // Queries Edge Routine plans.
17138 //
17139 // @return ListEdgeRoutinePlansResponse
17140 func ListEdgeRoutinePlans(client *Client, ) (_result *ListEdgeRoutinePlansResponse, _err error) {
17141 runtime := &dara.RuntimeOptions{}
17142 _result = &ListEdgeRoutinePlansResponse{}
17143 _body, _err := ListEdgeRoutinePlansWithOptions(client,runtime)
17144 if _err != nil {
17145 return _result, _err
17146 }
17147 _result = _body
17148 return _result, _err
17149 }
17150
17151 // Summary:
17152 //
17153 // Queries the records that are associated with Edge Routine routes for a website.
17154 //
17155 // Description:
17156 //
17157 // > You can call this operation 100 times per second.
17158 //
17159 // @param request - ListEdgeRoutineRecordsRequest
17160 //
17161 // @param runtime - runtime options for this request RuntimeOptions
17162 //
17163 // @return ListEdgeRoutineRecordsResponse
17164 func ListEdgeRoutineRecordsWithOptions(client *Client, request *ListEdgeRoutineRecordsRequest, runtime *dara.RuntimeOptions) (_result *ListEdgeRoutineRecordsResponse, _err error) {
17165 if dara.BoolValue(client.EnableValidate) == true {
17166 _err = request.Validate()
17167 if _err != nil {
17168 return _result, _err
17169 }
17170 }
17171 query := openapiutil.Query(dara.ToMap(request))
17172 req := &openapiutil.OpenApiRequest{
17173 Query: openapiutil.Query(query),
17174 }
17175 params := &openapiutil.Params{
17176 Action: dara.String("ListEdgeRoutineRecords"),
17177 Version: dara.String("2024-09-10"),
17178 Protocol: dara.String("HTTPS"),
17179 Pathname: dara.String("/"),
17180 Method: dara.String("GET"),
17181 AuthType: dara.String("AK"),
17182 Style: dara.String("RPC"),
17183 ReqBodyType: dara.String("formData"),
17184 BodyType: dara.String("json"),
17185 }
17186 _result = &ListEdgeRoutineRecordsResponse{}
17187 _body, _err := client.CallApi(params, req, runtime)
17188 if _err != nil {
17189 return _result, _err
17190 }
17191 _err = dara.Convert(_body, &_result)
17192 return _result, _err
17193 }
17194
17195 // Summary:
17196 //
17197 // Queries the records that are associated with Edge Routine routes for a website.
17198 //
17199 // Description:
17200 //
17201 // > You can call this operation 100 times per second.
17202 //
17203 // @param request - ListEdgeRoutineRecordsRequest
17204 //
17205 // @return ListEdgeRoutineRecordsResponse
17206 func ListEdgeRoutineRecords(client *Client, request *ListEdgeRoutineRecordsRequest) (_result *ListEdgeRoutineRecordsResponse, _err error) {
17207 runtime := &dara.RuntimeOptions{}
17208 _result = &ListEdgeRoutineRecordsResponse{}
17209 _body, _err := ListEdgeRoutineRecordsWithOptions(client,request, runtime)
17210 if _err != nil {
17211 return _result, _err
17212 }
17213 _result = _body
17214 return _result, _err
17215 }
17216
17217 // Summary:
17218 //
17219 // Queries the configuration details of an incoming HTTP request header modification rule for a website.
17220 //
17221 // @param request - ListHttpIncomingRequestHeaderModificationRulesRequest
17222 //
17223 // @param runtime - runtime options for this request RuntimeOptions
17224 //
17225 // @return ListHttpIncomingRequestHeaderModificationRulesResponse
17226 func ListHttpIncomingRequestHeaderModificationRulesWithOptions(client *Client, request *ListHttpIncomingRequestHeaderModificationRulesRequest, runtime *dara.RuntimeOptions) (_result *ListHttpIncomingRequestHeaderModificationRulesResponse, _err error) {
17227 if dara.BoolValue(client.EnableValidate) == true {
17228 _err = request.Validate()
17229 if _err != nil {
17230 return _result, _err
17231 }
17232 }
17233 query := openapiutil.Query(dara.ToMap(request))
17234 req := &openapiutil.OpenApiRequest{
17235 Query: openapiutil.Query(query),
17236 }
17237 params := &openapiutil.Params{
17238 Action: dara.String("ListHttpIncomingRequestHeaderModificationRules"),
17239 Version: dara.String("2024-09-10"),
17240 Protocol: dara.String("HTTPS"),
17241 Pathname: dara.String("/"),
17242 Method: dara.String("GET"),
17243 AuthType: dara.String("AK"),
17244 Style: dara.String("RPC"),
17245 ReqBodyType: dara.String("formData"),
17246 BodyType: dara.String("json"),
17247 }
17248 _result = &ListHttpIncomingRequestHeaderModificationRulesResponse{}
17249 _body, _err := client.CallApi(params, req, runtime)
17250 if _err != nil {
17251 return _result, _err
17252 }
17253 _err = dara.Convert(_body, &_result)
17254 return _result, _err
17255 }
17256
17257 // Summary:
17258 //
17259 // Queries the configuration details of an incoming HTTP request header modification rule for a website.
17260 //
17261 // @param request - ListHttpIncomingRequestHeaderModificationRulesRequest
17262 //
17263 // @return ListHttpIncomingRequestHeaderModificationRulesResponse
17264 func ListHttpIncomingRequestHeaderModificationRules(client *Client, request *ListHttpIncomingRequestHeaderModificationRulesRequest) (_result *ListHttpIncomingRequestHeaderModificationRulesResponse, _err error) {
17265 runtime := &dara.RuntimeOptions{}
17266 _result = &ListHttpIncomingRequestHeaderModificationRulesResponse{}
17267 _body, _err := ListHttpIncomingRequestHeaderModificationRulesWithOptions(client,request, runtime)
17268 if _err != nil {
17269 return _result, _err
17270 }
17271 _result = _body
17272 return _result, _err
17273 }
17274
17275 // Summary:
17276 //
17277 // Queries the configurations of an incoming HTTP response header modification rule for a website.
17278 //
17279 // @param request - ListHttpIncomingResponseHeaderModificationRulesRequest
17280 //
17281 // @param runtime - runtime options for this request RuntimeOptions
17282 //
17283 // @return ListHttpIncomingResponseHeaderModificationRulesResponse
17284 func ListHttpIncomingResponseHeaderModificationRulesWithOptions(client *Client, request *ListHttpIncomingResponseHeaderModificationRulesRequest, runtime *dara.RuntimeOptions) (_result *ListHttpIncomingResponseHeaderModificationRulesResponse, _err error) {
17285 if dara.BoolValue(client.EnableValidate) == true {
17286 _err = request.Validate()
17287 if _err != nil {
17288 return _result, _err
17289 }
17290 }
17291 query := openapiutil.Query(dara.ToMap(request))
17292 req := &openapiutil.OpenApiRequest{
17293 Query: openapiutil.Query(query),
17294 }
17295 params := &openapiutil.Params{
17296 Action: dara.String("ListHttpIncomingResponseHeaderModificationRules"),
17297 Version: dara.String("2024-09-10"),
17298 Protocol: dara.String("HTTPS"),
17299 Pathname: dara.String("/"),
17300 Method: dara.String("GET"),
17301 AuthType: dara.String("AK"),
17302 Style: dara.String("RPC"),
17303 ReqBodyType: dara.String("formData"),
17304 BodyType: dara.String("json"),
17305 }
17306 _result = &ListHttpIncomingResponseHeaderModificationRulesResponse{}
17307 _body, _err := client.CallApi(params, req, runtime)
17308 if _err != nil {
17309 return _result, _err
17310 }
17311 _err = dara.Convert(_body, &_result)
17312 return _result, _err
17313 }
17314
17315 // Summary:
17316 //
17317 // Queries the configurations of an incoming HTTP response header modification rule for a website.
17318 //
17319 // @param request - ListHttpIncomingResponseHeaderModificationRulesRequest
17320 //
17321 // @return ListHttpIncomingResponseHeaderModificationRulesResponse
17322 func ListHttpIncomingResponseHeaderModificationRules(client *Client, request *ListHttpIncomingResponseHeaderModificationRulesRequest) (_result *ListHttpIncomingResponseHeaderModificationRulesResponse, _err error) {
17323 runtime := &dara.RuntimeOptions{}
17324 _result = &ListHttpIncomingResponseHeaderModificationRulesResponse{}
17325 _body, _err := ListHttpIncomingResponseHeaderModificationRulesWithOptions(client,request, runtime)
17326 if _err != nil {
17327 return _result, _err
17328 }
17329 _result = _body
17330 return _result, _err
17331 }
17332
17333 // Summary:
17334 //
17335 // # List of HTTP Request Header Rules
17336 //
17337 // @param request - ListHttpRequestHeaderModificationRulesRequest
17338 //
17339 // @param runtime - runtime options for this request RuntimeOptions
17340 //
17341 // @return ListHttpRequestHeaderModificationRulesResponse
17342 func ListHttpRequestHeaderModificationRulesWithOptions(client *Client, request *ListHttpRequestHeaderModificationRulesRequest, runtime *dara.RuntimeOptions) (_result *ListHttpRequestHeaderModificationRulesResponse, _err error) {
17343 if dara.BoolValue(client.EnableValidate) == true {
17344 _err = request.Validate()
17345 if _err != nil {
17346 return _result, _err
17347 }
17348 }
17349 query := openapiutil.Query(dara.ToMap(request))
17350 req := &openapiutil.OpenApiRequest{
17351 Query: openapiutil.Query(query),
17352 }
17353 params := &openapiutil.Params{
17354 Action: dara.String("ListHttpRequestHeaderModificationRules"),
17355 Version: dara.String("2024-09-10"),
17356 Protocol: dara.String("HTTPS"),
17357 Pathname: dara.String("/"),
17358 Method: dara.String("GET"),
17359 AuthType: dara.String("AK"),
17360 Style: dara.String("RPC"),
17361 ReqBodyType: dara.String("formData"),
17362 BodyType: dara.String("json"),
17363 }
17364 _result = &ListHttpRequestHeaderModificationRulesResponse{}
17365 _body, _err := client.CallApi(params, req, runtime)
17366 if _err != nil {
17367 return _result, _err
17368 }
17369 _err = dara.Convert(_body, &_result)
17370 return _result, _err
17371 }
17372
17373 // Summary:
17374 //
17375 // # List of HTTP Request Header Rules
17376 //
17377 // @param request - ListHttpRequestHeaderModificationRulesRequest
17378 //
17379 // @return ListHttpRequestHeaderModificationRulesResponse
17380 func ListHttpRequestHeaderModificationRules(client *Client, request *ListHttpRequestHeaderModificationRulesRequest) (_result *ListHttpRequestHeaderModificationRulesResponse, _err error) {
17381 runtime := &dara.RuntimeOptions{}
17382 _result = &ListHttpRequestHeaderModificationRulesResponse{}
17383 _body, _err := ListHttpRequestHeaderModificationRulesWithOptions(client,request, runtime)
17384 if _err != nil {
17385 return _result, _err
17386 }
17387 _result = _body
17388 return _result, _err
17389 }
17390
17391 // Summary:
17392 //
17393 // # List of HTTP Response Header Rules
17394 //
17395 // @param request - ListHttpResponseHeaderModificationRulesRequest
17396 //
17397 // @param runtime - runtime options for this request RuntimeOptions
17398 //
17399 // @return ListHttpResponseHeaderModificationRulesResponse
17400 func ListHttpResponseHeaderModificationRulesWithOptions(client *Client, request *ListHttpResponseHeaderModificationRulesRequest, runtime *dara.RuntimeOptions) (_result *ListHttpResponseHeaderModificationRulesResponse, _err error) {
17401 if dara.BoolValue(client.EnableValidate) == true {
17402 _err = request.Validate()
17403 if _err != nil {
17404 return _result, _err
17405 }
17406 }
17407 query := openapiutil.Query(dara.ToMap(request))
17408 req := &openapiutil.OpenApiRequest{
17409 Query: openapiutil.Query(query),
17410 }
17411 params := &openapiutil.Params{
17412 Action: dara.String("ListHttpResponseHeaderModificationRules"),
17413 Version: dara.String("2024-09-10"),
17414 Protocol: dara.String("HTTPS"),
17415 Pathname: dara.String("/"),
17416 Method: dara.String("GET"),
17417 AuthType: dara.String("AK"),
17418 Style: dara.String("RPC"),
17419 ReqBodyType: dara.String("formData"),
17420 BodyType: dara.String("json"),
17421 }
17422 _result = &ListHttpResponseHeaderModificationRulesResponse{}
17423 _body, _err := client.CallApi(params, req, runtime)
17424 if _err != nil {
17425 return _result, _err
17426 }
17427 _err = dara.Convert(_body, &_result)
17428 return _result, _err
17429 }
17430
17431 // Summary:
17432 //
17433 // # List of HTTP Response Header Rules
17434 //
17435 // @param request - ListHttpResponseHeaderModificationRulesRequest
17436 //
17437 // @return ListHttpResponseHeaderModificationRulesResponse
17438 func ListHttpResponseHeaderModificationRules(client *Client, request *ListHttpResponseHeaderModificationRulesRequest) (_result *ListHttpResponseHeaderModificationRulesResponse, _err error) {
17439 runtime := &dara.RuntimeOptions{}
17440 _result = &ListHttpResponseHeaderModificationRulesResponse{}
17441 _body, _err := ListHttpResponseHeaderModificationRulesWithOptions(client,request, runtime)
17442 if _err != nil {
17443 return _result, _err
17444 }
17445 _result = _body
17446 return _result, _err
17447 }
17448
17449 // Summary:
17450 //
17451 // # Query multiple HTTPS application configurations
17452 //
17453 // @param request - ListHttpsApplicationConfigurationsRequest
17454 //
17455 // @param runtime - runtime options for this request RuntimeOptions
17456 //
17457 // @return ListHttpsApplicationConfigurationsResponse
17458 func ListHttpsApplicationConfigurationsWithOptions(client *Client, request *ListHttpsApplicationConfigurationsRequest, runtime *dara.RuntimeOptions) (_result *ListHttpsApplicationConfigurationsResponse, _err error) {
17459 if dara.BoolValue(client.EnableValidate) == true {
17460 _err = request.Validate()
17461 if _err != nil {
17462 return _result, _err
17463 }
17464 }
17465 query := openapiutil.Query(dara.ToMap(request))
17466 req := &openapiutil.OpenApiRequest{
17467 Query: openapiutil.Query(query),
17468 }
17469 params := &openapiutil.Params{
17470 Action: dara.String("ListHttpsApplicationConfigurations"),
17471 Version: dara.String("2024-09-10"),
17472 Protocol: dara.String("HTTPS"),
17473 Pathname: dara.String("/"),
17474 Method: dara.String("GET"),
17475 AuthType: dara.String("AK"),
17476 Style: dara.String("RPC"),
17477 ReqBodyType: dara.String("formData"),
17478 BodyType: dara.String("json"),
17479 }
17480 _result = &ListHttpsApplicationConfigurationsResponse{}
17481 _body, _err := client.CallApi(params, req, runtime)
17482 if _err != nil {
17483 return _result, _err
17484 }
17485 _err = dara.Convert(_body, &_result)
17486 return _result, _err
17487 }
17488
17489 // Summary:
17490 //
17491 // # Query multiple HTTPS application configurations
17492 //
17493 // @param request - ListHttpsApplicationConfigurationsRequest
17494 //
17495 // @return ListHttpsApplicationConfigurationsResponse
17496 func ListHttpsApplicationConfigurations(client *Client, request *ListHttpsApplicationConfigurationsRequest) (_result *ListHttpsApplicationConfigurationsResponse, _err error) {
17497 runtime := &dara.RuntimeOptions{}
17498 _result = &ListHttpsApplicationConfigurationsResponse{}
17499 _body, _err := ListHttpsApplicationConfigurationsWithOptions(client,request, runtime)
17500 if _err != nil {
17501 return _result, _err
17502 }
17503 _result = _body
17504 return _result, _err
17505 }
17506
17507 // Summary:
17508 //
17509 // # Query multiple HTTPS basic configurations
17510 //
17511 // @param request - ListHttpsBasicConfigurationsRequest
17512 //
17513 // @param runtime - runtime options for this request RuntimeOptions
17514 //
17515 // @return ListHttpsBasicConfigurationsResponse
17516 func ListHttpsBasicConfigurationsWithOptions(client *Client, request *ListHttpsBasicConfigurationsRequest, runtime *dara.RuntimeOptions) (_result *ListHttpsBasicConfigurationsResponse, _err error) {
17517 if dara.BoolValue(client.EnableValidate) == true {
17518 _err = request.Validate()
17519 if _err != nil {
17520 return _result, _err
17521 }
17522 }
17523 query := openapiutil.Query(dara.ToMap(request))
17524 req := &openapiutil.OpenApiRequest{
17525 Query: openapiutil.Query(query),
17526 }
17527 params := &openapiutil.Params{
17528 Action: dara.String("ListHttpsBasicConfigurations"),
17529 Version: dara.String("2024-09-10"),
17530 Protocol: dara.String("HTTPS"),
17531 Pathname: dara.String("/"),
17532 Method: dara.String("GET"),
17533 AuthType: dara.String("AK"),
17534 Style: dara.String("RPC"),
17535 ReqBodyType: dara.String("formData"),
17536 BodyType: dara.String("json"),
17537 }
17538 _result = &ListHttpsBasicConfigurationsResponse{}
17539 _body, _err := client.CallApi(params, req, runtime)
17540 if _err != nil {
17541 return _result, _err
17542 }
17543 _err = dara.Convert(_body, &_result)
17544 return _result, _err
17545 }
17546
17547 // Summary:
17548 //
17549 // # Query multiple HTTPS basic configurations
17550 //
17551 // @param request - ListHttpsBasicConfigurationsRequest
17552 //
17553 // @return ListHttpsBasicConfigurationsResponse
17554 func ListHttpsBasicConfigurations(client *Client, request *ListHttpsBasicConfigurationsRequest) (_result *ListHttpsBasicConfigurationsResponse, _err error) {
17555 runtime := &dara.RuntimeOptions{}
17556 _result = &ListHttpsBasicConfigurationsResponse{}
17557 _body, _err := ListHttpsBasicConfigurationsWithOptions(client,request, runtime)
17558 if _err != nil {
17559 return _result, _err
17560 }
17561 _result = _body
17562 return _result, _err
17563 }
17564
17565 // Summary:
17566 //
17567 // # Query Multiple Site Image Transformation Configurations
17568 //
17569 // @param request - ListImageTransformsRequest
17570 //
17571 // @param runtime - runtime options for this request RuntimeOptions
17572 //
17573 // @return ListImageTransformsResponse
17574 func ListImageTransformsWithOptions(client *Client, request *ListImageTransformsRequest, runtime *dara.RuntimeOptions) (_result *ListImageTransformsResponse, _err error) {
17575 if dara.BoolValue(client.EnableValidate) == true {
17576 _err = request.Validate()
17577 if _err != nil {
17578 return _result, _err
17579 }
17580 }
17581 query := openapiutil.Query(dara.ToMap(request))
17582 req := &openapiutil.OpenApiRequest{
17583 Query: openapiutil.Query(query),
17584 }
17585 params := &openapiutil.Params{
17586 Action: dara.String("ListImageTransforms"),
17587 Version: dara.String("2024-09-10"),
17588 Protocol: dara.String("HTTPS"),
17589 Pathname: dara.String("/"),
17590 Method: dara.String("GET"),
17591 AuthType: dara.String("AK"),
17592 Style: dara.String("RPC"),
17593 ReqBodyType: dara.String("formData"),
17594 BodyType: dara.String("json"),
17595 }
17596 _result = &ListImageTransformsResponse{}
17597 _body, _err := client.CallApi(params, req, runtime)
17598 if _err != nil {
17599 return _result, _err
17600 }
17601 _err = dara.Convert(_body, &_result)
17602 return _result, _err
17603 }
17604
17605 // Summary:
17606 //
17607 // # Query Multiple Site Image Transformation Configurations
17608 //
17609 // @param request - ListImageTransformsRequest
17610 //
17611 // @return ListImageTransformsResponse
17612 func ListImageTransforms(client *Client, request *ListImageTransformsRequest) (_result *ListImageTransformsResponse, _err error) {
17613 runtime := &dara.RuntimeOptions{}
17614 _result = &ListImageTransformsResponse{}
17615 _body, _err := ListImageTransformsWithOptions(client,request, runtime)
17616 if _err != nil {
17617 return _result, _err
17618 }
17619 _result = _body
17620 return _result, _err
17621 }
17622
17623 // Summary:
17624 //
17625 // Queries the quota details in a subscription plan.
17626 //
17627 // @param request - ListInstanceQuotasRequest
17628 //
17629 // @param runtime - runtime options for this request RuntimeOptions
17630 //
17631 // @return ListInstanceQuotasResponse
17632 func ListInstanceQuotasWithOptions(client *Client, request *ListInstanceQuotasRequest, runtime *dara.RuntimeOptions) (_result *ListInstanceQuotasResponse, _err error) {
17633 if dara.BoolValue(client.EnableValidate) == true {
17634 _err = request.Validate()
17635 if _err != nil {
17636 return _result, _err
17637 }
17638 }
17639 query := openapiutil.Query(dara.ToMap(request))
17640 req := &openapiutil.OpenApiRequest{
17641 Query: openapiutil.Query(query),
17642 }
17643 params := &openapiutil.Params{
17644 Action: dara.String("ListInstanceQuotas"),
17645 Version: dara.String("2024-09-10"),
17646 Protocol: dara.String("HTTPS"),
17647 Pathname: dara.String("/"),
17648 Method: dara.String("GET"),
17649 AuthType: dara.String("AK"),
17650 Style: dara.String("RPC"),
17651 ReqBodyType: dara.String("formData"),
17652 BodyType: dara.String("json"),
17653 }
17654 _result = &ListInstanceQuotasResponse{}
17655 _body, _err := client.CallApi(params, req, runtime)
17656 if _err != nil {
17657 return _result, _err
17658 }
17659 _err = dara.Convert(_body, &_result)
17660 return _result, _err
17661 }
17662
17663 // Summary:
17664 //
17665 // Queries the quota details in a subscription plan.
17666 //
17667 // @param request - ListInstanceQuotasRequest
17668 //
17669 // @return ListInstanceQuotasResponse
17670 func ListInstanceQuotas(client *Client, request *ListInstanceQuotasRequest) (_result *ListInstanceQuotasResponse, _err error) {
17671 runtime := &dara.RuntimeOptions{}
17672 _result = &ListInstanceQuotasResponse{}
17673 _body, _err := ListInstanceQuotasWithOptions(client,request, runtime)
17674 if _err != nil {
17675 return _result, _err
17676 }
17677 _result = _body
17678 return _result, _err
17679 }
17680
17681 // Summary:
17682 //
17683 // Queries quotas and the actual usage in a plan based on the website or plan ID.
17684 //
17685 // @param request - ListInstanceQuotasWithUsageRequest
17686 //
17687 // @param runtime - runtime options for this request RuntimeOptions
17688 //
17689 // @return ListInstanceQuotasWithUsageResponse
17690 func ListInstanceQuotasWithUsageWithOptions(client *Client, request *ListInstanceQuotasWithUsageRequest, runtime *dara.RuntimeOptions) (_result *ListInstanceQuotasWithUsageResponse, _err error) {
17691 if dara.BoolValue(client.EnableValidate) == true {
17692 _err = request.Validate()
17693 if _err != nil {
17694 return _result, _err
17695 }
17696 }
17697 query := openapiutil.Query(dara.ToMap(request))
17698 req := &openapiutil.OpenApiRequest{
17699 Query: openapiutil.Query(query),
17700 }
17701 params := &openapiutil.Params{
17702 Action: dara.String("ListInstanceQuotasWithUsage"),
17703 Version: dara.String("2024-09-10"),
17704 Protocol: dara.String("HTTPS"),
17705 Pathname: dara.String("/"),
17706 Method: dara.String("GET"),
17707 AuthType: dara.String("AK"),
17708 Style: dara.String("RPC"),
17709 ReqBodyType: dara.String("formData"),
17710 BodyType: dara.String("json"),
17711 }
17712 _result = &ListInstanceQuotasWithUsageResponse{}
17713 _body, _err := client.CallApi(params, req, runtime)
17714 if _err != nil {
17715 return _result, _err
17716 }
17717 _err = dara.Convert(_body, &_result)
17718 return _result, _err
17719 }
17720
17721 // Summary:
17722 //
17723 // Queries quotas and the actual usage in a plan based on the website or plan ID.
17724 //
17725 // @param request - ListInstanceQuotasWithUsageRequest
17726 //
17727 // @return ListInstanceQuotasWithUsageResponse
17728 func ListInstanceQuotasWithUsage(client *Client, request *ListInstanceQuotasWithUsageRequest) (_result *ListInstanceQuotasWithUsageResponse, _err error) {
17729 runtime := &dara.RuntimeOptions{}
17730 _result = &ListInstanceQuotasWithUsageResponse{}
17731 _body, _err := ListInstanceQuotasWithUsageWithOptions(client,request, runtime)
17732 if _err != nil {
17733 return _result, _err
17734 }
17735 _result = _body
17736 return _result, _err
17737 }
17738
17739 // Summary:
17740 //
17741 // Lists all key-value pairs in a namespace in your Alibaba Cloud account.
17742 //
17743 // @param request - ListKvsRequest
17744 //
17745 // @param runtime - runtime options for this request RuntimeOptions
17746 //
17747 // @return ListKvsResponse
17748 func ListKvsWithOptions(client *Client, request *ListKvsRequest, runtime *dara.RuntimeOptions) (_result *ListKvsResponse, _err error) {
17749 if dara.BoolValue(client.EnableValidate) == true {
17750 _err = request.Validate()
17751 if _err != nil {
17752 return _result, _err
17753 }
17754 }
17755 query := openapiutil.Query(dara.ToMap(request))
17756 req := &openapiutil.OpenApiRequest{
17757 Query: openapiutil.Query(query),
17758 }
17759 params := &openapiutil.Params{
17760 Action: dara.String("ListKvs"),
17761 Version: dara.String("2024-09-10"),
17762 Protocol: dara.String("HTTPS"),
17763 Pathname: dara.String("/"),
17764 Method: dara.String("GET"),
17765 AuthType: dara.String("AK"),
17766 Style: dara.String("RPC"),
17767 ReqBodyType: dara.String("formData"),
17768 BodyType: dara.String("json"),
17769 }
17770 _result = &ListKvsResponse{}
17771 _body, _err := client.CallApi(params, req, runtime)
17772 if _err != nil {
17773 return _result, _err
17774 }
17775 _err = dara.Convert(_body, &_result)
17776 return _result, _err
17777 }
17778
17779 // Summary:
17780 //
17781 // Lists all key-value pairs in a namespace in your Alibaba Cloud account.
17782 //
17783 // @param request - ListKvsRequest
17784 //
17785 // @return ListKvsResponse
17786 func ListKvs(client *Client, request *ListKvsRequest) (_result *ListKvsResponse, _err error) {
17787 runtime := &dara.RuntimeOptions{}
17788 _result = &ListKvsResponse{}
17789 _body, _err := ListKvsWithOptions(client,request, runtime)
17790 if _err != nil {
17791 return _result, _err
17792 }
17793 _result = _body
17794 return _result, _err
17795 }
17796
17797 // Summary:
17798 //
17799 // 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.
17800 //
17801 // @param tmpReq - ListListsRequest
17802 //
17803 // @param runtime - runtime options for this request RuntimeOptions
17804 //
17805 // @return ListListsResponse
17806 func ListListsWithOptions(client *Client, tmpReq *ListListsRequest, runtime *dara.RuntimeOptions) (_result *ListListsResponse, _err error) {
17807 if dara.BoolValue(client.EnableValidate) == true {
17808 _err = tmpReq.Validate()
17809 if _err != nil {
17810 return _result, _err
17811 }
17812 }
17813 request := &ListListsShrinkRequest{}
17814 openapiutil.Convert(tmpReq, request)
17815 if !dara.IsNil(tmpReq.QueryArgs) {
17816 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
17817 }
17818
17819 query := map[string]interface{}{}
17820 if !dara.IsNil(request.PageNumber) {
17821 query["PageNumber"] = request.PageNumber
17822 }
17823
17824 if !dara.IsNil(request.PageSize) {
17825 query["PageSize"] = request.PageSize
17826 }
17827
17828 if !dara.IsNil(request.QueryArgsShrink) {
17829 query["QueryArgs"] = request.QueryArgsShrink
17830 }
17831
17832 req := &openapiutil.OpenApiRequest{
17833 Query: openapiutil.Query(query),
17834 }
17835 params := &openapiutil.Params{
17836 Action: dara.String("ListLists"),
17837 Version: dara.String("2024-09-10"),
17838 Protocol: dara.String("HTTPS"),
17839 Pathname: dara.String("/"),
17840 Method: dara.String("POST"),
17841 AuthType: dara.String("AK"),
17842 Style: dara.String("RPC"),
17843 ReqBodyType: dara.String("formData"),
17844 BodyType: dara.String("json"),
17845 }
17846 _result = &ListListsResponse{}
17847 _body, _err := client.CallApi(params, req, runtime)
17848 if _err != nil {
17849 return _result, _err
17850 }
17851 _err = dara.Convert(_body, &_result)
17852 return _result, _err
17853 }
17854
17855 // Summary:
17856 //
17857 // 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.
17858 //
17859 // @param request - ListListsRequest
17860 //
17861 // @return ListListsResponse
17862 func ListLists(client *Client, request *ListListsRequest) (_result *ListListsResponse, _err error) {
17863 runtime := &dara.RuntimeOptions{}
17864 _result = &ListListsResponse{}
17865 _body, _err := ListListsWithOptions(client,request, runtime)
17866 if _err != nil {
17867 return _result, _err
17868 }
17869 _result = _body
17870 return _result, _err
17871 }
17872
17873 // Summary:
17874 //
17875 // # Query the status of origins in load balancers
17876 //
17877 // Description:
17878 //
17879 // 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.
17880 //
17881 // - Healthy(healthy): The probe result is available.
17882 //
17883 // - Unhealthy(unhealthy): The probe result is unavailable.
17884 //
17885 // - Unknown(unknown): Unknown, the monitor has not yet probed.
17886 //
17887 // - Undetected(undetected): The load balancer to which the origin belongs is not bound to a monitor.
17888 //
17889 // @param request - ListLoadBalancerOriginStatusRequest
17890 //
17891 // @param runtime - runtime options for this request RuntimeOptions
17892 //
17893 // @return ListLoadBalancerOriginStatusResponse
17894 func ListLoadBalancerOriginStatusWithOptions(client *Client, request *ListLoadBalancerOriginStatusRequest, runtime *dara.RuntimeOptions) (_result *ListLoadBalancerOriginStatusResponse, _err error) {
17895 if dara.BoolValue(client.EnableValidate) == true {
17896 _err = request.Validate()
17897 if _err != nil {
17898 return _result, _err
17899 }
17900 }
17901 query := openapiutil.Query(dara.ToMap(request))
17902 req := &openapiutil.OpenApiRequest{
17903 Query: openapiutil.Query(query),
17904 }
17905 params := &openapiutil.Params{
17906 Action: dara.String("ListLoadBalancerOriginStatus"),
17907 Version: dara.String("2024-09-10"),
17908 Protocol: dara.String("HTTPS"),
17909 Pathname: dara.String("/"),
17910 Method: dara.String("GET"),
17911 AuthType: dara.String("AK"),
17912 Style: dara.String("RPC"),
17913 ReqBodyType: dara.String("formData"),
17914 BodyType: dara.String("json"),
17915 }
17916 _result = &ListLoadBalancerOriginStatusResponse{}
17917 _body, _err := client.CallApi(params, req, runtime)
17918 if _err != nil {
17919 return _result, _err
17920 }
17921 _err = dara.Convert(_body, &_result)
17922 return _result, _err
17923 }
17924
17925 // Summary:
17926 //
17927 // # Query the status of origins in load balancers
17928 //
17929 // Description:
17930 //
17931 // 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.
17932 //
17933 // - Healthy(healthy): The probe result is available.
17934 //
17935 // - Unhealthy(unhealthy): The probe result is unavailable.
17936 //
17937 // - Unknown(unknown): Unknown, the monitor has not yet probed.
17938 //
17939 // - Undetected(undetected): The load balancer to which the origin belongs is not bound to a monitor.
17940 //
17941 // @param request - ListLoadBalancerOriginStatusRequest
17942 //
17943 // @return ListLoadBalancerOriginStatusResponse
17944 func ListLoadBalancerOriginStatus(client *Client, request *ListLoadBalancerOriginStatusRequest) (_result *ListLoadBalancerOriginStatusResponse, _err error) {
17945 runtime := &dara.RuntimeOptions{}
17946 _result = &ListLoadBalancerOriginStatusResponse{}
17947 _body, _err := ListLoadBalancerOriginStatusWithOptions(client,request, runtime)
17948 if _err != nil {
17949 return _result, _err
17950 }
17951 _result = _body
17952 return _result, _err
17953 }
17954
17955 // Summary:
17956 //
17957 // # Query Load Balancer Region List
17958 //
17959 // Description:
17960 //
17961 // 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.
17962 //
17963 // @param request - ListLoadBalancerRegionsRequest
17964 //
17965 // @param runtime - runtime options for this request RuntimeOptions
17966 //
17967 // @return ListLoadBalancerRegionsResponse
17968 func ListLoadBalancerRegionsWithOptions(client *Client, request *ListLoadBalancerRegionsRequest, runtime *dara.RuntimeOptions) (_result *ListLoadBalancerRegionsResponse, _err error) {
17969 if dara.BoolValue(client.EnableValidate) == true {
17970 _err = request.Validate()
17971 if _err != nil {
17972 return _result, _err
17973 }
17974 }
17975 query := openapiutil.Query(dara.ToMap(request))
17976 req := &openapiutil.OpenApiRequest{
17977 Query: openapiutil.Query(query),
17978 }
17979 params := &openapiutil.Params{
17980 Action: dara.String("ListLoadBalancerRegions"),
17981 Version: dara.String("2024-09-10"),
17982 Protocol: dara.String("HTTPS"),
17983 Pathname: dara.String("/"),
17984 Method: dara.String("GET"),
17985 AuthType: dara.String("AK"),
17986 Style: dara.String("RPC"),
17987 ReqBodyType: dara.String("formData"),
17988 BodyType: dara.String("json"),
17989 }
17990 _result = &ListLoadBalancerRegionsResponse{}
17991 _body, _err := client.CallApi(params, req, runtime)
17992 if _err != nil {
17993 return _result, _err
17994 }
17995 _err = dara.Convert(_body, &_result)
17996 return _result, _err
17997 }
17998
17999 // Summary:
18000 //
18001 // # Query Load Balancer Region List
18002 //
18003 // Description:
18004 //
18005 // 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.
18006 //
18007 // @param request - ListLoadBalancerRegionsRequest
18008 //
18009 // @return ListLoadBalancerRegionsResponse
18010 func ListLoadBalancerRegions(client *Client, request *ListLoadBalancerRegionsRequest) (_result *ListLoadBalancerRegionsResponse, _err error) {
18011 runtime := &dara.RuntimeOptions{}
18012 _result = &ListLoadBalancerRegionsResponse{}
18013 _body, _err := ListLoadBalancerRegionsWithOptions(client,request, runtime)
18014 if _err != nil {
18015 return _result, _err
18016 }
18017 _result = _body
18018 return _result, _err
18019 }
18020
18021 // Summary:
18022 //
18023 // # Query the list of load balancers
18024 //
18025 // @param request - ListLoadBalancersRequest
18026 //
18027 // @param runtime - runtime options for this request RuntimeOptions
18028 //
18029 // @return ListLoadBalancersResponse
18030 func ListLoadBalancersWithOptions(client *Client, request *ListLoadBalancersRequest, runtime *dara.RuntimeOptions) (_result *ListLoadBalancersResponse, _err error) {
18031 if dara.BoolValue(client.EnableValidate) == true {
18032 _err = request.Validate()
18033 if _err != nil {
18034 return _result, _err
18035 }
18036 }
18037 query := openapiutil.Query(dara.ToMap(request))
18038 req := &openapiutil.OpenApiRequest{
18039 Query: openapiutil.Query(query),
18040 }
18041 params := &openapiutil.Params{
18042 Action: dara.String("ListLoadBalancers"),
18043 Version: dara.String("2024-09-10"),
18044 Protocol: dara.String("HTTPS"),
18045 Pathname: dara.String("/"),
18046 Method: dara.String("GET"),
18047 AuthType: dara.String("AK"),
18048 Style: dara.String("RPC"),
18049 ReqBodyType: dara.String("formData"),
18050 BodyType: dara.String("json"),
18051 }
18052 _result = &ListLoadBalancersResponse{}
18053 _body, _err := client.CallApi(params, req, runtime)
18054 if _err != nil {
18055 return _result, _err
18056 }
18057 _err = dara.Convert(_body, &_result)
18058 return _result, _err
18059 }
18060
18061 // Summary:
18062 //
18063 // # Query the list of load balancers
18064 //
18065 // @param request - ListLoadBalancersRequest
18066 //
18067 // @return ListLoadBalancersResponse
18068 func ListLoadBalancers(client *Client, request *ListLoadBalancersRequest) (_result *ListLoadBalancersResponse, _err error) {
18069 runtime := &dara.RuntimeOptions{}
18070 _result = &ListLoadBalancersResponse{}
18071 _body, _err := ListLoadBalancersWithOptions(client,request, runtime)
18072 if _err != nil {
18073 return _result, _err
18074 }
18075 _result = _body
18076 return _result, _err
18077 }
18078
18079 // Summary:
18080 //
18081 // # List Custom Managed Rule Groups
18082 //
18083 // @param request - ListManagedRulesGroupsRequest
18084 //
18085 // @param runtime - runtime options for this request RuntimeOptions
18086 //
18087 // @return ListManagedRulesGroupsResponse
18088 func ListManagedRulesGroupsWithOptions(client *Client, request *ListManagedRulesGroupsRequest, runtime *dara.RuntimeOptions) (_result *ListManagedRulesGroupsResponse, _err error) {
18089 if dara.BoolValue(client.EnableValidate) == true {
18090 _err = request.Validate()
18091 if _err != nil {
18092 return _result, _err
18093 }
18094 }
18095 query := map[string]interface{}{}
18096 if !dara.IsNil(request.PageNumber) {
18097 query["PageNumber"] = request.PageNumber
18098 }
18099
18100 if !dara.IsNil(request.PageSize) {
18101 query["PageSize"] = request.PageSize
18102 }
18103
18104 req := &openapiutil.OpenApiRequest{
18105 Query: openapiutil.Query(query),
18106 }
18107 params := &openapiutil.Params{
18108 Action: dara.String("ListManagedRulesGroups"),
18109 Version: dara.String("2024-09-10"),
18110 Protocol: dara.String("HTTPS"),
18111 Pathname: dara.String("/"),
18112 Method: dara.String("POST"),
18113 AuthType: dara.String("AK"),
18114 Style: dara.String("RPC"),
18115 ReqBodyType: dara.String("formData"),
18116 BodyType: dara.String("json"),
18117 }
18118 _result = &ListManagedRulesGroupsResponse{}
18119 _body, _err := client.CallApi(params, req, runtime)
18120 if _err != nil {
18121 return _result, _err
18122 }
18123 _err = dara.Convert(_body, &_result)
18124 return _result, _err
18125 }
18126
18127 // Summary:
18128 //
18129 // # List Custom Managed Rule Groups
18130 //
18131 // @param request - ListManagedRulesGroupsRequest
18132 //
18133 // @return ListManagedRulesGroupsResponse
18134 func ListManagedRulesGroups(client *Client, request *ListManagedRulesGroupsRequest) (_result *ListManagedRulesGroupsResponse, _err error) {
18135 runtime := &dara.RuntimeOptions{}
18136 _result = &ListManagedRulesGroupsResponse{}
18137 _body, _err := ListManagedRulesGroupsWithOptions(client,request, runtime)
18138 if _err != nil {
18139 return _result, _err
18140 }
18141 _result = _body
18142 return _result, _err
18143 }
18144
18145 // Summary:
18146 //
18147 // # Query multiple network optimization configurations
18148 //
18149 // @param request - ListNetworkOptimizationsRequest
18150 //
18151 // @param runtime - runtime options for this request RuntimeOptions
18152 //
18153 // @return ListNetworkOptimizationsResponse
18154 func ListNetworkOptimizationsWithOptions(client *Client, request *ListNetworkOptimizationsRequest, runtime *dara.RuntimeOptions) (_result *ListNetworkOptimizationsResponse, _err error) {
18155 if dara.BoolValue(client.EnableValidate) == true {
18156 _err = request.Validate()
18157 if _err != nil {
18158 return _result, _err
18159 }
18160 }
18161 query := openapiutil.Query(dara.ToMap(request))
18162 req := &openapiutil.OpenApiRequest{
18163 Query: openapiutil.Query(query),
18164 }
18165 params := &openapiutil.Params{
18166 Action: dara.String("ListNetworkOptimizations"),
18167 Version: dara.String("2024-09-10"),
18168 Protocol: dara.String("HTTPS"),
18169 Pathname: dara.String("/"),
18170 Method: dara.String("GET"),
18171 AuthType: dara.String("AK"),
18172 Style: dara.String("RPC"),
18173 ReqBodyType: dara.String("formData"),
18174 BodyType: dara.String("json"),
18175 }
18176 _result = &ListNetworkOptimizationsResponse{}
18177 _body, _err := client.CallApi(params, req, runtime)
18178 if _err != nil {
18179 return _result, _err
18180 }
18181 _err = dara.Convert(_body, &_result)
18182 return _result, _err
18183 }
18184
18185 // Summary:
18186 //
18187 // # Query multiple network optimization configurations
18188 //
18189 // @param request - ListNetworkOptimizationsRequest
18190 //
18191 // @return ListNetworkOptimizationsResponse
18192 func ListNetworkOptimizations(client *Client, request *ListNetworkOptimizationsRequest) (_result *ListNetworkOptimizationsResponse, _err error) {
18193 runtime := &dara.RuntimeOptions{}
18194 _result = &ListNetworkOptimizationsResponse{}
18195 _body, _err := ListNetworkOptimizationsWithOptions(client,request, runtime)
18196 if _err != nil {
18197 return _result, _err
18198 }
18199 _result = _body
18200 return _result, _err
18201 }
18202
18203 // Summary:
18204 //
18205 // 查询源服务器CA证书列表
18206 //
18207 // @param request - ListOriginCaCertificatesRequest
18208 //
18209 // @param runtime - runtime options for this request RuntimeOptions
18210 //
18211 // @return ListOriginCaCertificatesResponse
18212 func ListOriginCaCertificatesWithOptions(client *Client, request *ListOriginCaCertificatesRequest, runtime *dara.RuntimeOptions) (_result *ListOriginCaCertificatesResponse, _err error) {
18213 if dara.BoolValue(client.EnableValidate) == true {
18214 _err = request.Validate()
18215 if _err != nil {
18216 return _result, _err
18217 }
18218 }
18219 query := openapiutil.Query(dara.ToMap(request))
18220 req := &openapiutil.OpenApiRequest{
18221 Query: openapiutil.Query(query),
18222 }
18223 params := &openapiutil.Params{
18224 Action: dara.String("ListOriginCaCertificates"),
18225 Version: dara.String("2024-09-10"),
18226 Protocol: dara.String("HTTPS"),
18227 Pathname: dara.String("/"),
18228 Method: dara.String("GET"),
18229 AuthType: dara.String("AK"),
18230 Style: dara.String("RPC"),
18231 ReqBodyType: dara.String("formData"),
18232 BodyType: dara.String("json"),
18233 }
18234 _result = &ListOriginCaCertificatesResponse{}
18235 _body, _err := client.CallApi(params, req, runtime)
18236 if _err != nil {
18237 return _result, _err
18238 }
18239 _err = dara.Convert(_body, &_result)
18240 return _result, _err
18241 }
18242
18243 // Summary:
18244 //
18245 // 查询源服务器CA证书列表
18246 //
18247 // @param request - ListOriginCaCertificatesRequest
18248 //
18249 // @return ListOriginCaCertificatesResponse
18250 func ListOriginCaCertificates(client *Client, request *ListOriginCaCertificatesRequest) (_result *ListOriginCaCertificatesResponse, _err error) {
18251 runtime := &dara.RuntimeOptions{}
18252 _result = &ListOriginCaCertificatesResponse{}
18253 _body, _err := ListOriginCaCertificatesWithOptions(client,request, runtime)
18254 if _err != nil {
18255 return _result, _err
18256 }
18257 _result = _body
18258 return _result, _err
18259 }
18260
18261 // Summary:
18262 //
18263 // 查询域名回源客户端证书列表
18264 //
18265 // @param request - ListOriginClientCertificatesRequest
18266 //
18267 // @param runtime - runtime options for this request RuntimeOptions
18268 //
18269 // @return ListOriginClientCertificatesResponse
18270 func ListOriginClientCertificatesWithOptions(client *Client, request *ListOriginClientCertificatesRequest, runtime *dara.RuntimeOptions) (_result *ListOriginClientCertificatesResponse, _err error) {
18271 if dara.BoolValue(client.EnableValidate) == true {
18272 _err = request.Validate()
18273 if _err != nil {
18274 return _result, _err
18275 }
18276 }
18277 query := openapiutil.Query(dara.ToMap(request))
18278 req := &openapiutil.OpenApiRequest{
18279 Query: openapiutil.Query(query),
18280 }
18281 params := &openapiutil.Params{
18282 Action: dara.String("ListOriginClientCertificates"),
18283 Version: dara.String("2024-09-10"),
18284 Protocol: dara.String("HTTPS"),
18285 Pathname: dara.String("/"),
18286 Method: dara.String("GET"),
18287 AuthType: dara.String("AK"),
18288 Style: dara.String("RPC"),
18289 ReqBodyType: dara.String("formData"),
18290 BodyType: dara.String("json"),
18291 }
18292 _result = &ListOriginClientCertificatesResponse{}
18293 _body, _err := client.CallApi(params, req, runtime)
18294 if _err != nil {
18295 return _result, _err
18296 }
18297 _err = dara.Convert(_body, &_result)
18298 return _result, _err
18299 }
18300
18301 // Summary:
18302 //
18303 // 查询域名回源客户端证书列表
18304 //
18305 // @param request - ListOriginClientCertificatesRequest
18306 //
18307 // @return ListOriginClientCertificatesResponse
18308 func ListOriginClientCertificates(client *Client, request *ListOriginClientCertificatesRequest) (_result *ListOriginClientCertificatesResponse, _err error) {
18309 runtime := &dara.RuntimeOptions{}
18310 _result = &ListOriginClientCertificatesResponse{}
18311 _body, _err := ListOriginClientCertificatesWithOptions(client,request, runtime)
18312 if _err != nil {
18313 return _result, _err
18314 }
18315 _result = _body
18316 return _result, _err
18317 }
18318
18319 // Summary:
18320 //
18321 // # List Origin Pools
18322 //
18323 // @param request - ListOriginPoolsRequest
18324 //
18325 // @param runtime - runtime options for this request RuntimeOptions
18326 //
18327 // @return ListOriginPoolsResponse
18328 func ListOriginPoolsWithOptions(client *Client, request *ListOriginPoolsRequest, runtime *dara.RuntimeOptions) (_result *ListOriginPoolsResponse, _err error) {
18329 if dara.BoolValue(client.EnableValidate) == true {
18330 _err = request.Validate()
18331 if _err != nil {
18332 return _result, _err
18333 }
18334 }
18335 query := openapiutil.Query(dara.ToMap(request))
18336 req := &openapiutil.OpenApiRequest{
18337 Query: openapiutil.Query(query),
18338 }
18339 params := &openapiutil.Params{
18340 Action: dara.String("ListOriginPools"),
18341 Version: dara.String("2024-09-10"),
18342 Protocol: dara.String("HTTPS"),
18343 Pathname: dara.String("/"),
18344 Method: dara.String("GET"),
18345 AuthType: dara.String("AK"),
18346 Style: dara.String("RPC"),
18347 ReqBodyType: dara.String("formData"),
18348 BodyType: dara.String("json"),
18349 }
18350 _result = &ListOriginPoolsResponse{}
18351 _body, _err := client.CallApi(params, req, runtime)
18352 if _err != nil {
18353 return _result, _err
18354 }
18355 _err = dara.Convert(_body, &_result)
18356 return _result, _err
18357 }
18358
18359 // Summary:
18360 //
18361 // # List Origin Pools
18362 //
18363 // @param request - ListOriginPoolsRequest
18364 //
18365 // @return ListOriginPoolsResponse
18366 func ListOriginPools(client *Client, request *ListOriginPoolsRequest) (_result *ListOriginPoolsResponse, _err error) {
18367 runtime := &dara.RuntimeOptions{}
18368 _result = &ListOriginPoolsResponse{}
18369 _body, _err := ListOriginPoolsWithOptions(client,request, runtime)
18370 if _err != nil {
18371 return _result, _err
18372 }
18373 _result = _body
18374 return _result, _err
18375 }
18376
18377 // Summary:
18378 //
18379 // # Query multiple origin rule configurations
18380 //
18381 // @param request - ListOriginRulesRequest
18382 //
18383 // @param runtime - runtime options for this request RuntimeOptions
18384 //
18385 // @return ListOriginRulesResponse
18386 func ListOriginRulesWithOptions(client *Client, request *ListOriginRulesRequest, runtime *dara.RuntimeOptions) (_result *ListOriginRulesResponse, _err error) {
18387 if dara.BoolValue(client.EnableValidate) == true {
18388 _err = request.Validate()
18389 if _err != nil {
18390 return _result, _err
18391 }
18392 }
18393 query := openapiutil.Query(dara.ToMap(request))
18394 req := &openapiutil.OpenApiRequest{
18395 Query: openapiutil.Query(query),
18396 }
18397 params := &openapiutil.Params{
18398 Action: dara.String("ListOriginRules"),
18399 Version: dara.String("2024-09-10"),
18400 Protocol: dara.String("HTTPS"),
18401 Pathname: dara.String("/"),
18402 Method: dara.String("GET"),
18403 AuthType: dara.String("AK"),
18404 Style: dara.String("RPC"),
18405 ReqBodyType: dara.String("formData"),
18406 BodyType: dara.String("json"),
18407 }
18408 _result = &ListOriginRulesResponse{}
18409 _body, _err := client.CallApi(params, req, runtime)
18410 if _err != nil {
18411 return _result, _err
18412 }
18413 _err = dara.Convert(_body, &_result)
18414 return _result, _err
18415 }
18416
18417 // Summary:
18418 //
18419 // # Query multiple origin rule configurations
18420 //
18421 // @param request - ListOriginRulesRequest
18422 //
18423 // @return ListOriginRulesResponse
18424 func ListOriginRules(client *Client, request *ListOriginRulesRequest) (_result *ListOriginRulesResponse, _err error) {
18425 runtime := &dara.RuntimeOptions{}
18426 _result = &ListOriginRulesResponse{}
18427 _body, _err := ListOriginRulesWithOptions(client,request, runtime)
18428 if _err != nil {
18429 return _result, _err
18430 }
18431 _result = _body
18432 return _result, _err
18433 }
18434
18435 // Summary:
18436 //
18437 // 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.
18438 //
18439 // @param tmpReq - ListPagesRequest
18440 //
18441 // @param runtime - runtime options for this request RuntimeOptions
18442 //
18443 // @return ListPagesResponse
18444 func ListPagesWithOptions(client *Client, tmpReq *ListPagesRequest, runtime *dara.RuntimeOptions) (_result *ListPagesResponse, _err error) {
18445 if dara.BoolValue(client.EnableValidate) == true {
18446 _err = tmpReq.Validate()
18447 if _err != nil {
18448 return _result, _err
18449 }
18450 }
18451 request := &ListPagesShrinkRequest{}
18452 openapiutil.Convert(tmpReq, request)
18453 if !dara.IsNil(tmpReq.QueryArgs) {
18454 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
18455 }
18456
18457 query := map[string]interface{}{}
18458 if !dara.IsNil(request.PageNumber) {
18459 query["PageNumber"] = request.PageNumber
18460 }
18461
18462 if !dara.IsNil(request.PageSize) {
18463 query["PageSize"] = request.PageSize
18464 }
18465
18466 if !dara.IsNil(request.QueryArgsShrink) {
18467 query["QueryArgs"] = request.QueryArgsShrink
18468 }
18469
18470 req := &openapiutil.OpenApiRequest{
18471 Query: openapiutil.Query(query),
18472 }
18473 params := &openapiutil.Params{
18474 Action: dara.String("ListPages"),
18475 Version: dara.String("2024-09-10"),
18476 Protocol: dara.String("HTTPS"),
18477 Pathname: dara.String("/"),
18478 Method: dara.String("POST"),
18479 AuthType: dara.String("AK"),
18480 Style: dara.String("RPC"),
18481 ReqBodyType: dara.String("formData"),
18482 BodyType: dara.String("json"),
18483 }
18484 _result = &ListPagesResponse{}
18485 _body, _err := client.CallApi(params, req, runtime)
18486 if _err != nil {
18487 return _result, _err
18488 }
18489 _err = dara.Convert(_body, &_result)
18490 return _result, _err
18491 }
18492
18493 // Summary:
18494 //
18495 // 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.
18496 //
18497 // @param request - ListPagesRequest
18498 //
18499 // @return ListPagesResponse
18500 func ListPages(client *Client, request *ListPagesRequest) (_result *ListPagesResponse, _err error) {
18501 runtime := &dara.RuntimeOptions{}
18502 _result = &ListPagesResponse{}
18503 _body, _err := ListPagesWithOptions(client,request, runtime)
18504 if _err != nil {
18505 return _result, _err
18506 }
18507 _result = _body
18508 return _result, _err
18509 }
18510
18511 // Summary:
18512 //
18513 // 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.
18514 //
18515 // Description:
18516 //
18517 // The DNS records related to Edge Container, Edge Routine, and TCP/UDP proxy are not returned in this operation.
18518 //
18519 // @param request - ListRecordsRequest
18520 //
18521 // @param runtime - runtime options for this request RuntimeOptions
18522 //
18523 // @return ListRecordsResponse
18524 func ListRecordsWithOptions(client *Client, request *ListRecordsRequest, runtime *dara.RuntimeOptions) (_result *ListRecordsResponse, _err error) {
18525 if dara.BoolValue(client.EnableValidate) == true {
18526 _err = request.Validate()
18527 if _err != nil {
18528 return _result, _err
18529 }
18530 }
18531 query := openapiutil.Query(dara.ToMap(request))
18532 req := &openapiutil.OpenApiRequest{
18533 Query: openapiutil.Query(query),
18534 }
18535 params := &openapiutil.Params{
18536 Action: dara.String("ListRecords"),
18537 Version: dara.String("2024-09-10"),
18538 Protocol: dara.String("HTTPS"),
18539 Pathname: dara.String("/"),
18540 Method: dara.String("GET"),
18541 AuthType: dara.String("AK"),
18542 Style: dara.String("RPC"),
18543 ReqBodyType: dara.String("formData"),
18544 BodyType: dara.String("json"),
18545 }
18546 _result = &ListRecordsResponse{}
18547 _body, _err := client.CallApi(params, req, runtime)
18548 if _err != nil {
18549 return _result, _err
18550 }
18551 _err = dara.Convert(_body, &_result)
18552 return _result, _err
18553 }
18554
18555 // Summary:
18556 //
18557 // 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.
18558 //
18559 // Description:
18560 //
18561 // The DNS records related to Edge Container, Edge Routine, and TCP/UDP proxy are not returned in this operation.
18562 //
18563 // @param request - ListRecordsRequest
18564 //
18565 // @return ListRecordsResponse
18566 func ListRecords(client *Client, request *ListRecordsRequest) (_result *ListRecordsResponse, _err error) {
18567 runtime := &dara.RuntimeOptions{}
18568 _result = &ListRecordsResponse{}
18569 _body, _err := ListRecordsWithOptions(client,request, runtime)
18570 if _err != nil {
18571 return _result, _err
18572 }
18573 _result = _body
18574 return _result, _err
18575 }
18576
18577 // Summary:
18578 //
18579 // # Query Redirect Rule List
18580 //
18581 // @param request - ListRedirectRulesRequest
18582 //
18583 // @param runtime - runtime options for this request RuntimeOptions
18584 //
18585 // @return ListRedirectRulesResponse
18586 func ListRedirectRulesWithOptions(client *Client, request *ListRedirectRulesRequest, runtime *dara.RuntimeOptions) (_result *ListRedirectRulesResponse, _err error) {
18587 if dara.BoolValue(client.EnableValidate) == true {
18588 _err = request.Validate()
18589 if _err != nil {
18590 return _result, _err
18591 }
18592 }
18593 query := openapiutil.Query(dara.ToMap(request))
18594 req := &openapiutil.OpenApiRequest{
18595 Query: openapiutil.Query(query),
18596 }
18597 params := &openapiutil.Params{
18598 Action: dara.String("ListRedirectRules"),
18599 Version: dara.String("2024-09-10"),
18600 Protocol: dara.String("HTTPS"),
18601 Pathname: dara.String("/"),
18602 Method: dara.String("GET"),
18603 AuthType: dara.String("AK"),
18604 Style: dara.String("RPC"),
18605 ReqBodyType: dara.String("formData"),
18606 BodyType: dara.String("json"),
18607 }
18608 _result = &ListRedirectRulesResponse{}
18609 _body, _err := client.CallApi(params, req, runtime)
18610 if _err != nil {
18611 return _result, _err
18612 }
18613 _err = dara.Convert(_body, &_result)
18614 return _result, _err
18615 }
18616
18617 // Summary:
18618 //
18619 // # Query Redirect Rule List
18620 //
18621 // @param request - ListRedirectRulesRequest
18622 //
18623 // @return ListRedirectRulesResponse
18624 func ListRedirectRules(client *Client, request *ListRedirectRulesRequest) (_result *ListRedirectRulesResponse, _err error) {
18625 runtime := &dara.RuntimeOptions{}
18626 _result = &ListRedirectRulesResponse{}
18627 _body, _err := ListRedirectRulesWithOptions(client,request, runtime)
18628 if _err != nil {
18629 return _result, _err
18630 }
18631 _result = _body
18632 return _result, _err
18633 }
18634
18635 // Summary:
18636 //
18637 // # List of Rewrite URL Rules
18638 //
18639 // @param request - ListRewriteUrlRulesRequest
18640 //
18641 // @param runtime - runtime options for this request RuntimeOptions
18642 //
18643 // @return ListRewriteUrlRulesResponse
18644 func ListRewriteUrlRulesWithOptions(client *Client, request *ListRewriteUrlRulesRequest, runtime *dara.RuntimeOptions) (_result *ListRewriteUrlRulesResponse, _err error) {
18645 if dara.BoolValue(client.EnableValidate) == true {
18646 _err = request.Validate()
18647 if _err != nil {
18648 return _result, _err
18649 }
18650 }
18651 query := openapiutil.Query(dara.ToMap(request))
18652 req := &openapiutil.OpenApiRequest{
18653 Query: openapiutil.Query(query),
18654 }
18655 params := &openapiutil.Params{
18656 Action: dara.String("ListRewriteUrlRules"),
18657 Version: dara.String("2024-09-10"),
18658 Protocol: dara.String("HTTPS"),
18659 Pathname: dara.String("/"),
18660 Method: dara.String("GET"),
18661 AuthType: dara.String("AK"),
18662 Style: dara.String("RPC"),
18663 ReqBodyType: dara.String("formData"),
18664 BodyType: dara.String("json"),
18665 }
18666 _result = &ListRewriteUrlRulesResponse{}
18667 _body, _err := client.CallApi(params, req, runtime)
18668 if _err != nil {
18669 return _result, _err
18670 }
18671 _err = dara.Convert(_body, &_result)
18672 return _result, _err
18673 }
18674
18675 // Summary:
18676 //
18677 // # List of Rewrite URL Rules
18678 //
18679 // @param request - ListRewriteUrlRulesRequest
18680 //
18681 // @return ListRewriteUrlRulesResponse
18682 func ListRewriteUrlRules(client *Client, request *ListRewriteUrlRulesRequest) (_result *ListRewriteUrlRulesResponse, _err error) {
18683 runtime := &dara.RuntimeOptions{}
18684 _result = &ListRewriteUrlRulesResponse{}
18685 _body, _err := ListRewriteUrlRulesWithOptions(client,request, runtime)
18686 if _err != nil {
18687 return _result, _err
18688 }
18689 _result = _body
18690 return _result, _err
18691 }
18692
18693 // Summary:
18694 //
18695 // Lists the regions to which Edge Routine code can be released for canary deployment.
18696 //
18697 // @param request - ListRoutineCanaryAreasRequest
18698 //
18699 // @param runtime - runtime options for this request RuntimeOptions
18700 //
18701 // @return ListRoutineCanaryAreasResponse
18702 func ListRoutineCanaryAreasWithOptions(client *Client, runtime *dara.RuntimeOptions) (_result *ListRoutineCanaryAreasResponse, _err error) {
18703 req := &openapiutil.OpenApiRequest{}
18704 params := &openapiutil.Params{
18705 Action: dara.String("ListRoutineCanaryAreas"),
18706 Version: dara.String("2024-09-10"),
18707 Protocol: dara.String("HTTPS"),
18708 Pathname: dara.String("/"),
18709 Method: dara.String("POST"),
18710 AuthType: dara.String("AK"),
18711 Style: dara.String("RPC"),
18712 ReqBodyType: dara.String("formData"),
18713 BodyType: dara.String("json"),
18714 }
18715 _result = &ListRoutineCanaryAreasResponse{}
18716 _body, _err := client.CallApi(params, req, runtime)
18717 if _err != nil {
18718 return _result, _err
18719 }
18720 _err = dara.Convert(_body, &_result)
18721 return _result, _err
18722 }
18723
18724 // Summary:
18725 //
18726 // Lists the regions to which Edge Routine code can be released for canary deployment.
18727 //
18728 // @return ListRoutineCanaryAreasResponse
18729 func ListRoutineCanaryAreas(client *Client, ) (_result *ListRoutineCanaryAreasResponse, _err error) {
18730 runtime := &dara.RuntimeOptions{}
18731 _result = &ListRoutineCanaryAreasResponse{}
18732 _body, _err := ListRoutineCanaryAreasWithOptions(client,runtime)
18733 if _err != nil {
18734 return _result, _err
18735 }
18736 _result = _body
18737 return _result, _err
18738 }
18739
18740 // Summary:
18741 //
18742 // Queries the code versions of a function (routine) by page.
18743 //
18744 // Description:
18745 //
18746 // 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.
18747 //
18748 // Specify `PageNumber` and `PageSize` to control the number of entries returned in a request, and use `SearchKeyWord` to specify a keyword for fuzzy search.
18749 //
18750 // The response includes the number, description, and creation time of each code version.
18751 //
18752 // @param request - ListRoutineCodeVersionsRequest
18753 //
18754 // @param runtime - runtime options for this request RuntimeOptions
18755 //
18756 // @return ListRoutineCodeVersionsResponse
18757 func ListRoutineCodeVersionsWithOptions(client *Client, request *ListRoutineCodeVersionsRequest, runtime *dara.RuntimeOptions) (_result *ListRoutineCodeVersionsResponse, _err error) {
18758 if dara.BoolValue(client.EnableValidate) == true {
18759 _err = request.Validate()
18760 if _err != nil {
18761 return _result, _err
18762 }
18763 }
18764 body := map[string]interface{}{}
18765 if !dara.IsNil(request.Name) {
18766 body["Name"] = request.Name
18767 }
18768
18769 if !dara.IsNil(request.PageNumber) {
18770 body["PageNumber"] = request.PageNumber
18771 }
18772
18773 if !dara.IsNil(request.PageSize) {
18774 body["PageSize"] = request.PageSize
18775 }
18776
18777 if !dara.IsNil(request.SearchKeyWord) {
18778 body["SearchKeyWord"] = request.SearchKeyWord
18779 }
18780
18781 req := &openapiutil.OpenApiRequest{
18782 Body: openapiutil.ParseToMap(body),
18783 }
18784 params := &openapiutil.Params{
18785 Action: dara.String("ListRoutineCodeVersions"),
18786 Version: dara.String("2024-09-10"),
18787 Protocol: dara.String("HTTPS"),
18788 Pathname: dara.String("/"),
18789 Method: dara.String("POST"),
18790 AuthType: dara.String("AK"),
18791 Style: dara.String("RPC"),
18792 ReqBodyType: dara.String("formData"),
18793 BodyType: dara.String("json"),
18794 }
18795 _result = &ListRoutineCodeVersionsResponse{}
18796 _body, _err := client.CallApi(params, req, runtime)
18797 if _err != nil {
18798 return _result, _err
18799 }
18800 _err = dara.Convert(_body, &_result)
18801 return _result, _err
18802 }
18803
18804 // Summary:
18805 //
18806 // Queries the code versions of a function (routine) by page.
18807 //
18808 // Description:
18809 //
18810 // 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.
18811 //
18812 // Specify `PageNumber` and `PageSize` to control the number of entries returned in a request, and use `SearchKeyWord` to specify a keyword for fuzzy search.
18813 //
18814 // The response includes the number, description, and creation time of each code version.
18815 //
18816 // @param request - ListRoutineCodeVersionsRequest
18817 //
18818 // @return ListRoutineCodeVersionsResponse
18819 func ListRoutineCodeVersions(client *Client, request *ListRoutineCodeVersionsRequest) (_result *ListRoutineCodeVersionsResponse, _err error) {
18820 runtime := &dara.RuntimeOptions{}
18821 _result = &ListRoutineCodeVersionsResponse{}
18822 _body, _err := ListRoutineCodeVersionsWithOptions(client,request, runtime)
18823 if _err != nil {
18824 return _result, _err
18825 }
18826 _result = _body
18827 return _result, _err
18828 }
18829
18830 // Summary:
18831 //
18832 // The records associated with the function.
18833 //
18834 // Description:
18835 //
18836 // 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.
18837 //
18838 // @param request - ListRoutineRelatedRecordsRequest
18839 //
18840 // @param runtime - runtime options for this request RuntimeOptions
18841 //
18842 // @return ListRoutineRelatedRecordsResponse
18843 func ListRoutineRelatedRecordsWithOptions(client *Client, request *ListRoutineRelatedRecordsRequest, runtime *dara.RuntimeOptions) (_result *ListRoutineRelatedRecordsResponse, _err error) {
18844 if dara.BoolValue(client.EnableValidate) == true {
18845 _err = request.Validate()
18846 if _err != nil {
18847 return _result, _err
18848 }
18849 }
18850 body := map[string]interface{}{}
18851 if !dara.IsNil(request.Name) {
18852 body["Name"] = request.Name
18853 }
18854
18855 if !dara.IsNil(request.PageNumber) {
18856 body["PageNumber"] = request.PageNumber
18857 }
18858
18859 if !dara.IsNil(request.PageSize) {
18860 body["PageSize"] = request.PageSize
18861 }
18862
18863 if !dara.IsNil(request.SearchKeyWord) {
18864 body["SearchKeyWord"] = request.SearchKeyWord
18865 }
18866
18867 req := &openapiutil.OpenApiRequest{
18868 Body: openapiutil.ParseToMap(body),
18869 }
18870 params := &openapiutil.Params{
18871 Action: dara.String("ListRoutineRelatedRecords"),
18872 Version: dara.String("2024-09-10"),
18873 Protocol: dara.String("HTTPS"),
18874 Pathname: dara.String("/"),
18875 Method: dara.String("POST"),
18876 AuthType: dara.String("AK"),
18877 Style: dara.String("RPC"),
18878 ReqBodyType: dara.String("formData"),
18879 BodyType: dara.String("json"),
18880 }
18881 _result = &ListRoutineRelatedRecordsResponse{}
18882 _body, _err := client.CallApi(params, req, runtime)
18883 if _err != nil {
18884 return _result, _err
18885 }
18886 _err = dara.Convert(_body, &_result)
18887 return _result, _err
18888 }
18889
18890 // Summary:
18891 //
18892 // The records associated with the function.
18893 //
18894 // Description:
18895 //
18896 // 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.
18897 //
18898 // @param request - ListRoutineRelatedRecordsRequest
18899 //
18900 // @return ListRoutineRelatedRecordsResponse
18901 func ListRoutineRelatedRecords(client *Client, request *ListRoutineRelatedRecordsRequest) (_result *ListRoutineRelatedRecordsResponse, _err error) {
18902 runtime := &dara.RuntimeOptions{}
18903 _result = &ListRoutineRelatedRecordsResponse{}
18904 _body, _err := ListRoutineRelatedRecordsWithOptions(client,request, runtime)
18905 if _err != nil {
18906 return _result, _err
18907 }
18908 _result = _body
18909 return _result, _err
18910 }
18911
18912 // Summary:
18913 //
18914 // Queries the routes of an edge function.
18915 //
18916 // @param request - ListRoutineRoutesRequest
18917 //
18918 // @param runtime - runtime options for this request RuntimeOptions
18919 //
18920 // @return ListRoutineRoutesResponse
18921 func ListRoutineRoutesWithOptions(client *Client, request *ListRoutineRoutesRequest, runtime *dara.RuntimeOptions) (_result *ListRoutineRoutesResponse, _err error) {
18922 if dara.BoolValue(client.EnableValidate) == true {
18923 _err = request.Validate()
18924 if _err != nil {
18925 return _result, _err
18926 }
18927 }
18928 query := map[string]interface{}{}
18929 if !dara.IsNil(request.PageNumber) {
18930 query["PageNumber"] = request.PageNumber
18931 }
18932
18933 if !dara.IsNil(request.PageSize) {
18934 query["PageSize"] = request.PageSize
18935 }
18936
18937 if !dara.IsNil(request.RoutineName) {
18938 query["RoutineName"] = request.RoutineName
18939 }
18940
18941 req := &openapiutil.OpenApiRequest{
18942 Query: openapiutil.Query(query),
18943 }
18944 params := &openapiutil.Params{
18945 Action: dara.String("ListRoutineRoutes"),
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 = &ListRoutineRoutesResponse{}
18956 _body, _err := client.CallApi(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 // Queries the routes of an edge function.
18967 //
18968 // @param request - ListRoutineRoutesRequest
18969 //
18970 // @return ListRoutineRoutesResponse
18971 func ListRoutineRoutes(client *Client, request *ListRoutineRoutesRequest) (_result *ListRoutineRoutesResponse, _err error) {
18972 runtime := &dara.RuntimeOptions{}
18973 _result = &ListRoutineRoutesResponse{}
18974 _body, _err := ListRoutineRoutesWithOptions(client,request, runtime)
18975 if _err != nil {
18976 return _result, _err
18977 }
18978 _result = _body
18979 return _result, _err
18980 }
18981
18982 // Summary:
18983 //
18984 // Lists the plans in a scheduled prefetch task by task ID.
18985 //
18986 // @param request - ListScheduledPreloadExecutionsRequest
18987 //
18988 // @param runtime - runtime options for this request RuntimeOptions
18989 //
18990 // @return ListScheduledPreloadExecutionsResponse
18991 func ListScheduledPreloadExecutionsWithOptions(client *Client, request *ListScheduledPreloadExecutionsRequest, runtime *dara.RuntimeOptions) (_result *ListScheduledPreloadExecutionsResponse, _err error) {
18992 if dara.BoolValue(client.EnableValidate) == true {
18993 _err = request.Validate()
18994 if _err != nil {
18995 return _result, _err
18996 }
18997 }
18998 query := openapiutil.Query(dara.ToMap(request))
18999 req := &openapiutil.OpenApiRequest{
19000 Query: openapiutil.Query(query),
19001 }
19002 params := &openapiutil.Params{
19003 Action: dara.String("ListScheduledPreloadExecutions"),
19004 Version: dara.String("2024-09-10"),
19005 Protocol: dara.String("HTTPS"),
19006 Pathname: dara.String("/"),
19007 Method: dara.String("GET"),
19008 AuthType: dara.String("AK"),
19009 Style: dara.String("RPC"),
19010 ReqBodyType: dara.String("formData"),
19011 BodyType: dara.String("json"),
19012 }
19013 _result = &ListScheduledPreloadExecutionsResponse{}
19014 _body, _err := client.CallApi(params, req, runtime)
19015 if _err != nil {
19016 return _result, _err
19017 }
19018 _err = dara.Convert(_body, &_result)
19019 return _result, _err
19020 }
19021
19022 // Summary:
19023 //
19024 // Lists the plans in a scheduled prefetch task by task ID.
19025 //
19026 // @param request - ListScheduledPreloadExecutionsRequest
19027 //
19028 // @return ListScheduledPreloadExecutionsResponse
19029 func ListScheduledPreloadExecutions(client *Client, request *ListScheduledPreloadExecutionsRequest) (_result *ListScheduledPreloadExecutionsResponse, _err error) {
19030 runtime := &dara.RuntimeOptions{}
19031 _result = &ListScheduledPreloadExecutionsResponse{}
19032 _body, _err := ListScheduledPreloadExecutionsWithOptions(client,request, runtime)
19033 if _err != nil {
19034 return _result, _err
19035 }
19036 _result = _body
19037 return _result, _err
19038 }
19039
19040 // Summary:
19041 //
19042 // Queries the scheduled prefetch tasks for a website.
19043 //
19044 // @param request - ListScheduledPreloadJobsRequest
19045 //
19046 // @param runtime - runtime options for this request RuntimeOptions
19047 //
19048 // @return ListScheduledPreloadJobsResponse
19049 func ListScheduledPreloadJobsWithOptions(client *Client, request *ListScheduledPreloadJobsRequest, runtime *dara.RuntimeOptions) (_result *ListScheduledPreloadJobsResponse, _err error) {
19050 if dara.BoolValue(client.EnableValidate) == true {
19051 _err = request.Validate()
19052 if _err != nil {
19053 return _result, _err
19054 }
19055 }
19056 query := openapiutil.Query(dara.ToMap(request))
19057 req := &openapiutil.OpenApiRequest{
19058 Query: openapiutil.Query(query),
19059 }
19060 params := &openapiutil.Params{
19061 Action: dara.String("ListScheduledPreloadJobs"),
19062 Version: dara.String("2024-09-10"),
19063 Protocol: dara.String("HTTPS"),
19064 Pathname: dara.String("/"),
19065 Method: dara.String("GET"),
19066 AuthType: dara.String("AK"),
19067 Style: dara.String("RPC"),
19068 ReqBodyType: dara.String("formData"),
19069 BodyType: dara.String("json"),
19070 }
19071 _result = &ListScheduledPreloadJobsResponse{}
19072 _body, _err := client.CallApi(params, req, runtime)
19073 if _err != nil {
19074 return _result, _err
19075 }
19076 _err = dara.Convert(_body, &_result)
19077 return _result, _err
19078 }
19079
19080 // Summary:
19081 //
19082 // Queries the scheduled prefetch tasks for a website.
19083 //
19084 // @param request - ListScheduledPreloadJobsRequest
19085 //
19086 // @return ListScheduledPreloadJobsResponse
19087 func ListScheduledPreloadJobs(client *Client, request *ListScheduledPreloadJobsRequest) (_result *ListScheduledPreloadJobsResponse, _err error) {
19088 runtime := &dara.RuntimeOptions{}
19089 _result = &ListScheduledPreloadJobsResponse{}
19090 _body, _err := ListScheduledPreloadJobsWithOptions(client,request, runtime)
19091 if _err != nil {
19092 return _result, _err
19093 }
19094 _result = _body
19095 return _result, _err
19096 }
19097
19098 // Summary:
19099 //
19100 // Lists all log delivery tasks that are in progress.
19101 //
19102 // @param request - ListSiteDeliveryTasksRequest
19103 //
19104 // @param runtime - runtime options for this request RuntimeOptions
19105 //
19106 // @return ListSiteDeliveryTasksResponse
19107 func ListSiteDeliveryTasksWithOptions(client *Client, request *ListSiteDeliveryTasksRequest, runtime *dara.RuntimeOptions) (_result *ListSiteDeliveryTasksResponse, _err error) {
19108 if dara.BoolValue(client.EnableValidate) == true {
19109 _err = request.Validate()
19110 if _err != nil {
19111 return _result, _err
19112 }
19113 }
19114 query := openapiutil.Query(dara.ToMap(request))
19115 req := &openapiutil.OpenApiRequest{
19116 Query: openapiutil.Query(query),
19117 }
19118 params := &openapiutil.Params{
19119 Action: dara.String("ListSiteDeliveryTasks"),
19120 Version: dara.String("2024-09-10"),
19121 Protocol: dara.String("HTTPS"),
19122 Pathname: dara.String("/"),
19123 Method: dara.String("GET"),
19124 AuthType: dara.String("AK"),
19125 Style: dara.String("RPC"),
19126 ReqBodyType: dara.String("formData"),
19127 BodyType: dara.String("json"),
19128 }
19129 _result = &ListSiteDeliveryTasksResponse{}
19130 _body, _err := client.CallApi(params, req, runtime)
19131 if _err != nil {
19132 return _result, _err
19133 }
19134 _err = dara.Convert(_body, &_result)
19135 return _result, _err
19136 }
19137
19138 // Summary:
19139 //
19140 // Lists all log delivery tasks that are in progress.
19141 //
19142 // @param request - ListSiteDeliveryTasksRequest
19143 //
19144 // @return ListSiteDeliveryTasksResponse
19145 func ListSiteDeliveryTasks(client *Client, request *ListSiteDeliveryTasksRequest) (_result *ListSiteDeliveryTasksResponse, _err error) {
19146 runtime := &dara.RuntimeOptions{}
19147 _result = &ListSiteDeliveryTasksResponse{}
19148 _body, _err := ListSiteDeliveryTasksWithOptions(client,request, runtime)
19149 if _err != nil {
19150 return _result, _err
19151 }
19152 _result = _body
19153 return _result, _err
19154 }
19155
19156 // Summary:
19157 //
19158 // Queries the edge function routes for a website.
19159 //
19160 // @param request - ListSiteRoutesRequest
19161 //
19162 // @param runtime - runtime options for this request RuntimeOptions
19163 //
19164 // @return ListSiteRoutesResponse
19165 func ListSiteRoutesWithOptions(client *Client, request *ListSiteRoutesRequest, runtime *dara.RuntimeOptions) (_result *ListSiteRoutesResponse, _err error) {
19166 if dara.BoolValue(client.EnableValidate) == true {
19167 _err = request.Validate()
19168 if _err != nil {
19169 return _result, _err
19170 }
19171 }
19172 query := map[string]interface{}{}
19173 if !dara.IsNil(request.ConfigId) {
19174 query["ConfigId"] = request.ConfigId
19175 }
19176
19177 if !dara.IsNil(request.ConfigType) {
19178 query["ConfigType"] = request.ConfigType
19179 }
19180
19181 if !dara.IsNil(request.PageNumber) {
19182 query["PageNumber"] = request.PageNumber
19183 }
19184
19185 if !dara.IsNil(request.PageSize) {
19186 query["PageSize"] = request.PageSize
19187 }
19188
19189 if !dara.IsNil(request.RouteName) {
19190 query["RouteName"] = request.RouteName
19191 }
19192
19193 if !dara.IsNil(request.SiteId) {
19194 query["SiteId"] = request.SiteId
19195 }
19196
19197 req := &openapiutil.OpenApiRequest{
19198 Query: openapiutil.Query(query),
19199 }
19200 params := &openapiutil.Params{
19201 Action: dara.String("ListSiteRoutes"),
19202 Version: dara.String("2024-09-10"),
19203 Protocol: dara.String("HTTPS"),
19204 Pathname: dara.String("/"),
19205 Method: dara.String("POST"),
19206 AuthType: dara.String("AK"),
19207 Style: dara.String("RPC"),
19208 ReqBodyType: dara.String("formData"),
19209 BodyType: dara.String("json"),
19210 }
19211 _result = &ListSiteRoutesResponse{}
19212 _body, _err := client.CallApi(params, req, runtime)
19213 if _err != nil {
19214 return _result, _err
19215 }
19216 _err = dara.Convert(_body, &_result)
19217 return _result, _err
19218 }
19219
19220 // Summary:
19221 //
19222 // Queries the edge function routes for a website.
19223 //
19224 // @param request - ListSiteRoutesRequest
19225 //
19226 // @return ListSiteRoutesResponse
19227 func ListSiteRoutes(client *Client, request *ListSiteRoutesRequest) (_result *ListSiteRoutesResponse, _err error) {
19228 runtime := &dara.RuntimeOptions{}
19229 _result = &ListSiteRoutesResponse{}
19230 _body, _err := ListSiteRoutesWithOptions(client,request, runtime)
19231 if _err != nil {
19232 return _result, _err
19233 }
19234 _result = _body
19235 return _result, _err
19236 }
19237
19238 // Summary:
19239 //
19240 // Queries the information about websites in your account, such as the name, status, and configuration of each website.
19241 //
19242 // @param tmpReq - ListSitesRequest
19243 //
19244 // @param runtime - runtime options for this request RuntimeOptions
19245 //
19246 // @return ListSitesResponse
19247 func ListSitesWithOptions(client *Client, tmpReq *ListSitesRequest, runtime *dara.RuntimeOptions) (_result *ListSitesResponse, _err error) {
19248 if dara.BoolValue(client.EnableValidate) == true {
19249 _err = tmpReq.Validate()
19250 if _err != nil {
19251 return _result, _err
19252 }
19253 }
19254 request := &ListSitesShrinkRequest{}
19255 openapiutil.Convert(tmpReq, request)
19256 if !dara.IsNil(tmpReq.TagFilter) {
19257 request.TagFilterShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.TagFilter, dara.String("TagFilter"), dara.String("json"))
19258 }
19259
19260 query := openapiutil.Query(dara.ToMap(request))
19261 req := &openapiutil.OpenApiRequest{
19262 Query: openapiutil.Query(query),
19263 }
19264 params := &openapiutil.Params{
19265 Action: dara.String("ListSites"),
19266 Version: dara.String("2024-09-10"),
19267 Protocol: dara.String("HTTPS"),
19268 Pathname: dara.String("/"),
19269 Method: dara.String("GET"),
19270 AuthType: dara.String("AK"),
19271 Style: dara.String("RPC"),
19272 ReqBodyType: dara.String("formData"),
19273 BodyType: dara.String("json"),
19274 }
19275 _result = &ListSitesResponse{}
19276 _body, _err := client.CallApi(params, req, runtime)
19277 if _err != nil {
19278 return _result, _err
19279 }
19280 _err = dara.Convert(_body, &_result)
19281 return _result, _err
19282 }
19283
19284 // Summary:
19285 //
19286 // Queries the information about websites in your account, such as the name, status, and configuration of each website.
19287 //
19288 // @param request - ListSitesRequest
19289 //
19290 // @return ListSitesResponse
19291 func ListSites(client *Client, request *ListSitesRequest) (_result *ListSitesResponse, _err error) {
19292 runtime := &dara.RuntimeOptions{}
19293 _result = &ListSitesResponse{}
19294 _body, _err := ListSitesWithOptions(client,request, runtime)
19295 if _err != nil {
19296 return _result, _err
19297 }
19298 _result = _body
19299 return _result, _err
19300 }
19301
19302 // Summary:
19303 //
19304 // Queries tags based on the region ID and resource type.
19305 //
19306 // @param request - ListTagResourcesRequest
19307 //
19308 // @param runtime - runtime options for this request RuntimeOptions
19309 //
19310 // @return ListTagResourcesResponse
19311 func ListTagResourcesWithOptions(client *Client, request *ListTagResourcesRequest, runtime *dara.RuntimeOptions) (_result *ListTagResourcesResponse, _err error) {
19312 if dara.BoolValue(client.EnableValidate) == true {
19313 _err = request.Validate()
19314 if _err != nil {
19315 return _result, _err
19316 }
19317 }
19318 query := map[string]interface{}{}
19319 if !dara.IsNil(request.MaxItem) {
19320 query["MaxItem"] = request.MaxItem
19321 }
19322
19323 if !dara.IsNil(request.NextToken) {
19324 query["NextToken"] = request.NextToken
19325 }
19326
19327 if !dara.IsNil(request.OwnerId) {
19328 query["OwnerId"] = request.OwnerId
19329 }
19330
19331 if !dara.IsNil(request.RegionId) {
19332 query["RegionId"] = request.RegionId
19333 }
19334
19335 if !dara.IsNil(request.ResourceId) {
19336 query["ResourceId"] = request.ResourceId
19337 }
19338
19339 if !dara.IsNil(request.ResourceType) {
19340 query["ResourceType"] = request.ResourceType
19341 }
19342
19343 if !dara.IsNil(request.SecurityToken) {
19344 query["SecurityToken"] = request.SecurityToken
19345 }
19346
19347 if !dara.IsNil(request.Tag) {
19348 query["Tag"] = request.Tag
19349 }
19350
19351 req := &openapiutil.OpenApiRequest{
19352 Query: openapiutil.Query(query),
19353 }
19354 params := &openapiutil.Params{
19355 Action: dara.String("ListTagResources"),
19356 Version: dara.String("2024-09-10"),
19357 Protocol: dara.String("HTTPS"),
19358 Pathname: dara.String("/"),
19359 Method: dara.String("POST"),
19360 AuthType: dara.String("AK"),
19361 Style: dara.String("RPC"),
19362 ReqBodyType: dara.String("formData"),
19363 BodyType: dara.String("json"),
19364 }
19365 _result = &ListTagResourcesResponse{}
19366 _body, _err := client.CallApi(params, req, runtime)
19367 if _err != nil {
19368 return _result, _err
19369 }
19370 _err = dara.Convert(_body, &_result)
19371 return _result, _err
19372 }
19373
19374 // Summary:
19375 //
19376 // Queries tags based on the region ID and resource type.
19377 //
19378 // @param request - ListTagResourcesRequest
19379 //
19380 // @return ListTagResourcesResponse
19381 func ListTagResources(client *Client, request *ListTagResourcesRequest) (_result *ListTagResourcesResponse, _err error) {
19382 runtime := &dara.RuntimeOptions{}
19383 _result = &ListTagResourcesResponse{}
19384 _body, _err := ListTagResourcesWithOptions(client,request, runtime)
19385 if _err != nil {
19386 return _result, _err
19387 }
19388 _result = _body
19389 return _result, _err
19390 }
19391
19392 // Summary:
19393 //
19394 // # List of Transport Layer Applications
19395 //
19396 // @param request - ListTransportLayerApplicationsRequest
19397 //
19398 // @param runtime - runtime options for this request RuntimeOptions
19399 //
19400 // @return ListTransportLayerApplicationsResponse
19401 func ListTransportLayerApplicationsWithOptions(client *Client, request *ListTransportLayerApplicationsRequest, runtime *dara.RuntimeOptions) (_result *ListTransportLayerApplicationsResponse, _err error) {
19402 if dara.BoolValue(client.EnableValidate) == true {
19403 _err = request.Validate()
19404 if _err != nil {
19405 return _result, _err
19406 }
19407 }
19408 query := openapiutil.Query(dara.ToMap(request))
19409 req := &openapiutil.OpenApiRequest{
19410 Query: openapiutil.Query(query),
19411 }
19412 params := &openapiutil.Params{
19413 Action: dara.String("ListTransportLayerApplications"),
19414 Version: dara.String("2024-09-10"),
19415 Protocol: dara.String("HTTPS"),
19416 Pathname: dara.String("/"),
19417 Method: dara.String("GET"),
19418 AuthType: dara.String("AK"),
19419 Style: dara.String("RPC"),
19420 ReqBodyType: dara.String("formData"),
19421 BodyType: dara.String("json"),
19422 }
19423 _result = &ListTransportLayerApplicationsResponse{}
19424 _body, _err := client.CallApi(params, req, runtime)
19425 if _err != nil {
19426 return _result, _err
19427 }
19428 _err = dara.Convert(_body, &_result)
19429 return _result, _err
19430 }
19431
19432 // Summary:
19433 //
19434 // # List of Transport Layer Applications
19435 //
19436 // @param request - ListTransportLayerApplicationsRequest
19437 //
19438 // @return ListTransportLayerApplicationsResponse
19439 func ListTransportLayerApplications(client *Client, request *ListTransportLayerApplicationsRequest) (_result *ListTransportLayerApplicationsResponse, _err error) {
19440 runtime := &dara.RuntimeOptions{}
19441 _result = &ListTransportLayerApplicationsResponse{}
19442 _body, _err := ListTransportLayerApplicationsWithOptions(client,request, runtime)
19443 if _err != nil {
19444 return _result, _err
19445 }
19446 _result = _body
19447 return _result, _err
19448 }
19449
19450 // Summary:
19451 //
19452 // Queries the execution status and running information of file upload tasks based on the task time and type.
19453 //
19454 // @param request - ListUploadTasksRequest
19455 //
19456 // @param runtime - runtime options for this request RuntimeOptions
19457 //
19458 // @return ListUploadTasksResponse
19459 func ListUploadTasksWithOptions(client *Client, request *ListUploadTasksRequest, runtime *dara.RuntimeOptions) (_result *ListUploadTasksResponse, _err error) {
19460 if dara.BoolValue(client.EnableValidate) == true {
19461 _err = request.Validate()
19462 if _err != nil {
19463 return _result, _err
19464 }
19465 }
19466 query := openapiutil.Query(dara.ToMap(request))
19467 req := &openapiutil.OpenApiRequest{
19468 Query: openapiutil.Query(query),
19469 }
19470 params := &openapiutil.Params{
19471 Action: dara.String("ListUploadTasks"),
19472 Version: dara.String("2024-09-10"),
19473 Protocol: dara.String("HTTPS"),
19474 Pathname: dara.String("/"),
19475 Method: dara.String("GET"),
19476 AuthType: dara.String("AK"),
19477 Style: dara.String("RPC"),
19478 ReqBodyType: dara.String("formData"),
19479 BodyType: dara.String("json"),
19480 }
19481 _result = &ListUploadTasksResponse{}
19482 _body, _err := client.CallApi(params, req, runtime)
19483 if _err != nil {
19484 return _result, _err
19485 }
19486 _err = dara.Convert(_body, &_result)
19487 return _result, _err
19488 }
19489
19490 // Summary:
19491 //
19492 // Queries the execution status and running information of file upload tasks based on the task time and type.
19493 //
19494 // @param request - ListUploadTasksRequest
19495 //
19496 // @return ListUploadTasksResponse
19497 func ListUploadTasks(client *Client, request *ListUploadTasksRequest) (_result *ListUploadTasksResponse, _err error) {
19498 runtime := &dara.RuntimeOptions{}
19499 _result = &ListUploadTasksResponse{}
19500 _body, _err := ListUploadTasksWithOptions(client,request, runtime)
19501 if _err != nil {
19502 return _result, _err
19503 }
19504 _result = _body
19505 return _result, _err
19506 }
19507
19508 // Summary:
19509 //
19510 // Queries the list of page monitoring configurations.
19511 //
19512 // @param request - ListUrlObservationsRequest
19513 //
19514 // @param runtime - runtime options for this request RuntimeOptions
19515 //
19516 // @return ListUrlObservationsResponse
19517 func ListUrlObservationsWithOptions(client *Client, request *ListUrlObservationsRequest, runtime *dara.RuntimeOptions) (_result *ListUrlObservationsResponse, _err error) {
19518 if dara.BoolValue(client.EnableValidate) == true {
19519 _err = request.Validate()
19520 if _err != nil {
19521 return _result, _err
19522 }
19523 }
19524 query := map[string]interface{}{}
19525 if !dara.IsNil(request.ConfigId) {
19526 query["ConfigId"] = request.ConfigId
19527 }
19528
19529 if !dara.IsNil(request.PageNumber) {
19530 query["PageNumber"] = request.PageNumber
19531 }
19532
19533 if !dara.IsNil(request.PageSize) {
19534 query["PageSize"] = request.PageSize
19535 }
19536
19537 if !dara.IsNil(request.SiteId) {
19538 query["SiteId"] = request.SiteId
19539 }
19540
19541 req := &openapiutil.OpenApiRequest{
19542 Query: openapiutil.Query(query),
19543 }
19544 params := &openapiutil.Params{
19545 Action: dara.String("ListUrlObservations"),
19546 Version: dara.String("2024-09-10"),
19547 Protocol: dara.String("HTTPS"),
19548 Pathname: dara.String("/"),
19549 Method: dara.String("POST"),
19550 AuthType: dara.String("AK"),
19551 Style: dara.String("RPC"),
19552 ReqBodyType: dara.String("formData"),
19553 BodyType: dara.String("json"),
19554 }
19555 _result = &ListUrlObservationsResponse{}
19556 _body, _err := client.CallApi(params, req, runtime)
19557 if _err != nil {
19558 return _result, _err
19559 }
19560 _err = dara.Convert(_body, &_result)
19561 return _result, _err
19562 }
19563
19564 // Summary:
19565 //
19566 // Queries the list of page monitoring configurations.
19567 //
19568 // @param request - ListUrlObservationsRequest
19569 //
19570 // @return ListUrlObservationsResponse
19571 func ListUrlObservations(client *Client, request *ListUrlObservationsRequest) (_result *ListUrlObservationsResponse, _err error) {
19572 runtime := &dara.RuntimeOptions{}
19573 _result = &ListUrlObservationsResponse{}
19574 _body, _err := ListUrlObservationsWithOptions(client,request, runtime)
19575 if _err != nil {
19576 return _result, _err
19577 }
19578 _result = _body
19579 return _result, _err
19580 }
19581
19582 // Summary:
19583 //
19584 // 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.
19585 //
19586 // @param request - ListUserDeliveryTasksRequest
19587 //
19588 // @param runtime - runtime options for this request RuntimeOptions
19589 //
19590 // @return ListUserDeliveryTasksResponse
19591 func ListUserDeliveryTasksWithOptions(client *Client, request *ListUserDeliveryTasksRequest, runtime *dara.RuntimeOptions) (_result *ListUserDeliveryTasksResponse, _err error) {
19592 if dara.BoolValue(client.EnableValidate) == true {
19593 _err = request.Validate()
19594 if _err != nil {
19595 return _result, _err
19596 }
19597 }
19598 query := openapiutil.Query(dara.ToMap(request))
19599 req := &openapiutil.OpenApiRequest{
19600 Query: openapiutil.Query(query),
19601 }
19602 params := &openapiutil.Params{
19603 Action: dara.String("ListUserDeliveryTasks"),
19604 Version: dara.String("2024-09-10"),
19605 Protocol: dara.String("HTTPS"),
19606 Pathname: dara.String("/"),
19607 Method: dara.String("GET"),
19608 AuthType: dara.String("AK"),
19609 Style: dara.String("RPC"),
19610 ReqBodyType: dara.String("formData"),
19611 BodyType: dara.String("json"),
19612 }
19613 _result = &ListUserDeliveryTasksResponse{}
19614 _body, _err := client.CallApi(params, req, runtime)
19615 if _err != nil {
19616 return _result, _err
19617 }
19618 _err = dara.Convert(_body, &_result)
19619 return _result, _err
19620 }
19621
19622 // Summary:
19623 //
19624 // 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.
19625 //
19626 // @param request - ListUserDeliveryTasksRequest
19627 //
19628 // @return ListUserDeliveryTasksResponse
19629 func ListUserDeliveryTasks(client *Client, request *ListUserDeliveryTasksRequest) (_result *ListUserDeliveryTasksResponse, _err error) {
19630 runtime := &dara.RuntimeOptions{}
19631 _result = &ListUserDeliveryTasksResponse{}
19632 _body, _err := ListUserDeliveryTasksWithOptions(client,request, runtime)
19633 if _err != nil {
19634 return _result, _err
19635 }
19636 _result = _body
19637 return _result, _err
19638 }
19639
19640 // Summary:
19641 //
19642 // Queries the plans that you purchased and the details of the plans.
19643 //
19644 // @param request - ListUserRatePlanInstancesRequest
19645 //
19646 // @param runtime - runtime options for this request RuntimeOptions
19647 //
19648 // @return ListUserRatePlanInstancesResponse
19649 func ListUserRatePlanInstancesWithOptions(client *Client, request *ListUserRatePlanInstancesRequest, runtime *dara.RuntimeOptions) (_result *ListUserRatePlanInstancesResponse, _err error) {
19650 if dara.BoolValue(client.EnableValidate) == true {
19651 _err = request.Validate()
19652 if _err != nil {
19653 return _result, _err
19654 }
19655 }
19656 query := openapiutil.Query(dara.ToMap(request))
19657 req := &openapiutil.OpenApiRequest{
19658 Query: openapiutil.Query(query),
19659 }
19660 params := &openapiutil.Params{
19661 Action: dara.String("ListUserRatePlanInstances"),
19662 Version: dara.String("2024-09-10"),
19663 Protocol: dara.String("HTTPS"),
19664 Pathname: dara.String("/"),
19665 Method: dara.String("GET"),
19666 AuthType: dara.String("AK"),
19667 Style: dara.String("RPC"),
19668 ReqBodyType: dara.String("formData"),
19669 BodyType: dara.String("json"),
19670 }
19671 _result = &ListUserRatePlanInstancesResponse{}
19672 _body, _err := client.CallApi(params, req, runtime)
19673 if _err != nil {
19674 return _result, _err
19675 }
19676 _err = dara.Convert(_body, &_result)
19677 return _result, _err
19678 }
19679
19680 // Summary:
19681 //
19682 // Queries the plans that you purchased and the details of the plans.
19683 //
19684 // @param request - ListUserRatePlanInstancesRequest
19685 //
19686 // @return ListUserRatePlanInstancesResponse
19687 func ListUserRatePlanInstances(client *Client, request *ListUserRatePlanInstancesRequest) (_result *ListUserRatePlanInstancesResponse, _err error) {
19688 runtime := &dara.RuntimeOptions{}
19689 _result = &ListUserRatePlanInstancesResponse{}
19690 _body, _err := ListUserRatePlanInstancesWithOptions(client,request, runtime)
19691 if _err != nil {
19692 return _result, _err
19693 }
19694 _result = _body
19695 return _result, _err
19696 }
19697
19698 // Summary:
19699 //
19700 // 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.
19701 //
19702 // Description:
19703 //
19704 // 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.
19705 //
19706 // @param request - ListUserRoutinesRequest
19707 //
19708 // @param runtime - runtime options for this request RuntimeOptions
19709 //
19710 // @return ListUserRoutinesResponse
19711 func ListUserRoutinesWithOptions(client *Client, request *ListUserRoutinesRequest, runtime *dara.RuntimeOptions) (_result *ListUserRoutinesResponse, _err error) {
19712 if dara.BoolValue(client.EnableValidate) == true {
19713 _err = request.Validate()
19714 if _err != nil {
19715 return _result, _err
19716 }
19717 }
19718 query := map[string]interface{}{}
19719 if !dara.IsNil(request.PageNumber) {
19720 query["PageNumber"] = request.PageNumber
19721 }
19722
19723 if !dara.IsNil(request.PageSize) {
19724 query["PageSize"] = request.PageSize
19725 }
19726
19727 if !dara.IsNil(request.SearchKeyWord) {
19728 query["SearchKeyWord"] = request.SearchKeyWord
19729 }
19730
19731 req := &openapiutil.OpenApiRequest{
19732 Query: openapiutil.Query(query),
19733 }
19734 params := &openapiutil.Params{
19735 Action: dara.String("ListUserRoutines"),
19736 Version: dara.String("2024-09-10"),
19737 Protocol: dara.String("HTTPS"),
19738 Pathname: dara.String("/"),
19739 Method: dara.String("POST"),
19740 AuthType: dara.String("AK"),
19741 Style: dara.String("RPC"),
19742 ReqBodyType: dara.String("formData"),
19743 BodyType: dara.String("json"),
19744 }
19745 _result = &ListUserRoutinesResponse{}
19746 _body, _err := client.CallApi(params, req, runtime)
19747 if _err != nil {
19748 return _result, _err
19749 }
19750 _err = dara.Convert(_body, &_result)
19751 return _result, _err
19752 }
19753
19754 // Summary:
19755 //
19756 // 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.
19757 //
19758 // Description:
19759 //
19760 // 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.
19761 //
19762 // @param request - ListUserRoutinesRequest
19763 //
19764 // @return ListUserRoutinesResponse
19765 func ListUserRoutines(client *Client, request *ListUserRoutinesRequest) (_result *ListUserRoutinesResponse, _err error) {
19766 runtime := &dara.RuntimeOptions{}
19767 _result = &ListUserRoutinesResponse{}
19768 _body, _err := ListUserRoutinesWithOptions(client,request, runtime)
19769 if _err != nil {
19770 return _result, _err
19771 }
19772 _result = _body
19773 return _result, _err
19774 }
19775
19776 // Summary:
19777 //
19778 // 用于列举实例级别的Web应用防火墙规则集。
19779 //
19780 // @param tmpReq - ListUserWafRulesetsRequest
19781 //
19782 // @param runtime - runtime options for this request RuntimeOptions
19783 //
19784 // @return ListUserWafRulesetsResponse
19785 func ListUserWafRulesetsWithOptions(client *Client, tmpReq *ListUserWafRulesetsRequest, runtime *dara.RuntimeOptions) (_result *ListUserWafRulesetsResponse, _err error) {
19786 if dara.BoolValue(client.EnableValidate) == true {
19787 _err = tmpReq.Validate()
19788 if _err != nil {
19789 return _result, _err
19790 }
19791 }
19792 request := &ListUserWafRulesetsShrinkRequest{}
19793 openapiutil.Convert(tmpReq, request)
19794 if !dara.IsNil(tmpReq.QueryArgs) {
19795 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
19796 }
19797
19798 query := map[string]interface{}{}
19799 if !dara.IsNil(request.InstanceId) {
19800 query["InstanceId"] = request.InstanceId
19801 }
19802
19803 if !dara.IsNil(request.PageNumber) {
19804 query["PageNumber"] = request.PageNumber
19805 }
19806
19807 if !dara.IsNil(request.PageSize) {
19808 query["PageSize"] = request.PageSize
19809 }
19810
19811 if !dara.IsNil(request.Phase) {
19812 query["Phase"] = request.Phase
19813 }
19814
19815 if !dara.IsNil(request.QueryArgsShrink) {
19816 query["QueryArgs"] = request.QueryArgsShrink
19817 }
19818
19819 req := &openapiutil.OpenApiRequest{
19820 Query: openapiutil.Query(query),
19821 }
19822 params := &openapiutil.Params{
19823 Action: dara.String("ListUserWafRulesets"),
19824 Version: dara.String("2024-09-10"),
19825 Protocol: dara.String("HTTPS"),
19826 Pathname: dara.String("/"),
19827 Method: dara.String("POST"),
19828 AuthType: dara.String("AK"),
19829 Style: dara.String("RPC"),
19830 ReqBodyType: dara.String("formData"),
19831 BodyType: dara.String("json"),
19832 }
19833 _result = &ListUserWafRulesetsResponse{}
19834 _body, _err := client.CallApi(params, req, runtime)
19835 if _err != nil {
19836 return _result, _err
19837 }
19838 _err = dara.Convert(_body, &_result)
19839 return _result, _err
19840 }
19841
19842 // Summary:
19843 //
19844 // 用于列举实例级别的Web应用防火墙规则集。
19845 //
19846 // @param request - ListUserWafRulesetsRequest
19847 //
19848 // @return ListUserWafRulesetsResponse
19849 func ListUserWafRulesets(client *Client, request *ListUserWafRulesetsRequest) (_result *ListUserWafRulesetsResponse, _err error) {
19850 runtime := &dara.RuntimeOptions{}
19851 _result = &ListUserWafRulesetsResponse{}
19852 _body, _err := ListUserWafRulesetsWithOptions(client,request, runtime)
19853 if _err != nil {
19854 return _result, _err
19855 }
19856 _result = _body
19857 return _result, _err
19858 }
19859
19860 // Summary:
19861 //
19862 // Queries the video processing configurations of a site.
19863 //
19864 // @param request - ListVideoProcessingsRequest
19865 //
19866 // @param runtime - runtime options for this request RuntimeOptions
19867 //
19868 // @return ListVideoProcessingsResponse
19869 func ListVideoProcessingsWithOptions(client *Client, request *ListVideoProcessingsRequest, runtime *dara.RuntimeOptions) (_result *ListVideoProcessingsResponse, _err error) {
19870 if dara.BoolValue(client.EnableValidate) == true {
19871 _err = request.Validate()
19872 if _err != nil {
19873 return _result, _err
19874 }
19875 }
19876 query := map[string]interface{}{}
19877 if !dara.IsNil(request.ConfigId) {
19878 query["ConfigId"] = request.ConfigId
19879 }
19880
19881 if !dara.IsNil(request.ConfigType) {
19882 query["ConfigType"] = request.ConfigType
19883 }
19884
19885 if !dara.IsNil(request.PageNumber) {
19886 query["PageNumber"] = request.PageNumber
19887 }
19888
19889 if !dara.IsNil(request.PageSize) {
19890 query["PageSize"] = request.PageSize
19891 }
19892
19893 if !dara.IsNil(request.RuleName) {
19894 query["RuleName"] = request.RuleName
19895 }
19896
19897 if !dara.IsNil(request.SiteId) {
19898 query["SiteId"] = request.SiteId
19899 }
19900
19901 if !dara.IsNil(request.SiteVersion) {
19902 query["SiteVersion"] = request.SiteVersion
19903 }
19904
19905 req := &openapiutil.OpenApiRequest{
19906 Query: openapiutil.Query(query),
19907 }
19908 params := &openapiutil.Params{
19909 Action: dara.String("ListVideoProcessings"),
19910 Version: dara.String("2024-09-10"),
19911 Protocol: dara.String("HTTPS"),
19912 Pathname: dara.String("/"),
19913 Method: dara.String("POST"),
19914 AuthType: dara.String("AK"),
19915 Style: dara.String("RPC"),
19916 ReqBodyType: dara.String("formData"),
19917 BodyType: dara.String("json"),
19918 }
19919 _result = &ListVideoProcessingsResponse{}
19920 _body, _err := client.CallApi(params, req, runtime)
19921 if _err != nil {
19922 return _result, _err
19923 }
19924 _err = dara.Convert(_body, &_result)
19925 return _result, _err
19926 }
19927
19928 // Summary:
19929 //
19930 // Queries the video processing configurations of a site.
19931 //
19932 // @param request - ListVideoProcessingsRequest
19933 //
19934 // @return ListVideoProcessingsResponse
19935 func ListVideoProcessings(client *Client, request *ListVideoProcessingsRequest) (_result *ListVideoProcessingsResponse, _err error) {
19936 runtime := &dara.RuntimeOptions{}
19937 _result = &ListVideoProcessingsResponse{}
19938 _body, _err := ListVideoProcessingsWithOptions(client,request, runtime)
19939 if _err != nil {
19940 return _result, _err
19941 }
19942 _result = _body
19943 return _result, _err
19944 }
19945
19946 // Summary:
19947 //
19948 // # List WAF Managed Rules
19949 //
19950 // @param tmpReq - ListWafManagedRulesRequest
19951 //
19952 // @param runtime - runtime options for this request RuntimeOptions
19953 //
19954 // @return ListWafManagedRulesResponse
19955 func ListWafManagedRulesWithOptions(client *Client, tmpReq *ListWafManagedRulesRequest, runtime *dara.RuntimeOptions) (_result *ListWafManagedRulesResponse, _err error) {
19956 if dara.BoolValue(client.EnableValidate) == true {
19957 _err = tmpReq.Validate()
19958 if _err != nil {
19959 return _result, _err
19960 }
19961 }
19962 request := &ListWafManagedRulesShrinkRequest{}
19963 openapiutil.Convert(tmpReq, request)
19964 if !dara.IsNil(tmpReq.ManagedRuleset) {
19965 request.ManagedRulesetShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ManagedRuleset, dara.String("ManagedRuleset"), dara.String("json"))
19966 }
19967
19968 if !dara.IsNil(tmpReq.QueryArgs) {
19969 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
19970 }
19971
19972 query := map[string]interface{}{}
19973 if !dara.IsNil(request.AttackType) {
19974 query["AttackType"] = request.AttackType
19975 }
19976
19977 if !dara.IsNil(request.Id) {
19978 query["Id"] = request.Id
19979 }
19980
19981 if !dara.IsNil(request.InstanceId) {
19982 query["InstanceId"] = request.InstanceId
19983 }
19984
19985 if !dara.IsNil(request.Language) {
19986 query["Language"] = request.Language
19987 }
19988
19989 if !dara.IsNil(request.ManagedRulesetShrink) {
19990 query["ManagedRuleset"] = request.ManagedRulesetShrink
19991 }
19992
19993 if !dara.IsNil(request.PageNumber) {
19994 query["PageNumber"] = request.PageNumber
19995 }
19996
19997 if !dara.IsNil(request.PageSize) {
19998 query["PageSize"] = request.PageSize
19999 }
20000
20001 if !dara.IsNil(request.ProtectionLevel) {
20002 query["ProtectionLevel"] = request.ProtectionLevel
20003 }
20004
20005 if !dara.IsNil(request.QueryArgsShrink) {
20006 query["QueryArgs"] = request.QueryArgsShrink
20007 }
20008
20009 if !dara.IsNil(request.SiteId) {
20010 query["SiteId"] = request.SiteId
20011 }
20012
20013 req := &openapiutil.OpenApiRequest{
20014 Query: openapiutil.Query(query),
20015 }
20016 params := &openapiutil.Params{
20017 Action: dara.String("ListWafManagedRules"),
20018 Version: dara.String("2024-09-10"),
20019 Protocol: dara.String("HTTPS"),
20020 Pathname: dara.String("/"),
20021 Method: dara.String("POST"),
20022 AuthType: dara.String("AK"),
20023 Style: dara.String("RPC"),
20024 ReqBodyType: dara.String("formData"),
20025 BodyType: dara.String("json"),
20026 }
20027 _result = &ListWafManagedRulesResponse{}
20028 _body, _err := client.CallApi(params, req, runtime)
20029 if _err != nil {
20030 return _result, _err
20031 }
20032 _err = dara.Convert(_body, &_result)
20033 return _result, _err
20034 }
20035
20036 // Summary:
20037 //
20038 // # List WAF Managed Rules
20039 //
20040 // @param request - ListWafManagedRulesRequest
20041 //
20042 // @return ListWafManagedRulesResponse
20043 func ListWafManagedRules(client *Client, request *ListWafManagedRulesRequest) (_result *ListWafManagedRulesResponse, _err error) {
20044 runtime := &dara.RuntimeOptions{}
20045 _result = &ListWafManagedRulesResponse{}
20046 _body, _err := ListWafManagedRulesWithOptions(client,request, runtime)
20047 if _err != nil {
20048 return _result, _err
20049 }
20050 _result = _body
20051 return _result, _err
20052 }
20053
20054 // Summary:
20055 //
20056 // # List WAF Phases
20057 //
20058 // @param request - ListWafPhasesRequest
20059 //
20060 // @param runtime - runtime options for this request RuntimeOptions
20061 //
20062 // @return ListWafPhasesResponse
20063 func ListWafPhasesWithOptions(client *Client, request *ListWafPhasesRequest, runtime *dara.RuntimeOptions) (_result *ListWafPhasesResponse, _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 if !dara.IsNil(request.SiteVersion) {
20076 query["SiteVersion"] = request.SiteVersion
20077 }
20078
20079 req := &openapiutil.OpenApiRequest{
20080 Query: openapiutil.Query(query),
20081 }
20082 params := &openapiutil.Params{
20083 Action: dara.String("ListWafPhases"),
20084 Version: dara.String("2024-09-10"),
20085 Protocol: dara.String("HTTPS"),
20086 Pathname: dara.String("/"),
20087 Method: dara.String("POST"),
20088 AuthType: dara.String("AK"),
20089 Style: dara.String("RPC"),
20090 ReqBodyType: dara.String("formData"),
20091 BodyType: dara.String("json"),
20092 }
20093 _result = &ListWafPhasesResponse{}
20094 _body, _err := client.CallApi(params, req, runtime)
20095 if _err != nil {
20096 return _result, _err
20097 }
20098 _err = dara.Convert(_body, &_result)
20099 return _result, _err
20100 }
20101
20102 // Summary:
20103 //
20104 // # List WAF Phases
20105 //
20106 // @param request - ListWafPhasesRequest
20107 //
20108 // @return ListWafPhasesResponse
20109 func ListWafPhases(client *Client, request *ListWafPhasesRequest) (_result *ListWafPhasesResponse, _err error) {
20110 runtime := &dara.RuntimeOptions{}
20111 _result = &ListWafPhasesResponse{}
20112 _body, _err := ListWafPhasesWithOptions(client,request, runtime)
20113 if _err != nil {
20114 return _result, _err
20115 }
20116 _result = _body
20117 return _result, _err
20118 }
20119
20120 // Summary:
20121 //
20122 // # List WAF Rules
20123 //
20124 // @param tmpReq - ListWafRulesRequest
20125 //
20126 // @param runtime - runtime options for this request RuntimeOptions
20127 //
20128 // @return ListWafRulesResponse
20129 func ListWafRulesWithOptions(client *Client, tmpReq *ListWafRulesRequest, runtime *dara.RuntimeOptions) (_result *ListWafRulesResponse, _err error) {
20130 if dara.BoolValue(client.EnableValidate) == true {
20131 _err = tmpReq.Validate()
20132 if _err != nil {
20133 return _result, _err
20134 }
20135 }
20136 request := &ListWafRulesShrinkRequest{}
20137 openapiutil.Convert(tmpReq, request)
20138 if !dara.IsNil(tmpReq.QueryArgs) {
20139 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
20140 }
20141
20142 query := map[string]interface{}{}
20143 if !dara.IsNil(request.PageNumber) {
20144 query["PageNumber"] = request.PageNumber
20145 }
20146
20147 if !dara.IsNil(request.PageSize) {
20148 query["PageSize"] = request.PageSize
20149 }
20150
20151 if !dara.IsNil(request.Phase) {
20152 query["Phase"] = request.Phase
20153 }
20154
20155 if !dara.IsNil(request.QueryArgsShrink) {
20156 query["QueryArgs"] = request.QueryArgsShrink
20157 }
20158
20159 if !dara.IsNil(request.RulesetId) {
20160 query["RulesetId"] = request.RulesetId
20161 }
20162
20163 if !dara.IsNil(request.SiteId) {
20164 query["SiteId"] = request.SiteId
20165 }
20166
20167 if !dara.IsNil(request.SiteVersion) {
20168 query["SiteVersion"] = request.SiteVersion
20169 }
20170
20171 req := &openapiutil.OpenApiRequest{
20172 Query: openapiutil.Query(query),
20173 }
20174 params := &openapiutil.Params{
20175 Action: dara.String("ListWafRules"),
20176 Version: dara.String("2024-09-10"),
20177 Protocol: dara.String("HTTPS"),
20178 Pathname: dara.String("/"),
20179 Method: dara.String("POST"),
20180 AuthType: dara.String("AK"),
20181 Style: dara.String("RPC"),
20182 ReqBodyType: dara.String("formData"),
20183 BodyType: dara.String("json"),
20184 }
20185 _result = &ListWafRulesResponse{}
20186 _body, _err := client.CallApi(params, req, runtime)
20187 if _err != nil {
20188 return _result, _err
20189 }
20190 _err = dara.Convert(_body, &_result)
20191 return _result, _err
20192 }
20193
20194 // Summary:
20195 //
20196 // # List WAF Rules
20197 //
20198 // @param request - ListWafRulesRequest
20199 //
20200 // @return ListWafRulesResponse
20201 func ListWafRules(client *Client, request *ListWafRulesRequest) (_result *ListWafRulesResponse, _err error) {
20202 runtime := &dara.RuntimeOptions{}
20203 _result = &ListWafRulesResponse{}
20204 _body, _err := ListWafRulesWithOptions(client,request, runtime)
20205 if _err != nil {
20206 return _result, _err
20207 }
20208 _result = _body
20209 return _result, _err
20210 }
20211
20212 // Summary:
20213 //
20214 // # List WAF Rule Sets
20215 //
20216 // @param tmpReq - ListWafRulesetsRequest
20217 //
20218 // @param runtime - runtime options for this request RuntimeOptions
20219 //
20220 // @return ListWafRulesetsResponse
20221 func ListWafRulesetsWithOptions(client *Client, tmpReq *ListWafRulesetsRequest, runtime *dara.RuntimeOptions) (_result *ListWafRulesetsResponse, _err error) {
20222 if dara.BoolValue(client.EnableValidate) == true {
20223 _err = tmpReq.Validate()
20224 if _err != nil {
20225 return _result, _err
20226 }
20227 }
20228 request := &ListWafRulesetsShrinkRequest{}
20229 openapiutil.Convert(tmpReq, request)
20230 if !dara.IsNil(tmpReq.QueryArgs) {
20231 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
20232 }
20233
20234 query := map[string]interface{}{}
20235 if !dara.IsNil(request.PageNumber) {
20236 query["PageNumber"] = request.PageNumber
20237 }
20238
20239 if !dara.IsNil(request.PageSize) {
20240 query["PageSize"] = request.PageSize
20241 }
20242
20243 if !dara.IsNil(request.Phase) {
20244 query["Phase"] = request.Phase
20245 }
20246
20247 if !dara.IsNil(request.QueryArgsShrink) {
20248 query["QueryArgs"] = request.QueryArgsShrink
20249 }
20250
20251 if !dara.IsNil(request.SiteId) {
20252 query["SiteId"] = request.SiteId
20253 }
20254
20255 if !dara.IsNil(request.SiteVersion) {
20256 query["SiteVersion"] = request.SiteVersion
20257 }
20258
20259 req := &openapiutil.OpenApiRequest{
20260 Query: openapiutil.Query(query),
20261 }
20262 params := &openapiutil.Params{
20263 Action: dara.String("ListWafRulesets"),
20264 Version: dara.String("2024-09-10"),
20265 Protocol: dara.String("HTTPS"),
20266 Pathname: dara.String("/"),
20267 Method: dara.String("POST"),
20268 AuthType: dara.String("AK"),
20269 Style: dara.String("RPC"),
20270 ReqBodyType: dara.String("formData"),
20271 BodyType: dara.String("json"),
20272 }
20273 _result = &ListWafRulesetsResponse{}
20274 _body, _err := client.CallApi(params, req, runtime)
20275 if _err != nil {
20276 return _result, _err
20277 }
20278 _err = dara.Convert(_body, &_result)
20279 return _result, _err
20280 }
20281
20282 // Summary:
20283 //
20284 // # List WAF Rule Sets
20285 //
20286 // @param request - ListWafRulesetsRequest
20287 //
20288 // @return ListWafRulesetsResponse
20289 func ListWafRulesets(client *Client, request *ListWafRulesetsRequest) (_result *ListWafRulesetsResponse, _err error) {
20290 runtime := &dara.RuntimeOptions{}
20291 _result = &ListWafRulesetsResponse{}
20292 _body, _err := ListWafRulesetsWithOptions(client,request, runtime)
20293 if _err != nil {
20294 return _result, _err
20295 }
20296 _result = _body
20297 return _result, _err
20298 }
20299
20300 // Summary:
20301 //
20302 // # List WAF Template Rules
20303 //
20304 // @param tmpReq - ListWafTemplateRulesRequest
20305 //
20306 // @param runtime - runtime options for this request RuntimeOptions
20307 //
20308 // @return ListWafTemplateRulesResponse
20309 func ListWafTemplateRulesWithOptions(client *Client, tmpReq *ListWafTemplateRulesRequest, runtime *dara.RuntimeOptions) (_result *ListWafTemplateRulesResponse, _err error) {
20310 if dara.BoolValue(client.EnableValidate) == true {
20311 _err = tmpReq.Validate()
20312 if _err != nil {
20313 return _result, _err
20314 }
20315 }
20316 request := &ListWafTemplateRulesShrinkRequest{}
20317 openapiutil.Convert(tmpReq, request)
20318 if !dara.IsNil(tmpReq.QueryArgs) {
20319 request.QueryArgsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.QueryArgs, dara.String("QueryArgs"), dara.String("json"))
20320 }
20321
20322 query := map[string]interface{}{}
20323 if !dara.IsNil(request.InstanceId) {
20324 query["InstanceId"] = request.InstanceId
20325 }
20326
20327 if !dara.IsNil(request.Phase) {
20328 query["Phase"] = request.Phase
20329 }
20330
20331 if !dara.IsNil(request.QueryArgsShrink) {
20332 query["QueryArgs"] = request.QueryArgsShrink
20333 }
20334
20335 if !dara.IsNil(request.SiteId) {
20336 query["SiteId"] = request.SiteId
20337 }
20338
20339 req := &openapiutil.OpenApiRequest{
20340 Query: openapiutil.Query(query),
20341 }
20342 params := &openapiutil.Params{
20343 Action: dara.String("ListWafTemplateRules"),
20344 Version: dara.String("2024-09-10"),
20345 Protocol: dara.String("HTTPS"),
20346 Pathname: dara.String("/"),
20347 Method: dara.String("POST"),
20348 AuthType: dara.String("AK"),
20349 Style: dara.String("RPC"),
20350 ReqBodyType: dara.String("formData"),
20351 BodyType: dara.String("json"),
20352 }
20353 _result = &ListWafTemplateRulesResponse{}
20354 _body, _err := client.CallApi(params, req, runtime)
20355 if _err != nil {
20356 return _result, _err
20357 }
20358 _err = dara.Convert(_body, &_result)
20359 return _result, _err
20360 }
20361
20362 // Summary:
20363 //
20364 // # List WAF Template Rules
20365 //
20366 // @param request - ListWafTemplateRulesRequest
20367 //
20368 // @return ListWafTemplateRulesResponse
20369 func ListWafTemplateRules(client *Client, request *ListWafTemplateRulesRequest) (_result *ListWafTemplateRulesResponse, _err error) {
20370 runtime := &dara.RuntimeOptions{}
20371 _result = &ListWafTemplateRulesResponse{}
20372 _body, _err := ListWafTemplateRulesWithOptions(client,request, runtime)
20373 if _err != nil {
20374 return _result, _err
20375 }
20376 _result = _body
20377 return _result, _err
20378 }
20379
20380 // Summary:
20381 //
20382 // # List WAF Rule Usage
20383 //
20384 // @param request - ListWafUsageOfRulesRequest
20385 //
20386 // @param runtime - runtime options for this request RuntimeOptions
20387 //
20388 // @return ListWafUsageOfRulesResponse
20389 func ListWafUsageOfRulesWithOptions(client *Client, request *ListWafUsageOfRulesRequest, runtime *dara.RuntimeOptions) (_result *ListWafUsageOfRulesResponse, _err error) {
20390 if dara.BoolValue(client.EnableValidate) == true {
20391 _err = request.Validate()
20392 if _err != nil {
20393 return _result, _err
20394 }
20395 }
20396 query := map[string]interface{}{}
20397 if !dara.IsNil(request.InstanceId) {
20398 query["InstanceId"] = request.InstanceId
20399 }
20400
20401 if !dara.IsNil(request.Phase) {
20402 query["Phase"] = request.Phase
20403 }
20404
20405 if !dara.IsNil(request.SiteId) {
20406 query["SiteId"] = request.SiteId
20407 }
20408
20409 req := &openapiutil.OpenApiRequest{
20410 Query: openapiutil.Query(query),
20411 }
20412 params := &openapiutil.Params{
20413 Action: dara.String("ListWafUsageOfRules"),
20414 Version: dara.String("2024-09-10"),
20415 Protocol: dara.String("HTTPS"),
20416 Pathname: dara.String("/"),
20417 Method: dara.String("POST"),
20418 AuthType: dara.String("AK"),
20419 Style: dara.String("RPC"),
20420 ReqBodyType: dara.String("formData"),
20421 BodyType: dara.String("json"),
20422 }
20423 _result = &ListWafUsageOfRulesResponse{}
20424 _body, _err := client.CallApi(params, req, runtime)
20425 if _err != nil {
20426 return _result, _err
20427 }
20428 _err = dara.Convert(_body, &_result)
20429 return _result, _err
20430 }
20431
20432 // Summary:
20433 //
20434 // # List WAF Rule Usage
20435 //
20436 // @param request - ListWafUsageOfRulesRequest
20437 //
20438 // @return ListWafUsageOfRulesResponse
20439 func ListWafUsageOfRules(client *Client, request *ListWafUsageOfRulesRequest) (_result *ListWafUsageOfRulesResponse, _err error) {
20440 runtime := &dara.RuntimeOptions{}
20441 _result = &ListWafUsageOfRulesResponse{}
20442 _body, _err := ListWafUsageOfRulesWithOptions(client,request, runtime)
20443 if _err != nil {
20444 return _result, _err
20445 }
20446 _result = _body
20447 return _result, _err
20448 }
20449
20450 // Summary:
20451 //
20452 // Queries the information about waiting room events for a waiting room.
20453 //
20454 // Description:
20455 //
20456 // You can call this operation to query details of all waiting room events related to a waiting room in a website.
20457 //
20458 // @param request - ListWaitingRoomEventsRequest
20459 //
20460 // @param runtime - runtime options for this request RuntimeOptions
20461 //
20462 // @return ListWaitingRoomEventsResponse
20463 func ListWaitingRoomEventsWithOptions(client *Client, request *ListWaitingRoomEventsRequest, runtime *dara.RuntimeOptions) (_result *ListWaitingRoomEventsResponse, _err error) {
20464 if dara.BoolValue(client.EnableValidate) == true {
20465 _err = request.Validate()
20466 if _err != nil {
20467 return _result, _err
20468 }
20469 }
20470 query := openapiutil.Query(dara.ToMap(request))
20471 req := &openapiutil.OpenApiRequest{
20472 Query: openapiutil.Query(query),
20473 }
20474 params := &openapiutil.Params{
20475 Action: dara.String("ListWaitingRoomEvents"),
20476 Version: dara.String("2024-09-10"),
20477 Protocol: dara.String("HTTPS"),
20478 Pathname: dara.String("/"),
20479 Method: dara.String("GET"),
20480 AuthType: dara.String("AK"),
20481 Style: dara.String("RPC"),
20482 ReqBodyType: dara.String("formData"),
20483 BodyType: dara.String("json"),
20484 }
20485 _result = &ListWaitingRoomEventsResponse{}
20486 _body, _err := client.CallApi(params, req, runtime)
20487 if _err != nil {
20488 return _result, _err
20489 }
20490 _err = dara.Convert(_body, &_result)
20491 return _result, _err
20492 }
20493
20494 // Summary:
20495 //
20496 // Queries the information about waiting room events for a waiting room.
20497 //
20498 // Description:
20499 //
20500 // You can call this operation to query details of all waiting room events related to a waiting room in a website.
20501 //
20502 // @param request - ListWaitingRoomEventsRequest
20503 //
20504 // @return ListWaitingRoomEventsResponse
20505 func ListWaitingRoomEvents(client *Client, request *ListWaitingRoomEventsRequest) (_result *ListWaitingRoomEventsResponse, _err error) {
20506 runtime := &dara.RuntimeOptions{}
20507 _result = &ListWaitingRoomEventsResponse{}
20508 _body, _err := ListWaitingRoomEventsWithOptions(client,request, runtime)
20509 if _err != nil {
20510 return _result, _err
20511 }
20512 _result = _body
20513 return _result, _err
20514 }
20515
20516 // Summary:
20517 //
20518 // # Query Waiting Room Bypass Rules
20519 //
20520 // Description:
20521 //
20522 // This API allows users to query the list of waiting room bypass rules associated with a specific site.
20523 //
20524 // @param request - ListWaitingRoomRulesRequest
20525 //
20526 // @param runtime - runtime options for this request RuntimeOptions
20527 //
20528 // @return ListWaitingRoomRulesResponse
20529 func ListWaitingRoomRulesWithOptions(client *Client, request *ListWaitingRoomRulesRequest, runtime *dara.RuntimeOptions) (_result *ListWaitingRoomRulesResponse, _err error) {
20530 if dara.BoolValue(client.EnableValidate) == true {
20531 _err = request.Validate()
20532 if _err != nil {
20533 return _result, _err
20534 }
20535 }
20536 query := openapiutil.Query(dara.ToMap(request))
20537 req := &openapiutil.OpenApiRequest{
20538 Query: openapiutil.Query(query),
20539 }
20540 params := &openapiutil.Params{
20541 Action: dara.String("ListWaitingRoomRules"),
20542 Version: dara.String("2024-09-10"),
20543 Protocol: dara.String("HTTPS"),
20544 Pathname: dara.String("/"),
20545 Method: dara.String("GET"),
20546 AuthType: dara.String("AK"),
20547 Style: dara.String("RPC"),
20548 ReqBodyType: dara.String("formData"),
20549 BodyType: dara.String("json"),
20550 }
20551 _result = &ListWaitingRoomRulesResponse{}
20552 _body, _err := client.CallApi(params, req, runtime)
20553 if _err != nil {
20554 return _result, _err
20555 }
20556 _err = dara.Convert(_body, &_result)
20557 return _result, _err
20558 }
20559
20560 // Summary:
20561 //
20562 // # Query Waiting Room Bypass Rules
20563 //
20564 // Description:
20565 //
20566 // This API allows users to query the list of waiting room bypass rules associated with a specific site.
20567 //
20568 // @param request - ListWaitingRoomRulesRequest
20569 //
20570 // @return ListWaitingRoomRulesResponse
20571 func ListWaitingRoomRules(client *Client, request *ListWaitingRoomRulesRequest) (_result *ListWaitingRoomRulesResponse, _err error) {
20572 runtime := &dara.RuntimeOptions{}
20573 _result = &ListWaitingRoomRulesResponse{}
20574 _body, _err := ListWaitingRoomRulesWithOptions(client,request, runtime)
20575 if _err != nil {
20576 return _result, _err
20577 }
20578 _result = _body
20579 return _result, _err
20580 }
20581
20582 // Summary:
20583 //
20584 // Queries the information about all waiting rooms in a website.
20585 //
20586 // Description:
20587 //
20588 // 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.
20589 //
20590 // @param request - ListWaitingRoomsRequest
20591 //
20592 // @param runtime - runtime options for this request RuntimeOptions
20593 //
20594 // @return ListWaitingRoomsResponse
20595 func ListWaitingRoomsWithOptions(client *Client, request *ListWaitingRoomsRequest, runtime *dara.RuntimeOptions) (_result *ListWaitingRoomsResponse, _err error) {
20596 if dara.BoolValue(client.EnableValidate) == true {
20597 _err = request.Validate()
20598 if _err != nil {
20599 return _result, _err
20600 }
20601 }
20602 query := openapiutil.Query(dara.ToMap(request))
20603 req := &openapiutil.OpenApiRequest{
20604 Query: openapiutil.Query(query),
20605 }
20606 params := &openapiutil.Params{
20607 Action: dara.String("ListWaitingRooms"),
20608 Version: dara.String("2024-09-10"),
20609 Protocol: dara.String("HTTPS"),
20610 Pathname: dara.String("/"),
20611 Method: dara.String("GET"),
20612 AuthType: dara.String("AK"),
20613 Style: dara.String("RPC"),
20614 ReqBodyType: dara.String("formData"),
20615 BodyType: dara.String("json"),
20616 }
20617 _result = &ListWaitingRoomsResponse{}
20618 _body, _err := client.CallApi(params, req, runtime)
20619 if _err != nil {
20620 return _result, _err
20621 }
20622 _err = dara.Convert(_body, &_result)
20623 return _result, _err
20624 }
20625
20626 // Summary:
20627 //
20628 // Queries the information about all waiting rooms in a website.
20629 //
20630 // Description:
20631 //
20632 // 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.
20633 //
20634 // @param request - ListWaitingRoomsRequest
20635 //
20636 // @return ListWaitingRoomsResponse
20637 func ListWaitingRooms(client *Client, request *ListWaitingRoomsRequest) (_result *ListWaitingRoomsResponse, _err error) {
20638 runtime := &dara.RuntimeOptions{}
20639 _result = &ListWaitingRoomsResponse{}
20640 _body, _err := ListWaitingRoomsWithOptions(client,request, runtime)
20641 if _err != nil {
20642 return _result, _err
20643 }
20644 _result = _body
20645 return _result, _err
20646 }
20647
20648 // Summary:
20649 //
20650 // # OpenErService
20651 //
20652 // @param request - OpenErServiceRequest
20653 //
20654 // @param runtime - runtime options for this request RuntimeOptions
20655 //
20656 // @return OpenErServiceResponse
20657 func OpenErServiceWithOptions(client *Client, request *OpenErServiceRequest, runtime *dara.RuntimeOptions) (_result *OpenErServiceResponse, _err error) {
20658 if dara.BoolValue(client.EnableValidate) == true {
20659 _err = request.Validate()
20660 if _err != nil {
20661 return _result, _err
20662 }
20663 }
20664 query := map[string]interface{}{}
20665 if !dara.IsNil(request.OwnerId) {
20666 query["OwnerId"] = request.OwnerId
20667 }
20668
20669 if !dara.IsNil(request.SecurityToken) {
20670 query["SecurityToken"] = request.SecurityToken
20671 }
20672
20673 req := &openapiutil.OpenApiRequest{
20674 Query: openapiutil.Query(query),
20675 }
20676 params := &openapiutil.Params{
20677 Action: dara.String("OpenErService"),
20678 Version: dara.String("2024-09-10"),
20679 Protocol: dara.String("HTTPS"),
20680 Pathname: dara.String("/"),
20681 Method: dara.String("POST"),
20682 AuthType: dara.String("AK"),
20683 Style: dara.String("RPC"),
20684 ReqBodyType: dara.String("formData"),
20685 BodyType: dara.String("json"),
20686 }
20687 _result = &OpenErServiceResponse{}
20688 _body, _err := client.CallApi(params, req, runtime)
20689 if _err != nil {
20690 return _result, _err
20691 }
20692 _err = dara.Convert(_body, &_result)
20693 return _result, _err
20694 }
20695
20696 // Summary:
20697 //
20698 // # OpenErService
20699 //
20700 // @param request - OpenErServiceRequest
20701 //
20702 // @return OpenErServiceResponse
20703 func OpenErService(client *Client, request *OpenErServiceRequest) (_result *OpenErServiceResponse, _err error) {
20704 runtime := &dara.RuntimeOptions{}
20705 _result = &OpenErServiceResponse{}
20706 _body, _err := OpenErServiceWithOptions(client,request, runtime)
20707 if _err != nil {
20708 return _result, _err
20709 }
20710 _result = _body
20711 return _result, _err
20712 }
20713
20714 // Summary:
20715 //
20716 // Prefetches cache.
20717 //
20718 // @param tmpReq - PreloadCachesRequest
20719 //
20720 // @param runtime - runtime options for this request RuntimeOptions
20721 //
20722 // @return PreloadCachesResponse
20723 func PreloadCachesWithOptions(client *Client, tmpReq *PreloadCachesRequest, runtime *dara.RuntimeOptions) (_result *PreloadCachesResponse, _err error) {
20724 if dara.BoolValue(client.EnableValidate) == true {
20725 _err = tmpReq.Validate()
20726 if _err != nil {
20727 return _result, _err
20728 }
20729 }
20730 request := &PreloadCachesShrinkRequest{}
20731 openapiutil.Convert(tmpReq, request)
20732 if !dara.IsNil(tmpReq.Content) {
20733 request.ContentShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Content, dara.String("Content"), dara.String("json"))
20734 }
20735
20736 if !dara.IsNil(tmpReq.Headers) {
20737 request.HeadersShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Headers, dara.String("Headers"), dara.String("json"))
20738 }
20739
20740 query := map[string]interface{}{}
20741 if !dara.IsNil(request.ContentShrink) {
20742 query["Content"] = request.ContentShrink
20743 }
20744
20745 if !dara.IsNil(request.HeadersShrink) {
20746 query["Headers"] = request.HeadersShrink
20747 }
20748
20749 if !dara.IsNil(request.SiteId) {
20750 query["SiteId"] = request.SiteId
20751 }
20752
20753 req := &openapiutil.OpenApiRequest{
20754 Query: openapiutil.Query(query),
20755 }
20756 params := &openapiutil.Params{
20757 Action: dara.String("PreloadCaches"),
20758 Version: dara.String("2024-09-10"),
20759 Protocol: dara.String("HTTPS"),
20760 Pathname: dara.String("/"),
20761 Method: dara.String("POST"),
20762 AuthType: dara.String("AK"),
20763 Style: dara.String("RPC"),
20764 ReqBodyType: dara.String("formData"),
20765 BodyType: dara.String("json"),
20766 }
20767 _result = &PreloadCachesResponse{}
20768 _body, _err := client.CallApi(params, req, runtime)
20769 if _err != nil {
20770 return _result, _err
20771 }
20772 _err = dara.Convert(_body, &_result)
20773 return _result, _err
20774 }
20775
20776 // Summary:
20777 //
20778 // Prefetches cache.
20779 //
20780 // @param request - PreloadCachesRequest
20781 //
20782 // @return PreloadCachesResponse
20783 func PreloadCaches(client *Client, request *PreloadCachesRequest) (_result *PreloadCachesResponse, _err error) {
20784 runtime := &dara.RuntimeOptions{}
20785 _result = &PreloadCachesResponse{}
20786 _body, _err := PreloadCachesWithOptions(client,request, runtime)
20787 if _err != nil {
20788 return _result, _err
20789 }
20790 _result = _body
20791 return _result, _err
20792 }
20793
20794 // Summary:
20795 //
20796 // Releases a specific version of a containerized application. You can call this operation to iterate an application.
20797 //
20798 // @param tmpReq - PublishEdgeContainerAppVersionRequest
20799 //
20800 // @param runtime - runtime options for this request RuntimeOptions
20801 //
20802 // @return PublishEdgeContainerAppVersionResponse
20803 func PublishEdgeContainerAppVersionWithOptions(client *Client, tmpReq *PublishEdgeContainerAppVersionRequest, runtime *dara.RuntimeOptions) (_result *PublishEdgeContainerAppVersionResponse, _err error) {
20804 if dara.BoolValue(client.EnableValidate) == true {
20805 _err = tmpReq.Validate()
20806 if _err != nil {
20807 return _result, _err
20808 }
20809 }
20810 request := &PublishEdgeContainerAppVersionShrinkRequest{}
20811 openapiutil.Convert(tmpReq, request)
20812 if !dara.IsNil(tmpReq.Regions) {
20813 request.RegionsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Regions, dara.String("Regions"), dara.String("json"))
20814 }
20815
20816 query := map[string]interface{}{}
20817 if !dara.IsNil(request.FullRelease) {
20818 query["FullRelease"] = request.FullRelease
20819 }
20820
20821 if !dara.IsNil(request.PublishType) {
20822 query["PublishType"] = request.PublishType
20823 }
20824
20825 if !dara.IsNil(request.RegionsShrink) {
20826 query["Regions"] = request.RegionsShrink
20827 }
20828
20829 if !dara.IsNil(request.VersionId) {
20830 query["VersionId"] = request.VersionId
20831 }
20832
20833 body := map[string]interface{}{}
20834 if !dara.IsNil(request.AppId) {
20835 body["AppId"] = request.AppId
20836 }
20837
20838 if !dara.IsNil(request.Percentage) {
20839 body["Percentage"] = request.Percentage
20840 }
20841
20842 if !dara.IsNil(request.PublishEnv) {
20843 body["PublishEnv"] = request.PublishEnv
20844 }
20845
20846 if !dara.IsNil(request.Remarks) {
20847 body["Remarks"] = request.Remarks
20848 }
20849
20850 if !dara.IsNil(request.StartTime) {
20851 body["StartTime"] = request.StartTime
20852 }
20853
20854 req := &openapiutil.OpenApiRequest{
20855 Query: openapiutil.Query(query),
20856 Body: openapiutil.ParseToMap(body),
20857 }
20858 params := &openapiutil.Params{
20859 Action: dara.String("PublishEdgeContainerAppVersion"),
20860 Version: dara.String("2024-09-10"),
20861 Protocol: dara.String("HTTPS"),
20862 Pathname: dara.String("/"),
20863 Method: dara.String("POST"),
20864 AuthType: dara.String("AK"),
20865 Style: dara.String("RPC"),
20866 ReqBodyType: dara.String("formData"),
20867 BodyType: dara.String("json"),
20868 }
20869 _result = &PublishEdgeContainerAppVersionResponse{}
20870 _body, _err := client.CallApi(params, req, runtime)
20871 if _err != nil {
20872 return _result, _err
20873 }
20874 _err = dara.Convert(_body, &_result)
20875 return _result, _err
20876 }
20877
20878 // Summary:
20879 //
20880 // Releases a specific version of a containerized application. You can call this operation to iterate an application.
20881 //
20882 // @param request - PublishEdgeContainerAppVersionRequest
20883 //
20884 // @return PublishEdgeContainerAppVersionResponse
20885 func PublishEdgeContainerAppVersion(client *Client, request *PublishEdgeContainerAppVersionRequest) (_result *PublishEdgeContainerAppVersionResponse, _err error) {
20886 runtime := &dara.RuntimeOptions{}
20887 _result = &PublishEdgeContainerAppVersionResponse{}
20888 _body, _err := PublishEdgeContainerAppVersionWithOptions(client,request, runtime)
20889 if _err != nil {
20890 return _result, _err
20891 }
20892 _result = _body
20893 return _result, _err
20894 }
20895
20896 // Summary:
20897 //
20898 // 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.
20899 //
20900 // @param request - PublishRoutineCodeVersionRequest
20901 //
20902 // @param runtime - runtime options for this request RuntimeOptions
20903 //
20904 // @return PublishRoutineCodeVersionResponse
20905 func PublishRoutineCodeVersionWithOptions(client *Client, request *PublishRoutineCodeVersionRequest, runtime *dara.RuntimeOptions) (_result *PublishRoutineCodeVersionResponse, _err error) {
20906 if dara.BoolValue(client.EnableValidate) == true {
20907 _err = request.Validate()
20908 if _err != nil {
20909 return _result, _err
20910 }
20911 }
20912 body := map[string]interface{}{}
20913 if !dara.IsNil(request.CodeVersion) {
20914 body["CodeVersion"] = request.CodeVersion
20915 }
20916
20917 if !dara.IsNil(request.Env) {
20918 body["Env"] = request.Env
20919 }
20920
20921 if !dara.IsNil(request.Name) {
20922 body["Name"] = request.Name
20923 }
20924
20925 req := &openapiutil.OpenApiRequest{
20926 Body: openapiutil.ParseToMap(body),
20927 }
20928 params := &openapiutil.Params{
20929 Action: dara.String("PublishRoutineCodeVersion"),
20930 Version: dara.String("2024-09-10"),
20931 Protocol: dara.String("HTTPS"),
20932 Pathname: dara.String("/"),
20933 Method: dara.String("POST"),
20934 AuthType: dara.String("AK"),
20935 Style: dara.String("RPC"),
20936 ReqBodyType: dara.String("formData"),
20937 BodyType: dara.String("json"),
20938 }
20939 _result = &PublishRoutineCodeVersionResponse{}
20940 _body, _err := client.CallApi(params, req, runtime)
20941 if _err != nil {
20942 return _result, _err
20943 }
20944 _err = dara.Convert(_body, &_result)
20945 return _result, _err
20946 }
20947
20948 // Summary:
20949 //
20950 // 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.
20951 //
20952 // @param request - PublishRoutineCodeVersionRequest
20953 //
20954 // @return PublishRoutineCodeVersionResponse
20955 func PublishRoutineCodeVersion(client *Client, request *PublishRoutineCodeVersionRequest) (_result *PublishRoutineCodeVersionResponse, _err error) {
20956 runtime := &dara.RuntimeOptions{}
20957 _result = &PublishRoutineCodeVersionResponse{}
20958 _body, _err := PublishRoutineCodeVersionWithOptions(client,request, runtime)
20959 if _err != nil {
20960 return _result, _err
20961 }
20962 _result = _body
20963 return _result, _err
20964 }
20965
20966 // Summary:
20967 //
20968 // # New Purchase of Cache Retention
20969 //
20970 // @param request - PurchaseCacheReserveRequest
20971 //
20972 // @param runtime - runtime options for this request RuntimeOptions
20973 //
20974 // @return PurchaseCacheReserveResponse
20975 func PurchaseCacheReserveWithOptions(client *Client, request *PurchaseCacheReserveRequest, runtime *dara.RuntimeOptions) (_result *PurchaseCacheReserveResponse, _err error) {
20976 if dara.BoolValue(client.EnableValidate) == true {
20977 _err = request.Validate()
20978 if _err != nil {
20979 return _result, _err
20980 }
20981 }
20982 query := map[string]interface{}{}
20983 if !dara.IsNil(request.AutoPay) {
20984 query["AutoPay"] = request.AutoPay
20985 }
20986
20987 if !dara.IsNil(request.AutoRenew) {
20988 query["AutoRenew"] = request.AutoRenew
20989 }
20990
20991 if !dara.IsNil(request.ChargeType) {
20992 query["ChargeType"] = request.ChargeType
20993 }
20994
20995 if !dara.IsNil(request.CrRegion) {
20996 query["CrRegion"] = request.CrRegion
20997 }
20998
20999 if !dara.IsNil(request.Period) {
21000 query["Period"] = request.Period
21001 }
21002
21003 if !dara.IsNil(request.QuotaGb) {
21004 query["QuotaGb"] = request.QuotaGb
21005 }
21006
21007 req := &openapiutil.OpenApiRequest{
21008 Query: openapiutil.Query(query),
21009 }
21010 params := &openapiutil.Params{
21011 Action: dara.String("PurchaseCacheReserve"),
21012 Version: dara.String("2024-09-10"),
21013 Protocol: dara.String("HTTPS"),
21014 Pathname: dara.String("/"),
21015 Method: dara.String("POST"),
21016 AuthType: dara.String("AK"),
21017 Style: dara.String("RPC"),
21018 ReqBodyType: dara.String("formData"),
21019 BodyType: dara.String("json"),
21020 }
21021 _result = &PurchaseCacheReserveResponse{}
21022 _body, _err := client.CallApi(params, req, runtime)
21023 if _err != nil {
21024 return _result, _err
21025 }
21026 _err = dara.Convert(_body, &_result)
21027 return _result, _err
21028 }
21029
21030 // Summary:
21031 //
21032 // # New Purchase of Cache Retention
21033 //
21034 // @param request - PurchaseCacheReserveRequest
21035 //
21036 // @return PurchaseCacheReserveResponse
21037 func PurchaseCacheReserve(client *Client, request *PurchaseCacheReserveRequest) (_result *PurchaseCacheReserveResponse, _err error) {
21038 runtime := &dara.RuntimeOptions{}
21039 _result = &PurchaseCacheReserveResponse{}
21040 _body, _err := PurchaseCacheReserveWithOptions(client,request, runtime)
21041 if _err != nil {
21042 return _result, _err
21043 }
21044 _result = _body
21045 return _result, _err
21046 }
21047
21048 // Summary:
21049 //
21050 // # Purchase New Package
21051 //
21052 // Description:
21053 //
21054 // 1. The package name and code can be obtained from the DescribeRatePlanPrice interface.
21055 //
21056 // 2. If the acceleration area is not overseas, the site must have successfully completed the filing process.
21057 //
21058 // @param request - PurchaseRatePlanRequest
21059 //
21060 // @param runtime - runtime options for this request RuntimeOptions
21061 //
21062 // @return PurchaseRatePlanResponse
21063 func PurchaseRatePlanWithOptions(client *Client, request *PurchaseRatePlanRequest, runtime *dara.RuntimeOptions) (_result *PurchaseRatePlanResponse, _err error) {
21064 if dara.BoolValue(client.EnableValidate) == true {
21065 _err = request.Validate()
21066 if _err != nil {
21067 return _result, _err
21068 }
21069 }
21070 query := map[string]interface{}{}
21071 if !dara.IsNil(request.Amount) {
21072 query["Amount"] = request.Amount
21073 }
21074
21075 if !dara.IsNil(request.AutoPay) {
21076 query["AutoPay"] = request.AutoPay
21077 }
21078
21079 if !dara.IsNil(request.AutoRenew) {
21080 query["AutoRenew"] = request.AutoRenew
21081 }
21082
21083 if !dara.IsNil(request.Channel) {
21084 query["Channel"] = request.Channel
21085 }
21086
21087 if !dara.IsNil(request.ChargeType) {
21088 query["ChargeType"] = request.ChargeType
21089 }
21090
21091 if !dara.IsNil(request.Coverage) {
21092 query["Coverage"] = request.Coverage
21093 }
21094
21095 if !dara.IsNil(request.Period) {
21096 query["Period"] = request.Period
21097 }
21098
21099 if !dara.IsNil(request.PlanCode) {
21100 query["PlanCode"] = request.PlanCode
21101 }
21102
21103 if !dara.IsNil(request.PlanName) {
21104 query["PlanName"] = request.PlanName
21105 }
21106
21107 if !dara.IsNil(request.SiteName) {
21108 query["SiteName"] = request.SiteName
21109 }
21110
21111 if !dara.IsNil(request.Type) {
21112 query["Type"] = request.Type
21113 }
21114
21115 req := &openapiutil.OpenApiRequest{
21116 Query: openapiutil.Query(query),
21117 }
21118 params := &openapiutil.Params{
21119 Action: dara.String("PurchaseRatePlan"),
21120 Version: dara.String("2024-09-10"),
21121 Protocol: dara.String("HTTPS"),
21122 Pathname: dara.String("/"),
21123 Method: dara.String("POST"),
21124 AuthType: dara.String("AK"),
21125 Style: dara.String("RPC"),
21126 ReqBodyType: dara.String("formData"),
21127 BodyType: dara.String("json"),
21128 }
21129 _result = &PurchaseRatePlanResponse{}
21130 _body, _err := client.CallApi(params, req, runtime)
21131 if _err != nil {
21132 return _result, _err
21133 }
21134 _err = dara.Convert(_body, &_result)
21135 return _result, _err
21136 }
21137
21138 // Summary:
21139 //
21140 // # Purchase New Package
21141 //
21142 // Description:
21143 //
21144 // 1. The package name and code can be obtained from the DescribeRatePlanPrice interface.
21145 //
21146 // 2. If the acceleration area is not overseas, the site must have successfully completed the filing process.
21147 //
21148 // @param request - PurchaseRatePlanRequest
21149 //
21150 // @return PurchaseRatePlanResponse
21151 func PurchaseRatePlan(client *Client, request *PurchaseRatePlanRequest) (_result *PurchaseRatePlanResponse, _err error) {
21152 runtime := &dara.RuntimeOptions{}
21153 _result = &PurchaseRatePlanResponse{}
21154 _body, _err := PurchaseRatePlanWithOptions(client,request, runtime)
21155 if _err != nil {
21156 return _result, _err
21157 }
21158 _result = _body
21159 return _result, _err
21160 }
21161
21162 // Summary:
21163 //
21164 // # Cache Refresh
21165 //
21166 // @param tmpReq - PurgeCachesRequest
21167 //
21168 // @param runtime - runtime options for this request RuntimeOptions
21169 //
21170 // @return PurgeCachesResponse
21171 func PurgeCachesWithOptions(client *Client, tmpReq *PurgeCachesRequest, runtime *dara.RuntimeOptions) (_result *PurgeCachesResponse, _err error) {
21172 if dara.BoolValue(client.EnableValidate) == true {
21173 _err = tmpReq.Validate()
21174 if _err != nil {
21175 return _result, _err
21176 }
21177 }
21178 request := &PurgeCachesShrinkRequest{}
21179 openapiutil.Convert(tmpReq, request)
21180 if !dara.IsNil(tmpReq.Content) {
21181 request.ContentShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Content, dara.String("Content"), dara.String("json"))
21182 }
21183
21184 query := map[string]interface{}{}
21185 if !dara.IsNil(request.ContentShrink) {
21186 query["Content"] = request.ContentShrink
21187 }
21188
21189 if !dara.IsNil(request.EdgeComputePurge) {
21190 query["EdgeComputePurge"] = request.EdgeComputePurge
21191 }
21192
21193 if !dara.IsNil(request.Force) {
21194 query["Force"] = request.Force
21195 }
21196
21197 if !dara.IsNil(request.SiteId) {
21198 query["SiteId"] = request.SiteId
21199 }
21200
21201 if !dara.IsNil(request.Type) {
21202 query["Type"] = request.Type
21203 }
21204
21205 req := &openapiutil.OpenApiRequest{
21206 Query: openapiutil.Query(query),
21207 }
21208 params := &openapiutil.Params{
21209 Action: dara.String("PurgeCaches"),
21210 Version: dara.String("2024-09-10"),
21211 Protocol: dara.String("HTTPS"),
21212 Pathname: dara.String("/"),
21213 Method: dara.String("POST"),
21214 AuthType: dara.String("AK"),
21215 Style: dara.String("RPC"),
21216 ReqBodyType: dara.String("formData"),
21217 BodyType: dara.String("json"),
21218 }
21219 _result = &PurgeCachesResponse{}
21220 _body, _err := client.CallApi(params, req, runtime)
21221 if _err != nil {
21222 return _result, _err
21223 }
21224 _err = dara.Convert(_body, &_result)
21225 return _result, _err
21226 }
21227
21228 // Summary:
21229 //
21230 // # Cache Refresh
21231 //
21232 // @param request - PurgeCachesRequest
21233 //
21234 // @return PurgeCachesResponse
21235 func PurgeCaches(client *Client, request *PurgeCachesRequest) (_result *PurgeCachesResponse, _err error) {
21236 runtime := &dara.RuntimeOptions{}
21237 _result = &PurgeCachesResponse{}
21238 _body, _err := PurgeCachesWithOptions(client,request, runtime)
21239 if _err != nil {
21240 return _result, _err
21241 }
21242 _result = _body
21243 return _result, _err
21244 }
21245
21246 // Summary:
21247 //
21248 // Configures a key-value pair for a namespace. The request body can be up to 2 MB.
21249 //
21250 // @param request - PutKvRequest
21251 //
21252 // @param runtime - runtime options for this request RuntimeOptions
21253 //
21254 // @return PutKvResponse
21255 func PutKvWithOptions(client *Client, request *PutKvRequest, runtime *dara.RuntimeOptions) (_result *PutKvResponse, _err error) {
21256 if dara.BoolValue(client.EnableValidate) == true {
21257 _err = request.Validate()
21258 if _err != nil {
21259 return _result, _err
21260 }
21261 }
21262 query := map[string]interface{}{}
21263 if !dara.IsNil(request.Base64) {
21264 query["Base64"] = request.Base64
21265 }
21266
21267 if !dara.IsNil(request.Expiration) {
21268 query["Expiration"] = request.Expiration
21269 }
21270
21271 if !dara.IsNil(request.ExpirationTtl) {
21272 query["ExpirationTtl"] = request.ExpirationTtl
21273 }
21274
21275 if !dara.IsNil(request.Key) {
21276 query["Key"] = request.Key
21277 }
21278
21279 if !dara.IsNil(request.Namespace) {
21280 query["Namespace"] = request.Namespace
21281 }
21282
21283 body := map[string]interface{}{}
21284 if !dara.IsNil(request.Value) {
21285 body["Value"] = request.Value
21286 }
21287
21288 req := &openapiutil.OpenApiRequest{
21289 Query: openapiutil.Query(query),
21290 Body: openapiutil.ParseToMap(body),
21291 }
21292 params := &openapiutil.Params{
21293 Action: dara.String("PutKv"),
21294 Version: dara.String("2024-09-10"),
21295 Protocol: dara.String("HTTPS"),
21296 Pathname: dara.String("/"),
21297 Method: dara.String("POST"),
21298 AuthType: dara.String("AK"),
21299 Style: dara.String("RPC"),
21300 ReqBodyType: dara.String("formData"),
21301 BodyType: dara.String("json"),
21302 }
21303 _result = &PutKvResponse{}
21304 _body, _err := client.CallApi(params, req, runtime)
21305 if _err != nil {
21306 return _result, _err
21307 }
21308 _err = dara.Convert(_body, &_result)
21309 return _result, _err
21310 }
21311
21312 // Summary:
21313 //
21314 // Configures a key-value pair for a namespace. The request body can be up to 2 MB.
21315 //
21316 // @param request - PutKvRequest
21317 //
21318 // @return PutKvResponse
21319 func PutKv(client *Client, request *PutKvRequest) (_result *PutKvResponse, _err error) {
21320 runtime := &dara.RuntimeOptions{}
21321 _result = &PutKvResponse{}
21322 _body, _err := PutKvWithOptions(client,request, runtime)
21323 if _err != nil {
21324 return _result, _err
21325 }
21326 _result = _body
21327 return _result, _err
21328 }
21329
21330 // Summary:
21331 //
21332 // Configures a large key-value pair for a namespace. The request body can be up to 25 MB.
21333 //
21334 // Description:
21335 //
21336 // 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.
21337 //
21338 // func TestPutKvWithHighCapacity() {
21339 //
21340 // // Initialize the configurations.
21341 //
21342 // cfg := new(openapi.Config)
21343 //
21344 // cfg.SetAccessKeyId("xxxxxxxxx")
21345 //
21346 // cfg.SetAccessKeySecret("xxxxxxxxxx")
21347 //
21348 // cli, err := NewClient(cfg)
21349 //
21350 // if err != nil {
21351 //
21352 // return err
21353 //
21354 // }
21355 //
21356 // runtime := &util.RuntimeOptions{}
21357 //
21358 // // Construct a request for uploading key-value pairs.
21359 //
21360 // namespace := "test-put-kv"
21361 //
21362 // key := "test_PutKvWithHighCapacity_0"
21363 //
21364 // value := strings.Repeat("t", 10*1024*1024)
21365 //
21366 // rawReq := &PutKvRequest{
21367 //
21368 // Namespace: &namespace,
21369 //
21370 // Key: &key,
21371 //
21372 // Value: &value,
21373 //
21374 // }
21375 //
21376 // payload, err := json.Marshal(rawReq)
21377 //
21378 // if err != nil {
21379 //
21380 // return err
21381 //
21382 // }
21383 //
21384 // // If the payload is greater than 2 MB, call the PutKvWithHighCapacity operation for upload.
21385 //
21386 // reqHighCapacity := &PutKvWithHighCapacityAdvanceRequest{
21387 //
21388 // Namespace: &namespace,
21389 //
21390 // Key: &key,
21391 //
21392 // UrlObject: bytes.NewReader([]byte(payload)),
21393 //
21394 // }
21395 //
21396 // resp, err := cli.PutKvWithHighCapacityAdvance(reqHighCapacity, runtime)
21397 //
21398 // if err != nil {
21399 //
21400 // return err
21401 //
21402 // }
21403 //
21404 // return nil
21405 //
21406 // }
21407 //
21408 // @param request - PutKvWithHighCapacityRequest
21409 //
21410 // @param runtime - runtime options for this request RuntimeOptions
21411 //
21412 // @return PutKvWithHighCapacityResponse
21413 func PutKvWithHighCapacityWithOptions(client *Client, request *PutKvWithHighCapacityRequest, runtime *dara.RuntimeOptions) (_result *PutKvWithHighCapacityResponse, _err error) {
21414 if dara.BoolValue(client.EnableValidate) == true {
21415 _err = request.Validate()
21416 if _err != nil {
21417 return _result, _err
21418 }
21419 }
21420 query := map[string]interface{}{}
21421 if !dara.IsNil(request.Key) {
21422 query["Key"] = request.Key
21423 }
21424
21425 if !dara.IsNil(request.Namespace) {
21426 query["Namespace"] = request.Namespace
21427 }
21428
21429 if !dara.IsNil(request.Url) {
21430 query["Url"] = request.Url
21431 }
21432
21433 req := &openapiutil.OpenApiRequest{
21434 Query: openapiutil.Query(query),
21435 }
21436 params := &openapiutil.Params{
21437 Action: dara.String("PutKvWithHighCapacity"),
21438 Version: dara.String("2024-09-10"),
21439 Protocol: dara.String("HTTPS"),
21440 Pathname: dara.String("/"),
21441 Method: dara.String("POST"),
21442 AuthType: dara.String("AK"),
21443 Style: dara.String("RPC"),
21444 ReqBodyType: dara.String("formData"),
21445 BodyType: dara.String("json"),
21446 }
21447 _result = &PutKvWithHighCapacityResponse{}
21448 _body, _err := client.CallApi(params, req, runtime)
21449 if _err != nil {
21450 return _result, _err
21451 }
21452 _err = dara.Convert(_body, &_result)
21453 return _result, _err
21454 }
21455
21456 // Summary:
21457 //
21458 // Configures a large key-value pair for a namespace. The request body can be up to 25 MB.
21459 //
21460 // Description:
21461 //
21462 // 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.
21463 //
21464 // func TestPutKvWithHighCapacity() {
21465 //
21466 // // Initialize the configurations.
21467 //
21468 // cfg := new(openapi.Config)
21469 //
21470 // cfg.SetAccessKeyId("xxxxxxxxx")
21471 //
21472 // cfg.SetAccessKeySecret("xxxxxxxxxx")
21473 //
21474 // cli, err := NewClient(cfg)
21475 //
21476 // if err != nil {
21477 //
21478 // return err
21479 //
21480 // }
21481 //
21482 // runtime := &util.RuntimeOptions{}
21483 //
21484 // // Construct a request for uploading key-value pairs.
21485 //
21486 // namespace := "test-put-kv"
21487 //
21488 // key := "test_PutKvWithHighCapacity_0"
21489 //
21490 // value := strings.Repeat("t", 10*1024*1024)
21491 //
21492 // rawReq := &PutKvRequest{
21493 //
21494 // Namespace: &namespace,
21495 //
21496 // Key: &key,
21497 //
21498 // Value: &value,
21499 //
21500 // }
21501 //
21502 // payload, err := json.Marshal(rawReq)
21503 //
21504 // if err != nil {
21505 //
21506 // return err
21507 //
21508 // }
21509 //
21510 // // If the payload is greater than 2 MB, call the PutKvWithHighCapacity operation for upload.
21511 //
21512 // reqHighCapacity := &PutKvWithHighCapacityAdvanceRequest{
21513 //
21514 // Namespace: &namespace,
21515 //
21516 // Key: &key,
21517 //
21518 // UrlObject: bytes.NewReader([]byte(payload)),
21519 //
21520 // }
21521 //
21522 // resp, err := cli.PutKvWithHighCapacityAdvance(reqHighCapacity, runtime)
21523 //
21524 // if err != nil {
21525 //
21526 // return err
21527 //
21528 // }
21529 //
21530 // return nil
21531 //
21532 // }
21533 //
21534 // @param request - PutKvWithHighCapacityRequest
21535 //
21536 // @return PutKvWithHighCapacityResponse
21537 func PutKvWithHighCapacity(client *Client, request *PutKvWithHighCapacityRequest) (_result *PutKvWithHighCapacityResponse, _err error) {
21538 runtime := &dara.RuntimeOptions{}
21539 _result = &PutKvWithHighCapacityResponse{}
21540 _body, _err := PutKvWithHighCapacityWithOptions(client,request, runtime)
21541 if _err != nil {
21542 return _result, _err
21543 }
21544 _result = _body
21545 return _result, _err
21546 }
21547
21548 func PutKvWithHighCapacityAdvance(client *Client, request *PutKvWithHighCapacityAdvanceRequest, runtime *dara.RuntimeOptions) (_result *PutKvWithHighCapacityResponse, _err error) {
21549 // Step 0: init client
21550 if dara.IsNil(client.Credential) {
21551 _err = &openapi.ClientError{
21552 Code: dara.String("InvalidCredentials"),
21553 Message: dara.String("Please set up the credentials correctly. If you are setting them through environment variables, please ensure that ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set correctly. See https://help.aliyun.com/zh/sdk/developer-reference/configure-the-alibaba-cloud-accesskey-environment-variable-on-linux-macos-and-windows-systems for more details."),
21554 }
21555 return _result, _err
21556 }
21557
21558 credentialModel, _err := client.Credential.GetCredential()
21559 if _err != nil {
21560 return _result, _err
21561 }
21562
21563 accessKeyId := dara.StringValue(credentialModel.AccessKeyId)
21564 accessKeySecret := dara.StringValue(credentialModel.AccessKeySecret)
21565 securityToken := dara.StringValue(credentialModel.SecurityToken)
21566 credentialType := dara.StringValue(credentialModel.Type)
21567 openPlatformEndpoint := dara.StringValue(client.OpenPlatformEndpoint)
21568 if dara.IsNil(dara.String(openPlatformEndpoint)) || openPlatformEndpoint == "" {
21569 openPlatformEndpoint = "openplatform.aliyuncs.com"
21570 }
21571
21572 if dara.IsNil(dara.String(credentialType)) {
21573 credentialType = "access_key"
21574 }
21575
21576 authConfig := &openapiutil.Config{
21577 AccessKeyId: dara.String(accessKeyId),
21578 AccessKeySecret: dara.String(accessKeySecret),
21579 SecurityToken: dara.String(securityToken),
21580 Type: dara.String(credentialType),
21581 Endpoint: dara.String(openPlatformEndpoint),
21582 Protocol: client.Protocol,
21583 RegionId: client.RegionId,
21584 }
21585 authClient, _err := openapi.NewClient(authConfig)
21586 if _err != nil {
21587 return _result, _err
21588 }
21589
21590 authRequest := map[string]*string{
21591 "Product": dara.String("ESA"),
21592 "RegionId": client.RegionId,
21593 }
21594 authReq := &openapiutil.OpenApiRequest{
21595 Query: openapiutil.Query(authRequest),
21596 }
21597 authParams := &openapiutil.Params{
21598 Action: dara.String("AuthorizeFileUpload"),
21599 Version: dara.String("2019-12-19"),
21600 Protocol: dara.String("HTTPS"),
21601 Pathname: dara.String("/"),
21602 Method: dara.String("GET"),
21603 AuthType: dara.String("AK"),
21604 Style: dara.String("RPC"),
21605 ReqBodyType: dara.String("formData"),
21606 BodyType: dara.String("json"),
21607 }
21608 authResponse := map[string]interface{}{}
21609 fileObj := &dara.FileField{}
21610 ossHeader := map[string]interface{}{}
21611 tmpBody := map[string]interface{}{}
21612 useAccelerate := false
21613 authResponseBody := make(map[string]*string)
21614 putKvWithHighCapacityReq := &PutKvWithHighCapacityRequest{}
21615 openapiutil.Convert(request, putKvWithHighCapacityReq)
21616 if !dara.IsNil(request.UrlObject) {
21617 authResponse, _err = authClient.CallApi(authParams, authReq, runtime)
21618 if _err != nil {
21619 return _result, _err
21620 }
21621
21622 tmpBody = dara.ToMap(authResponse["body"])
21623 useAccelerate = dara.ForceBoolean(tmpBody["UseAccelerate"])
21624 authResponseBody = openapiutil.StringifyMapValue(tmpBody)
21625 fileObj = &dara.FileField{
21626 Filename: authResponseBody["ObjectKey"],
21627 Content: request.UrlObject,
21628 ContentType: dara.String(""),
21629 }
21630 ossHeader = map[string]interface{}{
21631 "host": dara.StringValue(authResponseBody["Bucket"]) + "." + dara.StringValue(openapiutil.GetEndpoint(authResponseBody["Endpoint"], dara.Bool(useAccelerate), client.EndpointType)),
21632 "OSSAccessKeyId": dara.StringValue(authResponseBody["AccessKeyId"]),
21633 "policy": dara.StringValue(authResponseBody["EncodedPolicy"]),
21634 "Signature": dara.StringValue(authResponseBody["Signature"]),
21635 "key": dara.StringValue(authResponseBody["ObjectKey"]),
21636 "file": fileObj,
21637 "success_action_status": "201",
21638 }
21639 _, _err = _postOSSObject(client,authResponseBody["Bucket"], ossHeader, runtime)
21640 if _err != nil {
21641 return _result, _err
21642 }
21643 putKvWithHighCapacityReq.Url = dara.String("http://" + dara.StringValue(authResponseBody["Bucket"]) + "." + dara.StringValue(authResponseBody["Endpoint"]) + "/" + dara.StringValue(authResponseBody["ObjectKey"]))
21644 }
21645
21646 putKvWithHighCapacityResp, _err := PutKvWithHighCapacityWithOptions(client,putKvWithHighCapacityReq, runtime)
21647 if _err != nil {
21648 return _result, _err
21649 }
21650
21651 _result = putKvWithHighCapacityResp
21652 return _result, _err
21653 }
21654
21655 // Summary:
21656 //
21657 // Rebuilds the staging environment for containerized applications.
21658 //
21659 // @param request - RebuildEdgeContainerAppStagingEnvRequest
21660 //
21661 // @param runtime - runtime options for this request RuntimeOptions
21662 //
21663 // @return RebuildEdgeContainerAppStagingEnvResponse
21664 func RebuildEdgeContainerAppStagingEnvWithOptions(client *Client, request *RebuildEdgeContainerAppStagingEnvRequest, runtime *dara.RuntimeOptions) (_result *RebuildEdgeContainerAppStagingEnvResponse, _err error) {
21665 if dara.BoolValue(client.EnableValidate) == true {
21666 _err = request.Validate()
21667 if _err != nil {
21668 return _result, _err
21669 }
21670 }
21671 query := map[string]interface{}{}
21672 if !dara.IsNil(request.AppId) {
21673 query["AppId"] = request.AppId
21674 }
21675
21676 req := &openapiutil.OpenApiRequest{
21677 Query: openapiutil.Query(query),
21678 }
21679 params := &openapiutil.Params{
21680 Action: dara.String("RebuildEdgeContainerAppStagingEnv"),
21681 Version: dara.String("2024-09-10"),
21682 Protocol: dara.String("HTTPS"),
21683 Pathname: dara.String("/"),
21684 Method: dara.String("POST"),
21685 AuthType: dara.String("AK"),
21686 Style: dara.String("RPC"),
21687 ReqBodyType: dara.String("formData"),
21688 BodyType: dara.String("json"),
21689 }
21690 _result = &RebuildEdgeContainerAppStagingEnvResponse{}
21691 _body, _err := client.CallApi(params, req, runtime)
21692 if _err != nil {
21693 return _result, _err
21694 }
21695 _err = dara.Convert(_body, &_result)
21696 return _result, _err
21697 }
21698
21699 // Summary:
21700 //
21701 // Rebuilds the staging environment for containerized applications.
21702 //
21703 // @param request - RebuildEdgeContainerAppStagingEnvRequest
21704 //
21705 // @return RebuildEdgeContainerAppStagingEnvResponse
21706 func RebuildEdgeContainerAppStagingEnv(client *Client, request *RebuildEdgeContainerAppStagingEnvRequest) (_result *RebuildEdgeContainerAppStagingEnvResponse, _err error) {
21707 runtime := &dara.RuntimeOptions{}
21708 _result = &RebuildEdgeContainerAppStagingEnvResponse{}
21709 _body, _err := RebuildEdgeContainerAppStagingEnvWithOptions(client,request, runtime)
21710 if _err != nil {
21711 return _result, _err
21712 }
21713 _result = _body
21714 return _result, _err
21715 }
21716
21717 // Summary:
21718 //
21719 // Resets the progress of a scheduled prefetch task and starts the prefetch from the beginning.
21720 //
21721 // @param request - ResetScheduledPreloadJobRequest
21722 //
21723 // @param runtime - runtime options for this request RuntimeOptions
21724 //
21725 // @return ResetScheduledPreloadJobResponse
21726 func ResetScheduledPreloadJobWithOptions(client *Client, request *ResetScheduledPreloadJobRequest, runtime *dara.RuntimeOptions) (_result *ResetScheduledPreloadJobResponse, _err error) {
21727 if dara.BoolValue(client.EnableValidate) == true {
21728 _err = request.Validate()
21729 if _err != nil {
21730 return _result, _err
21731 }
21732 }
21733 query := map[string]interface{}{}
21734 if !dara.IsNil(request.Id) {
21735 query["Id"] = request.Id
21736 }
21737
21738 req := &openapiutil.OpenApiRequest{
21739 Query: openapiutil.Query(query),
21740 }
21741 params := &openapiutil.Params{
21742 Action: dara.String("ResetScheduledPreloadJob"),
21743 Version: dara.String("2024-09-10"),
21744 Protocol: dara.String("HTTPS"),
21745 Pathname: dara.String("/"),
21746 Method: dara.String("POST"),
21747 AuthType: dara.String("AK"),
21748 Style: dara.String("RPC"),
21749 ReqBodyType: dara.String("formData"),
21750 BodyType: dara.String("json"),
21751 }
21752 _result = &ResetScheduledPreloadJobResponse{}
21753 _body, _err := client.CallApi(params, req, runtime)
21754 if _err != nil {
21755 return _result, _err
21756 }
21757 _err = dara.Convert(_body, &_result)
21758 return _result, _err
21759 }
21760
21761 // Summary:
21762 //
21763 // Resets the progress of a scheduled prefetch task and starts the prefetch from the beginning.
21764 //
21765 // @param request - ResetScheduledPreloadJobRequest
21766 //
21767 // @return ResetScheduledPreloadJobResponse
21768 func ResetScheduledPreloadJob(client *Client, request *ResetScheduledPreloadJobRequest) (_result *ResetScheduledPreloadJobResponse, _err error) {
21769 runtime := &dara.RuntimeOptions{}
21770 _result = &ResetScheduledPreloadJobResponse{}
21771 _body, _err := ResetScheduledPreloadJobWithOptions(client,request, runtime)
21772 if _err != nil {
21773 return _result, _err
21774 }
21775 _result = _body
21776 return _result, _err
21777 }
21778
21779 // Summary:
21780 //
21781 // Revokes an activated client certificate.
21782 //
21783 // @param request - RevokeClientCertificateRequest
21784 //
21785 // @param runtime - runtime options for this request RuntimeOptions
21786 //
21787 // @return RevokeClientCertificateResponse
21788 func RevokeClientCertificateWithOptions(client *Client, request *RevokeClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *RevokeClientCertificateResponse, _err error) {
21789 if dara.BoolValue(client.EnableValidate) == true {
21790 _err = request.Validate()
21791 if _err != nil {
21792 return _result, _err
21793 }
21794 }
21795 query := openapiutil.Query(dara.ToMap(request))
21796 req := &openapiutil.OpenApiRequest{
21797 Query: openapiutil.Query(query),
21798 }
21799 params := &openapiutil.Params{
21800 Action: dara.String("RevokeClientCertificate"),
21801 Version: dara.String("2024-09-10"),
21802 Protocol: dara.String("HTTPS"),
21803 Pathname: dara.String("/"),
21804 Method: dara.String("GET"),
21805 AuthType: dara.String("AK"),
21806 Style: dara.String("RPC"),
21807 ReqBodyType: dara.String("formData"),
21808 BodyType: dara.String("json"),
21809 }
21810 _result = &RevokeClientCertificateResponse{}
21811 _body, _err := client.CallApi(params, req, runtime)
21812 if _err != nil {
21813 return _result, _err
21814 }
21815 _err = dara.Convert(_body, &_result)
21816 return _result, _err
21817 }
21818
21819 // Summary:
21820 //
21821 // Revokes an activated client certificate.
21822 //
21823 // @param request - RevokeClientCertificateRequest
21824 //
21825 // @return RevokeClientCertificateResponse
21826 func RevokeClientCertificate(client *Client, request *RevokeClientCertificateRequest) (_result *RevokeClientCertificateResponse, _err error) {
21827 runtime := &dara.RuntimeOptions{}
21828 _result = &RevokeClientCertificateResponse{}
21829 _body, _err := RevokeClientCertificateWithOptions(client,request, runtime)
21830 if _err != nil {
21831 return _result, _err
21832 }
21833 _result = _body
21834 return _result, _err
21835 }
21836
21837 // Summary:
21838 //
21839 // Rolls back a version of a containerized application.
21840 //
21841 // @param request - RollbackEdgeContainerAppVersionRequest
21842 //
21843 // @param runtime - runtime options for this request RuntimeOptions
21844 //
21845 // @return RollbackEdgeContainerAppVersionResponse
21846 func RollbackEdgeContainerAppVersionWithOptions(client *Client, request *RollbackEdgeContainerAppVersionRequest, runtime *dara.RuntimeOptions) (_result *RollbackEdgeContainerAppVersionResponse, _err error) {
21847 if dara.BoolValue(client.EnableValidate) == true {
21848 _err = request.Validate()
21849 if _err != nil {
21850 return _result, _err
21851 }
21852 }
21853 query := map[string]interface{}{}
21854 if !dara.IsNil(request.Percentage) {
21855 query["Percentage"] = request.Percentage
21856 }
21857
21858 if !dara.IsNil(request.UsedPercent) {
21859 query["UsedPercent"] = request.UsedPercent
21860 }
21861
21862 if !dara.IsNil(request.VersionId) {
21863 query["VersionId"] = request.VersionId
21864 }
21865
21866 body := map[string]interface{}{}
21867 if !dara.IsNil(request.AppId) {
21868 body["AppId"] = request.AppId
21869 }
21870
21871 if !dara.IsNil(request.Remarks) {
21872 body["Remarks"] = request.Remarks
21873 }
21874
21875 req := &openapiutil.OpenApiRequest{
21876 Query: openapiutil.Query(query),
21877 Body: openapiutil.ParseToMap(body),
21878 }
21879 params := &openapiutil.Params{
21880 Action: dara.String("RollbackEdgeContainerAppVersion"),
21881 Version: dara.String("2024-09-10"),
21882 Protocol: dara.String("HTTPS"),
21883 Pathname: dara.String("/"),
21884 Method: dara.String("POST"),
21885 AuthType: dara.String("AK"),
21886 Style: dara.String("RPC"),
21887 ReqBodyType: dara.String("formData"),
21888 BodyType: dara.String("json"),
21889 }
21890 _result = &RollbackEdgeContainerAppVersionResponse{}
21891 _body, _err := client.CallApi(params, req, runtime)
21892 if _err != nil {
21893 return _result, _err
21894 }
21895 _err = dara.Convert(_body, &_result)
21896 return _result, _err
21897 }
21898
21899 // Summary:
21900 //
21901 // Rolls back a version of a containerized application.
21902 //
21903 // @param request - RollbackEdgeContainerAppVersionRequest
21904 //
21905 // @return RollbackEdgeContainerAppVersionResponse
21906 func RollbackEdgeContainerAppVersion(client *Client, request *RollbackEdgeContainerAppVersionRequest) (_result *RollbackEdgeContainerAppVersionResponse, _err error) {
21907 runtime := &dara.RuntimeOptions{}
21908 _result = &RollbackEdgeContainerAppVersionResponse{}
21909 _body, _err := RollbackEdgeContainerAppVersionWithOptions(client,request, runtime)
21910 if _err != nil {
21911 return _result, _err
21912 }
21913 _result = _body
21914 return _result, _err
21915 }
21916
21917 // Summary:
21918 //
21919 // Configures whether to enable certificates and update certificate information for a website.
21920 //
21921 // @param request - SetCertificateRequest
21922 //
21923 // @param runtime - runtime options for this request RuntimeOptions
21924 //
21925 // @return SetCertificateResponse
21926 func SetCertificateWithOptions(client *Client, request *SetCertificateRequest, runtime *dara.RuntimeOptions) (_result *SetCertificateResponse, _err error) {
21927 if dara.BoolValue(client.EnableValidate) == true {
21928 _err = request.Validate()
21929 if _err != nil {
21930 return _result, _err
21931 }
21932 }
21933 query := map[string]interface{}{}
21934 if !dara.IsNil(request.OwnerId) {
21935 query["OwnerId"] = request.OwnerId
21936 }
21937
21938 if !dara.IsNil(request.SecurityToken) {
21939 query["SecurityToken"] = request.SecurityToken
21940 }
21941
21942 body := map[string]interface{}{}
21943 if !dara.IsNil(request.CasId) {
21944 body["CasId"] = request.CasId
21945 }
21946
21947 if !dara.IsNil(request.Certificate) {
21948 body["Certificate"] = request.Certificate
21949 }
21950
21951 if !dara.IsNil(request.Id) {
21952 body["Id"] = request.Id
21953 }
21954
21955 if !dara.IsNil(request.Name) {
21956 body["Name"] = request.Name
21957 }
21958
21959 if !dara.IsNil(request.PrivateKey) {
21960 body["PrivateKey"] = request.PrivateKey
21961 }
21962
21963 if !dara.IsNil(request.Region) {
21964 body["Region"] = request.Region
21965 }
21966
21967 if !dara.IsNil(request.SiteId) {
21968 body["SiteId"] = request.SiteId
21969 }
21970
21971 if !dara.IsNil(request.Type) {
21972 body["Type"] = request.Type
21973 }
21974
21975 req := &openapiutil.OpenApiRequest{
21976 Query: openapiutil.Query(query),
21977 Body: openapiutil.ParseToMap(body),
21978 }
21979 params := &openapiutil.Params{
21980 Action: dara.String("SetCertificate"),
21981 Version: dara.String("2024-09-10"),
21982 Protocol: dara.String("HTTPS"),
21983 Pathname: dara.String("/"),
21984 Method: dara.String("POST"),
21985 AuthType: dara.String("AK"),
21986 Style: dara.String("RPC"),
21987 ReqBodyType: dara.String("formData"),
21988 BodyType: dara.String("json"),
21989 }
21990 _result = &SetCertificateResponse{}
21991 _body, _err := client.CallApi(params, req, runtime)
21992 if _err != nil {
21993 return _result, _err
21994 }
21995 _err = dara.Convert(_body, &_result)
21996 return _result, _err
21997 }
21998
21999 // Summary:
22000 //
22001 // Configures whether to enable certificates and update certificate information for a website.
22002 //
22003 // @param request - SetCertificateRequest
22004 //
22005 // @return SetCertificateResponse
22006 func SetCertificate(client *Client, request *SetCertificateRequest) (_result *SetCertificateResponse, _err error) {
22007 runtime := &dara.RuntimeOptions{}
22008 _result = &SetCertificateResponse{}
22009 _body, _err := SetCertificateWithOptions(client,request, runtime)
22010 if _err != nil {
22011 return _result, _err
22012 }
22013 _result = _body
22014 return _result, _err
22015 }
22016
22017 // Summary:
22018 //
22019 // 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.
22020 //
22021 // @param tmpReq - SetClientCertificateHostnamesRequest
22022 //
22023 // @param runtime - runtime options for this request RuntimeOptions
22024 //
22025 // @return SetClientCertificateHostnamesResponse
22026 func SetClientCertificateHostnamesWithOptions(client *Client, tmpReq *SetClientCertificateHostnamesRequest, runtime *dara.RuntimeOptions) (_result *SetClientCertificateHostnamesResponse, _err error) {
22027 if dara.BoolValue(client.EnableValidate) == true {
22028 _err = tmpReq.Validate()
22029 if _err != nil {
22030 return _result, _err
22031 }
22032 }
22033 request := &SetClientCertificateHostnamesShrinkRequest{}
22034 openapiutil.Convert(tmpReq, request)
22035 if !dara.IsNil(tmpReq.Hostnames) {
22036 request.HostnamesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Hostnames, dara.String("Hostnames"), dara.String("json"))
22037 }
22038
22039 query := map[string]interface{}{}
22040 if !dara.IsNil(request.SiteId) {
22041 query["SiteId"] = request.SiteId
22042 }
22043
22044 body := map[string]interface{}{}
22045 if !dara.IsNil(request.HostnamesShrink) {
22046 body["Hostnames"] = request.HostnamesShrink
22047 }
22048
22049 if !dara.IsNil(request.Id) {
22050 body["Id"] = request.Id
22051 }
22052
22053 req := &openapiutil.OpenApiRequest{
22054 Query: openapiutil.Query(query),
22055 Body: openapiutil.ParseToMap(body),
22056 }
22057 params := &openapiutil.Params{
22058 Action: dara.String("SetClientCertificateHostnames"),
22059 Version: dara.String("2024-09-10"),
22060 Protocol: dara.String("HTTPS"),
22061 Pathname: dara.String("/"),
22062 Method: dara.String("POST"),
22063 AuthType: dara.String("AK"),
22064 Style: dara.String("RPC"),
22065 ReqBodyType: dara.String("formData"),
22066 BodyType: dara.String("json"),
22067 }
22068 _result = &SetClientCertificateHostnamesResponse{}
22069 _body, _err := client.CallApi(params, req, runtime)
22070 if _err != nil {
22071 return _result, _err
22072 }
22073 _err = dara.Convert(_body, &_result)
22074 return _result, _err
22075 }
22076
22077 // Summary:
22078 //
22079 // 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.
22080 //
22081 // @param request - SetClientCertificateHostnamesRequest
22082 //
22083 // @return SetClientCertificateHostnamesResponse
22084 func SetClientCertificateHostnames(client *Client, request *SetClientCertificateHostnamesRequest) (_result *SetClientCertificateHostnamesResponse, _err error) {
22085 runtime := &dara.RuntimeOptions{}
22086 _result = &SetClientCertificateHostnamesResponse{}
22087 _body, _err := SetClientCertificateHostnamesWithOptions(client,request, runtime)
22088 if _err != nil {
22089 return _result, _err
22090 }
22091 _result = _body
22092 return _result, _err
22093 }
22094
22095 // Summary:
22096 //
22097 // Configures smart HTTP DDoS protection.
22098 //
22099 // @param request - SetHttpDDoSAttackIntelligentProtectionRequest
22100 //
22101 // @param runtime - runtime options for this request RuntimeOptions
22102 //
22103 // @return SetHttpDDoSAttackIntelligentProtectionResponse
22104 func SetHttpDDoSAttackIntelligentProtectionWithOptions(client *Client, request *SetHttpDDoSAttackIntelligentProtectionRequest, runtime *dara.RuntimeOptions) (_result *SetHttpDDoSAttackIntelligentProtectionResponse, _err error) {
22105 if dara.BoolValue(client.EnableValidate) == true {
22106 _err = request.Validate()
22107 if _err != nil {
22108 return _result, _err
22109 }
22110 }
22111 query := map[string]interface{}{}
22112 if !dara.IsNil(request.AiMode) {
22113 query["AiMode"] = request.AiMode
22114 }
22115
22116 if !dara.IsNil(request.AiTemplate) {
22117 query["AiTemplate"] = request.AiTemplate
22118 }
22119
22120 if !dara.IsNil(request.SiteId) {
22121 query["SiteId"] = request.SiteId
22122 }
22123
22124 req := &openapiutil.OpenApiRequest{
22125 Query: openapiutil.Query(query),
22126 }
22127 params := &openapiutil.Params{
22128 Action: dara.String("SetHttpDDoSAttackIntelligentProtection"),
22129 Version: dara.String("2024-09-10"),
22130 Protocol: dara.String("HTTPS"),
22131 Pathname: dara.String("/"),
22132 Method: dara.String("POST"),
22133 AuthType: dara.String("AK"),
22134 Style: dara.String("RPC"),
22135 ReqBodyType: dara.String("formData"),
22136 BodyType: dara.String("json"),
22137 }
22138 _result = &SetHttpDDoSAttackIntelligentProtectionResponse{}
22139 _body, _err := client.CallApi(params, req, runtime)
22140 if _err != nil {
22141 return _result, _err
22142 }
22143 _err = dara.Convert(_body, &_result)
22144 return _result, _err
22145 }
22146
22147 // Summary:
22148 //
22149 // Configures smart HTTP DDoS protection.
22150 //
22151 // @param request - SetHttpDDoSAttackIntelligentProtectionRequest
22152 //
22153 // @return SetHttpDDoSAttackIntelligentProtectionResponse
22154 func SetHttpDDoSAttackIntelligentProtection(client *Client, request *SetHttpDDoSAttackIntelligentProtectionRequest) (_result *SetHttpDDoSAttackIntelligentProtectionResponse, _err error) {
22155 runtime := &dara.RuntimeOptions{}
22156 _result = &SetHttpDDoSAttackIntelligentProtectionResponse{}
22157 _body, _err := SetHttpDDoSAttackIntelligentProtectionWithOptions(client,request, runtime)
22158 if _err != nil {
22159 return _result, _err
22160 }
22161 _result = _body
22162 return _result, _err
22163 }
22164
22165 // Summary:
22166 //
22167 // Configures HTTP DDoS attack protection for a website.
22168 //
22169 // @param request - SetHttpDDoSAttackProtectionRequest
22170 //
22171 // @param runtime - runtime options for this request RuntimeOptions
22172 //
22173 // @return SetHttpDDoSAttackProtectionResponse
22174 func SetHttpDDoSAttackProtectionWithOptions(client *Client, request *SetHttpDDoSAttackProtectionRequest, runtime *dara.RuntimeOptions) (_result *SetHttpDDoSAttackProtectionResponse, _err error) {
22175 if dara.BoolValue(client.EnableValidate) == true {
22176 _err = request.Validate()
22177 if _err != nil {
22178 return _result, _err
22179 }
22180 }
22181 query := map[string]interface{}{}
22182 if !dara.IsNil(request.GlobalMode) {
22183 query["GlobalMode"] = request.GlobalMode
22184 }
22185
22186 if !dara.IsNil(request.SiteId) {
22187 query["SiteId"] = request.SiteId
22188 }
22189
22190 req := &openapiutil.OpenApiRequest{
22191 Query: openapiutil.Query(query),
22192 }
22193 params := &openapiutil.Params{
22194 Action: dara.String("SetHttpDDoSAttackProtection"),
22195 Version: dara.String("2024-09-10"),
22196 Protocol: dara.String("HTTPS"),
22197 Pathname: dara.String("/"),
22198 Method: dara.String("POST"),
22199 AuthType: dara.String("AK"),
22200 Style: dara.String("RPC"),
22201 ReqBodyType: dara.String("formData"),
22202 BodyType: dara.String("json"),
22203 }
22204 _result = &SetHttpDDoSAttackProtectionResponse{}
22205 _body, _err := client.CallApi(params, req, runtime)
22206 if _err != nil {
22207 return _result, _err
22208 }
22209 _err = dara.Convert(_body, &_result)
22210 return _result, _err
22211 }
22212
22213 // Summary:
22214 //
22215 // Configures HTTP DDoS attack protection for a website.
22216 //
22217 // @param request - SetHttpDDoSAttackProtectionRequest
22218 //
22219 // @return SetHttpDDoSAttackProtectionResponse
22220 func SetHttpDDoSAttackProtection(client *Client, request *SetHttpDDoSAttackProtectionRequest) (_result *SetHttpDDoSAttackProtectionResponse, _err error) {
22221 runtime := &dara.RuntimeOptions{}
22222 _result = &SetHttpDDoSAttackProtectionResponse{}
22223 _body, _err := SetHttpDDoSAttackProtectionWithOptions(client,request, runtime)
22224 if _err != nil {
22225 return _result, _err
22226 }
22227 _result = _body
22228 return _result, _err
22229 }
22230
22231 // Summary:
22232 //
22233 // 设置HTTP DDoS攻击防护指定规则防护动作
22234 //
22235 // @param request - SetHttpDDoSAttackRuleActionRequest
22236 //
22237 // @param runtime - runtime options for this request RuntimeOptions
22238 //
22239 // @return SetHttpDDoSAttackRuleActionResponse
22240 func SetHttpDDoSAttackRuleActionWithOptions(client *Client, request *SetHttpDDoSAttackRuleActionRequest, runtime *dara.RuntimeOptions) (_result *SetHttpDDoSAttackRuleActionResponse, _err error) {
22241 if dara.BoolValue(client.EnableValidate) == true {
22242 _err = request.Validate()
22243 if _err != nil {
22244 return _result, _err
22245 }
22246 }
22247 query := map[string]interface{}{}
22248 if !dara.IsNil(request.RuleAction) {
22249 query["RuleAction"] = request.RuleAction
22250 }
22251
22252 if !dara.IsNil(request.RuleIds) {
22253 query["RuleIds"] = request.RuleIds
22254 }
22255
22256 if !dara.IsNil(request.SiteId) {
22257 query["SiteId"] = request.SiteId
22258 }
22259
22260 req := &openapiutil.OpenApiRequest{
22261 Query: openapiutil.Query(query),
22262 }
22263 params := &openapiutil.Params{
22264 Action: dara.String("SetHttpDDoSAttackRuleAction"),
22265 Version: dara.String("2024-09-10"),
22266 Protocol: dara.String("HTTPS"),
22267 Pathname: dara.String("/"),
22268 Method: dara.String("POST"),
22269 AuthType: dara.String("AK"),
22270 Style: dara.String("RPC"),
22271 ReqBodyType: dara.String("formData"),
22272 BodyType: dara.String("json"),
22273 }
22274 _result = &SetHttpDDoSAttackRuleActionResponse{}
22275 _body, _err := client.CallApi(params, req, runtime)
22276 if _err != nil {
22277 return _result, _err
22278 }
22279 _err = dara.Convert(_body, &_result)
22280 return _result, _err
22281 }
22282
22283 // Summary:
22284 //
22285 // 设置HTTP DDoS攻击防护指定规则防护动作
22286 //
22287 // @param request - SetHttpDDoSAttackRuleActionRequest
22288 //
22289 // @return SetHttpDDoSAttackRuleActionResponse
22290 func SetHttpDDoSAttackRuleAction(client *Client, request *SetHttpDDoSAttackRuleActionRequest) (_result *SetHttpDDoSAttackRuleActionResponse, _err error) {
22291 runtime := &dara.RuntimeOptions{}
22292 _result = &SetHttpDDoSAttackRuleActionResponse{}
22293 _body, _err := SetHttpDDoSAttackRuleActionWithOptions(client,request, runtime)
22294 if _err != nil {
22295 return _result, _err
22296 }
22297 _result = _body
22298 return _result, _err
22299 }
22300
22301 // Summary:
22302 //
22303 // 设置HTTP DDoS攻击防护指定规则防护状态
22304 //
22305 // @param request - SetHttpDDoSAttackRuleStatusRequest
22306 //
22307 // @param runtime - runtime options for this request RuntimeOptions
22308 //
22309 // @return SetHttpDDoSAttackRuleStatusResponse
22310 func SetHttpDDoSAttackRuleStatusWithOptions(client *Client, request *SetHttpDDoSAttackRuleStatusRequest, runtime *dara.RuntimeOptions) (_result *SetHttpDDoSAttackRuleStatusResponse, _err error) {
22311 if dara.BoolValue(client.EnableValidate) == true {
22312 _err = request.Validate()
22313 if _err != nil {
22314 return _result, _err
22315 }
22316 }
22317 query := map[string]interface{}{}
22318 if !dara.IsNil(request.RuleIds) {
22319 query["RuleIds"] = request.RuleIds
22320 }
22321
22322 if !dara.IsNil(request.SiteId) {
22323 query["SiteId"] = request.SiteId
22324 }
22325
22326 if !dara.IsNil(request.Status) {
22327 query["Status"] = request.Status
22328 }
22329
22330 req := &openapiutil.OpenApiRequest{
22331 Query: openapiutil.Query(query),
22332 }
22333 params := &openapiutil.Params{
22334 Action: dara.String("SetHttpDDoSAttackRuleStatus"),
22335 Version: dara.String("2024-09-10"),
22336 Protocol: dara.String("HTTPS"),
22337 Pathname: dara.String("/"),
22338 Method: dara.String("POST"),
22339 AuthType: dara.String("AK"),
22340 Style: dara.String("RPC"),
22341 ReqBodyType: dara.String("formData"),
22342 BodyType: dara.String("json"),
22343 }
22344 _result = &SetHttpDDoSAttackRuleStatusResponse{}
22345 _body, _err := client.CallApi(params, req, runtime)
22346 if _err != nil {
22347 return _result, _err
22348 }
22349 _err = dara.Convert(_body, &_result)
22350 return _result, _err
22351 }
22352
22353 // Summary:
22354 //
22355 // 设置HTTP DDoS攻击防护指定规则防护状态
22356 //
22357 // @param request - SetHttpDDoSAttackRuleStatusRequest
22358 //
22359 // @return SetHttpDDoSAttackRuleStatusResponse
22360 func SetHttpDDoSAttackRuleStatus(client *Client, request *SetHttpDDoSAttackRuleStatusRequest) (_result *SetHttpDDoSAttackRuleStatusResponse, _err error) {
22361 runtime := &dara.RuntimeOptions{}
22362 _result = &SetHttpDDoSAttackRuleStatusResponse{}
22363 _body, _err := SetHttpDDoSAttackRuleStatusWithOptions(client,request, runtime)
22364 if _err != nil {
22365 return _result, _err
22366 }
22367 _result = _body
22368 return _result, _err
22369 }
22370
22371 // Summary:
22372 //
22373 // 为域名回源客户端证书绑定域名
22374 //
22375 // @param tmpReq - SetOriginClientCertificateHostnamesRequest
22376 //
22377 // @param runtime - runtime options for this request RuntimeOptions
22378 //
22379 // @return SetOriginClientCertificateHostnamesResponse
22380 func SetOriginClientCertificateHostnamesWithOptions(client *Client, tmpReq *SetOriginClientCertificateHostnamesRequest, runtime *dara.RuntimeOptions) (_result *SetOriginClientCertificateHostnamesResponse, _err error) {
22381 if dara.BoolValue(client.EnableValidate) == true {
22382 _err = tmpReq.Validate()
22383 if _err != nil {
22384 return _result, _err
22385 }
22386 }
22387 request := &SetOriginClientCertificateHostnamesShrinkRequest{}
22388 openapiutil.Convert(tmpReq, request)
22389 if !dara.IsNil(tmpReq.Hostnames) {
22390 request.HostnamesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Hostnames, dara.String("Hostnames"), dara.String("json"))
22391 }
22392
22393 body := map[string]interface{}{}
22394 if !dara.IsNil(request.HostnamesShrink) {
22395 body["Hostnames"] = request.HostnamesShrink
22396 }
22397
22398 if !dara.IsNil(request.Id) {
22399 body["Id"] = request.Id
22400 }
22401
22402 if !dara.IsNil(request.SiteId) {
22403 body["SiteId"] = request.SiteId
22404 }
22405
22406 req := &openapiutil.OpenApiRequest{
22407 Body: openapiutil.ParseToMap(body),
22408 }
22409 params := &openapiutil.Params{
22410 Action: dara.String("SetOriginClientCertificateHostnames"),
22411 Version: dara.String("2024-09-10"),
22412 Protocol: dara.String("HTTPS"),
22413 Pathname: dara.String("/"),
22414 Method: dara.String("POST"),
22415 AuthType: dara.String("AK"),
22416 Style: dara.String("RPC"),
22417 ReqBodyType: dara.String("formData"),
22418 BodyType: dara.String("json"),
22419 }
22420 _result = &SetOriginClientCertificateHostnamesResponse{}
22421 _body, _err := client.CallApi(params, req, runtime)
22422 if _err != nil {
22423 return _result, _err
22424 }
22425 _err = dara.Convert(_body, &_result)
22426 return _result, _err
22427 }
22428
22429 // Summary:
22430 //
22431 // 为域名回源客户端证书绑定域名
22432 //
22433 // @param request - SetOriginClientCertificateHostnamesRequest
22434 //
22435 // @return SetOriginClientCertificateHostnamesResponse
22436 func SetOriginClientCertificateHostnames(client *Client, request *SetOriginClientCertificateHostnamesRequest) (_result *SetOriginClientCertificateHostnamesResponse, _err error) {
22437 runtime := &dara.RuntimeOptions{}
22438 _result = &SetOriginClientCertificateHostnamesResponse{}
22439 _body, _err := SetOriginClientCertificateHostnamesWithOptions(client,request, runtime)
22440 if _err != nil {
22441 return _result, _err
22442 }
22443 _result = _body
22444 return _result, _err
22445 }
22446
22447 // Summary:
22448 //
22449 // Starts a scheduled prefetch plan based on the plan ID.
22450 //
22451 // @param request - StartScheduledPreloadExecutionRequest
22452 //
22453 // @param runtime - runtime options for this request RuntimeOptions
22454 //
22455 // @return StartScheduledPreloadExecutionResponse
22456 func StartScheduledPreloadExecutionWithOptions(client *Client, request *StartScheduledPreloadExecutionRequest, runtime *dara.RuntimeOptions) (_result *StartScheduledPreloadExecutionResponse, _err error) {
22457 if dara.BoolValue(client.EnableValidate) == true {
22458 _err = request.Validate()
22459 if _err != nil {
22460 return _result, _err
22461 }
22462 }
22463 query := map[string]interface{}{}
22464 if !dara.IsNil(request.Id) {
22465 query["Id"] = request.Id
22466 }
22467
22468 req := &openapiutil.OpenApiRequest{
22469 Query: openapiutil.Query(query),
22470 }
22471 params := &openapiutil.Params{
22472 Action: dara.String("StartScheduledPreloadExecution"),
22473 Version: dara.String("2024-09-10"),
22474 Protocol: dara.String("HTTPS"),
22475 Pathname: dara.String("/"),
22476 Method: dara.String("POST"),
22477 AuthType: dara.String("AK"),
22478 Style: dara.String("RPC"),
22479 ReqBodyType: dara.String("formData"),
22480 BodyType: dara.String("json"),
22481 }
22482 _result = &StartScheduledPreloadExecutionResponse{}
22483 _body, _err := client.CallApi(params, req, runtime)
22484 if _err != nil {
22485 return _result, _err
22486 }
22487 _err = dara.Convert(_body, &_result)
22488 return _result, _err
22489 }
22490
22491 // Summary:
22492 //
22493 // Starts a scheduled prefetch plan based on the plan ID.
22494 //
22495 // @param request - StartScheduledPreloadExecutionRequest
22496 //
22497 // @return StartScheduledPreloadExecutionResponse
22498 func StartScheduledPreloadExecution(client *Client, request *StartScheduledPreloadExecutionRequest) (_result *StartScheduledPreloadExecutionResponse, _err error) {
22499 runtime := &dara.RuntimeOptions{}
22500 _result = &StartScheduledPreloadExecutionResponse{}
22501 _body, _err := StartScheduledPreloadExecutionWithOptions(client,request, runtime)
22502 if _err != nil {
22503 return _result, _err
22504 }
22505 _result = _body
22506 return _result, _err
22507 }
22508
22509 // Summary:
22510 //
22511 // Stops a scheduled prefetch plan based on the plan ID.
22512 //
22513 // @param request - StopScheduledPreloadExecutionRequest
22514 //
22515 // @param runtime - runtime options for this request RuntimeOptions
22516 //
22517 // @return StopScheduledPreloadExecutionResponse
22518 func StopScheduledPreloadExecutionWithOptions(client *Client, request *StopScheduledPreloadExecutionRequest, runtime *dara.RuntimeOptions) (_result *StopScheduledPreloadExecutionResponse, _err error) {
22519 if dara.BoolValue(client.EnableValidate) == true {
22520 _err = request.Validate()
22521 if _err != nil {
22522 return _result, _err
22523 }
22524 }
22525 query := map[string]interface{}{}
22526 if !dara.IsNil(request.Id) {
22527 query["Id"] = request.Id
22528 }
22529
22530 req := &openapiutil.OpenApiRequest{
22531 Query: openapiutil.Query(query),
22532 }
22533 params := &openapiutil.Params{
22534 Action: dara.String("StopScheduledPreloadExecution"),
22535 Version: dara.String("2024-09-10"),
22536 Protocol: dara.String("HTTPS"),
22537 Pathname: dara.String("/"),
22538 Method: dara.String("POST"),
22539 AuthType: dara.String("AK"),
22540 Style: dara.String("RPC"),
22541 ReqBodyType: dara.String("formData"),
22542 BodyType: dara.String("json"),
22543 }
22544 _result = &StopScheduledPreloadExecutionResponse{}
22545 _body, _err := client.CallApi(params, req, runtime)
22546 if _err != nil {
22547 return _result, _err
22548 }
22549 _err = dara.Convert(_body, &_result)
22550 return _result, _err
22551 }
22552
22553 // Summary:
22554 //
22555 // Stops a scheduled prefetch plan based on the plan ID.
22556 //
22557 // @param request - StopScheduledPreloadExecutionRequest
22558 //
22559 // @return StopScheduledPreloadExecutionResponse
22560 func StopScheduledPreloadExecution(client *Client, request *StopScheduledPreloadExecutionRequest) (_result *StopScheduledPreloadExecutionResponse, _err error) {
22561 runtime := &dara.RuntimeOptions{}
22562 _result = &StopScheduledPreloadExecutionResponse{}
22563 _body, _err := StopScheduledPreloadExecutionWithOptions(client,request, runtime)
22564 if _err != nil {
22565 return _result, _err
22566 }
22567 _result = _body
22568 return _result, _err
22569 }
22570
22571 // Summary:
22572 //
22573 // Adds one or more tags to resources.
22574 //
22575 // @param request - TagResourcesRequest
22576 //
22577 // @param runtime - runtime options for this request RuntimeOptions
22578 //
22579 // @return TagResourcesResponse
22580 func TagResourcesWithOptions(client *Client, request *TagResourcesRequest, runtime *dara.RuntimeOptions) (_result *TagResourcesResponse, _err error) {
22581 if dara.BoolValue(client.EnableValidate) == true {
22582 _err = request.Validate()
22583 if _err != nil {
22584 return _result, _err
22585 }
22586 }
22587 query := map[string]interface{}{}
22588 if !dara.IsNil(request.OwnerId) {
22589 query["OwnerId"] = request.OwnerId
22590 }
22591
22592 if !dara.IsNil(request.RegionId) {
22593 query["RegionId"] = request.RegionId
22594 }
22595
22596 if !dara.IsNil(request.ResourceId) {
22597 query["ResourceId"] = request.ResourceId
22598 }
22599
22600 if !dara.IsNil(request.ResourceType) {
22601 query["ResourceType"] = request.ResourceType
22602 }
22603
22604 if !dara.IsNil(request.SecurityToken) {
22605 query["SecurityToken"] = request.SecurityToken
22606 }
22607
22608 if !dara.IsNil(request.Tag) {
22609 query["Tag"] = request.Tag
22610 }
22611
22612 req := &openapiutil.OpenApiRequest{
22613 Query: openapiutil.Query(query),
22614 }
22615 params := &openapiutil.Params{
22616 Action: dara.String("TagResources"),
22617 Version: dara.String("2024-09-10"),
22618 Protocol: dara.String("HTTPS"),
22619 Pathname: dara.String("/"),
22620 Method: dara.String("POST"),
22621 AuthType: dara.String("AK"),
22622 Style: dara.String("RPC"),
22623 ReqBodyType: dara.String("formData"),
22624 BodyType: dara.String("json"),
22625 }
22626 _result = &TagResourcesResponse{}
22627 _body, _err := client.CallApi(params, req, runtime)
22628 if _err != nil {
22629 return _result, _err
22630 }
22631 _err = dara.Convert(_body, &_result)
22632 return _result, _err
22633 }
22634
22635 // Summary:
22636 //
22637 // Adds one or more tags to resources.
22638 //
22639 // @param request - TagResourcesRequest
22640 //
22641 // @return TagResourcesResponse
22642 func TagResources(client *Client, request *TagResourcesRequest) (_result *TagResourcesResponse, _err error) {
22643 runtime := &dara.RuntimeOptions{}
22644 _result = &TagResourcesResponse{}
22645 _body, _err := TagResourcesWithOptions(client,request, runtime)
22646 if _err != nil {
22647 return _result, _err
22648 }
22649 _result = _body
22650 return _result, _err
22651 }
22652
22653 // Summary:
22654 //
22655 // Deletes a resource tag based on a specified resource ID.
22656 //
22657 // @param request - UntagResourcesRequest
22658 //
22659 // @param runtime - runtime options for this request RuntimeOptions
22660 //
22661 // @return UntagResourcesResponse
22662 func UntagResourcesWithOptions(client *Client, request *UntagResourcesRequest, runtime *dara.RuntimeOptions) (_result *UntagResourcesResponse, _err error) {
22663 if dara.BoolValue(client.EnableValidate) == true {
22664 _err = request.Validate()
22665 if _err != nil {
22666 return _result, _err
22667 }
22668 }
22669 query := map[string]interface{}{}
22670 if !dara.IsNil(request.All) {
22671 query["All"] = request.All
22672 }
22673
22674 if !dara.IsNil(request.OwnerId) {
22675 query["OwnerId"] = request.OwnerId
22676 }
22677
22678 if !dara.IsNil(request.RegionId) {
22679 query["RegionId"] = request.RegionId
22680 }
22681
22682 if !dara.IsNil(request.ResourceId) {
22683 query["ResourceId"] = request.ResourceId
22684 }
22685
22686 if !dara.IsNil(request.ResourceType) {
22687 query["ResourceType"] = request.ResourceType
22688 }
22689
22690 if !dara.IsNil(request.SecurityToken) {
22691 query["SecurityToken"] = request.SecurityToken
22692 }
22693
22694 if !dara.IsNil(request.TagKey) {
22695 query["TagKey"] = request.TagKey
22696 }
22697
22698 req := &openapiutil.OpenApiRequest{
22699 Query: openapiutil.Query(query),
22700 }
22701 params := &openapiutil.Params{
22702 Action: dara.String("UntagResources"),
22703 Version: dara.String("2024-09-10"),
22704 Protocol: dara.String("HTTPS"),
22705 Pathname: dara.String("/"),
22706 Method: dara.String("POST"),
22707 AuthType: dara.String("AK"),
22708 Style: dara.String("RPC"),
22709 ReqBodyType: dara.String("formData"),
22710 BodyType: dara.String("json"),
22711 }
22712 _result = &UntagResourcesResponse{}
22713 _body, _err := client.CallApi(params, req, runtime)
22714 if _err != nil {
22715 return _result, _err
22716 }
22717 _err = dara.Convert(_body, &_result)
22718 return _result, _err
22719 }
22720
22721 // Summary:
22722 //
22723 // Deletes a resource tag based on a specified resource ID.
22724 //
22725 // @param request - UntagResourcesRequest
22726 //
22727 // @return UntagResourcesResponse
22728 func UntagResources(client *Client, request *UntagResourcesRequest) (_result *UntagResourcesResponse, _err error) {
22729 runtime := &dara.RuntimeOptions{}
22730 _result = &UntagResourcesResponse{}
22731 _body, _err := UntagResourcesWithOptions(client,request, runtime)
22732 if _err != nil {
22733 return _result, _err
22734 }
22735 _result = _body
22736 return _result, _err
22737 }
22738
22739 // Summary:
22740 //
22741 // # Cache Reserve Specification Change
22742 //
22743 // @param request - UpdateCacheReserveSpecRequest
22744 //
22745 // @param runtime - runtime options for this request RuntimeOptions
22746 //
22747 // @return UpdateCacheReserveSpecResponse
22748 func UpdateCacheReserveSpecWithOptions(client *Client, request *UpdateCacheReserveSpecRequest, runtime *dara.RuntimeOptions) (_result *UpdateCacheReserveSpecResponse, _err error) {
22749 if dara.BoolValue(client.EnableValidate) == true {
22750 _err = request.Validate()
22751 if _err != nil {
22752 return _result, _err
22753 }
22754 }
22755 query := map[string]interface{}{}
22756 if !dara.IsNil(request.AutoPay) {
22757 query["AutoPay"] = request.AutoPay
22758 }
22759
22760 if !dara.IsNil(request.ChargeType) {
22761 query["ChargeType"] = request.ChargeType
22762 }
22763
22764 if !dara.IsNil(request.InstanceId) {
22765 query["InstanceId"] = request.InstanceId
22766 }
22767
22768 if !dara.IsNil(request.TargetQuotaGb) {
22769 query["TargetQuotaGb"] = request.TargetQuotaGb
22770 }
22771
22772 req := &openapiutil.OpenApiRequest{
22773 Query: openapiutil.Query(query),
22774 }
22775 params := &openapiutil.Params{
22776 Action: dara.String("UpdateCacheReserveSpec"),
22777 Version: dara.String("2024-09-10"),
22778 Protocol: dara.String("HTTPS"),
22779 Pathname: dara.String("/"),
22780 Method: dara.String("POST"),
22781 AuthType: dara.String("AK"),
22782 Style: dara.String("RPC"),
22783 ReqBodyType: dara.String("formData"),
22784 BodyType: dara.String("json"),
22785 }
22786 _result = &UpdateCacheReserveSpecResponse{}
22787 _body, _err := client.CallApi(params, req, runtime)
22788 if _err != nil {
22789 return _result, _err
22790 }
22791 _err = dara.Convert(_body, &_result)
22792 return _result, _err
22793 }
22794
22795 // Summary:
22796 //
22797 // # Cache Reserve Specification Change
22798 //
22799 // @param request - UpdateCacheReserveSpecRequest
22800 //
22801 // @return UpdateCacheReserveSpecResponse
22802 func UpdateCacheReserveSpec(client *Client, request *UpdateCacheReserveSpecRequest) (_result *UpdateCacheReserveSpecResponse, _err error) {
22803 runtime := &dara.RuntimeOptions{}
22804 _result = &UpdateCacheReserveSpecResponse{}
22805 _body, _err := UpdateCacheReserveSpecWithOptions(client,request, runtime)
22806 if _err != nil {
22807 return _result, _err
22808 }
22809 _result = _body
22810 return _result, _err
22811 }
22812
22813 // Summary:
22814 //
22815 // # Modify cache configuration
22816 //
22817 // @param request - UpdateCacheRuleRequest
22818 //
22819 // @param runtime - runtime options for this request RuntimeOptions
22820 //
22821 // @return UpdateCacheRuleResponse
22822 func UpdateCacheRuleWithOptions(client *Client, request *UpdateCacheRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateCacheRuleResponse, _err error) {
22823 if dara.BoolValue(client.EnableValidate) == true {
22824 _err = request.Validate()
22825 if _err != nil {
22826 return _result, _err
22827 }
22828 }
22829 query := map[string]interface{}{}
22830 if !dara.IsNil(request.AdditionalCacheablePorts) {
22831 query["AdditionalCacheablePorts"] = request.AdditionalCacheablePorts
22832 }
22833
22834 if !dara.IsNil(request.BrowserCacheMode) {
22835 query["BrowserCacheMode"] = request.BrowserCacheMode
22836 }
22837
22838 if !dara.IsNil(request.BrowserCacheTtl) {
22839 query["BrowserCacheTtl"] = request.BrowserCacheTtl
22840 }
22841
22842 if !dara.IsNil(request.BypassCache) {
22843 query["BypassCache"] = request.BypassCache
22844 }
22845
22846 if !dara.IsNil(request.CacheDeceptionArmor) {
22847 query["CacheDeceptionArmor"] = request.CacheDeceptionArmor
22848 }
22849
22850 if !dara.IsNil(request.CacheReserveEligibility) {
22851 query["CacheReserveEligibility"] = request.CacheReserveEligibility
22852 }
22853
22854 if !dara.IsNil(request.CheckPresenceCookie) {
22855 query["CheckPresenceCookie"] = request.CheckPresenceCookie
22856 }
22857
22858 if !dara.IsNil(request.CheckPresenceHeader) {
22859 query["CheckPresenceHeader"] = request.CheckPresenceHeader
22860 }
22861
22862 if !dara.IsNil(request.ConfigId) {
22863 query["ConfigId"] = request.ConfigId
22864 }
22865
22866 if !dara.IsNil(request.EdgeCacheMode) {
22867 query["EdgeCacheMode"] = request.EdgeCacheMode
22868 }
22869
22870 if !dara.IsNil(request.EdgeCacheTtl) {
22871 query["EdgeCacheTtl"] = request.EdgeCacheTtl
22872 }
22873
22874 if !dara.IsNil(request.EdgeStatusCodeCacheTtl) {
22875 query["EdgeStatusCodeCacheTtl"] = request.EdgeStatusCodeCacheTtl
22876 }
22877
22878 if !dara.IsNil(request.IncludeCookie) {
22879 query["IncludeCookie"] = request.IncludeCookie
22880 }
22881
22882 if !dara.IsNil(request.IncludeHeader) {
22883 query["IncludeHeader"] = request.IncludeHeader
22884 }
22885
22886 if !dara.IsNil(request.PostBodyCacheKey) {
22887 query["PostBodyCacheKey"] = request.PostBodyCacheKey
22888 }
22889
22890 if !dara.IsNil(request.PostBodySizeLimit) {
22891 query["PostBodySizeLimit"] = request.PostBodySizeLimit
22892 }
22893
22894 if !dara.IsNil(request.PostCache) {
22895 query["PostCache"] = request.PostCache
22896 }
22897
22898 if !dara.IsNil(request.QueryString) {
22899 query["QueryString"] = request.QueryString
22900 }
22901
22902 if !dara.IsNil(request.QueryStringMode) {
22903 query["QueryStringMode"] = request.QueryStringMode
22904 }
22905
22906 if !dara.IsNil(request.Rule) {
22907 query["Rule"] = request.Rule
22908 }
22909
22910 if !dara.IsNil(request.RuleEnable) {
22911 query["RuleEnable"] = request.RuleEnable
22912 }
22913
22914 if !dara.IsNil(request.RuleName) {
22915 query["RuleName"] = request.RuleName
22916 }
22917
22918 if !dara.IsNil(request.Sequence) {
22919 query["Sequence"] = request.Sequence
22920 }
22921
22922 if !dara.IsNil(request.ServeStale) {
22923 query["ServeStale"] = request.ServeStale
22924 }
22925
22926 if !dara.IsNil(request.SiteId) {
22927 query["SiteId"] = request.SiteId
22928 }
22929
22930 if !dara.IsNil(request.SortQueryStringForCache) {
22931 query["SortQueryStringForCache"] = request.SortQueryStringForCache
22932 }
22933
22934 if !dara.IsNil(request.UserDeviceType) {
22935 query["UserDeviceType"] = request.UserDeviceType
22936 }
22937
22938 if !dara.IsNil(request.UserGeo) {
22939 query["UserGeo"] = request.UserGeo
22940 }
22941
22942 if !dara.IsNil(request.UserLanguage) {
22943 query["UserLanguage"] = request.UserLanguage
22944 }
22945
22946 req := &openapiutil.OpenApiRequest{
22947 Query: openapiutil.Query(query),
22948 }
22949 params := &openapiutil.Params{
22950 Action: dara.String("UpdateCacheRule"),
22951 Version: dara.String("2024-09-10"),
22952 Protocol: dara.String("HTTPS"),
22953 Pathname: dara.String("/"),
22954 Method: dara.String("POST"),
22955 AuthType: dara.String("AK"),
22956 Style: dara.String("RPC"),
22957 ReqBodyType: dara.String("formData"),
22958 BodyType: dara.String("json"),
22959 }
22960 _result = &UpdateCacheRuleResponse{}
22961 _body, _err := client.CallApi(params, req, runtime)
22962 if _err != nil {
22963 return _result, _err
22964 }
22965 _err = dara.Convert(_body, &_result)
22966 return _result, _err
22967 }
22968
22969 // Summary:
22970 //
22971 // # Modify cache configuration
22972 //
22973 // @param request - UpdateCacheRuleRequest
22974 //
22975 // @return UpdateCacheRuleResponse
22976 func UpdateCacheRule(client *Client, request *UpdateCacheRuleRequest) (_result *UpdateCacheRuleResponse, _err error) {
22977 runtime := &dara.RuntimeOptions{}
22978 _result = &UpdateCacheRuleResponse{}
22979 _body, _err := UpdateCacheRuleWithOptions(client,request, runtime)
22980 if _err != nil {
22981 return _result, _err
22982 }
22983 _result = _body
22984 return _result, _err
22985 }
22986
22987 // Summary:
22988 //
22989 // 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.
22990 //
22991 // @param request - UpdateCacheTagRequest
22992 //
22993 // @param runtime - runtime options for this request RuntimeOptions
22994 //
22995 // @return UpdateCacheTagResponse
22996 func UpdateCacheTagWithOptions(client *Client, request *UpdateCacheTagRequest, runtime *dara.RuntimeOptions) (_result *UpdateCacheTagResponse, _err error) {
22997 if dara.BoolValue(client.EnableValidate) == true {
22998 _err = request.Validate()
22999 if _err != nil {
23000 return _result, _err
23001 }
23002 }
23003 query := map[string]interface{}{}
23004 if !dara.IsNil(request.CaseInsensitive) {
23005 query["CaseInsensitive"] = request.CaseInsensitive
23006 }
23007
23008 if !dara.IsNil(request.SiteId) {
23009 query["SiteId"] = request.SiteId
23010 }
23011
23012 if !dara.IsNil(request.SiteVersion) {
23013 query["SiteVersion"] = request.SiteVersion
23014 }
23015
23016 if !dara.IsNil(request.TagName) {
23017 query["TagName"] = request.TagName
23018 }
23019
23020 req := &openapiutil.OpenApiRequest{
23021 Query: openapiutil.Query(query),
23022 }
23023 params := &openapiutil.Params{
23024 Action: dara.String("UpdateCacheTag"),
23025 Version: dara.String("2024-09-10"),
23026 Protocol: dara.String("HTTPS"),
23027 Pathname: dara.String("/"),
23028 Method: dara.String("POST"),
23029 AuthType: dara.String("AK"),
23030 Style: dara.String("RPC"),
23031 ReqBodyType: dara.String("formData"),
23032 BodyType: dara.String("json"),
23033 }
23034 _result = &UpdateCacheTagResponse{}
23035 _body, _err := client.CallApi(params, req, runtime)
23036 if _err != nil {
23037 return _result, _err
23038 }
23039 _err = dara.Convert(_body, &_result)
23040 return _result, _err
23041 }
23042
23043 // Summary:
23044 //
23045 // 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.
23046 //
23047 // @param request - UpdateCacheTagRequest
23048 //
23049 // @return UpdateCacheTagResponse
23050 func UpdateCacheTag(client *Client, request *UpdateCacheTagRequest) (_result *UpdateCacheTagResponse, _err error) {
23051 runtime := &dara.RuntimeOptions{}
23052 _result = &UpdateCacheTagResponse{}
23053 _body, _err := UpdateCacheTagWithOptions(client,request, runtime)
23054 if _err != nil {
23055 return _result, _err
23056 }
23057 _result = _body
23058 return _result, _err
23059 }
23060
23061 // Summary:
23062 //
23063 // Modifies the CNAME flattening configuration of a website.
23064 //
23065 // @param request - UpdateCnameFlatteningRequest
23066 //
23067 // @param runtime - runtime options for this request RuntimeOptions
23068 //
23069 // @return UpdateCnameFlatteningResponse
23070 func UpdateCnameFlatteningWithOptions(client *Client, request *UpdateCnameFlatteningRequest, runtime *dara.RuntimeOptions) (_result *UpdateCnameFlatteningResponse, _err error) {
23071 if dara.BoolValue(client.EnableValidate) == true {
23072 _err = request.Validate()
23073 if _err != nil {
23074 return _result, _err
23075 }
23076 }
23077 query := map[string]interface{}{}
23078 if !dara.IsNil(request.FlattenMode) {
23079 query["FlattenMode"] = request.FlattenMode
23080 }
23081
23082 if !dara.IsNil(request.SiteId) {
23083 query["SiteId"] = request.SiteId
23084 }
23085
23086 req := &openapiutil.OpenApiRequest{
23087 Query: openapiutil.Query(query),
23088 }
23089 params := &openapiutil.Params{
23090 Action: dara.String("UpdateCnameFlattening"),
23091 Version: dara.String("2024-09-10"),
23092 Protocol: dara.String("HTTPS"),
23093 Pathname: dara.String("/"),
23094 Method: dara.String("POST"),
23095 AuthType: dara.String("AK"),
23096 Style: dara.String("RPC"),
23097 ReqBodyType: dara.String("formData"),
23098 BodyType: dara.String("json"),
23099 }
23100 _result = &UpdateCnameFlatteningResponse{}
23101 _body, _err := client.CallApi(params, req, runtime)
23102 if _err != nil {
23103 return _result, _err
23104 }
23105 _err = dara.Convert(_body, &_result)
23106 return _result, _err
23107 }
23108
23109 // Summary:
23110 //
23111 // Modifies the CNAME flattening configuration of a website.
23112 //
23113 // @param request - UpdateCnameFlatteningRequest
23114 //
23115 // @return UpdateCnameFlatteningResponse
23116 func UpdateCnameFlattening(client *Client, request *UpdateCnameFlatteningRequest) (_result *UpdateCnameFlatteningResponse, _err error) {
23117 runtime := &dara.RuntimeOptions{}
23118 _result = &UpdateCnameFlatteningResponse{}
23119 _body, _err := UpdateCnameFlatteningWithOptions(client,request, runtime)
23120 if _err != nil {
23121 return _result, _err
23122 }
23123 _result = _body
23124 return _result, _err
23125 }
23126
23127 // Summary:
23128 //
23129 // # Modify compression rule
23130 //
23131 // @param request - UpdateCompressionRuleRequest
23132 //
23133 // @param runtime - runtime options for this request RuntimeOptions
23134 //
23135 // @return UpdateCompressionRuleResponse
23136 func UpdateCompressionRuleWithOptions(client *Client, request *UpdateCompressionRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateCompressionRuleResponse, _err error) {
23137 if dara.BoolValue(client.EnableValidate) == true {
23138 _err = request.Validate()
23139 if _err != nil {
23140 return _result, _err
23141 }
23142 }
23143 query := map[string]interface{}{}
23144 if !dara.IsNil(request.Brotli) {
23145 query["Brotli"] = request.Brotli
23146 }
23147
23148 if !dara.IsNil(request.ConfigId) {
23149 query["ConfigId"] = request.ConfigId
23150 }
23151
23152 if !dara.IsNil(request.Gzip) {
23153 query["Gzip"] = request.Gzip
23154 }
23155
23156 if !dara.IsNil(request.Rule) {
23157 query["Rule"] = request.Rule
23158 }
23159
23160 if !dara.IsNil(request.RuleEnable) {
23161 query["RuleEnable"] = request.RuleEnable
23162 }
23163
23164 if !dara.IsNil(request.RuleName) {
23165 query["RuleName"] = request.RuleName
23166 }
23167
23168 if !dara.IsNil(request.Sequence) {
23169 query["Sequence"] = request.Sequence
23170 }
23171
23172 if !dara.IsNil(request.SiteId) {
23173 query["SiteId"] = request.SiteId
23174 }
23175
23176 if !dara.IsNil(request.Zstd) {
23177 query["Zstd"] = request.Zstd
23178 }
23179
23180 req := &openapiutil.OpenApiRequest{
23181 Query: openapiutil.Query(query),
23182 }
23183 params := &openapiutil.Params{
23184 Action: dara.String("UpdateCompressionRule"),
23185 Version: dara.String("2024-09-10"),
23186 Protocol: dara.String("HTTPS"),
23187 Pathname: dara.String("/"),
23188 Method: dara.String("POST"),
23189 AuthType: dara.String("AK"),
23190 Style: dara.String("RPC"),
23191 ReqBodyType: dara.String("formData"),
23192 BodyType: dara.String("json"),
23193 }
23194 _result = &UpdateCompressionRuleResponse{}
23195 _body, _err := client.CallApi(params, req, runtime)
23196 if _err != nil {
23197 return _result, _err
23198 }
23199 _err = dara.Convert(_body, &_result)
23200 return _result, _err
23201 }
23202
23203 // Summary:
23204 //
23205 // # Modify compression rule
23206 //
23207 // @param request - UpdateCompressionRuleRequest
23208 //
23209 // @return UpdateCompressionRuleResponse
23210 func UpdateCompressionRule(client *Client, request *UpdateCompressionRuleRequest) (_result *UpdateCompressionRuleResponse, _err error) {
23211 runtime := &dara.RuntimeOptions{}
23212 _result = &UpdateCompressionRuleResponse{}
23213 _body, _err := UpdateCompressionRuleWithOptions(client,request, runtime)
23214 if _err != nil {
23215 return _result, _err
23216 }
23217 _result = _body
23218 return _result, _err
23219 }
23220
23221 // Summary:
23222 //
23223 // Modifies the configuration of the Chinese mainland network access optimization.
23224 //
23225 // @param request - UpdateCrossBorderOptimizationRequest
23226 //
23227 // @param runtime - runtime options for this request RuntimeOptions
23228 //
23229 // @return UpdateCrossBorderOptimizationResponse
23230 func UpdateCrossBorderOptimizationWithOptions(client *Client, request *UpdateCrossBorderOptimizationRequest, runtime *dara.RuntimeOptions) (_result *UpdateCrossBorderOptimizationResponse, _err error) {
23231 if dara.BoolValue(client.EnableValidate) == true {
23232 _err = request.Validate()
23233 if _err != nil {
23234 return _result, _err
23235 }
23236 }
23237 query := map[string]interface{}{}
23238 if !dara.IsNil(request.Enable) {
23239 query["Enable"] = request.Enable
23240 }
23241
23242 if !dara.IsNil(request.SiteId) {
23243 query["SiteId"] = request.SiteId
23244 }
23245
23246 req := &openapiutil.OpenApiRequest{
23247 Query: openapiutil.Query(query),
23248 }
23249 params := &openapiutil.Params{
23250 Action: dara.String("UpdateCrossBorderOptimization"),
23251 Version: dara.String("2024-09-10"),
23252 Protocol: dara.String("HTTPS"),
23253 Pathname: dara.String("/"),
23254 Method: dara.String("POST"),
23255 AuthType: dara.String("AK"),
23256 Style: dara.String("RPC"),
23257 ReqBodyType: dara.String("formData"),
23258 BodyType: dara.String("json"),
23259 }
23260 _result = &UpdateCrossBorderOptimizationResponse{}
23261 _body, _err := client.CallApi(params, req, runtime)
23262 if _err != nil {
23263 return _result, _err
23264 }
23265 _err = dara.Convert(_body, &_result)
23266 return _result, _err
23267 }
23268
23269 // Summary:
23270 //
23271 // Modifies the configuration of the Chinese mainland network access optimization.
23272 //
23273 // @param request - UpdateCrossBorderOptimizationRequest
23274 //
23275 // @return UpdateCrossBorderOptimizationResponse
23276 func UpdateCrossBorderOptimization(client *Client, request *UpdateCrossBorderOptimizationRequest) (_result *UpdateCrossBorderOptimizationResponse, _err error) {
23277 runtime := &dara.RuntimeOptions{}
23278 _result = &UpdateCrossBorderOptimizationResponse{}
23279 _body, _err := UpdateCrossBorderOptimizationWithOptions(client,request, runtime)
23280 if _err != nil {
23281 return _result, _err
23282 }
23283 _result = _body
23284 return _result, _err
23285 }
23286
23287 // Summary:
23288 //
23289 // Modifies the configurations of a custom scenario-specific policy.
23290 //
23291 // @param request - UpdateCustomScenePolicyRequest
23292 //
23293 // @param runtime - runtime options for this request RuntimeOptions
23294 //
23295 // @return UpdateCustomScenePolicyResponse
23296 func UpdateCustomScenePolicyWithOptions(client *Client, request *UpdateCustomScenePolicyRequest, runtime *dara.RuntimeOptions) (_result *UpdateCustomScenePolicyResponse, _err error) {
23297 if dara.BoolValue(client.EnableValidate) == true {
23298 _err = request.Validate()
23299 if _err != nil {
23300 return _result, _err
23301 }
23302 }
23303 query := map[string]interface{}{}
23304 if !dara.IsNil(request.EndTime) {
23305 query["EndTime"] = request.EndTime
23306 }
23307
23308 if !dara.IsNil(request.Name) {
23309 query["Name"] = request.Name
23310 }
23311
23312 if !dara.IsNil(request.Objects) {
23313 query["Objects"] = request.Objects
23314 }
23315
23316 if !dara.IsNil(request.PolicyId) {
23317 query["PolicyId"] = request.PolicyId
23318 }
23319
23320 if !dara.IsNil(request.SiteIds) {
23321 query["SiteIds"] = request.SiteIds
23322 }
23323
23324 if !dara.IsNil(request.StartTime) {
23325 query["StartTime"] = request.StartTime
23326 }
23327
23328 if !dara.IsNil(request.Template) {
23329 query["Template"] = request.Template
23330 }
23331
23332 req := &openapiutil.OpenApiRequest{
23333 Query: openapiutil.Query(query),
23334 }
23335 params := &openapiutil.Params{
23336 Action: dara.String("UpdateCustomScenePolicy"),
23337 Version: dara.String("2024-09-10"),
23338 Protocol: dara.String("HTTPS"),
23339 Pathname: dara.String("/"),
23340 Method: dara.String("POST"),
23341 AuthType: dara.String("AK"),
23342 Style: dara.String("RPC"),
23343 ReqBodyType: dara.String("formData"),
23344 BodyType: dara.String("json"),
23345 }
23346 _result = &UpdateCustomScenePolicyResponse{}
23347 _body, _err := client.CallApi(params, req, runtime)
23348 if _err != nil {
23349 return _result, _err
23350 }
23351 _err = dara.Convert(_body, &_result)
23352 return _result, _err
23353 }
23354
23355 // Summary:
23356 //
23357 // Modifies the configurations of a custom scenario-specific policy.
23358 //
23359 // @param request - UpdateCustomScenePolicyRequest
23360 //
23361 // @return UpdateCustomScenePolicyResponse
23362 func UpdateCustomScenePolicy(client *Client, request *UpdateCustomScenePolicyRequest) (_result *UpdateCustomScenePolicyResponse, _err error) {
23363 runtime := &dara.RuntimeOptions{}
23364 _result = &UpdateCustomScenePolicyResponse{}
23365 _body, _err := UpdateCustomScenePolicyWithOptions(client,request, runtime)
23366 if _err != nil {
23367 return _result, _err
23368 }
23369 _result = _body
23370 return _result, _err
23371 }
23372
23373 // Summary:
23374 //
23375 // 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.
23376 //
23377 // @param request - UpdateDevelopmentModeRequest
23378 //
23379 // @param runtime - runtime options for this request RuntimeOptions
23380 //
23381 // @return UpdateDevelopmentModeResponse
23382 func UpdateDevelopmentModeWithOptions(client *Client, request *UpdateDevelopmentModeRequest, runtime *dara.RuntimeOptions) (_result *UpdateDevelopmentModeResponse, _err error) {
23383 if dara.BoolValue(client.EnableValidate) == true {
23384 _err = request.Validate()
23385 if _err != nil {
23386 return _result, _err
23387 }
23388 }
23389 query := map[string]interface{}{}
23390 if !dara.IsNil(request.Enable) {
23391 query["Enable"] = request.Enable
23392 }
23393
23394 if !dara.IsNil(request.SiteId) {
23395 query["SiteId"] = request.SiteId
23396 }
23397
23398 req := &openapiutil.OpenApiRequest{
23399 Query: openapiutil.Query(query),
23400 }
23401 params := &openapiutil.Params{
23402 Action: dara.String("UpdateDevelopmentMode"),
23403 Version: dara.String("2024-09-10"),
23404 Protocol: dara.String("HTTPS"),
23405 Pathname: dara.String("/"),
23406 Method: dara.String("POST"),
23407 AuthType: dara.String("AK"),
23408 Style: dara.String("RPC"),
23409 ReqBodyType: dara.String("formData"),
23410 BodyType: dara.String("json"),
23411 }
23412 _result = &UpdateDevelopmentModeResponse{}
23413 _body, _err := client.CallApi(params, req, runtime)
23414 if _err != nil {
23415 return _result, _err
23416 }
23417 _err = dara.Convert(_body, &_result)
23418 return _result, _err
23419 }
23420
23421 // Summary:
23422 //
23423 // 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.
23424 //
23425 // @param request - UpdateDevelopmentModeRequest
23426 //
23427 // @return UpdateDevelopmentModeResponse
23428 func UpdateDevelopmentMode(client *Client, request *UpdateDevelopmentModeRequest) (_result *UpdateDevelopmentModeResponse, _err error) {
23429 runtime := &dara.RuntimeOptions{}
23430 _result = &UpdateDevelopmentModeResponse{}
23431 _body, _err := UpdateDevelopmentModeWithOptions(client,request, runtime)
23432 if _err != nil {
23433 return _result, _err
23434 }
23435 _result = _body
23436 return _result, _err
23437 }
23438
23439 // Summary:
23440 //
23441 // Updates the log collection configuration of a containerized application.
23442 //
23443 // @param request - UpdateEdgeContainerAppLogRiverRequest
23444 //
23445 // @param runtime - runtime options for this request RuntimeOptions
23446 //
23447 // @return UpdateEdgeContainerAppLogRiverResponse
23448 func UpdateEdgeContainerAppLogRiverWithOptions(client *Client, request *UpdateEdgeContainerAppLogRiverRequest, runtime *dara.RuntimeOptions) (_result *UpdateEdgeContainerAppLogRiverResponse, _err error) {
23449 if dara.BoolValue(client.EnableValidate) == true {
23450 _err = request.Validate()
23451 if _err != nil {
23452 return _result, _err
23453 }
23454 }
23455 query := map[string]interface{}{}
23456 if !dara.IsNil(request.AppId) {
23457 query["AppId"] = request.AppId
23458 }
23459
23460 if !dara.IsNil(request.Path) {
23461 query["Path"] = request.Path
23462 }
23463
23464 if !dara.IsNil(request.Stdout) {
23465 query["Stdout"] = request.Stdout
23466 }
23467
23468 req := &openapiutil.OpenApiRequest{
23469 Query: openapiutil.Query(query),
23470 }
23471 params := &openapiutil.Params{
23472 Action: dara.String("UpdateEdgeContainerAppLogRiver"),
23473 Version: dara.String("2024-09-10"),
23474 Protocol: dara.String("HTTPS"),
23475 Pathname: dara.String("/"),
23476 Method: dara.String("POST"),
23477 AuthType: dara.String("AK"),
23478 Style: dara.String("RPC"),
23479 ReqBodyType: dara.String("formData"),
23480 BodyType: dara.String("json"),
23481 }
23482 _result = &UpdateEdgeContainerAppLogRiverResponse{}
23483 _body, _err := client.CallApi(params, req, runtime)
23484 if _err != nil {
23485 return _result, _err
23486 }
23487 _err = dara.Convert(_body, &_result)
23488 return _result, _err
23489 }
23490
23491 // Summary:
23492 //
23493 // Updates the log collection configuration of a containerized application.
23494 //
23495 // @param request - UpdateEdgeContainerAppLogRiverRequest
23496 //
23497 // @return UpdateEdgeContainerAppLogRiverResponse
23498 func UpdateEdgeContainerAppLogRiver(client *Client, request *UpdateEdgeContainerAppLogRiverRequest) (_result *UpdateEdgeContainerAppLogRiverResponse, _err error) {
23499 runtime := &dara.RuntimeOptions{}
23500 _result = &UpdateEdgeContainerAppLogRiverResponse{}
23501 _body, _err := UpdateEdgeContainerAppLogRiverWithOptions(client,request, runtime)
23502 if _err != nil {
23503 return _result, _err
23504 }
23505 _result = _body
23506 return _result, _err
23507 }
23508
23509 // Summary:
23510 //
23511 // Updates the resource reservation configuration of an edge container.
23512 //
23513 // @param tmpReq - UpdateEdgeContainerAppResourceReserveRequest
23514 //
23515 // @param runtime - runtime options for this request RuntimeOptions
23516 //
23517 // @return UpdateEdgeContainerAppResourceReserveResponse
23518 func UpdateEdgeContainerAppResourceReserveWithOptions(client *Client, tmpReq *UpdateEdgeContainerAppResourceReserveRequest, runtime *dara.RuntimeOptions) (_result *UpdateEdgeContainerAppResourceReserveResponse, _err error) {
23519 if dara.BoolValue(client.EnableValidate) == true {
23520 _err = tmpReq.Validate()
23521 if _err != nil {
23522 return _result, _err
23523 }
23524 }
23525 request := &UpdateEdgeContainerAppResourceReserveShrinkRequest{}
23526 openapiutil.Convert(tmpReq, request)
23527 if !dara.IsNil(tmpReq.ReserveSet) {
23528 request.ReserveSetShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ReserveSet, dara.String("ReserveSet"), dara.String("json"))
23529 }
23530
23531 query := map[string]interface{}{}
23532 if !dara.IsNil(request.AppId) {
23533 query["AppId"] = request.AppId
23534 }
23535
23536 if !dara.IsNil(request.DurationTime) {
23537 query["DurationTime"] = request.DurationTime
23538 }
23539
23540 if !dara.IsNil(request.Enable) {
23541 query["Enable"] = request.Enable
23542 }
23543
23544 if !dara.IsNil(request.Forever) {
23545 query["Forever"] = request.Forever
23546 }
23547
23548 if !dara.IsNil(request.ReserveSetShrink) {
23549 query["ReserveSet"] = request.ReserveSetShrink
23550 }
23551
23552 req := &openapiutil.OpenApiRequest{
23553 Query: openapiutil.Query(query),
23554 }
23555 params := &openapiutil.Params{
23556 Action: dara.String("UpdateEdgeContainerAppResourceReserve"),
23557 Version: dara.String("2024-09-10"),
23558 Protocol: dara.String("HTTPS"),
23559 Pathname: dara.String("/"),
23560 Method: dara.String("POST"),
23561 AuthType: dara.String("AK"),
23562 Style: dara.String("RPC"),
23563 ReqBodyType: dara.String("formData"),
23564 BodyType: dara.String("json"),
23565 }
23566 _result = &UpdateEdgeContainerAppResourceReserveResponse{}
23567 _body, _err := client.CallApi(params, req, runtime)
23568 if _err != nil {
23569 return _result, _err
23570 }
23571 _err = dara.Convert(_body, &_result)
23572 return _result, _err
23573 }
23574
23575 // Summary:
23576 //
23577 // Updates the resource reservation configuration of an edge container.
23578 //
23579 // @param request - UpdateEdgeContainerAppResourceReserveRequest
23580 //
23581 // @return UpdateEdgeContainerAppResourceReserveResponse
23582 func UpdateEdgeContainerAppResourceReserve(client *Client, request *UpdateEdgeContainerAppResourceReserveRequest) (_result *UpdateEdgeContainerAppResourceReserveResponse, _err error) {
23583 runtime := &dara.RuntimeOptions{}
23584 _result = &UpdateEdgeContainerAppResourceReserveResponse{}
23585 _body, _err := UpdateEdgeContainerAppResourceReserveWithOptions(client,request, runtime)
23586 if _err != nil {
23587 return _result, _err
23588 }
23589 _result = _body
23590 return _result, _err
23591 }
23592
23593 // Summary:
23594 //
23595 // Updates the HTTP incoming request header modification rule.
23596 //
23597 // @param tmpReq - UpdateHttpIncomingRequestHeaderModificationRuleRequest
23598 //
23599 // @param runtime - runtime options for this request RuntimeOptions
23600 //
23601 // @return UpdateHttpIncomingRequestHeaderModificationRuleResponse
23602 func UpdateHttpIncomingRequestHeaderModificationRuleWithOptions(client *Client, tmpReq *UpdateHttpIncomingRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateHttpIncomingRequestHeaderModificationRuleResponse, _err error) {
23603 if dara.BoolValue(client.EnableValidate) == true {
23604 _err = tmpReq.Validate()
23605 if _err != nil {
23606 return _result, _err
23607 }
23608 }
23609 request := &UpdateHttpIncomingRequestHeaderModificationRuleShrinkRequest{}
23610 openapiutil.Convert(tmpReq, request)
23611 if !dara.IsNil(tmpReq.RequestHeaderModification) {
23612 request.RequestHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RequestHeaderModification, dara.String("RequestHeaderModification"), dara.String("json"))
23613 }
23614
23615 query := map[string]interface{}{}
23616 if !dara.IsNil(request.ConfigId) {
23617 query["ConfigId"] = request.ConfigId
23618 }
23619
23620 if !dara.IsNil(request.RequestHeaderModificationShrink) {
23621 query["RequestHeaderModification"] = request.RequestHeaderModificationShrink
23622 }
23623
23624 if !dara.IsNil(request.Rule) {
23625 query["Rule"] = request.Rule
23626 }
23627
23628 if !dara.IsNil(request.RuleEnable) {
23629 query["RuleEnable"] = request.RuleEnable
23630 }
23631
23632 if !dara.IsNil(request.RuleName) {
23633 query["RuleName"] = request.RuleName
23634 }
23635
23636 if !dara.IsNil(request.Sequence) {
23637 query["Sequence"] = request.Sequence
23638 }
23639
23640 if !dara.IsNil(request.SiteId) {
23641 query["SiteId"] = request.SiteId
23642 }
23643
23644 req := &openapiutil.OpenApiRequest{
23645 Query: openapiutil.Query(query),
23646 }
23647 params := &openapiutil.Params{
23648 Action: dara.String("UpdateHttpIncomingRequestHeaderModificationRule"),
23649 Version: dara.String("2024-09-10"),
23650 Protocol: dara.String("HTTPS"),
23651 Pathname: dara.String("/"),
23652 Method: dara.String("POST"),
23653 AuthType: dara.String("AK"),
23654 Style: dara.String("RPC"),
23655 ReqBodyType: dara.String("formData"),
23656 BodyType: dara.String("json"),
23657 }
23658 _result = &UpdateHttpIncomingRequestHeaderModificationRuleResponse{}
23659 _body, _err := client.CallApi(params, req, runtime)
23660 if _err != nil {
23661 return _result, _err
23662 }
23663 _err = dara.Convert(_body, &_result)
23664 return _result, _err
23665 }
23666
23667 // Summary:
23668 //
23669 // Updates the HTTP incoming request header modification rule.
23670 //
23671 // @param request - UpdateHttpIncomingRequestHeaderModificationRuleRequest
23672 //
23673 // @return UpdateHttpIncomingRequestHeaderModificationRuleResponse
23674 func UpdateHttpIncomingRequestHeaderModificationRule(client *Client, request *UpdateHttpIncomingRequestHeaderModificationRuleRequest) (_result *UpdateHttpIncomingRequestHeaderModificationRuleResponse, _err error) {
23675 runtime := &dara.RuntimeOptions{}
23676 _result = &UpdateHttpIncomingRequestHeaderModificationRuleResponse{}
23677 _body, _err := UpdateHttpIncomingRequestHeaderModificationRuleWithOptions(client,request, runtime)
23678 if _err != nil {
23679 return _result, _err
23680 }
23681 _result = _body
23682 return _result, _err
23683 }
23684
23685 // Summary:
23686 //
23687 // Updates the configuration of modifying HTTP response headers for a website.
23688 //
23689 // @param tmpReq - UpdateHttpIncomingResponseHeaderModificationRuleRequest
23690 //
23691 // @param runtime - runtime options for this request RuntimeOptions
23692 //
23693 // @return UpdateHttpIncomingResponseHeaderModificationRuleResponse
23694 func UpdateHttpIncomingResponseHeaderModificationRuleWithOptions(client *Client, tmpReq *UpdateHttpIncomingResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateHttpIncomingResponseHeaderModificationRuleResponse, _err error) {
23695 if dara.BoolValue(client.EnableValidate) == true {
23696 _err = tmpReq.Validate()
23697 if _err != nil {
23698 return _result, _err
23699 }
23700 }
23701 request := &UpdateHttpIncomingResponseHeaderModificationRuleShrinkRequest{}
23702 openapiutil.Convert(tmpReq, request)
23703 if !dara.IsNil(tmpReq.ResponseHeaderModification) {
23704 request.ResponseHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ResponseHeaderModification, dara.String("ResponseHeaderModification"), dara.String("json"))
23705 }
23706
23707 query := map[string]interface{}{}
23708 if !dara.IsNil(request.ConfigId) {
23709 query["ConfigId"] = request.ConfigId
23710 }
23711
23712 if !dara.IsNil(request.ResponseHeaderModificationShrink) {
23713 query["ResponseHeaderModification"] = request.ResponseHeaderModificationShrink
23714 }
23715
23716 if !dara.IsNil(request.Rule) {
23717 query["Rule"] = request.Rule
23718 }
23719
23720 if !dara.IsNil(request.RuleEnable) {
23721 query["RuleEnable"] = request.RuleEnable
23722 }
23723
23724 if !dara.IsNil(request.RuleName) {
23725 query["RuleName"] = request.RuleName
23726 }
23727
23728 if !dara.IsNil(request.Sequence) {
23729 query["Sequence"] = request.Sequence
23730 }
23731
23732 if !dara.IsNil(request.SiteId) {
23733 query["SiteId"] = request.SiteId
23734 }
23735
23736 req := &openapiutil.OpenApiRequest{
23737 Query: openapiutil.Query(query),
23738 }
23739 params := &openapiutil.Params{
23740 Action: dara.String("UpdateHttpIncomingResponseHeaderModificationRule"),
23741 Version: dara.String("2024-09-10"),
23742 Protocol: dara.String("HTTPS"),
23743 Pathname: dara.String("/"),
23744 Method: dara.String("POST"),
23745 AuthType: dara.String("AK"),
23746 Style: dara.String("RPC"),
23747 ReqBodyType: dara.String("formData"),
23748 BodyType: dara.String("json"),
23749 }
23750 _result = &UpdateHttpIncomingResponseHeaderModificationRuleResponse{}
23751 _body, _err := client.CallApi(params, req, runtime)
23752 if _err != nil {
23753 return _result, _err
23754 }
23755 _err = dara.Convert(_body, &_result)
23756 return _result, _err
23757 }
23758
23759 // Summary:
23760 //
23761 // Updates the configuration of modifying HTTP response headers for a website.
23762 //
23763 // @param request - UpdateHttpIncomingResponseHeaderModificationRuleRequest
23764 //
23765 // @return UpdateHttpIncomingResponseHeaderModificationRuleResponse
23766 func UpdateHttpIncomingResponseHeaderModificationRule(client *Client, request *UpdateHttpIncomingResponseHeaderModificationRuleRequest) (_result *UpdateHttpIncomingResponseHeaderModificationRuleResponse, _err error) {
23767 runtime := &dara.RuntimeOptions{}
23768 _result = &UpdateHttpIncomingResponseHeaderModificationRuleResponse{}
23769 _body, _err := UpdateHttpIncomingResponseHeaderModificationRuleWithOptions(client,request, runtime)
23770 if _err != nil {
23771 return _result, _err
23772 }
23773 _result = _body
23774 return _result, _err
23775 }
23776
23777 // Summary:
23778 //
23779 // # Modify HTTP Request Header Rules
23780 //
23781 // @param tmpReq - UpdateHttpRequestHeaderModificationRuleRequest
23782 //
23783 // @param runtime - runtime options for this request RuntimeOptions
23784 //
23785 // @return UpdateHttpRequestHeaderModificationRuleResponse
23786 func UpdateHttpRequestHeaderModificationRuleWithOptions(client *Client, tmpReq *UpdateHttpRequestHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateHttpRequestHeaderModificationRuleResponse, _err error) {
23787 if dara.BoolValue(client.EnableValidate) == true {
23788 _err = tmpReq.Validate()
23789 if _err != nil {
23790 return _result, _err
23791 }
23792 }
23793 request := &UpdateHttpRequestHeaderModificationRuleShrinkRequest{}
23794 openapiutil.Convert(tmpReq, request)
23795 if !dara.IsNil(tmpReq.RequestHeaderModification) {
23796 request.RequestHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RequestHeaderModification, dara.String("RequestHeaderModification"), dara.String("json"))
23797 }
23798
23799 query := map[string]interface{}{}
23800 if !dara.IsNil(request.ConfigId) {
23801 query["ConfigId"] = request.ConfigId
23802 }
23803
23804 if !dara.IsNil(request.RequestHeaderModificationShrink) {
23805 query["RequestHeaderModification"] = request.RequestHeaderModificationShrink
23806 }
23807
23808 if !dara.IsNil(request.Rule) {
23809 query["Rule"] = request.Rule
23810 }
23811
23812 if !dara.IsNil(request.RuleEnable) {
23813 query["RuleEnable"] = request.RuleEnable
23814 }
23815
23816 if !dara.IsNil(request.RuleName) {
23817 query["RuleName"] = request.RuleName
23818 }
23819
23820 if !dara.IsNil(request.Sequence) {
23821 query["Sequence"] = request.Sequence
23822 }
23823
23824 if !dara.IsNil(request.SiteId) {
23825 query["SiteId"] = request.SiteId
23826 }
23827
23828 req := &openapiutil.OpenApiRequest{
23829 Query: openapiutil.Query(query),
23830 }
23831 params := &openapiutil.Params{
23832 Action: dara.String("UpdateHttpRequestHeaderModificationRule"),
23833 Version: dara.String("2024-09-10"),
23834 Protocol: dara.String("HTTPS"),
23835 Pathname: dara.String("/"),
23836 Method: dara.String("POST"),
23837 AuthType: dara.String("AK"),
23838 Style: dara.String("RPC"),
23839 ReqBodyType: dara.String("formData"),
23840 BodyType: dara.String("json"),
23841 }
23842 _result = &UpdateHttpRequestHeaderModificationRuleResponse{}
23843 _body, _err := client.CallApi(params, req, runtime)
23844 if _err != nil {
23845 return _result, _err
23846 }
23847 _err = dara.Convert(_body, &_result)
23848 return _result, _err
23849 }
23850
23851 // Summary:
23852 //
23853 // # Modify HTTP Request Header Rules
23854 //
23855 // @param request - UpdateHttpRequestHeaderModificationRuleRequest
23856 //
23857 // @return UpdateHttpRequestHeaderModificationRuleResponse
23858 func UpdateHttpRequestHeaderModificationRule(client *Client, request *UpdateHttpRequestHeaderModificationRuleRequest) (_result *UpdateHttpRequestHeaderModificationRuleResponse, _err error) {
23859 runtime := &dara.RuntimeOptions{}
23860 _result = &UpdateHttpRequestHeaderModificationRuleResponse{}
23861 _body, _err := UpdateHttpRequestHeaderModificationRuleWithOptions(client,request, runtime)
23862 if _err != nil {
23863 return _result, _err
23864 }
23865 _result = _body
23866 return _result, _err
23867 }
23868
23869 // Summary:
23870 //
23871 // # Modify HTTP response header rules
23872 //
23873 // @param tmpReq - UpdateHttpResponseHeaderModificationRuleRequest
23874 //
23875 // @param runtime - runtime options for this request RuntimeOptions
23876 //
23877 // @return UpdateHttpResponseHeaderModificationRuleResponse
23878 func UpdateHttpResponseHeaderModificationRuleWithOptions(client *Client, tmpReq *UpdateHttpResponseHeaderModificationRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateHttpResponseHeaderModificationRuleResponse, _err error) {
23879 if dara.BoolValue(client.EnableValidate) == true {
23880 _err = tmpReq.Validate()
23881 if _err != nil {
23882 return _result, _err
23883 }
23884 }
23885 request := &UpdateHttpResponseHeaderModificationRuleShrinkRequest{}
23886 openapiutil.Convert(tmpReq, request)
23887 if !dara.IsNil(tmpReq.ResponseHeaderModification) {
23888 request.ResponseHeaderModificationShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ResponseHeaderModification, dara.String("ResponseHeaderModification"), dara.String("json"))
23889 }
23890
23891 query := map[string]interface{}{}
23892 if !dara.IsNil(request.ConfigId) {
23893 query["ConfigId"] = request.ConfigId
23894 }
23895
23896 if !dara.IsNil(request.ResponseHeaderModificationShrink) {
23897 query["ResponseHeaderModification"] = request.ResponseHeaderModificationShrink
23898 }
23899
23900 if !dara.IsNil(request.Rule) {
23901 query["Rule"] = request.Rule
23902 }
23903
23904 if !dara.IsNil(request.RuleEnable) {
23905 query["RuleEnable"] = request.RuleEnable
23906 }
23907
23908 if !dara.IsNil(request.RuleName) {
23909 query["RuleName"] = request.RuleName
23910 }
23911
23912 if !dara.IsNil(request.Sequence) {
23913 query["Sequence"] = request.Sequence
23914 }
23915
23916 if !dara.IsNil(request.SiteId) {
23917 query["SiteId"] = request.SiteId
23918 }
23919
23920 req := &openapiutil.OpenApiRequest{
23921 Query: openapiutil.Query(query),
23922 }
23923 params := &openapiutil.Params{
23924 Action: dara.String("UpdateHttpResponseHeaderModificationRule"),
23925 Version: dara.String("2024-09-10"),
23926 Protocol: dara.String("HTTPS"),
23927 Pathname: dara.String("/"),
23928 Method: dara.String("POST"),
23929 AuthType: dara.String("AK"),
23930 Style: dara.String("RPC"),
23931 ReqBodyType: dara.String("formData"),
23932 BodyType: dara.String("json"),
23933 }
23934 _result = &UpdateHttpResponseHeaderModificationRuleResponse{}
23935 _body, _err := client.CallApi(params, req, runtime)
23936 if _err != nil {
23937 return _result, _err
23938 }
23939 _err = dara.Convert(_body, &_result)
23940 return _result, _err
23941 }
23942
23943 // Summary:
23944 //
23945 // # Modify HTTP response header rules
23946 //
23947 // @param request - UpdateHttpResponseHeaderModificationRuleRequest
23948 //
23949 // @return UpdateHttpResponseHeaderModificationRuleResponse
23950 func UpdateHttpResponseHeaderModificationRule(client *Client, request *UpdateHttpResponseHeaderModificationRuleRequest) (_result *UpdateHttpResponseHeaderModificationRuleResponse, _err error) {
23951 runtime := &dara.RuntimeOptions{}
23952 _result = &UpdateHttpResponseHeaderModificationRuleResponse{}
23953 _body, _err := UpdateHttpResponseHeaderModificationRuleWithOptions(client,request, runtime)
23954 if _err != nil {
23955 return _result, _err
23956 }
23957 _result = _body
23958 return _result, _err
23959 }
23960
23961 // Summary:
23962 //
23963 // # Modify HTTPS Application Configuration
23964 //
23965 // @param request - UpdateHttpsApplicationConfigurationRequest
23966 //
23967 // @param runtime - runtime options for this request RuntimeOptions
23968 //
23969 // @return UpdateHttpsApplicationConfigurationResponse
23970 func UpdateHttpsApplicationConfigurationWithOptions(client *Client, request *UpdateHttpsApplicationConfigurationRequest, runtime *dara.RuntimeOptions) (_result *UpdateHttpsApplicationConfigurationResponse, _err error) {
23971 if dara.BoolValue(client.EnableValidate) == true {
23972 _err = request.Validate()
23973 if _err != nil {
23974 return _result, _err
23975 }
23976 }
23977 query := map[string]interface{}{}
23978 if !dara.IsNil(request.AltSvc) {
23979 query["AltSvc"] = request.AltSvc
23980 }
23981
23982 if !dara.IsNil(request.AltSvcClear) {
23983 query["AltSvcClear"] = request.AltSvcClear
23984 }
23985
23986 if !dara.IsNil(request.AltSvcMa) {
23987 query["AltSvcMa"] = request.AltSvcMa
23988 }
23989
23990 if !dara.IsNil(request.AltSvcPersist) {
23991 query["AltSvcPersist"] = request.AltSvcPersist
23992 }
23993
23994 if !dara.IsNil(request.ConfigId) {
23995 query["ConfigId"] = request.ConfigId
23996 }
23997
23998 if !dara.IsNil(request.Hsts) {
23999 query["Hsts"] = request.Hsts
24000 }
24001
24002 if !dara.IsNil(request.HstsIncludeSubdomains) {
24003 query["HstsIncludeSubdomains"] = request.HstsIncludeSubdomains
24004 }
24005
24006 if !dara.IsNil(request.HstsMaxAge) {
24007 query["HstsMaxAge"] = request.HstsMaxAge
24008 }
24009
24010 if !dara.IsNil(request.HstsPreload) {
24011 query["HstsPreload"] = request.HstsPreload
24012 }
24013
24014 if !dara.IsNil(request.HttpsForce) {
24015 query["HttpsForce"] = request.HttpsForce
24016 }
24017
24018 if !dara.IsNil(request.HttpsForceCode) {
24019 query["HttpsForceCode"] = request.HttpsForceCode
24020 }
24021
24022 if !dara.IsNil(request.HttpsNoSniDeny) {
24023 query["HttpsNoSniDeny"] = request.HttpsNoSniDeny
24024 }
24025
24026 if !dara.IsNil(request.HttpsSniVerify) {
24027 query["HttpsSniVerify"] = request.HttpsSniVerify
24028 }
24029
24030 if !dara.IsNil(request.HttpsSniWhitelist) {
24031 query["HttpsSniWhitelist"] = request.HttpsSniWhitelist
24032 }
24033
24034 if !dara.IsNil(request.Rule) {
24035 query["Rule"] = request.Rule
24036 }
24037
24038 if !dara.IsNil(request.RuleEnable) {
24039 query["RuleEnable"] = request.RuleEnable
24040 }
24041
24042 if !dara.IsNil(request.RuleName) {
24043 query["RuleName"] = request.RuleName
24044 }
24045
24046 if !dara.IsNil(request.Sequence) {
24047 query["Sequence"] = request.Sequence
24048 }
24049
24050 if !dara.IsNil(request.SiteId) {
24051 query["SiteId"] = request.SiteId
24052 }
24053
24054 req := &openapiutil.OpenApiRequest{
24055 Query: openapiutil.Query(query),
24056 }
24057 params := &openapiutil.Params{
24058 Action: dara.String("UpdateHttpsApplicationConfiguration"),
24059 Version: dara.String("2024-09-10"),
24060 Protocol: dara.String("HTTPS"),
24061 Pathname: dara.String("/"),
24062 Method: dara.String("POST"),
24063 AuthType: dara.String("AK"),
24064 Style: dara.String("RPC"),
24065 ReqBodyType: dara.String("formData"),
24066 BodyType: dara.String("json"),
24067 }
24068 _result = &UpdateHttpsApplicationConfigurationResponse{}
24069 _body, _err := client.CallApi(params, req, runtime)
24070 if _err != nil {
24071 return _result, _err
24072 }
24073 _err = dara.Convert(_body, &_result)
24074 return _result, _err
24075 }
24076
24077 // Summary:
24078 //
24079 // # Modify HTTPS Application Configuration
24080 //
24081 // @param request - UpdateHttpsApplicationConfigurationRequest
24082 //
24083 // @return UpdateHttpsApplicationConfigurationResponse
24084 func UpdateHttpsApplicationConfiguration(client *Client, request *UpdateHttpsApplicationConfigurationRequest) (_result *UpdateHttpsApplicationConfigurationResponse, _err error) {
24085 runtime := &dara.RuntimeOptions{}
24086 _result = &UpdateHttpsApplicationConfigurationResponse{}
24087 _body, _err := UpdateHttpsApplicationConfigurationWithOptions(client,request, runtime)
24088 if _err != nil {
24089 return _result, _err
24090 }
24091 _result = _body
24092 return _result, _err
24093 }
24094
24095 // Summary:
24096 //
24097 // # Modify HTTPS Basic Configuration
24098 //
24099 // @param request - UpdateHttpsBasicConfigurationRequest
24100 //
24101 // @param runtime - runtime options for this request RuntimeOptions
24102 //
24103 // @return UpdateHttpsBasicConfigurationResponse
24104 func UpdateHttpsBasicConfigurationWithOptions(client *Client, request *UpdateHttpsBasicConfigurationRequest, runtime *dara.RuntimeOptions) (_result *UpdateHttpsBasicConfigurationResponse, _err error) {
24105 if dara.BoolValue(client.EnableValidate) == true {
24106 _err = request.Validate()
24107 if _err != nil {
24108 return _result, _err
24109 }
24110 }
24111 query := map[string]interface{}{}
24112 if !dara.IsNil(request.Ciphersuite) {
24113 query["Ciphersuite"] = request.Ciphersuite
24114 }
24115
24116 if !dara.IsNil(request.CiphersuiteGroup) {
24117 query["CiphersuiteGroup"] = request.CiphersuiteGroup
24118 }
24119
24120 if !dara.IsNil(request.ConfigId) {
24121 query["ConfigId"] = request.ConfigId
24122 }
24123
24124 if !dara.IsNil(request.Http2) {
24125 query["Http2"] = request.Http2
24126 }
24127
24128 if !dara.IsNil(request.Http3) {
24129 query["Http3"] = request.Http3
24130 }
24131
24132 if !dara.IsNil(request.Https) {
24133 query["Https"] = request.Https
24134 }
24135
24136 if !dara.IsNil(request.OcspStapling) {
24137 query["OcspStapling"] = request.OcspStapling
24138 }
24139
24140 if !dara.IsNil(request.Rule) {
24141 query["Rule"] = request.Rule
24142 }
24143
24144 if !dara.IsNil(request.RuleEnable) {
24145 query["RuleEnable"] = request.RuleEnable
24146 }
24147
24148 if !dara.IsNil(request.RuleName) {
24149 query["RuleName"] = request.RuleName
24150 }
24151
24152 if !dara.IsNil(request.Sequence) {
24153 query["Sequence"] = request.Sequence
24154 }
24155
24156 if !dara.IsNil(request.SiteId) {
24157 query["SiteId"] = request.SiteId
24158 }
24159
24160 if !dara.IsNil(request.Tls10) {
24161 query["Tls10"] = request.Tls10
24162 }
24163
24164 if !dara.IsNil(request.Tls11) {
24165 query["Tls11"] = request.Tls11
24166 }
24167
24168 if !dara.IsNil(request.Tls12) {
24169 query["Tls12"] = request.Tls12
24170 }
24171
24172 if !dara.IsNil(request.Tls13) {
24173 query["Tls13"] = request.Tls13
24174 }
24175
24176 req := &openapiutil.OpenApiRequest{
24177 Query: openapiutil.Query(query),
24178 }
24179 params := &openapiutil.Params{
24180 Action: dara.String("UpdateHttpsBasicConfiguration"),
24181 Version: dara.String("2024-09-10"),
24182 Protocol: dara.String("HTTPS"),
24183 Pathname: dara.String("/"),
24184 Method: dara.String("POST"),
24185 AuthType: dara.String("AK"),
24186 Style: dara.String("RPC"),
24187 ReqBodyType: dara.String("formData"),
24188 BodyType: dara.String("json"),
24189 }
24190 _result = &UpdateHttpsBasicConfigurationResponse{}
24191 _body, _err := client.CallApi(params, req, runtime)
24192 if _err != nil {
24193 return _result, _err
24194 }
24195 _err = dara.Convert(_body, &_result)
24196 return _result, _err
24197 }
24198
24199 // Summary:
24200 //
24201 // # Modify HTTPS Basic Configuration
24202 //
24203 // @param request - UpdateHttpsBasicConfigurationRequest
24204 //
24205 // @return UpdateHttpsBasicConfigurationResponse
24206 func UpdateHttpsBasicConfiguration(client *Client, request *UpdateHttpsBasicConfigurationRequest) (_result *UpdateHttpsBasicConfigurationResponse, _err error) {
24207 runtime := &dara.RuntimeOptions{}
24208 _result = &UpdateHttpsBasicConfigurationResponse{}
24209 _body, _err := UpdateHttpsBasicConfigurationWithOptions(client,request, runtime)
24210 if _err != nil {
24211 return _result, _err
24212 }
24213 _result = _body
24214 return _result, _err
24215 }
24216
24217 // Summary:
24218 //
24219 // Modifies the IPv6 configuration of a website.
24220 //
24221 // @param request - UpdateIPv6Request
24222 //
24223 // @param runtime - runtime options for this request RuntimeOptions
24224 //
24225 // @return UpdateIPv6Response
24226 func UpdateIPv6WithOptions(client *Client, request *UpdateIPv6Request, runtime *dara.RuntimeOptions) (_result *UpdateIPv6Response, _err error) {
24227 if dara.BoolValue(client.EnableValidate) == true {
24228 _err = request.Validate()
24229 if _err != nil {
24230 return _result, _err
24231 }
24232 }
24233 query := map[string]interface{}{}
24234 if !dara.IsNil(request.Enable) {
24235 query["Enable"] = request.Enable
24236 }
24237
24238 if !dara.IsNil(request.Region) {
24239 query["Region"] = request.Region
24240 }
24241
24242 if !dara.IsNil(request.SiteId) {
24243 query["SiteId"] = request.SiteId
24244 }
24245
24246 req := &openapiutil.OpenApiRequest{
24247 Query: openapiutil.Query(query),
24248 }
24249 params := &openapiutil.Params{
24250 Action: dara.String("UpdateIPv6"),
24251 Version: dara.String("2024-09-10"),
24252 Protocol: dara.String("HTTPS"),
24253 Pathname: dara.String("/"),
24254 Method: dara.String("POST"),
24255 AuthType: dara.String("AK"),
24256 Style: dara.String("RPC"),
24257 ReqBodyType: dara.String("formData"),
24258 BodyType: dara.String("json"),
24259 }
24260 _result = &UpdateIPv6Response{}
24261 _body, _err := client.CallApi(params, req, runtime)
24262 if _err != nil {
24263 return _result, _err
24264 }
24265 _err = dara.Convert(_body, &_result)
24266 return _result, _err
24267 }
24268
24269 // Summary:
24270 //
24271 // Modifies the IPv6 configuration of a website.
24272 //
24273 // @param request - UpdateIPv6Request
24274 //
24275 // @return UpdateIPv6Response
24276 func UpdateIPv6(client *Client, request *UpdateIPv6Request) (_result *UpdateIPv6Response, _err error) {
24277 runtime := &dara.RuntimeOptions{}
24278 _result = &UpdateIPv6Response{}
24279 _body, _err := UpdateIPv6WithOptions(client,request, runtime)
24280 if _err != nil {
24281 return _result, _err
24282 }
24283 _result = _body
24284 return _result, _err
24285 }
24286
24287 // Summary:
24288 //
24289 // # Modify Site Image Transformation Configuration
24290 //
24291 // @param request - UpdateImageTransformRequest
24292 //
24293 // @param runtime - runtime options for this request RuntimeOptions
24294 //
24295 // @return UpdateImageTransformResponse
24296 func UpdateImageTransformWithOptions(client *Client, request *UpdateImageTransformRequest, runtime *dara.RuntimeOptions) (_result *UpdateImageTransformResponse, _err error) {
24297 if dara.BoolValue(client.EnableValidate) == true {
24298 _err = request.Validate()
24299 if _err != nil {
24300 return _result, _err
24301 }
24302 }
24303 query := map[string]interface{}{}
24304 if !dara.IsNil(request.ConfigId) {
24305 query["ConfigId"] = request.ConfigId
24306 }
24307
24308 if !dara.IsNil(request.Enable) {
24309 query["Enable"] = request.Enable
24310 }
24311
24312 if !dara.IsNil(request.Rule) {
24313 query["Rule"] = request.Rule
24314 }
24315
24316 if !dara.IsNil(request.RuleEnable) {
24317 query["RuleEnable"] = request.RuleEnable
24318 }
24319
24320 if !dara.IsNil(request.RuleName) {
24321 query["RuleName"] = request.RuleName
24322 }
24323
24324 if !dara.IsNil(request.Sequence) {
24325 query["Sequence"] = request.Sequence
24326 }
24327
24328 if !dara.IsNil(request.SiteId) {
24329 query["SiteId"] = request.SiteId
24330 }
24331
24332 req := &openapiutil.OpenApiRequest{
24333 Query: openapiutil.Query(query),
24334 }
24335 params := &openapiutil.Params{
24336 Action: dara.String("UpdateImageTransform"),
24337 Version: dara.String("2024-09-10"),
24338 Protocol: dara.String("HTTPS"),
24339 Pathname: dara.String("/"),
24340 Method: dara.String("POST"),
24341 AuthType: dara.String("AK"),
24342 Style: dara.String("RPC"),
24343 ReqBodyType: dara.String("formData"),
24344 BodyType: dara.String("json"),
24345 }
24346 _result = &UpdateImageTransformResponse{}
24347 _body, _err := client.CallApi(params, req, runtime)
24348 if _err != nil {
24349 return _result, _err
24350 }
24351 _err = dara.Convert(_body, &_result)
24352 return _result, _err
24353 }
24354
24355 // Summary:
24356 //
24357 // # Modify Site Image Transformation Configuration
24358 //
24359 // @param request - UpdateImageTransformRequest
24360 //
24361 // @return UpdateImageTransformResponse
24362 func UpdateImageTransform(client *Client, request *UpdateImageTransformRequest) (_result *UpdateImageTransformResponse, _err error) {
24363 runtime := &dara.RuntimeOptions{}
24364 _result = &UpdateImageTransformResponse{}
24365 _body, _err := UpdateImageTransformWithOptions(client,request, runtime)
24366 if _err != nil {
24367 return _result, _err
24368 }
24369 _result = _body
24370 return _result, _err
24371 }
24372
24373 // Summary:
24374 //
24375 // Updates a custom list.
24376 //
24377 // @param tmpReq - UpdateListRequest
24378 //
24379 // @param runtime - runtime options for this request RuntimeOptions
24380 //
24381 // @return UpdateListResponse
24382 func UpdateListWithOptions(client *Client, tmpReq *UpdateListRequest, runtime *dara.RuntimeOptions) (_result *UpdateListResponse, _err error) {
24383 if dara.BoolValue(client.EnableValidate) == true {
24384 _err = tmpReq.Validate()
24385 if _err != nil {
24386 return _result, _err
24387 }
24388 }
24389 request := &UpdateListShrinkRequest{}
24390 openapiutil.Convert(tmpReq, request)
24391 if !dara.IsNil(tmpReq.Items) {
24392 request.ItemsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Items, dara.String("Items"), dara.String("json"))
24393 }
24394
24395 body := map[string]interface{}{}
24396 if !dara.IsNil(request.Description) {
24397 body["Description"] = request.Description
24398 }
24399
24400 if !dara.IsNil(request.Id) {
24401 body["Id"] = request.Id
24402 }
24403
24404 if !dara.IsNil(request.ItemsShrink) {
24405 body["Items"] = request.ItemsShrink
24406 }
24407
24408 if !dara.IsNil(request.Name) {
24409 body["Name"] = request.Name
24410 }
24411
24412 req := &openapiutil.OpenApiRequest{
24413 Body: openapiutil.ParseToMap(body),
24414 }
24415 params := &openapiutil.Params{
24416 Action: dara.String("UpdateList"),
24417 Version: dara.String("2024-09-10"),
24418 Protocol: dara.String("HTTPS"),
24419 Pathname: dara.String("/"),
24420 Method: dara.String("POST"),
24421 AuthType: dara.String("AK"),
24422 Style: dara.String("RPC"),
24423 ReqBodyType: dara.String("formData"),
24424 BodyType: dara.String("json"),
24425 }
24426 _result = &UpdateListResponse{}
24427 _body, _err := client.CallApi(params, req, runtime)
24428 if _err != nil {
24429 return _result, _err
24430 }
24431 _err = dara.Convert(_body, &_result)
24432 return _result, _err
24433 }
24434
24435 // Summary:
24436 //
24437 // Updates a custom list.
24438 //
24439 // @param request - UpdateListRequest
24440 //
24441 // @return UpdateListResponse
24442 func UpdateList(client *Client, request *UpdateListRequest) (_result *UpdateListResponse, _err error) {
24443 runtime := &dara.RuntimeOptions{}
24444 _result = &UpdateListResponse{}
24445 _body, _err := UpdateListWithOptions(client,request, runtime)
24446 if _err != nil {
24447 return _result, _err
24448 }
24449 _result = _body
24450 return _result, _err
24451 }
24452
24453 // Summary:
24454 //
24455 // # Modify Load Balancer
24456 //
24457 // Description:
24458 //
24459 // 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.
24460 //
24461 // @param tmpReq - UpdateLoadBalancerRequest
24462 //
24463 // @param runtime - runtime options for this request RuntimeOptions
24464 //
24465 // @return UpdateLoadBalancerResponse
24466 func UpdateLoadBalancerWithOptions(client *Client, tmpReq *UpdateLoadBalancerRequest, runtime *dara.RuntimeOptions) (_result *UpdateLoadBalancerResponse, _err error) {
24467 if dara.BoolValue(client.EnableValidate) == true {
24468 _err = tmpReq.Validate()
24469 if _err != nil {
24470 return _result, _err
24471 }
24472 }
24473 request := &UpdateLoadBalancerShrinkRequest{}
24474 openapiutil.Convert(tmpReq, request)
24475 if !dara.IsNil(tmpReq.AdaptiveRouting) {
24476 request.AdaptiveRoutingShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AdaptiveRouting, dara.String("AdaptiveRouting"), dara.String("json"))
24477 }
24478
24479 if !dara.IsNil(tmpReq.DefaultPools) {
24480 request.DefaultPoolsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.DefaultPools, dara.String("DefaultPools"), dara.String("json"))
24481 }
24482
24483 if !dara.IsNil(tmpReq.Monitor) {
24484 request.MonitorShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Monitor, dara.String("Monitor"), dara.String("json"))
24485 }
24486
24487 if !dara.IsNil(tmpReq.RandomSteering) {
24488 request.RandomSteeringShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RandomSteering, dara.String("RandomSteering"), dara.String("json"))
24489 }
24490
24491 if !dara.IsNil(tmpReq.Rules) {
24492 request.RulesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Rules, dara.String("Rules"), dara.String("json"))
24493 }
24494
24495 query := map[string]interface{}{}
24496 if !dara.IsNil(request.AdaptiveRoutingShrink) {
24497 query["AdaptiveRouting"] = request.AdaptiveRoutingShrink
24498 }
24499
24500 if !dara.IsNil(request.DefaultPoolsShrink) {
24501 query["DefaultPools"] = request.DefaultPoolsShrink
24502 }
24503
24504 if !dara.IsNil(request.Description) {
24505 query["Description"] = request.Description
24506 }
24507
24508 if !dara.IsNil(request.Enabled) {
24509 query["Enabled"] = request.Enabled
24510 }
24511
24512 if !dara.IsNil(request.FallbackPool) {
24513 query["FallbackPool"] = request.FallbackPool
24514 }
24515
24516 if !dara.IsNil(request.Id) {
24517 query["Id"] = request.Id
24518 }
24519
24520 if !dara.IsNil(request.MonitorShrink) {
24521 query["Monitor"] = request.MonitorShrink
24522 }
24523
24524 if !dara.IsNil(request.RandomSteeringShrink) {
24525 query["RandomSteering"] = request.RandomSteeringShrink
24526 }
24527
24528 if !dara.IsNil(request.RegionPools) {
24529 query["RegionPools"] = request.RegionPools
24530 }
24531
24532 if !dara.IsNil(request.RulesShrink) {
24533 query["Rules"] = request.RulesShrink
24534 }
24535
24536 if !dara.IsNil(request.SessionAffinity) {
24537 query["SessionAffinity"] = request.SessionAffinity
24538 }
24539
24540 if !dara.IsNil(request.SiteId) {
24541 query["SiteId"] = request.SiteId
24542 }
24543
24544 if !dara.IsNil(request.SteeringPolicy) {
24545 query["SteeringPolicy"] = request.SteeringPolicy
24546 }
24547
24548 if !dara.IsNil(request.SubRegionPools) {
24549 query["SubRegionPools"] = request.SubRegionPools
24550 }
24551
24552 if !dara.IsNil(request.Ttl) {
24553 query["Ttl"] = request.Ttl
24554 }
24555
24556 req := &openapiutil.OpenApiRequest{
24557 Query: openapiutil.Query(query),
24558 }
24559 params := &openapiutil.Params{
24560 Action: dara.String("UpdateLoadBalancer"),
24561 Version: dara.String("2024-09-10"),
24562 Protocol: dara.String("HTTPS"),
24563 Pathname: dara.String("/"),
24564 Method: dara.String("POST"),
24565 AuthType: dara.String("AK"),
24566 Style: dara.String("RPC"),
24567 ReqBodyType: dara.String("formData"),
24568 BodyType: dara.String("json"),
24569 }
24570 _result = &UpdateLoadBalancerResponse{}
24571 _body, _err := client.CallApi(params, req, runtime)
24572 if _err != nil {
24573 return _result, _err
24574 }
24575 _err = dara.Convert(_body, &_result)
24576 return _result, _err
24577 }
24578
24579 // Summary:
24580 //
24581 // # Modify Load Balancer
24582 //
24583 // Description:
24584 //
24585 // 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.
24586 //
24587 // @param request - UpdateLoadBalancerRequest
24588 //
24589 // @return UpdateLoadBalancerResponse
24590 func UpdateLoadBalancer(client *Client, request *UpdateLoadBalancerRequest) (_result *UpdateLoadBalancerResponse, _err error) {
24591 runtime := &dara.RuntimeOptions{}
24592 _result = &UpdateLoadBalancerResponse{}
24593 _body, _err := UpdateLoadBalancerWithOptions(client,request, runtime)
24594 if _err != nil {
24595 return _result, _err
24596 }
24597 _result = _body
24598 return _result, _err
24599 }
24600
24601 // Summary:
24602 //
24603 // Modifies the configuration of managed transforms for your website.
24604 //
24605 // @param request - UpdateManagedTransformRequest
24606 //
24607 // @param runtime - runtime options for this request RuntimeOptions
24608 //
24609 // @return UpdateManagedTransformResponse
24610 func UpdateManagedTransformWithOptions(client *Client, request *UpdateManagedTransformRequest, runtime *dara.RuntimeOptions) (_result *UpdateManagedTransformResponse, _err error) {
24611 if dara.BoolValue(client.EnableValidate) == true {
24612 _err = request.Validate()
24613 if _err != nil {
24614 return _result, _err
24615 }
24616 }
24617 query := map[string]interface{}{}
24618 if !dara.IsNil(request.AddClientGeolocationHeader) {
24619 query["AddClientGeolocationHeader"] = request.AddClientGeolocationHeader
24620 }
24621
24622 if !dara.IsNil(request.AddRealClientIpHeader) {
24623 query["AddRealClientIpHeader"] = request.AddRealClientIpHeader
24624 }
24625
24626 if !dara.IsNil(request.RealClientIpHeaderName) {
24627 query["RealClientIpHeaderName"] = request.RealClientIpHeaderName
24628 }
24629
24630 if !dara.IsNil(request.SiteId) {
24631 query["SiteId"] = request.SiteId
24632 }
24633
24634 if !dara.IsNil(request.SiteVersion) {
24635 query["SiteVersion"] = request.SiteVersion
24636 }
24637
24638 req := &openapiutil.OpenApiRequest{
24639 Query: openapiutil.Query(query),
24640 }
24641 params := &openapiutil.Params{
24642 Action: dara.String("UpdateManagedTransform"),
24643 Version: dara.String("2024-09-10"),
24644 Protocol: dara.String("HTTPS"),
24645 Pathname: dara.String("/"),
24646 Method: dara.String("POST"),
24647 AuthType: dara.String("AK"),
24648 Style: dara.String("RPC"),
24649 ReqBodyType: dara.String("formData"),
24650 BodyType: dara.String("json"),
24651 }
24652 _result = &UpdateManagedTransformResponse{}
24653 _body, _err := client.CallApi(params, req, runtime)
24654 if _err != nil {
24655 return _result, _err
24656 }
24657 _err = dara.Convert(_body, &_result)
24658 return _result, _err
24659 }
24660
24661 // Summary:
24662 //
24663 // Modifies the configuration of managed transforms for your website.
24664 //
24665 // @param request - UpdateManagedTransformRequest
24666 //
24667 // @return UpdateManagedTransformResponse
24668 func UpdateManagedTransform(client *Client, request *UpdateManagedTransformRequest) (_result *UpdateManagedTransformResponse, _err error) {
24669 runtime := &dara.RuntimeOptions{}
24670 _result = &UpdateManagedTransformResponse{}
24671 _body, _err := UpdateManagedTransformWithOptions(client,request, runtime)
24672 if _err != nil {
24673 return _result, _err
24674 }
24675 _result = _body
24676 return _result, _err
24677 }
24678
24679 // Summary:
24680 //
24681 // # Modify network optimization configuration
24682 //
24683 // @param request - UpdateNetworkOptimizationRequest
24684 //
24685 // @param runtime - runtime options for this request RuntimeOptions
24686 //
24687 // @return UpdateNetworkOptimizationResponse
24688 func UpdateNetworkOptimizationWithOptions(client *Client, request *UpdateNetworkOptimizationRequest, runtime *dara.RuntimeOptions) (_result *UpdateNetworkOptimizationResponse, _err error) {
24689 if dara.BoolValue(client.EnableValidate) == true {
24690 _err = request.Validate()
24691 if _err != nil {
24692 return _result, _err
24693 }
24694 }
24695 query := map[string]interface{}{}
24696 if !dara.IsNil(request.ConfigId) {
24697 query["ConfigId"] = request.ConfigId
24698 }
24699
24700 if !dara.IsNil(request.Grpc) {
24701 query["Grpc"] = request.Grpc
24702 }
24703
24704 if !dara.IsNil(request.Http2Origin) {
24705 query["Http2Origin"] = request.Http2Origin
24706 }
24707
24708 if !dara.IsNil(request.Rule) {
24709 query["Rule"] = request.Rule
24710 }
24711
24712 if !dara.IsNil(request.RuleEnable) {
24713 query["RuleEnable"] = request.RuleEnable
24714 }
24715
24716 if !dara.IsNil(request.RuleName) {
24717 query["RuleName"] = request.RuleName
24718 }
24719
24720 if !dara.IsNil(request.Sequence) {
24721 query["Sequence"] = request.Sequence
24722 }
24723
24724 if !dara.IsNil(request.SiteId) {
24725 query["SiteId"] = request.SiteId
24726 }
24727
24728 if !dara.IsNil(request.SmartRouting) {
24729 query["SmartRouting"] = request.SmartRouting
24730 }
24731
24732 if !dara.IsNil(request.UploadMaxFilesize) {
24733 query["UploadMaxFilesize"] = request.UploadMaxFilesize
24734 }
24735
24736 if !dara.IsNil(request.Websocket) {
24737 query["Websocket"] = request.Websocket
24738 }
24739
24740 req := &openapiutil.OpenApiRequest{
24741 Query: openapiutil.Query(query),
24742 }
24743 params := &openapiutil.Params{
24744 Action: dara.String("UpdateNetworkOptimization"),
24745 Version: dara.String("2024-09-10"),
24746 Protocol: dara.String("HTTPS"),
24747 Pathname: dara.String("/"),
24748 Method: dara.String("POST"),
24749 AuthType: dara.String("AK"),
24750 Style: dara.String("RPC"),
24751 ReqBodyType: dara.String("formData"),
24752 BodyType: dara.String("json"),
24753 }
24754 _result = &UpdateNetworkOptimizationResponse{}
24755 _body, _err := client.CallApi(params, req, runtime)
24756 if _err != nil {
24757 return _result, _err
24758 }
24759 _err = dara.Convert(_body, &_result)
24760 return _result, _err
24761 }
24762
24763 // Summary:
24764 //
24765 // # Modify network optimization configuration
24766 //
24767 // @param request - UpdateNetworkOptimizationRequest
24768 //
24769 // @return UpdateNetworkOptimizationResponse
24770 func UpdateNetworkOptimization(client *Client, request *UpdateNetworkOptimizationRequest) (_result *UpdateNetworkOptimizationResponse, _err error) {
24771 runtime := &dara.RuntimeOptions{}
24772 _result = &UpdateNetworkOptimizationResponse{}
24773 _body, _err := UpdateNetworkOptimizationWithOptions(client,request, runtime)
24774 if _err != nil {
24775 return _result, _err
24776 }
24777 _result = _body
24778 return _result, _err
24779 }
24780
24781 // Summary:
24782 //
24783 // # Modify the Monitor
24784 //
24785 // @param tmpReq - UpdateOriginPoolRequest
24786 //
24787 // @param runtime - runtime options for this request RuntimeOptions
24788 //
24789 // @return UpdateOriginPoolResponse
24790 func UpdateOriginPoolWithOptions(client *Client, tmpReq *UpdateOriginPoolRequest, runtime *dara.RuntimeOptions) (_result *UpdateOriginPoolResponse, _err error) {
24791 if dara.BoolValue(client.EnableValidate) == true {
24792 _err = tmpReq.Validate()
24793 if _err != nil {
24794 return _result, _err
24795 }
24796 }
24797 request := &UpdateOriginPoolShrinkRequest{}
24798 openapiutil.Convert(tmpReq, request)
24799 if !dara.IsNil(tmpReq.Origins) {
24800 request.OriginsShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Origins, dara.String("Origins"), dara.String("json"))
24801 }
24802
24803 query := map[string]interface{}{}
24804 if !dara.IsNil(request.Enabled) {
24805 query["Enabled"] = request.Enabled
24806 }
24807
24808 if !dara.IsNil(request.Id) {
24809 query["Id"] = request.Id
24810 }
24811
24812 if !dara.IsNil(request.OriginsShrink) {
24813 query["Origins"] = request.OriginsShrink
24814 }
24815
24816 if !dara.IsNil(request.SiteId) {
24817 query["SiteId"] = request.SiteId
24818 }
24819
24820 req := &openapiutil.OpenApiRequest{
24821 Query: openapiutil.Query(query),
24822 }
24823 params := &openapiutil.Params{
24824 Action: dara.String("UpdateOriginPool"),
24825 Version: dara.String("2024-09-10"),
24826 Protocol: dara.String("HTTPS"),
24827 Pathname: dara.String("/"),
24828 Method: dara.String("POST"),
24829 AuthType: dara.String("AK"),
24830 Style: dara.String("RPC"),
24831 ReqBodyType: dara.String("formData"),
24832 BodyType: dara.String("json"),
24833 }
24834 _result = &UpdateOriginPoolResponse{}
24835 _body, _err := client.CallApi(params, req, runtime)
24836 if _err != nil {
24837 return _result, _err
24838 }
24839 _err = dara.Convert(_body, &_result)
24840 return _result, _err
24841 }
24842
24843 // Summary:
24844 //
24845 // # Modify the Monitor
24846 //
24847 // @param request - UpdateOriginPoolRequest
24848 //
24849 // @return UpdateOriginPoolResponse
24850 func UpdateOriginPool(client *Client, request *UpdateOriginPoolRequest) (_result *UpdateOriginPoolResponse, _err error) {
24851 runtime := &dara.RuntimeOptions{}
24852 _result = &UpdateOriginPoolResponse{}
24853 _body, _err := UpdateOriginPoolWithOptions(client,request, runtime)
24854 if _err != nil {
24855 return _result, _err
24856 }
24857 _result = _body
24858 return _result, _err
24859 }
24860
24861 // Summary:
24862 //
24863 // Enables or disables IP convergence.
24864 //
24865 // @param request - UpdateOriginProtectionRequest
24866 //
24867 // @param runtime - runtime options for this request RuntimeOptions
24868 //
24869 // @return UpdateOriginProtectionResponse
24870 func UpdateOriginProtectionWithOptions(client *Client, request *UpdateOriginProtectionRequest, runtime *dara.RuntimeOptions) (_result *UpdateOriginProtectionResponse, _err error) {
24871 if dara.BoolValue(client.EnableValidate) == true {
24872 _err = request.Validate()
24873 if _err != nil {
24874 return _result, _err
24875 }
24876 }
24877 query := map[string]interface{}{}
24878 if !dara.IsNil(request.AutoConfirmIPList) {
24879 query["AutoConfirmIPList"] = request.AutoConfirmIPList
24880 }
24881
24882 if !dara.IsNil(request.OriginConverge) {
24883 query["OriginConverge"] = request.OriginConverge
24884 }
24885
24886 if !dara.IsNil(request.SiteId) {
24887 query["SiteId"] = request.SiteId
24888 }
24889
24890 req := &openapiutil.OpenApiRequest{
24891 Query: openapiutil.Query(query),
24892 }
24893 params := &openapiutil.Params{
24894 Action: dara.String("UpdateOriginProtection"),
24895 Version: dara.String("2024-09-10"),
24896 Protocol: dara.String("HTTPS"),
24897 Pathname: dara.String("/"),
24898 Method: dara.String("POST"),
24899 AuthType: dara.String("AK"),
24900 Style: dara.String("RPC"),
24901 ReqBodyType: dara.String("formData"),
24902 BodyType: dara.String("json"),
24903 }
24904 _result = &UpdateOriginProtectionResponse{}
24905 _body, _err := client.CallApi(params, req, runtime)
24906 if _err != nil {
24907 return _result, _err
24908 }
24909 _err = dara.Convert(_body, &_result)
24910 return _result, _err
24911 }
24912
24913 // Summary:
24914 //
24915 // Enables or disables IP convergence.
24916 //
24917 // @param request - UpdateOriginProtectionRequest
24918 //
24919 // @return UpdateOriginProtectionResponse
24920 func UpdateOriginProtection(client *Client, request *UpdateOriginProtectionRequest) (_result *UpdateOriginProtectionResponse, _err error) {
24921 runtime := &dara.RuntimeOptions{}
24922 _result = &UpdateOriginProtectionResponse{}
24923 _body, _err := UpdateOriginProtectionWithOptions(client,request, runtime)
24924 if _err != nil {
24925 return _result, _err
24926 }
24927 _result = _body
24928 return _result, _err
24929 }
24930
24931 // Summary:
24932 //
24933 // Updates the IP whitelist for origin protection used by a website to the latest version.
24934 //
24935 // @param request - UpdateOriginProtectionIpWhiteListRequest
24936 //
24937 // @param runtime - runtime options for this request RuntimeOptions
24938 //
24939 // @return UpdateOriginProtectionIpWhiteListResponse
24940 func UpdateOriginProtectionIpWhiteListWithOptions(client *Client, request *UpdateOriginProtectionIpWhiteListRequest, runtime *dara.RuntimeOptions) (_result *UpdateOriginProtectionIpWhiteListResponse, _err error) {
24941 if dara.BoolValue(client.EnableValidate) == true {
24942 _err = request.Validate()
24943 if _err != nil {
24944 return _result, _err
24945 }
24946 }
24947 query := map[string]interface{}{}
24948 if !dara.IsNil(request.SiteId) {
24949 query["SiteId"] = request.SiteId
24950 }
24951
24952 req := &openapiutil.OpenApiRequest{
24953 Query: openapiutil.Query(query),
24954 }
24955 params := &openapiutil.Params{
24956 Action: dara.String("UpdateOriginProtectionIpWhiteList"),
24957 Version: dara.String("2024-09-10"),
24958 Protocol: dara.String("HTTPS"),
24959 Pathname: dara.String("/"),
24960 Method: dara.String("POST"),
24961 AuthType: dara.String("AK"),
24962 Style: dara.String("RPC"),
24963 ReqBodyType: dara.String("formData"),
24964 BodyType: dara.String("json"),
24965 }
24966 _result = &UpdateOriginProtectionIpWhiteListResponse{}
24967 _body, _err := client.CallApi(params, req, runtime)
24968 if _err != nil {
24969 return _result, _err
24970 }
24971 _err = dara.Convert(_body, &_result)
24972 return _result, _err
24973 }
24974
24975 // Summary:
24976 //
24977 // Updates the IP whitelist for origin protection used by a website to the latest version.
24978 //
24979 // @param request - UpdateOriginProtectionIpWhiteListRequest
24980 //
24981 // @return UpdateOriginProtectionIpWhiteListResponse
24982 func UpdateOriginProtectionIpWhiteList(client *Client, request *UpdateOriginProtectionIpWhiteListRequest) (_result *UpdateOriginProtectionIpWhiteListResponse, _err error) {
24983 runtime := &dara.RuntimeOptions{}
24984 _result = &UpdateOriginProtectionIpWhiteListResponse{}
24985 _body, _err := UpdateOriginProtectionIpWhiteListWithOptions(client,request, runtime)
24986 if _err != nil {
24987 return _result, _err
24988 }
24989 _result = _body
24990 return _result, _err
24991 }
24992
24993 // Summary:
24994 //
24995 // # Modify Origin Rule Configuration for Site
24996 //
24997 // @param request - UpdateOriginRuleRequest
24998 //
24999 // @param runtime - runtime options for this request RuntimeOptions
25000 //
25001 // @return UpdateOriginRuleResponse
25002 func UpdateOriginRuleWithOptions(client *Client, request *UpdateOriginRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateOriginRuleResponse, _err error) {
25003 if dara.BoolValue(client.EnableValidate) == true {
25004 _err = request.Validate()
25005 if _err != nil {
25006 return _result, _err
25007 }
25008 }
25009 query := map[string]interface{}{}
25010 if !dara.IsNil(request.ConfigId) {
25011 query["ConfigId"] = request.ConfigId
25012 }
25013
25014 if !dara.IsNil(request.DnsRecord) {
25015 query["DnsRecord"] = request.DnsRecord
25016 }
25017
25018 if !dara.IsNil(request.Follow302Enable) {
25019 query["Follow302Enable"] = request.Follow302Enable
25020 }
25021
25022 if !dara.IsNil(request.Follow302MaxTries) {
25023 query["Follow302MaxTries"] = request.Follow302MaxTries
25024 }
25025
25026 if !dara.IsNil(request.Follow302RetainArgs) {
25027 query["Follow302RetainArgs"] = request.Follow302RetainArgs
25028 }
25029
25030 if !dara.IsNil(request.Follow302RetainHeader) {
25031 query["Follow302RetainHeader"] = request.Follow302RetainHeader
25032 }
25033
25034 if !dara.IsNil(request.Follow302TargetHost) {
25035 query["Follow302TargetHost"] = request.Follow302TargetHost
25036 }
25037
25038 if !dara.IsNil(request.OriginHost) {
25039 query["OriginHost"] = request.OriginHost
25040 }
25041
25042 if !dara.IsNil(request.OriginHttpPort) {
25043 query["OriginHttpPort"] = request.OriginHttpPort
25044 }
25045
25046 if !dara.IsNil(request.OriginHttpsPort) {
25047 query["OriginHttpsPort"] = request.OriginHttpsPort
25048 }
25049
25050 if !dara.IsNil(request.OriginMtls) {
25051 query["OriginMtls"] = request.OriginMtls
25052 }
25053
25054 if !dara.IsNil(request.OriginReadTimeout) {
25055 query["OriginReadTimeout"] = request.OriginReadTimeout
25056 }
25057
25058 if !dara.IsNil(request.OriginScheme) {
25059 query["OriginScheme"] = request.OriginScheme
25060 }
25061
25062 if !dara.IsNil(request.OriginSni) {
25063 query["OriginSni"] = request.OriginSni
25064 }
25065
25066 if !dara.IsNil(request.OriginVerify) {
25067 query["OriginVerify"] = request.OriginVerify
25068 }
25069
25070 if !dara.IsNil(request.Range) {
25071 query["Range"] = request.Range
25072 }
25073
25074 if !dara.IsNil(request.RangeChunkSize) {
25075 query["RangeChunkSize"] = request.RangeChunkSize
25076 }
25077
25078 if !dara.IsNil(request.Rule) {
25079 query["Rule"] = request.Rule
25080 }
25081
25082 if !dara.IsNil(request.RuleEnable) {
25083 query["RuleEnable"] = request.RuleEnable
25084 }
25085
25086 if !dara.IsNil(request.RuleName) {
25087 query["RuleName"] = request.RuleName
25088 }
25089
25090 if !dara.IsNil(request.Sequence) {
25091 query["Sequence"] = request.Sequence
25092 }
25093
25094 if !dara.IsNil(request.SiteId) {
25095 query["SiteId"] = request.SiteId
25096 }
25097
25098 req := &openapiutil.OpenApiRequest{
25099 Query: openapiutil.Query(query),
25100 }
25101 params := &openapiutil.Params{
25102 Action: dara.String("UpdateOriginRule"),
25103 Version: dara.String("2024-09-10"),
25104 Protocol: dara.String("HTTPS"),
25105 Pathname: dara.String("/"),
25106 Method: dara.String("POST"),
25107 AuthType: dara.String("AK"),
25108 Style: dara.String("RPC"),
25109 ReqBodyType: dara.String("formData"),
25110 BodyType: dara.String("json"),
25111 }
25112 _result = &UpdateOriginRuleResponse{}
25113 _body, _err := client.CallApi(params, req, runtime)
25114 if _err != nil {
25115 return _result, _err
25116 }
25117 _err = dara.Convert(_body, &_result)
25118 return _result, _err
25119 }
25120
25121 // Summary:
25122 //
25123 // # Modify Origin Rule Configuration for Site
25124 //
25125 // @param request - UpdateOriginRuleRequest
25126 //
25127 // @return UpdateOriginRuleResponse
25128 func UpdateOriginRule(client *Client, request *UpdateOriginRuleRequest) (_result *UpdateOriginRuleResponse, _err error) {
25129 runtime := &dara.RuntimeOptions{}
25130 _result = &UpdateOriginRuleResponse{}
25131 _body, _err := UpdateOriginRuleWithOptions(client,request, runtime)
25132 if _err != nil {
25133 return _result, _err
25134 }
25135 _result = _body
25136 return _result, _err
25137 }
25138
25139 // Summary:
25140 //
25141 // Modifies the configurations of a custom error page, such as the name, description, content type, and content of the page.
25142 //
25143 // @param request - UpdatePageRequest
25144 //
25145 // @param runtime - runtime options for this request RuntimeOptions
25146 //
25147 // @return UpdatePageResponse
25148 func UpdatePageWithOptions(client *Client, request *UpdatePageRequest, runtime *dara.RuntimeOptions) (_result *UpdatePageResponse, _err error) {
25149 if dara.BoolValue(client.EnableValidate) == true {
25150 _err = request.Validate()
25151 if _err != nil {
25152 return _result, _err
25153 }
25154 }
25155 body := map[string]interface{}{}
25156 if !dara.IsNil(request.Content) {
25157 body["Content"] = request.Content
25158 }
25159
25160 if !dara.IsNil(request.ContentType) {
25161 body["ContentType"] = request.ContentType
25162 }
25163
25164 if !dara.IsNil(request.Description) {
25165 body["Description"] = request.Description
25166 }
25167
25168 if !dara.IsNil(request.Id) {
25169 body["Id"] = request.Id
25170 }
25171
25172 if !dara.IsNil(request.Name) {
25173 body["Name"] = request.Name
25174 }
25175
25176 req := &openapiutil.OpenApiRequest{
25177 Body: openapiutil.ParseToMap(body),
25178 }
25179 params := &openapiutil.Params{
25180 Action: dara.String("UpdatePage"),
25181 Version: dara.String("2024-09-10"),
25182 Protocol: dara.String("HTTPS"),
25183 Pathname: dara.String("/"),
25184 Method: dara.String("POST"),
25185 AuthType: dara.String("AK"),
25186 Style: dara.String("RPC"),
25187 ReqBodyType: dara.String("formData"),
25188 BodyType: dara.String("json"),
25189 }
25190 _result = &UpdatePageResponse{}
25191 _body, _err := client.CallApi(params, req, runtime)
25192 if _err != nil {
25193 return _result, _err
25194 }
25195 _err = dara.Convert(_body, &_result)
25196 return _result, _err
25197 }
25198
25199 // Summary:
25200 //
25201 // Modifies the configurations of a custom error page, such as the name, description, content type, and content of the page.
25202 //
25203 // @param request - UpdatePageRequest
25204 //
25205 // @return UpdatePageResponse
25206 func UpdatePage(client *Client, request *UpdatePageRequest) (_result *UpdatePageResponse, _err error) {
25207 runtime := &dara.RuntimeOptions{}
25208 _result = &UpdatePageResponse{}
25209 _body, _err := UpdatePageWithOptions(client,request, runtime)
25210 if _err != nil {
25211 return _result, _err
25212 }
25213 _result = _body
25214 return _result, _err
25215 }
25216
25217 // Summary:
25218 //
25219 // 套餐变配
25220 //
25221 // @param request - UpdateRatePlanSpecRequest
25222 //
25223 // @param runtime - runtime options for this request RuntimeOptions
25224 //
25225 // @return UpdateRatePlanSpecResponse
25226 func UpdateRatePlanSpecWithOptions(client *Client, request *UpdateRatePlanSpecRequest, runtime *dara.RuntimeOptions) (_result *UpdateRatePlanSpecResponse, _err error) {
25227 if dara.BoolValue(client.EnableValidate) == true {
25228 _err = request.Validate()
25229 if _err != nil {
25230 return _result, _err
25231 }
25232 }
25233 query := map[string]interface{}{}
25234 if !dara.IsNil(request.AutoPay) {
25235 query["AutoPay"] = request.AutoPay
25236 }
25237
25238 if !dara.IsNil(request.ChargeType) {
25239 query["ChargeType"] = request.ChargeType
25240 }
25241
25242 if !dara.IsNil(request.InstanceId) {
25243 query["InstanceId"] = request.InstanceId
25244 }
25245
25246 if !dara.IsNil(request.OrderType) {
25247 query["OrderType"] = request.OrderType
25248 }
25249
25250 if !dara.IsNil(request.TargetPlanCode) {
25251 query["TargetPlanCode"] = request.TargetPlanCode
25252 }
25253
25254 if !dara.IsNil(request.TargetPlanName) {
25255 query["TargetPlanName"] = request.TargetPlanName
25256 }
25257
25258 req := &openapiutil.OpenApiRequest{
25259 Query: openapiutil.Query(query),
25260 }
25261 params := &openapiutil.Params{
25262 Action: dara.String("UpdateRatePlanSpec"),
25263 Version: dara.String("2024-09-10"),
25264 Protocol: dara.String("HTTPS"),
25265 Pathname: dara.String("/"),
25266 Method: dara.String("POST"),
25267 AuthType: dara.String("AK"),
25268 Style: dara.String("RPC"),
25269 ReqBodyType: dara.String("formData"),
25270 BodyType: dara.String("json"),
25271 }
25272 _result = &UpdateRatePlanSpecResponse{}
25273 _body, _err := client.CallApi(params, req, runtime)
25274 if _err != nil {
25275 return _result, _err
25276 }
25277 _err = dara.Convert(_body, &_result)
25278 return _result, _err
25279 }
25280
25281 // Summary:
25282 //
25283 // 套餐变配
25284 //
25285 // @param request - UpdateRatePlanSpecRequest
25286 //
25287 // @return UpdateRatePlanSpecResponse
25288 func UpdateRatePlanSpec(client *Client, request *UpdateRatePlanSpecRequest) (_result *UpdateRatePlanSpecResponse, _err error) {
25289 runtime := &dara.RuntimeOptions{}
25290 _result = &UpdateRatePlanSpecResponse{}
25291 _body, _err := UpdateRatePlanSpecWithOptions(client,request, runtime)
25292 if _err != nil {
25293 return _result, _err
25294 }
25295 _result = _body
25296 return _result, _err
25297 }
25298
25299 // Summary:
25300 //
25301 // Updates multiple types of DNS records and origin authentication configurations.
25302 //
25303 // Description:
25304 //
25305 // 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.
25306 //
25307 // ### [](#)Usage notes
25308 //
25309 // - The record value (Value) must match the record type. For example, the CNAME record should correspond to the target domain name.
25310 //
25311 // - You must specify a priority (Priority) for some record types, such as MX and SRV.
25312 //
25313 // - You must specify specific fields such as Flag and Tag for CAA records.
25314 //
25315 // - When you update security records such as CERT and SSHFP, you must accurately set fields such as Type and Algorithm.
25316 //
25317 // - If your origin type is OSS or S3, configure the authentication details in AuthConf based on the permissions.
25318 //
25319 // @param tmpReq - UpdateRecordRequest
25320 //
25321 // @param runtime - runtime options for this request RuntimeOptions
25322 //
25323 // @return UpdateRecordResponse
25324 func UpdateRecordWithOptions(client *Client, tmpReq *UpdateRecordRequest, runtime *dara.RuntimeOptions) (_result *UpdateRecordResponse, _err error) {
25325 if dara.BoolValue(client.EnableValidate) == true {
25326 _err = tmpReq.Validate()
25327 if _err != nil {
25328 return _result, _err
25329 }
25330 }
25331 request := &UpdateRecordShrinkRequest{}
25332 openapiutil.Convert(tmpReq, request)
25333 if !dara.IsNil(tmpReq.AuthConf) {
25334 request.AuthConfShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.AuthConf, dara.String("AuthConf"), dara.String("json"))
25335 }
25336
25337 if !dara.IsNil(tmpReq.Data) {
25338 request.DataShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Data, dara.String("Data"), dara.String("json"))
25339 }
25340
25341 query := map[string]interface{}{}
25342 if !dara.IsNil(request.AuthConfShrink) {
25343 query["AuthConf"] = request.AuthConfShrink
25344 }
25345
25346 if !dara.IsNil(request.BizName) {
25347 query["BizName"] = request.BizName
25348 }
25349
25350 if !dara.IsNil(request.Comment) {
25351 query["Comment"] = request.Comment
25352 }
25353
25354 if !dara.IsNil(request.DataShrink) {
25355 query["Data"] = request.DataShrink
25356 }
25357
25358 if !dara.IsNil(request.HostPolicy) {
25359 query["HostPolicy"] = request.HostPolicy
25360 }
25361
25362 if !dara.IsNil(request.Proxied) {
25363 query["Proxied"] = request.Proxied
25364 }
25365
25366 if !dara.IsNil(request.RecordId) {
25367 query["RecordId"] = request.RecordId
25368 }
25369
25370 if !dara.IsNil(request.SourceType) {
25371 query["SourceType"] = request.SourceType
25372 }
25373
25374 if !dara.IsNil(request.Ttl) {
25375 query["Ttl"] = request.Ttl
25376 }
25377
25378 if !dara.IsNil(request.Type) {
25379 query["Type"] = request.Type
25380 }
25381
25382 req := &openapiutil.OpenApiRequest{
25383 Query: openapiutil.Query(query),
25384 }
25385 params := &openapiutil.Params{
25386 Action: dara.String("UpdateRecord"),
25387 Version: dara.String("2024-09-10"),
25388 Protocol: dara.String("HTTPS"),
25389 Pathname: dara.String("/"),
25390 Method: dara.String("POST"),
25391 AuthType: dara.String("AK"),
25392 Style: dara.String("RPC"),
25393 ReqBodyType: dara.String("formData"),
25394 BodyType: dara.String("json"),
25395 }
25396 _result = &UpdateRecordResponse{}
25397 _body, _err := client.CallApi(params, req, runtime)
25398 if _err != nil {
25399 return _result, _err
25400 }
25401 _err = dara.Convert(_body, &_result)
25402 return _result, _err
25403 }
25404
25405 // Summary:
25406 //
25407 // Updates multiple types of DNS records and origin authentication configurations.
25408 //
25409 // Description:
25410 //
25411 // 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.
25412 //
25413 // ### [](#)Usage notes
25414 //
25415 // - The record value (Value) must match the record type. For example, the CNAME record should correspond to the target domain name.
25416 //
25417 // - You must specify a priority (Priority) for some record types, such as MX and SRV.
25418 //
25419 // - You must specify specific fields such as Flag and Tag for CAA records.
25420 //
25421 // - When you update security records such as CERT and SSHFP, you must accurately set fields such as Type and Algorithm.
25422 //
25423 // - If your origin type is OSS or S3, configure the authentication details in AuthConf based on the permissions.
25424 //
25425 // @param request - UpdateRecordRequest
25426 //
25427 // @return UpdateRecordResponse
25428 func UpdateRecord(client *Client, request *UpdateRecordRequest) (_result *UpdateRecordResponse, _err error) {
25429 runtime := &dara.RuntimeOptions{}
25430 _result = &UpdateRecordResponse{}
25431 _body, _err := UpdateRecordWithOptions(client,request, runtime)
25432 if _err != nil {
25433 return _result, _err
25434 }
25435 _result = _body
25436 return _result, _err
25437 }
25438
25439 // Summary:
25440 //
25441 // # Update Redirect Rule
25442 //
25443 // @param request - UpdateRedirectRuleRequest
25444 //
25445 // @param runtime - runtime options for this request RuntimeOptions
25446 //
25447 // @return UpdateRedirectRuleResponse
25448 func UpdateRedirectRuleWithOptions(client *Client, request *UpdateRedirectRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateRedirectRuleResponse, _err error) {
25449 if dara.BoolValue(client.EnableValidate) == true {
25450 _err = request.Validate()
25451 if _err != nil {
25452 return _result, _err
25453 }
25454 }
25455 query := map[string]interface{}{}
25456 if !dara.IsNil(request.ConfigId) {
25457 query["ConfigId"] = request.ConfigId
25458 }
25459
25460 if !dara.IsNil(request.ReserveQueryString) {
25461 query["ReserveQueryString"] = request.ReserveQueryString
25462 }
25463
25464 if !dara.IsNil(request.Rule) {
25465 query["Rule"] = request.Rule
25466 }
25467
25468 if !dara.IsNil(request.RuleEnable) {
25469 query["RuleEnable"] = request.RuleEnable
25470 }
25471
25472 if !dara.IsNil(request.RuleName) {
25473 query["RuleName"] = request.RuleName
25474 }
25475
25476 if !dara.IsNil(request.Sequence) {
25477 query["Sequence"] = request.Sequence
25478 }
25479
25480 if !dara.IsNil(request.SiteId) {
25481 query["SiteId"] = request.SiteId
25482 }
25483
25484 if !dara.IsNil(request.StatusCode) {
25485 query["StatusCode"] = request.StatusCode
25486 }
25487
25488 if !dara.IsNil(request.TargetUrl) {
25489 query["TargetUrl"] = request.TargetUrl
25490 }
25491
25492 if !dara.IsNil(request.Type) {
25493 query["Type"] = request.Type
25494 }
25495
25496 req := &openapiutil.OpenApiRequest{
25497 Query: openapiutil.Query(query),
25498 }
25499 params := &openapiutil.Params{
25500 Action: dara.String("UpdateRedirectRule"),
25501 Version: dara.String("2024-09-10"),
25502 Protocol: dara.String("HTTPS"),
25503 Pathname: dara.String("/"),
25504 Method: dara.String("POST"),
25505 AuthType: dara.String("AK"),
25506 Style: dara.String("RPC"),
25507 ReqBodyType: dara.String("formData"),
25508 BodyType: dara.String("json"),
25509 }
25510 _result = &UpdateRedirectRuleResponse{}
25511 _body, _err := client.CallApi(params, req, runtime)
25512 if _err != nil {
25513 return _result, _err
25514 }
25515 _err = dara.Convert(_body, &_result)
25516 return _result, _err
25517 }
25518
25519 // Summary:
25520 //
25521 // # Update Redirect Rule
25522 //
25523 // @param request - UpdateRedirectRuleRequest
25524 //
25525 // @return UpdateRedirectRuleResponse
25526 func UpdateRedirectRule(client *Client, request *UpdateRedirectRuleRequest) (_result *UpdateRedirectRuleResponse, _err error) {
25527 runtime := &dara.RuntimeOptions{}
25528 _result = &UpdateRedirectRuleResponse{}
25529 _body, _err := UpdateRedirectRuleWithOptions(client,request, runtime)
25530 if _err != nil {
25531 return _result, _err
25532 }
25533 _result = _body
25534 return _result, _err
25535 }
25536
25537 // Summary:
25538 //
25539 // # Modify Rewrite URL Rule
25540 //
25541 // @param request - UpdateRewriteUrlRuleRequest
25542 //
25543 // @param runtime - runtime options for this request RuntimeOptions
25544 //
25545 // @return UpdateRewriteUrlRuleResponse
25546 func UpdateRewriteUrlRuleWithOptions(client *Client, request *UpdateRewriteUrlRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateRewriteUrlRuleResponse, _err error) {
25547 if dara.BoolValue(client.EnableValidate) == true {
25548 _err = request.Validate()
25549 if _err != nil {
25550 return _result, _err
25551 }
25552 }
25553 query := map[string]interface{}{}
25554 if !dara.IsNil(request.ConfigId) {
25555 query["ConfigId"] = request.ConfigId
25556 }
25557
25558 if !dara.IsNil(request.QueryString) {
25559 query["QueryString"] = request.QueryString
25560 }
25561
25562 if !dara.IsNil(request.RewriteQueryStringType) {
25563 query["RewriteQueryStringType"] = request.RewriteQueryStringType
25564 }
25565
25566 if !dara.IsNil(request.RewriteUriType) {
25567 query["RewriteUriType"] = request.RewriteUriType
25568 }
25569
25570 if !dara.IsNil(request.Rule) {
25571 query["Rule"] = request.Rule
25572 }
25573
25574 if !dara.IsNil(request.RuleEnable) {
25575 query["RuleEnable"] = request.RuleEnable
25576 }
25577
25578 if !dara.IsNil(request.RuleName) {
25579 query["RuleName"] = request.RuleName
25580 }
25581
25582 if !dara.IsNil(request.Sequence) {
25583 query["Sequence"] = request.Sequence
25584 }
25585
25586 if !dara.IsNil(request.SiteId) {
25587 query["SiteId"] = request.SiteId
25588 }
25589
25590 if !dara.IsNil(request.Uri) {
25591 query["Uri"] = request.Uri
25592 }
25593
25594 req := &openapiutil.OpenApiRequest{
25595 Query: openapiutil.Query(query),
25596 }
25597 params := &openapiutil.Params{
25598 Action: dara.String("UpdateRewriteUrlRule"),
25599 Version: dara.String("2024-09-10"),
25600 Protocol: dara.String("HTTPS"),
25601 Pathname: dara.String("/"),
25602 Method: dara.String("POST"),
25603 AuthType: dara.String("AK"),
25604 Style: dara.String("RPC"),
25605 ReqBodyType: dara.String("formData"),
25606 BodyType: dara.String("json"),
25607 }
25608 _result = &UpdateRewriteUrlRuleResponse{}
25609 _body, _err := client.CallApi(params, req, runtime)
25610 if _err != nil {
25611 return _result, _err
25612 }
25613 _err = dara.Convert(_body, &_result)
25614 return _result, _err
25615 }
25616
25617 // Summary:
25618 //
25619 // # Modify Rewrite URL Rule
25620 //
25621 // @param request - UpdateRewriteUrlRuleRequest
25622 //
25623 // @return UpdateRewriteUrlRuleResponse
25624 func UpdateRewriteUrlRule(client *Client, request *UpdateRewriteUrlRuleRequest) (_result *UpdateRewriteUrlRuleResponse, _err error) {
25625 runtime := &dara.RuntimeOptions{}
25626 _result = &UpdateRewriteUrlRuleResponse{}
25627 _body, _err := UpdateRewriteUrlRuleWithOptions(client,request, runtime)
25628 if _err != nil {
25629 return _result, _err
25630 }
25631 _result = _body
25632 return _result, _err
25633 }
25634
25635 // Summary:
25636 //
25637 // Modifies the description of a routine.
25638 //
25639 // @param request - UpdateRoutineConfigDescriptionRequest
25640 //
25641 // @param runtime - runtime options for this request RuntimeOptions
25642 //
25643 // @return UpdateRoutineConfigDescriptionResponse
25644 func UpdateRoutineConfigDescriptionWithOptions(client *Client, request *UpdateRoutineConfigDescriptionRequest, runtime *dara.RuntimeOptions) (_result *UpdateRoutineConfigDescriptionResponse, _err error) {
25645 if dara.BoolValue(client.EnableValidate) == true {
25646 _err = request.Validate()
25647 if _err != nil {
25648 return _result, _err
25649 }
25650 }
25651 body := map[string]interface{}{}
25652 if !dara.IsNil(request.Description) {
25653 body["Description"] = request.Description
25654 }
25655
25656 if !dara.IsNil(request.Name) {
25657 body["Name"] = request.Name
25658 }
25659
25660 req := &openapiutil.OpenApiRequest{
25661 Body: openapiutil.ParseToMap(body),
25662 }
25663 params := &openapiutil.Params{
25664 Action: dara.String("UpdateRoutineConfigDescription"),
25665 Version: dara.String("2024-09-10"),
25666 Protocol: dara.String("HTTPS"),
25667 Pathname: dara.String("/"),
25668 Method: dara.String("POST"),
25669 AuthType: dara.String("AK"),
25670 Style: dara.String("RPC"),
25671 ReqBodyType: dara.String("formData"),
25672 BodyType: dara.String("json"),
25673 }
25674 _result = &UpdateRoutineConfigDescriptionResponse{}
25675 _body, _err := client.CallApi(params, req, runtime)
25676 if _err != nil {
25677 return _result, _err
25678 }
25679 _err = dara.Convert(_body, &_result)
25680 return _result, _err
25681 }
25682
25683 // Summary:
25684 //
25685 // Modifies the description of a routine.
25686 //
25687 // @param request - UpdateRoutineConfigDescriptionRequest
25688 //
25689 // @return UpdateRoutineConfigDescriptionResponse
25690 func UpdateRoutineConfigDescription(client *Client, request *UpdateRoutineConfigDescriptionRequest) (_result *UpdateRoutineConfigDescriptionResponse, _err error) {
25691 runtime := &dara.RuntimeOptions{}
25692 _result = &UpdateRoutineConfigDescriptionResponse{}
25693 _body, _err := UpdateRoutineConfigDescriptionWithOptions(client,request, runtime)
25694 if _err != nil {
25695 return _result, _err
25696 }
25697 _result = _body
25698 return _result, _err
25699 }
25700
25701 // Summary:
25702 //
25703 // Modifies the route configuration of an edge function.
25704 //
25705 // @param request - UpdateRoutineRouteRequest
25706 //
25707 // @param runtime - runtime options for this request RuntimeOptions
25708 //
25709 // @return UpdateRoutineRouteResponse
25710 func UpdateRoutineRouteWithOptions(client *Client, request *UpdateRoutineRouteRequest, runtime *dara.RuntimeOptions) (_result *UpdateRoutineRouteResponse, _err error) {
25711 if dara.BoolValue(client.EnableValidate) == true {
25712 _err = request.Validate()
25713 if _err != nil {
25714 return _result, _err
25715 }
25716 }
25717 query := map[string]interface{}{}
25718 if !dara.IsNil(request.Bypass) {
25719 query["Bypass"] = request.Bypass
25720 }
25721
25722 if !dara.IsNil(request.ConfigId) {
25723 query["ConfigId"] = request.ConfigId
25724 }
25725
25726 if !dara.IsNil(request.Fallback) {
25727 query["Fallback"] = request.Fallback
25728 }
25729
25730 if !dara.IsNil(request.RouteEnable) {
25731 query["RouteEnable"] = request.RouteEnable
25732 }
25733
25734 if !dara.IsNil(request.RouteName) {
25735 query["RouteName"] = request.RouteName
25736 }
25737
25738 if !dara.IsNil(request.RoutineName) {
25739 query["RoutineName"] = request.RoutineName
25740 }
25741
25742 if !dara.IsNil(request.Rule) {
25743 query["Rule"] = request.Rule
25744 }
25745
25746 if !dara.IsNil(request.Sequence) {
25747 query["Sequence"] = request.Sequence
25748 }
25749
25750 if !dara.IsNil(request.SiteId) {
25751 query["SiteId"] = request.SiteId
25752 }
25753
25754 req := &openapiutil.OpenApiRequest{
25755 Query: openapiutil.Query(query),
25756 }
25757 params := &openapiutil.Params{
25758 Action: dara.String("UpdateRoutineRoute"),
25759 Version: dara.String("2024-09-10"),
25760 Protocol: dara.String("HTTPS"),
25761 Pathname: dara.String("/"),
25762 Method: dara.String("POST"),
25763 AuthType: dara.String("AK"),
25764 Style: dara.String("RPC"),
25765 ReqBodyType: dara.String("formData"),
25766 BodyType: dara.String("json"),
25767 }
25768 _result = &UpdateRoutineRouteResponse{}
25769 _body, _err := client.CallApi(params, req, runtime)
25770 if _err != nil {
25771 return _result, _err
25772 }
25773 _err = dara.Convert(_body, &_result)
25774 return _result, _err
25775 }
25776
25777 // Summary:
25778 //
25779 // Modifies the route configuration of an edge function.
25780 //
25781 // @param request - UpdateRoutineRouteRequest
25782 //
25783 // @return UpdateRoutineRouteResponse
25784 func UpdateRoutineRoute(client *Client, request *UpdateRoutineRouteRequest) (_result *UpdateRoutineRouteResponse, _err error) {
25785 runtime := &dara.RuntimeOptions{}
25786 _result = &UpdateRoutineRouteResponse{}
25787 _body, _err := UpdateRoutineRouteWithOptions(client,request, runtime)
25788 if _err != nil {
25789 return _result, _err
25790 }
25791 _result = _body
25792 return _result, _err
25793 }
25794
25795 // Summary:
25796 //
25797 // Updates a scheduled prefetch plan based on the plan ID.
25798 //
25799 // @param request - UpdateScheduledPreloadExecutionRequest
25800 //
25801 // @param runtime - runtime options for this request RuntimeOptions
25802 //
25803 // @return UpdateScheduledPreloadExecutionResponse
25804 func UpdateScheduledPreloadExecutionWithOptions(client *Client, request *UpdateScheduledPreloadExecutionRequest, runtime *dara.RuntimeOptions) (_result *UpdateScheduledPreloadExecutionResponse, _err error) {
25805 if dara.BoolValue(client.EnableValidate) == true {
25806 _err = request.Validate()
25807 if _err != nil {
25808 return _result, _err
25809 }
25810 }
25811 query := map[string]interface{}{}
25812 if !dara.IsNil(request.Id) {
25813 query["Id"] = request.Id
25814 }
25815
25816 body := map[string]interface{}{}
25817 if !dara.IsNil(request.EndTime) {
25818 body["EndTime"] = request.EndTime
25819 }
25820
25821 if !dara.IsNil(request.Interval) {
25822 body["Interval"] = request.Interval
25823 }
25824
25825 if !dara.IsNil(request.SliceLen) {
25826 body["SliceLen"] = request.SliceLen
25827 }
25828
25829 if !dara.IsNil(request.StartTime) {
25830 body["StartTime"] = request.StartTime
25831 }
25832
25833 req := &openapiutil.OpenApiRequest{
25834 Query: openapiutil.Query(query),
25835 Body: openapiutil.ParseToMap(body),
25836 }
25837 params := &openapiutil.Params{
25838 Action: dara.String("UpdateScheduledPreloadExecution"),
25839 Version: dara.String("2024-09-10"),
25840 Protocol: dara.String("HTTPS"),
25841 Pathname: dara.String("/"),
25842 Method: dara.String("POST"),
25843 AuthType: dara.String("AK"),
25844 Style: dara.String("RPC"),
25845 ReqBodyType: dara.String("formData"),
25846 BodyType: dara.String("json"),
25847 }
25848 _result = &UpdateScheduledPreloadExecutionResponse{}
25849 _body, _err := client.CallApi(params, req, runtime)
25850 if _err != nil {
25851 return _result, _err
25852 }
25853 _err = dara.Convert(_body, &_result)
25854 return _result, _err
25855 }
25856
25857 // Summary:
25858 //
25859 // Updates a scheduled prefetch plan based on the plan ID.
25860 //
25861 // @param request - UpdateScheduledPreloadExecutionRequest
25862 //
25863 // @return UpdateScheduledPreloadExecutionResponse
25864 func UpdateScheduledPreloadExecution(client *Client, request *UpdateScheduledPreloadExecutionRequest) (_result *UpdateScheduledPreloadExecutionResponse, _err error) {
25865 runtime := &dara.RuntimeOptions{}
25866 _result = &UpdateScheduledPreloadExecutionResponse{}
25867 _body, _err := UpdateScheduledPreloadExecutionWithOptions(client,request, runtime)
25868 if _err != nil {
25869 return _result, _err
25870 }
25871 _result = _body
25872 return _result, _err
25873 }
25874
25875 // Summary:
25876 //
25877 // Modifies the search engine crawler configuration for a website.
25878 //
25879 // @param request - UpdateSeoBypassRequest
25880 //
25881 // @param runtime - runtime options for this request RuntimeOptions
25882 //
25883 // @return UpdateSeoBypassResponse
25884 func UpdateSeoBypassWithOptions(client *Client, request *UpdateSeoBypassRequest, runtime *dara.RuntimeOptions) (_result *UpdateSeoBypassResponse, _err error) {
25885 if dara.BoolValue(client.EnableValidate) == true {
25886 _err = request.Validate()
25887 if _err != nil {
25888 return _result, _err
25889 }
25890 }
25891 query := map[string]interface{}{}
25892 if !dara.IsNil(request.Enable) {
25893 query["Enable"] = request.Enable
25894 }
25895
25896 if !dara.IsNil(request.SiteId) {
25897 query["SiteId"] = request.SiteId
25898 }
25899
25900 req := &openapiutil.OpenApiRequest{
25901 Query: openapiutil.Query(query),
25902 }
25903 params := &openapiutil.Params{
25904 Action: dara.String("UpdateSeoBypass"),
25905 Version: dara.String("2024-09-10"),
25906 Protocol: dara.String("HTTPS"),
25907 Pathname: dara.String("/"),
25908 Method: dara.String("POST"),
25909 AuthType: dara.String("AK"),
25910 Style: dara.String("RPC"),
25911 ReqBodyType: dara.String("formData"),
25912 BodyType: dara.String("json"),
25913 }
25914 _result = &UpdateSeoBypassResponse{}
25915 _body, _err := client.CallApi(params, req, runtime)
25916 if _err != nil {
25917 return _result, _err
25918 }
25919 _err = dara.Convert(_body, &_result)
25920 return _result, _err
25921 }
25922
25923 // Summary:
25924 //
25925 // Modifies the search engine crawler configuration for a website.
25926 //
25927 // @param request - UpdateSeoBypassRequest
25928 //
25929 // @return UpdateSeoBypassResponse
25930 func UpdateSeoBypass(client *Client, request *UpdateSeoBypassRequest) (_result *UpdateSeoBypassResponse, _err error) {
25931 runtime := &dara.RuntimeOptions{}
25932 _result = &UpdateSeoBypassResponse{}
25933 _body, _err := UpdateSeoBypassWithOptions(client,request, runtime)
25934 if _err != nil {
25935 return _result, _err
25936 }
25937 _result = _body
25938 return _result, _err
25939 }
25940
25941 // Summary:
25942 //
25943 // Converts the DNS setup option of a website.
25944 //
25945 // Description:
25946 //
25947 // When you change the DNS setup of a website from NS to CNAME, note the following prerequisites:
25948 //
25949 // - The website only has proxied A/AAAA and CNAME records.
25950 //
25951 // - The DNS passthrough mode and custom nameserver features are not enabled for the website.
25952 //
25953 // @param request - UpdateSiteAccessTypeRequest
25954 //
25955 // @param runtime - runtime options for this request RuntimeOptions
25956 //
25957 // @return UpdateSiteAccessTypeResponse
25958 func UpdateSiteAccessTypeWithOptions(client *Client, request *UpdateSiteAccessTypeRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteAccessTypeResponse, _err error) {
25959 if dara.BoolValue(client.EnableValidate) == true {
25960 _err = request.Validate()
25961 if _err != nil {
25962 return _result, _err
25963 }
25964 }
25965 query := map[string]interface{}{}
25966 if !dara.IsNil(request.AccessType) {
25967 query["AccessType"] = request.AccessType
25968 }
25969
25970 if !dara.IsNil(request.SiteId) {
25971 query["SiteId"] = request.SiteId
25972 }
25973
25974 req := &openapiutil.OpenApiRequest{
25975 Query: openapiutil.Query(query),
25976 }
25977 params := &openapiutil.Params{
25978 Action: dara.String("UpdateSiteAccessType"),
25979 Version: dara.String("2024-09-10"),
25980 Protocol: dara.String("HTTPS"),
25981 Pathname: dara.String("/"),
25982 Method: dara.String("POST"),
25983 AuthType: dara.String("AK"),
25984 Style: dara.String("RPC"),
25985 ReqBodyType: dara.String("formData"),
25986 BodyType: dara.String("json"),
25987 }
25988 _result = &UpdateSiteAccessTypeResponse{}
25989 _body, _err := client.CallApi(params, req, runtime)
25990 if _err != nil {
25991 return _result, _err
25992 }
25993 _err = dara.Convert(_body, &_result)
25994 return _result, _err
25995 }
25996
25997 // Summary:
25998 //
25999 // Converts the DNS setup option of a website.
26000 //
26001 // Description:
26002 //
26003 // When you change the DNS setup of a website from NS to CNAME, note the following prerequisites:
26004 //
26005 // - The website only has proxied A/AAAA and CNAME records.
26006 //
26007 // - The DNS passthrough mode and custom nameserver features are not enabled for the website.
26008 //
26009 // @param request - UpdateSiteAccessTypeRequest
26010 //
26011 // @return UpdateSiteAccessTypeResponse
26012 func UpdateSiteAccessType(client *Client, request *UpdateSiteAccessTypeRequest) (_result *UpdateSiteAccessTypeResponse, _err error) {
26013 runtime := &dara.RuntimeOptions{}
26014 _result = &UpdateSiteAccessTypeResponse{}
26015 _body, _err := UpdateSiteAccessTypeWithOptions(client,request, runtime)
26016 if _err != nil {
26017 return _result, _err
26018 }
26019 _result = _body
26020 return _result, _err
26021 }
26022
26023 // Summary:
26024 //
26025 // 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.
26026 //
26027 // @param request - UpdateSiteCoverageRequest
26028 //
26029 // @param runtime - runtime options for this request RuntimeOptions
26030 //
26031 // @return UpdateSiteCoverageResponse
26032 func UpdateSiteCoverageWithOptions(client *Client, request *UpdateSiteCoverageRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteCoverageResponse, _err error) {
26033 if dara.BoolValue(client.EnableValidate) == true {
26034 _err = request.Validate()
26035 if _err != nil {
26036 return _result, _err
26037 }
26038 }
26039 query := map[string]interface{}{}
26040 if !dara.IsNil(request.Coverage) {
26041 query["Coverage"] = request.Coverage
26042 }
26043
26044 if !dara.IsNil(request.SiteId) {
26045 query["SiteId"] = request.SiteId
26046 }
26047
26048 req := &openapiutil.OpenApiRequest{
26049 Query: openapiutil.Query(query),
26050 }
26051 params := &openapiutil.Params{
26052 Action: dara.String("UpdateSiteCoverage"),
26053 Version: dara.String("2024-09-10"),
26054 Protocol: dara.String("HTTPS"),
26055 Pathname: dara.String("/"),
26056 Method: dara.String("POST"),
26057 AuthType: dara.String("AK"),
26058 Style: dara.String("RPC"),
26059 ReqBodyType: dara.String("formData"),
26060 BodyType: dara.String("json"),
26061 }
26062 _result = &UpdateSiteCoverageResponse{}
26063 _body, _err := client.CallApi(params, req, runtime)
26064 if _err != nil {
26065 return _result, _err
26066 }
26067 _err = dara.Convert(_body, &_result)
26068 return _result, _err
26069 }
26070
26071 // Summary:
26072 //
26073 // 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.
26074 //
26075 // @param request - UpdateSiteCoverageRequest
26076 //
26077 // @return UpdateSiteCoverageResponse
26078 func UpdateSiteCoverage(client *Client, request *UpdateSiteCoverageRequest) (_result *UpdateSiteCoverageResponse, _err error) {
26079 runtime := &dara.RuntimeOptions{}
26080 _result = &UpdateSiteCoverageResponse{}
26081 _body, _err := UpdateSiteCoverageWithOptions(client,request, runtime)
26082 if _err != nil {
26083 return _result, _err
26084 }
26085 _result = _body
26086 return _result, _err
26087 }
26088
26089 // Summary:
26090 //
26091 // Modifies the configuration of custom request header, response header, and cookie fields that are used to capture logs of a website.
26092 //
26093 // @param tmpReq - UpdateSiteCustomLogRequest
26094 //
26095 // @param runtime - runtime options for this request RuntimeOptions
26096 //
26097 // @return UpdateSiteCustomLogResponse
26098 func UpdateSiteCustomLogWithOptions(client *Client, tmpReq *UpdateSiteCustomLogRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteCustomLogResponse, _err error) {
26099 if dara.BoolValue(client.EnableValidate) == true {
26100 _err = tmpReq.Validate()
26101 if _err != nil {
26102 return _result, _err
26103 }
26104 }
26105 request := &UpdateSiteCustomLogShrinkRequest{}
26106 openapiutil.Convert(tmpReq, request)
26107 if !dara.IsNil(tmpReq.Cookies) {
26108 request.CookiesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Cookies, dara.String("Cookies"), dara.String("json"))
26109 }
26110
26111 if !dara.IsNil(tmpReq.RequestHeaders) {
26112 request.RequestHeadersShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.RequestHeaders, dara.String("RequestHeaders"), dara.String("json"))
26113 }
26114
26115 if !dara.IsNil(tmpReq.ResponseHeaders) {
26116 request.ResponseHeadersShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.ResponseHeaders, dara.String("ResponseHeaders"), dara.String("json"))
26117 }
26118
26119 body := map[string]interface{}{}
26120 if !dara.IsNil(request.CookiesShrink) {
26121 body["Cookies"] = request.CookiesShrink
26122 }
26123
26124 if !dara.IsNil(request.RequestHeadersShrink) {
26125 body["RequestHeaders"] = request.RequestHeadersShrink
26126 }
26127
26128 if !dara.IsNil(request.ResponseHeadersShrink) {
26129 body["ResponseHeaders"] = request.ResponseHeadersShrink
26130 }
26131
26132 if !dara.IsNil(request.SiteId) {
26133 body["SiteId"] = request.SiteId
26134 }
26135
26136 req := &openapiutil.OpenApiRequest{
26137 Body: openapiutil.ParseToMap(body),
26138 }
26139 params := &openapiutil.Params{
26140 Action: dara.String("UpdateSiteCustomLog"),
26141 Version: dara.String("2024-09-10"),
26142 Protocol: dara.String("HTTPS"),
26143 Pathname: dara.String("/"),
26144 Method: dara.String("POST"),
26145 AuthType: dara.String("AK"),
26146 Style: dara.String("RPC"),
26147 ReqBodyType: dara.String("formData"),
26148 BodyType: dara.String("json"),
26149 }
26150 _result = &UpdateSiteCustomLogResponse{}
26151 _body, _err := client.CallApi(params, req, runtime)
26152 if _err != nil {
26153 return _result, _err
26154 }
26155 _err = dara.Convert(_body, &_result)
26156 return _result, _err
26157 }
26158
26159 // Summary:
26160 //
26161 // Modifies the configuration of custom request header, response header, and cookie fields that are used to capture logs of a website.
26162 //
26163 // @param request - UpdateSiteCustomLogRequest
26164 //
26165 // @return UpdateSiteCustomLogResponse
26166 func UpdateSiteCustomLog(client *Client, request *UpdateSiteCustomLogRequest) (_result *UpdateSiteCustomLogResponse, _err error) {
26167 runtime := &dara.RuntimeOptions{}
26168 _result = &UpdateSiteCustomLogResponse{}
26169 _body, _err := UpdateSiteCustomLogWithOptions(client,request, runtime)
26170 if _err != nil {
26171 return _result, _err
26172 }
26173 _result = _body
26174 return _result, _err
26175 }
26176
26177 // Summary:
26178 //
26179 // Modifies a real-time log delivery task.
26180 //
26181 // @param request - UpdateSiteDeliveryTaskRequest
26182 //
26183 // @param runtime - runtime options for this request RuntimeOptions
26184 //
26185 // @return UpdateSiteDeliveryTaskResponse
26186 func UpdateSiteDeliveryTaskWithOptions(client *Client, request *UpdateSiteDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteDeliveryTaskResponse, _err error) {
26187 if dara.BoolValue(client.EnableValidate) == true {
26188 _err = request.Validate()
26189 if _err != nil {
26190 return _result, _err
26191 }
26192 }
26193 body := map[string]interface{}{}
26194 if !dara.IsNil(request.BusinessType) {
26195 body["BusinessType"] = request.BusinessType
26196 }
26197
26198 if !dara.IsNil(request.DiscardRate) {
26199 body["DiscardRate"] = request.DiscardRate
26200 }
26201
26202 if !dara.IsNil(request.FieldName) {
26203 body["FieldName"] = request.FieldName
26204 }
26205
26206 if !dara.IsNil(request.FilterVer) {
26207 body["FilterVer"] = request.FilterVer
26208 }
26209
26210 if !dara.IsNil(request.SiteId) {
26211 body["SiteId"] = request.SiteId
26212 }
26213
26214 if !dara.IsNil(request.TaskName) {
26215 body["TaskName"] = request.TaskName
26216 }
26217
26218 req := &openapiutil.OpenApiRequest{
26219 Body: openapiutil.ParseToMap(body),
26220 }
26221 params := &openapiutil.Params{
26222 Action: dara.String("UpdateSiteDeliveryTask"),
26223 Version: dara.String("2024-09-10"),
26224 Protocol: dara.String("HTTPS"),
26225 Pathname: dara.String("/"),
26226 Method: dara.String("POST"),
26227 AuthType: dara.String("AK"),
26228 Style: dara.String("RPC"),
26229 ReqBodyType: dara.String("formData"),
26230 BodyType: dara.String("json"),
26231 }
26232 _result = &UpdateSiteDeliveryTaskResponse{}
26233 _body, _err := client.CallApi(params, req, runtime)
26234 if _err != nil {
26235 return _result, _err
26236 }
26237 _err = dara.Convert(_body, &_result)
26238 return _result, _err
26239 }
26240
26241 // Summary:
26242 //
26243 // Modifies a real-time log delivery task.
26244 //
26245 // @param request - UpdateSiteDeliveryTaskRequest
26246 //
26247 // @return UpdateSiteDeliveryTaskResponse
26248 func UpdateSiteDeliveryTask(client *Client, request *UpdateSiteDeliveryTaskRequest) (_result *UpdateSiteDeliveryTaskResponse, _err error) {
26249 runtime := &dara.RuntimeOptions{}
26250 _result = &UpdateSiteDeliveryTaskResponse{}
26251 _body, _err := UpdateSiteDeliveryTaskWithOptions(client,request, runtime)
26252 if _err != nil {
26253 return _result, _err
26254 }
26255 _result = _body
26256 return _result, _err
26257 }
26258
26259 // Summary:
26260 //
26261 // Changes the status of a real-time log delivery task.
26262 //
26263 // @param request - UpdateSiteDeliveryTaskStatusRequest
26264 //
26265 // @param runtime - runtime options for this request RuntimeOptions
26266 //
26267 // @return UpdateSiteDeliveryTaskStatusResponse
26268 func UpdateSiteDeliveryTaskStatusWithOptions(client *Client, request *UpdateSiteDeliveryTaskStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteDeliveryTaskStatusResponse, _err error) {
26269 if dara.BoolValue(client.EnableValidate) == true {
26270 _err = request.Validate()
26271 if _err != nil {
26272 return _result, _err
26273 }
26274 }
26275 query := openapiutil.Query(dara.ToMap(request))
26276 req := &openapiutil.OpenApiRequest{
26277 Query: openapiutil.Query(query),
26278 }
26279 params := &openapiutil.Params{
26280 Action: dara.String("UpdateSiteDeliveryTaskStatus"),
26281 Version: dara.String("2024-09-10"),
26282 Protocol: dara.String("HTTPS"),
26283 Pathname: dara.String("/"),
26284 Method: dara.String("GET"),
26285 AuthType: dara.String("AK"),
26286 Style: dara.String("RPC"),
26287 ReqBodyType: dara.String("formData"),
26288 BodyType: dara.String("json"),
26289 }
26290 _result = &UpdateSiteDeliveryTaskStatusResponse{}
26291 _body, _err := client.CallApi(params, req, runtime)
26292 if _err != nil {
26293 return _result, _err
26294 }
26295 _err = dara.Convert(_body, &_result)
26296 return _result, _err
26297 }
26298
26299 // Summary:
26300 //
26301 // Changes the status of a real-time log delivery task.
26302 //
26303 // @param request - UpdateSiteDeliveryTaskStatusRequest
26304 //
26305 // @return UpdateSiteDeliveryTaskStatusResponse
26306 func UpdateSiteDeliveryTaskStatus(client *Client, request *UpdateSiteDeliveryTaskStatusRequest) (_result *UpdateSiteDeliveryTaskStatusResponse, _err error) {
26307 runtime := &dara.RuntimeOptions{}
26308 _result = &UpdateSiteDeliveryTaskStatusResponse{}
26309 _body, _err := UpdateSiteDeliveryTaskStatusWithOptions(client,request, runtime)
26310 if _err != nil {
26311 return _result, _err
26312 }
26313 _result = _body
26314 return _result, _err
26315 }
26316
26317 // Summary:
26318 //
26319 // 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.
26320 //
26321 // @param request - UpdateSiteNameExclusiveRequest
26322 //
26323 // @param runtime - runtime options for this request RuntimeOptions
26324 //
26325 // @return UpdateSiteNameExclusiveResponse
26326 func UpdateSiteNameExclusiveWithOptions(client *Client, request *UpdateSiteNameExclusiveRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteNameExclusiveResponse, _err error) {
26327 if dara.BoolValue(client.EnableValidate) == true {
26328 _err = request.Validate()
26329 if _err != nil {
26330 return _result, _err
26331 }
26332 }
26333 query := map[string]interface{}{}
26334 if !dara.IsNil(request.Enable) {
26335 query["Enable"] = request.Enable
26336 }
26337
26338 if !dara.IsNil(request.SiteId) {
26339 query["SiteId"] = request.SiteId
26340 }
26341
26342 req := &openapiutil.OpenApiRequest{
26343 Query: openapiutil.Query(query),
26344 }
26345 params := &openapiutil.Params{
26346 Action: dara.String("UpdateSiteNameExclusive"),
26347 Version: dara.String("2024-09-10"),
26348 Protocol: dara.String("HTTPS"),
26349 Pathname: dara.String("/"),
26350 Method: dara.String("POST"),
26351 AuthType: dara.String("AK"),
26352 Style: dara.String("RPC"),
26353 ReqBodyType: dara.String("formData"),
26354 BodyType: dara.String("json"),
26355 }
26356 _result = &UpdateSiteNameExclusiveResponse{}
26357 _body, _err := client.CallApi(params, req, runtime)
26358 if _err != nil {
26359 return _result, _err
26360 }
26361 _err = dara.Convert(_body, &_result)
26362 return _result, _err
26363 }
26364
26365 // Summary:
26366 //
26367 // 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.
26368 //
26369 // @param request - UpdateSiteNameExclusiveRequest
26370 //
26371 // @return UpdateSiteNameExclusiveResponse
26372 func UpdateSiteNameExclusive(client *Client, request *UpdateSiteNameExclusiveRequest) (_result *UpdateSiteNameExclusiveResponse, _err error) {
26373 runtime := &dara.RuntimeOptions{}
26374 _result = &UpdateSiteNameExclusiveResponse{}
26375 _body, _err := UpdateSiteNameExclusiveWithOptions(client,request, runtime)
26376 if _err != nil {
26377 return _result, _err
26378 }
26379 _result = _body
26380 return _result, _err
26381 }
26382
26383 // Summary:
26384 //
26385 // Modifies the ESA proxy configuration of a website.
26386 //
26387 // @param request - UpdateSitePauseRequest
26388 //
26389 // @param runtime - runtime options for this request RuntimeOptions
26390 //
26391 // @return UpdateSitePauseResponse
26392 func UpdateSitePauseWithOptions(client *Client, request *UpdateSitePauseRequest, runtime *dara.RuntimeOptions) (_result *UpdateSitePauseResponse, _err error) {
26393 if dara.BoolValue(client.EnableValidate) == true {
26394 _err = request.Validate()
26395 if _err != nil {
26396 return _result, _err
26397 }
26398 }
26399 query := map[string]interface{}{}
26400 if !dara.IsNil(request.Paused) {
26401 query["Paused"] = request.Paused
26402 }
26403
26404 if !dara.IsNil(request.SiteId) {
26405 query["SiteId"] = request.SiteId
26406 }
26407
26408 req := &openapiutil.OpenApiRequest{
26409 Query: openapiutil.Query(query),
26410 }
26411 params := &openapiutil.Params{
26412 Action: dara.String("UpdateSitePause"),
26413 Version: dara.String("2024-09-10"),
26414 Protocol: dara.String("HTTPS"),
26415 Pathname: dara.String("/"),
26416 Method: dara.String("POST"),
26417 AuthType: dara.String("AK"),
26418 Style: dara.String("RPC"),
26419 ReqBodyType: dara.String("formData"),
26420 BodyType: dara.String("json"),
26421 }
26422 _result = &UpdateSitePauseResponse{}
26423 _body, _err := client.CallApi(params, req, runtime)
26424 if _err != nil {
26425 return _result, _err
26426 }
26427 _err = dara.Convert(_body, &_result)
26428 return _result, _err
26429 }
26430
26431 // Summary:
26432 //
26433 // Modifies the ESA proxy configuration of a website.
26434 //
26435 // @param request - UpdateSitePauseRequest
26436 //
26437 // @return UpdateSitePauseResponse
26438 func UpdateSitePause(client *Client, request *UpdateSitePauseRequest) (_result *UpdateSitePauseResponse, _err error) {
26439 runtime := &dara.RuntimeOptions{}
26440 _result = &UpdateSitePauseResponse{}
26441 _body, _err := UpdateSitePauseWithOptions(client,request, runtime)
26442 if _err != nil {
26443 return _result, _err
26444 }
26445 _result = _body
26446 return _result, _err
26447 }
26448
26449 // Summary:
26450 //
26451 // Updates the custom nameserver names for a single website.
26452 //
26453 // @param request - UpdateSiteVanityNSRequest
26454 //
26455 // @param runtime - runtime options for this request RuntimeOptions
26456 //
26457 // @return UpdateSiteVanityNSResponse
26458 func UpdateSiteVanityNSWithOptions(client *Client, request *UpdateSiteVanityNSRequest, runtime *dara.RuntimeOptions) (_result *UpdateSiteVanityNSResponse, _err error) {
26459 if dara.BoolValue(client.EnableValidate) == true {
26460 _err = request.Validate()
26461 if _err != nil {
26462 return _result, _err
26463 }
26464 }
26465 query := map[string]interface{}{}
26466 if !dara.IsNil(request.SiteId) {
26467 query["SiteId"] = request.SiteId
26468 }
26469
26470 if !dara.IsNil(request.VanityNSList) {
26471 query["VanityNSList"] = request.VanityNSList
26472 }
26473
26474 req := &openapiutil.OpenApiRequest{
26475 Query: openapiutil.Query(query),
26476 }
26477 params := &openapiutil.Params{
26478 Action: dara.String("UpdateSiteVanityNS"),
26479 Version: dara.String("2024-09-10"),
26480 Protocol: dara.String("HTTPS"),
26481 Pathname: dara.String("/"),
26482 Method: dara.String("POST"),
26483 AuthType: dara.String("AK"),
26484 Style: dara.String("RPC"),
26485 ReqBodyType: dara.String("formData"),
26486 BodyType: dara.String("json"),
26487 }
26488 _result = &UpdateSiteVanityNSResponse{}
26489 _body, _err := client.CallApi(params, req, runtime)
26490 if _err != nil {
26491 return _result, _err
26492 }
26493 _err = dara.Convert(_body, &_result)
26494 return _result, _err
26495 }
26496
26497 // Summary:
26498 //
26499 // Updates the custom nameserver names for a single website.
26500 //
26501 // @param request - UpdateSiteVanityNSRequest
26502 //
26503 // @return UpdateSiteVanityNSResponse
26504 func UpdateSiteVanityNS(client *Client, request *UpdateSiteVanityNSRequest) (_result *UpdateSiteVanityNSResponse, _err error) {
26505 runtime := &dara.RuntimeOptions{}
26506 _result = &UpdateSiteVanityNSResponse{}
26507 _body, _err := UpdateSiteVanityNSWithOptions(client,request, runtime)
26508 if _err != nil {
26509 return _result, _err
26510 }
26511 _result = _body
26512 return _result, _err
26513 }
26514
26515 // Summary:
26516 //
26517 // Modifies the tiered cache configuration of your website.
26518 //
26519 // @param request - UpdateTieredCacheRequest
26520 //
26521 // @param runtime - runtime options for this request RuntimeOptions
26522 //
26523 // @return UpdateTieredCacheResponse
26524 func UpdateTieredCacheWithOptions(client *Client, request *UpdateTieredCacheRequest, runtime *dara.RuntimeOptions) (_result *UpdateTieredCacheResponse, _err error) {
26525 if dara.BoolValue(client.EnableValidate) == true {
26526 _err = request.Validate()
26527 if _err != nil {
26528 return _result, _err
26529 }
26530 }
26531 query := map[string]interface{}{}
26532 if !dara.IsNil(request.CacheArchitectureMode) {
26533 query["CacheArchitectureMode"] = request.CacheArchitectureMode
26534 }
26535
26536 if !dara.IsNil(request.SiteId) {
26537 query["SiteId"] = request.SiteId
26538 }
26539
26540 req := &openapiutil.OpenApiRequest{
26541 Query: openapiutil.Query(query),
26542 }
26543 params := &openapiutil.Params{
26544 Action: dara.String("UpdateTieredCache"),
26545 Version: dara.String("2024-09-10"),
26546 Protocol: dara.String("HTTPS"),
26547 Pathname: dara.String("/"),
26548 Method: dara.String("POST"),
26549 AuthType: dara.String("AK"),
26550 Style: dara.String("RPC"),
26551 ReqBodyType: dara.String("formData"),
26552 BodyType: dara.String("json"),
26553 }
26554 _result = &UpdateTieredCacheResponse{}
26555 _body, _err := client.CallApi(params, req, runtime)
26556 if _err != nil {
26557 return _result, _err
26558 }
26559 _err = dara.Convert(_body, &_result)
26560 return _result, _err
26561 }
26562
26563 // Summary:
26564 //
26565 // Modifies the tiered cache configuration of your website.
26566 //
26567 // @param request - UpdateTieredCacheRequest
26568 //
26569 // @return UpdateTieredCacheResponse
26570 func UpdateTieredCache(client *Client, request *UpdateTieredCacheRequest) (_result *UpdateTieredCacheResponse, _err error) {
26571 runtime := &dara.RuntimeOptions{}
26572 _result = &UpdateTieredCacheResponse{}
26573 _body, _err := UpdateTieredCacheWithOptions(client,request, runtime)
26574 if _err != nil {
26575 return _result, _err
26576 }
26577 _result = _body
26578 return _result, _err
26579 }
26580
26581 // Summary:
26582 //
26583 // # Modify Transport Layer Application
26584 //
26585 // @param tmpReq - UpdateTransportLayerApplicationRequest
26586 //
26587 // @param runtime - runtime options for this request RuntimeOptions
26588 //
26589 // @return UpdateTransportLayerApplicationResponse
26590 func UpdateTransportLayerApplicationWithOptions(client *Client, tmpReq *UpdateTransportLayerApplicationRequest, runtime *dara.RuntimeOptions) (_result *UpdateTransportLayerApplicationResponse, _err error) {
26591 if dara.BoolValue(client.EnableValidate) == true {
26592 _err = tmpReq.Validate()
26593 if _err != nil {
26594 return _result, _err
26595 }
26596 }
26597 request := &UpdateTransportLayerApplicationShrinkRequest{}
26598 openapiutil.Convert(tmpReq, request)
26599 if !dara.IsNil(tmpReq.Rules) {
26600 request.RulesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Rules, dara.String("Rules"), dara.String("json"))
26601 }
26602
26603 query := map[string]interface{}{}
26604 if !dara.IsNil(request.ApplicationId) {
26605 query["ApplicationId"] = request.ApplicationId
26606 }
26607
26608 if !dara.IsNil(request.CrossBorderOptimization) {
26609 query["CrossBorderOptimization"] = request.CrossBorderOptimization
26610 }
26611
26612 if !dara.IsNil(request.IpAccessRule) {
26613 query["IpAccessRule"] = request.IpAccessRule
26614 }
26615
26616 if !dara.IsNil(request.Ipv6) {
26617 query["Ipv6"] = request.Ipv6
26618 }
26619
26620 if !dara.IsNil(request.RulesShrink) {
26621 query["Rules"] = request.RulesShrink
26622 }
26623
26624 if !dara.IsNil(request.SiteId) {
26625 query["SiteId"] = request.SiteId
26626 }
26627
26628 if !dara.IsNil(request.StaticIp) {
26629 query["StaticIp"] = request.StaticIp
26630 }
26631
26632 req := &openapiutil.OpenApiRequest{
26633 Query: openapiutil.Query(query),
26634 }
26635 params := &openapiutil.Params{
26636 Action: dara.String("UpdateTransportLayerApplication"),
26637 Version: dara.String("2024-09-10"),
26638 Protocol: dara.String("HTTPS"),
26639 Pathname: dara.String("/"),
26640 Method: dara.String("POST"),
26641 AuthType: dara.String("AK"),
26642 Style: dara.String("RPC"),
26643 ReqBodyType: dara.String("formData"),
26644 BodyType: dara.String("json"),
26645 }
26646 _result = &UpdateTransportLayerApplicationResponse{}
26647 _body, _err := client.CallApi(params, req, runtime)
26648 if _err != nil {
26649 return _result, _err
26650 }
26651 _err = dara.Convert(_body, &_result)
26652 return _result, _err
26653 }
26654
26655 // Summary:
26656 //
26657 // # Modify Transport Layer Application
26658 //
26659 // @param request - UpdateTransportLayerApplicationRequest
26660 //
26661 // @return UpdateTransportLayerApplicationResponse
26662 func UpdateTransportLayerApplication(client *Client, request *UpdateTransportLayerApplicationRequest) (_result *UpdateTransportLayerApplicationResponse, _err error) {
26663 runtime := &dara.RuntimeOptions{}
26664 _result = &UpdateTransportLayerApplicationResponse{}
26665 _body, _err := UpdateTransportLayerApplicationWithOptions(client,request, runtime)
26666 if _err != nil {
26667 return _result, _err
26668 }
26669 _result = _body
26670 return _result, _err
26671 }
26672
26673 // Summary:
26674 //
26675 // Updates the webpage monitoring configuration.
26676 //
26677 // @param request - UpdateUrlObservationRequest
26678 //
26679 // @param runtime - runtime options for this request RuntimeOptions
26680 //
26681 // @return UpdateUrlObservationResponse
26682 func UpdateUrlObservationWithOptions(client *Client, request *UpdateUrlObservationRequest, runtime *dara.RuntimeOptions) (_result *UpdateUrlObservationResponse, _err error) {
26683 if dara.BoolValue(client.EnableValidate) == true {
26684 _err = request.Validate()
26685 if _err != nil {
26686 return _result, _err
26687 }
26688 }
26689 query := map[string]interface{}{}
26690 if !dara.IsNil(request.ConfigId) {
26691 query["ConfigId"] = request.ConfigId
26692 }
26693
26694 if !dara.IsNil(request.SdkType) {
26695 query["SdkType"] = request.SdkType
26696 }
26697
26698 if !dara.IsNil(request.SiteId) {
26699 query["SiteId"] = request.SiteId
26700 }
26701
26702 req := &openapiutil.OpenApiRequest{
26703 Query: openapiutil.Query(query),
26704 }
26705 params := &openapiutil.Params{
26706 Action: dara.String("UpdateUrlObservation"),
26707 Version: dara.String("2024-09-10"),
26708 Protocol: dara.String("HTTPS"),
26709 Pathname: dara.String("/"),
26710 Method: dara.String("POST"),
26711 AuthType: dara.String("AK"),
26712 Style: dara.String("RPC"),
26713 ReqBodyType: dara.String("formData"),
26714 BodyType: dara.String("json"),
26715 }
26716 _result = &UpdateUrlObservationResponse{}
26717 _body, _err := client.CallApi(params, req, runtime)
26718 if _err != nil {
26719 return _result, _err
26720 }
26721 _err = dara.Convert(_body, &_result)
26722 return _result, _err
26723 }
26724
26725 // Summary:
26726 //
26727 // Updates the webpage monitoring configuration.
26728 //
26729 // @param request - UpdateUrlObservationRequest
26730 //
26731 // @return UpdateUrlObservationResponse
26732 func UpdateUrlObservation(client *Client, request *UpdateUrlObservationRequest) (_result *UpdateUrlObservationResponse, _err error) {
26733 runtime := &dara.RuntimeOptions{}
26734 _result = &UpdateUrlObservationResponse{}
26735 _body, _err := UpdateUrlObservationWithOptions(client,request, runtime)
26736 if _err != nil {
26737 return _result, _err
26738 }
26739 _result = _body
26740 return _result, _err
26741 }
26742
26743 // Summary:
26744 //
26745 // Modifies the configurations of a delivery task, including the task name, log field, log category, and discard rate.
26746 //
26747 // @param request - UpdateUserDeliveryTaskRequest
26748 //
26749 // @param runtime - runtime options for this request RuntimeOptions
26750 //
26751 // @return UpdateUserDeliveryTaskResponse
26752 func UpdateUserDeliveryTaskWithOptions(client *Client, request *UpdateUserDeliveryTaskRequest, runtime *dara.RuntimeOptions) (_result *UpdateUserDeliveryTaskResponse, _err error) {
26753 if dara.BoolValue(client.EnableValidate) == true {
26754 _err = request.Validate()
26755 if _err != nil {
26756 return _result, _err
26757 }
26758 }
26759 body := map[string]interface{}{}
26760 if !dara.IsNil(request.BusinessType) {
26761 body["BusinessType"] = request.BusinessType
26762 }
26763
26764 if !dara.IsNil(request.Details) {
26765 body["Details"] = request.Details
26766 }
26767
26768 if !dara.IsNil(request.DiscardRate) {
26769 body["DiscardRate"] = request.DiscardRate
26770 }
26771
26772 if !dara.IsNil(request.FieldName) {
26773 body["FieldName"] = request.FieldName
26774 }
26775
26776 if !dara.IsNil(request.FilterVer) {
26777 body["FilterVer"] = request.FilterVer
26778 }
26779
26780 if !dara.IsNil(request.TaskName) {
26781 body["TaskName"] = request.TaskName
26782 }
26783
26784 req := &openapiutil.OpenApiRequest{
26785 Body: openapiutil.ParseToMap(body),
26786 }
26787 params := &openapiutil.Params{
26788 Action: dara.String("UpdateUserDeliveryTask"),
26789 Version: dara.String("2024-09-10"),
26790 Protocol: dara.String("HTTPS"),
26791 Pathname: dara.String("/"),
26792 Method: dara.String("POST"),
26793 AuthType: dara.String("AK"),
26794 Style: dara.String("RPC"),
26795 ReqBodyType: dara.String("formData"),
26796 BodyType: dara.String("json"),
26797 }
26798 _result = &UpdateUserDeliveryTaskResponse{}
26799 _body, _err := client.CallApi(params, req, runtime)
26800 if _err != nil {
26801 return _result, _err
26802 }
26803 _err = dara.Convert(_body, &_result)
26804 return _result, _err
26805 }
26806
26807 // Summary:
26808 //
26809 // Modifies the configurations of a delivery task, including the task name, log field, log category, and discard rate.
26810 //
26811 // @param request - UpdateUserDeliveryTaskRequest
26812 //
26813 // @return UpdateUserDeliveryTaskResponse
26814 func UpdateUserDeliveryTask(client *Client, request *UpdateUserDeliveryTaskRequest) (_result *UpdateUserDeliveryTaskResponse, _err error) {
26815 runtime := &dara.RuntimeOptions{}
26816 _result = &UpdateUserDeliveryTaskResponse{}
26817 _body, _err := UpdateUserDeliveryTaskWithOptions(client,request, runtime)
26818 if _err != nil {
26819 return _result, _err
26820 }
26821 _result = _body
26822 return _result, _err
26823 }
26824
26825 // Summary:
26826 //
26827 // Changes the status of a delivery task in your Alibaba Cloud account.
26828 //
26829 // Description:
26830 //
26831 // ## [](#)
26832 //
26833 // 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.
26834 //
26835 // @param request - UpdateUserDeliveryTaskStatusRequest
26836 //
26837 // @param runtime - runtime options for this request RuntimeOptions
26838 //
26839 // @return UpdateUserDeliveryTaskStatusResponse
26840 func UpdateUserDeliveryTaskStatusWithOptions(client *Client, request *UpdateUserDeliveryTaskStatusRequest, runtime *dara.RuntimeOptions) (_result *UpdateUserDeliveryTaskStatusResponse, _err error) {
26841 if dara.BoolValue(client.EnableValidate) == true {
26842 _err = request.Validate()
26843 if _err != nil {
26844 return _result, _err
26845 }
26846 }
26847 query := openapiutil.Query(dara.ToMap(request))
26848 req := &openapiutil.OpenApiRequest{
26849 Query: openapiutil.Query(query),
26850 }
26851 params := &openapiutil.Params{
26852 Action: dara.String("UpdateUserDeliveryTaskStatus"),
26853 Version: dara.String("2024-09-10"),
26854 Protocol: dara.String("HTTPS"),
26855 Pathname: dara.String("/"),
26856 Method: dara.String("GET"),
26857 AuthType: dara.String("AK"),
26858 Style: dara.String("RPC"),
26859 ReqBodyType: dara.String("formData"),
26860 BodyType: dara.String("json"),
26861 }
26862 _result = &UpdateUserDeliveryTaskStatusResponse{}
26863 _body, _err := client.CallApi(params, req, runtime)
26864 if _err != nil {
26865 return _result, _err
26866 }
26867 _err = dara.Convert(_body, &_result)
26868 return _result, _err
26869 }
26870
26871 // Summary:
26872 //
26873 // Changes the status of a delivery task in your Alibaba Cloud account.
26874 //
26875 // Description:
26876 //
26877 // ## [](#)
26878 //
26879 // 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.
26880 //
26881 // @param request - UpdateUserDeliveryTaskStatusRequest
26882 //
26883 // @return UpdateUserDeliveryTaskStatusResponse
26884 func UpdateUserDeliveryTaskStatus(client *Client, request *UpdateUserDeliveryTaskStatusRequest) (_result *UpdateUserDeliveryTaskStatusResponse, _err error) {
26885 runtime := &dara.RuntimeOptions{}
26886 _result = &UpdateUserDeliveryTaskStatusResponse{}
26887 _body, _err := UpdateUserDeliveryTaskStatusWithOptions(client,request, runtime)
26888 if _err != nil {
26889 return _result, _err
26890 }
26891 _result = _body
26892 return _result, _err
26893 }
26894
26895 // Summary:
26896 //
26897 // 用于更新实例级别的Web应用防火墙规则集，支持多种类型的防护规则。
26898 //
26899 // Description:
26900 //
26901 // ## 请求说明
26902 //
26903 // - 本API允许用户为指定实例创建新的WAF（Web Application Firewall）规则集。
26904 //
26905 // - `InstanceId` 是必需参数，指定了要为其创建规则集的具体实例。
26906 //
26907 // - `Phase` 参数定义了规则集的应用阶段，例如自定义规则、频次控制等。
26908 //
26909 // - `Name` 和 `Expression` 是必填项，分别代表规则集的名字和具体的匹配表达式。
26910 //
26911 // - 可选参数 `Description` 提供了对规则集功能或用途的文字描述。
26912 //
26913 // - `Status` 控制着规则集是否立即生效 (`on`) 或者处于关闭状态 (`off`)。
26914 //
26915 // - 通过 `Rules` 参数可以进一步配置更详细的规则列表，每个规则都包含名称、位置、表达式及动作等属性。
26916 //
26917 // - 成功响应将返回新创建规则集的唯一标识符 `Id` 以及所有关联规则的ID列表 `RuleIds`。
26918 //
26919 // @param tmpReq - UpdateUserWafRulesetRequest
26920 //
26921 // @param runtime - runtime options for this request RuntimeOptions
26922 //
26923 // @return UpdateUserWafRulesetResponse
26924 func UpdateUserWafRulesetWithOptions(client *Client, tmpReq *UpdateUserWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *UpdateUserWafRulesetResponse, _err error) {
26925 if dara.BoolValue(client.EnableValidate) == true {
26926 _err = tmpReq.Validate()
26927 if _err != nil {
26928 return _result, _err
26929 }
26930 }
26931 request := &UpdateUserWafRulesetShrinkRequest{}
26932 openapiutil.Convert(tmpReq, request)
26933 if !dara.IsNil(tmpReq.Rules) {
26934 request.RulesShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Rules, dara.String("Rules"), dara.String("json"))
26935 }
26936
26937 if !dara.IsNil(tmpReq.Shared) {
26938 request.SharedShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Shared, dara.String("Shared"), dara.String("json"))
26939 }
26940
26941 query := map[string]interface{}{}
26942 if !dara.IsNil(request.InstanceId) {
26943 query["InstanceId"] = request.InstanceId
26944 }
26945
26946 body := map[string]interface{}{}
26947 if !dara.IsNil(request.Description) {
26948 body["Description"] = request.Description
26949 }
26950
26951 if !dara.IsNil(request.Expression) {
26952 body["Expression"] = request.Expression
26953 }
26954
26955 if !dara.IsNil(request.Id) {
26956 body["Id"] = request.Id
26957 }
26958
26959 if !dara.IsNil(request.Name) {
26960 body["Name"] = request.Name
26961 }
26962
26963 if !dara.IsNil(request.Position) {
26964 body["Position"] = request.Position
26965 }
26966
26967 if !dara.IsNil(request.RulesShrink) {
26968 body["Rules"] = request.RulesShrink
26969 }
26970
26971 if !dara.IsNil(request.SharedShrink) {
26972 body["Shared"] = request.SharedShrink
26973 }
26974
26975 if !dara.IsNil(request.Status) {
26976 body["Status"] = request.Status
26977 }
26978
26979 req := &openapiutil.OpenApiRequest{
26980 Query: openapiutil.Query(query),
26981 Body: openapiutil.ParseToMap(body),
26982 }
26983 params := &openapiutil.Params{
26984 Action: dara.String("UpdateUserWafRuleset"),
26985 Version: dara.String("2024-09-10"),
26986 Protocol: dara.String("HTTPS"),
26987 Pathname: dara.String("/"),
26988 Method: dara.String("POST"),
26989 AuthType: dara.String("AK"),
26990 Style: dara.String("RPC"),
26991 ReqBodyType: dara.String("formData"),
26992 BodyType: dara.String("json"),
26993 }
26994 _result = &UpdateUserWafRulesetResponse{}
26995 _body, _err := client.CallApi(params, req, runtime)
26996 if _err != nil {
26997 return _result, _err
26998 }
26999 _err = dara.Convert(_body, &_result)
27000 return _result, _err
27001 }
27002
27003 // Summary:
27004 //
27005 // 用于更新实例级别的Web应用防火墙规则集，支持多种类型的防护规则。
27006 //
27007 // Description:
27008 //
27009 // ## 请求说明
27010 //
27011 // - 本API允许用户为指定实例创建新的WAF（Web Application Firewall）规则集。
27012 //
27013 // - `InstanceId` 是必需参数，指定了要为其创建规则集的具体实例。
27014 //
27015 // - `Phase` 参数定义了规则集的应用阶段，例如自定义规则、频次控制等。
27016 //
27017 // - `Name` 和 `Expression` 是必填项，分别代表规则集的名字和具体的匹配表达式。
27018 //
27019 // - 可选参数 `Description` 提供了对规则集功能或用途的文字描述。
27020 //
27021 // - `Status` 控制着规则集是否立即生效 (`on`) 或者处于关闭状态 (`off`)。
27022 //
27023 // - 通过 `Rules` 参数可以进一步配置更详细的规则列表，每个规则都包含名称、位置、表达式及动作等属性。
27024 //
27025 // - 成功响应将返回新创建规则集的唯一标识符 `Id` 以及所有关联规则的ID列表 `RuleIds`。
27026 //
27027 // @param request - UpdateUserWafRulesetRequest
27028 //
27029 // @return UpdateUserWafRulesetResponse
27030 func UpdateUserWafRuleset(client *Client, request *UpdateUserWafRulesetRequest) (_result *UpdateUserWafRulesetResponse, _err error) {
27031 runtime := &dara.RuntimeOptions{}
27032 _result = &UpdateUserWafRulesetResponse{}
27033 _body, _err := UpdateUserWafRulesetWithOptions(client,request, runtime)
27034 if _err != nil {
27035 return _result, _err
27036 }
27037 _result = _body
27038 return _result, _err
27039 }
27040
27041 // Summary:
27042 //
27043 // Modifies the video processing configuration of the site.
27044 //
27045 // @param request - UpdateVideoProcessingRequest
27046 //
27047 // @param runtime - runtime options for this request RuntimeOptions
27048 //
27049 // @return UpdateVideoProcessingResponse
27050 func UpdateVideoProcessingWithOptions(client *Client, request *UpdateVideoProcessingRequest, runtime *dara.RuntimeOptions) (_result *UpdateVideoProcessingResponse, _err error) {
27051 if dara.BoolValue(client.EnableValidate) == true {
27052 _err = request.Validate()
27053 if _err != nil {
27054 return _result, _err
27055 }
27056 }
27057 query := map[string]interface{}{}
27058 if !dara.IsNil(request.ConfigId) {
27059 query["ConfigId"] = request.ConfigId
27060 }
27061
27062 if !dara.IsNil(request.FlvSeekEnd) {
27063 query["FlvSeekEnd"] = request.FlvSeekEnd
27064 }
27065
27066 if !dara.IsNil(request.FlvSeekStart) {
27067 query["FlvSeekStart"] = request.FlvSeekStart
27068 }
27069
27070 if !dara.IsNil(request.FlvVideoSeekMode) {
27071 query["FlvVideoSeekMode"] = request.FlvVideoSeekMode
27072 }
27073
27074 if !dara.IsNil(request.Mp4SeekEnd) {
27075 query["Mp4SeekEnd"] = request.Mp4SeekEnd
27076 }
27077
27078 if !dara.IsNil(request.Mp4SeekStart) {
27079 query["Mp4SeekStart"] = request.Mp4SeekStart
27080 }
27081
27082 if !dara.IsNil(request.Rule) {
27083 query["Rule"] = request.Rule
27084 }
27085
27086 if !dara.IsNil(request.RuleEnable) {
27087 query["RuleEnable"] = request.RuleEnable
27088 }
27089
27090 if !dara.IsNil(request.RuleName) {
27091 query["RuleName"] = request.RuleName
27092 }
27093
27094 if !dara.IsNil(request.Sequence) {
27095 query["Sequence"] = request.Sequence
27096 }
27097
27098 if !dara.IsNil(request.SiteId) {
27099 query["SiteId"] = request.SiteId
27100 }
27101
27102 if !dara.IsNil(request.VideoSeekEnable) {
27103 query["VideoSeekEnable"] = request.VideoSeekEnable
27104 }
27105
27106 req := &openapiutil.OpenApiRequest{
27107 Query: openapiutil.Query(query),
27108 }
27109 params := &openapiutil.Params{
27110 Action: dara.String("UpdateVideoProcessing"),
27111 Version: dara.String("2024-09-10"),
27112 Protocol: dara.String("HTTPS"),
27113 Pathname: dara.String("/"),
27114 Method: dara.String("POST"),
27115 AuthType: dara.String("AK"),
27116 Style: dara.String("RPC"),
27117 ReqBodyType: dara.String("formData"),
27118 BodyType: dara.String("json"),
27119 }
27120 _result = &UpdateVideoProcessingResponse{}
27121 _body, _err := client.CallApi(params, req, runtime)
27122 if _err != nil {
27123 return _result, _err
27124 }
27125 _err = dara.Convert(_body, &_result)
27126 return _result, _err
27127 }
27128
27129 // Summary:
27130 //
27131 // Modifies the video processing configuration of the site.
27132 //
27133 // @param request - UpdateVideoProcessingRequest
27134 //
27135 // @return UpdateVideoProcessingResponse
27136 func UpdateVideoProcessing(client *Client, request *UpdateVideoProcessingRequest) (_result *UpdateVideoProcessingResponse, _err error) {
27137 runtime := &dara.RuntimeOptions{}
27138 _result = &UpdateVideoProcessingResponse{}
27139 _body, _err := UpdateVideoProcessingWithOptions(client,request, runtime)
27140 if _err != nil {
27141 return _result, _err
27142 }
27143 _result = _body
27144 return _result, _err
27145 }
27146
27147 // Summary:
27148 //
27149 // # Update WAF Rule Page
27150 //
27151 // @param tmpReq - UpdateWafRuleRequest
27152 //
27153 // @param runtime - runtime options for this request RuntimeOptions
27154 //
27155 // @return UpdateWafRuleResponse
27156 func UpdateWafRuleWithOptions(client *Client, tmpReq *UpdateWafRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateWafRuleResponse, _err error) {
27157 if dara.BoolValue(client.EnableValidate) == true {
27158 _err = tmpReq.Validate()
27159 if _err != nil {
27160 return _result, _err
27161 }
27162 }
27163 request := &UpdateWafRuleShrinkRequest{}
27164 openapiutil.Convert(tmpReq, request)
27165 if !dara.IsNil(tmpReq.Config) {
27166 request.ConfigShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.Config, dara.String("Config"), dara.String("json"))
27167 }
27168
27169 query := map[string]interface{}{}
27170 if !dara.IsNil(request.SiteId) {
27171 query["SiteId"] = request.SiteId
27172 }
27173
27174 if !dara.IsNil(request.SiteVersion) {
27175 query["SiteVersion"] = request.SiteVersion
27176 }
27177
27178 body := map[string]interface{}{}
27179 if !dara.IsNil(request.ConfigShrink) {
27180 body["Config"] = request.ConfigShrink
27181 }
27182
27183 if !dara.IsNil(request.Id) {
27184 body["Id"] = request.Id
27185 }
27186
27187 if !dara.IsNil(request.Position) {
27188 body["Position"] = request.Position
27189 }
27190
27191 if !dara.IsNil(request.Status) {
27192 body["Status"] = request.Status
27193 }
27194
27195 req := &openapiutil.OpenApiRequest{
27196 Query: openapiutil.Query(query),
27197 Body: openapiutil.ParseToMap(body),
27198 }
27199 params := &openapiutil.Params{
27200 Action: dara.String("UpdateWafRule"),
27201 Version: dara.String("2024-09-10"),
27202 Protocol: dara.String("HTTPS"),
27203 Pathname: dara.String("/"),
27204 Method: dara.String("POST"),
27205 AuthType: dara.String("AK"),
27206 Style: dara.String("RPC"),
27207 ReqBodyType: dara.String("formData"),
27208 BodyType: dara.String("json"),
27209 }
27210 _result = &UpdateWafRuleResponse{}
27211 _body, _err := client.CallApi(params, req, runtime)
27212 if _err != nil {
27213 return _result, _err
27214 }
27215 _err = dara.Convert(_body, &_result)
27216 return _result, _err
27217 }
27218
27219 // Summary:
27220 //
27221 // # Update WAF Rule Page
27222 //
27223 // @param request - UpdateWafRuleRequest
27224 //
27225 // @return UpdateWafRuleResponse
27226 func UpdateWafRule(client *Client, request *UpdateWafRuleRequest) (_result *UpdateWafRuleResponse, _err error) {
27227 runtime := &dara.RuntimeOptions{}
27228 _result = &UpdateWafRuleResponse{}
27229 _body, _err := UpdateWafRuleWithOptions(client,request, runtime)
27230 if _err != nil {
27231 return _result, _err
27232 }
27233 _result = _body
27234 return _result, _err
27235 }
27236
27237 // Summary:
27238 //
27239 // # Update WAF Ruleset
27240 //
27241 // @param request - UpdateWafRulesetRequest
27242 //
27243 // @param runtime - runtime options for this request RuntimeOptions
27244 //
27245 // @return UpdateWafRulesetResponse
27246 func UpdateWafRulesetWithOptions(client *Client, request *UpdateWafRulesetRequest, runtime *dara.RuntimeOptions) (_result *UpdateWafRulesetResponse, _err error) {
27247 if dara.BoolValue(client.EnableValidate) == true {
27248 _err = request.Validate()
27249 if _err != nil {
27250 return _result, _err
27251 }
27252 }
27253 query := map[string]interface{}{}
27254 if !dara.IsNil(request.SiteId) {
27255 query["SiteId"] = request.SiteId
27256 }
27257
27258 if !dara.IsNil(request.SiteVersion) {
27259 query["SiteVersion"] = request.SiteVersion
27260 }
27261
27262 body := map[string]interface{}{}
27263 if !dara.IsNil(request.Id) {
27264 body["Id"] = request.Id
27265 }
27266
27267 if !dara.IsNil(request.Status) {
27268 body["Status"] = request.Status
27269 }
27270
27271 req := &openapiutil.OpenApiRequest{
27272 Query: openapiutil.Query(query),
27273 Body: openapiutil.ParseToMap(body),
27274 }
27275 params := &openapiutil.Params{
27276 Action: dara.String("UpdateWafRuleset"),
27277 Version: dara.String("2024-09-10"),
27278 Protocol: dara.String("HTTPS"),
27279 Pathname: dara.String("/"),
27280 Method: dara.String("POST"),
27281 AuthType: dara.String("AK"),
27282 Style: dara.String("RPC"),
27283 ReqBodyType: dara.String("formData"),
27284 BodyType: dara.String("json"),
27285 }
27286 _result = &UpdateWafRulesetResponse{}
27287 _body, _err := client.CallApi(params, req, runtime)
27288 if _err != nil {
27289 return _result, _err
27290 }
27291 _err = dara.Convert(_body, &_result)
27292 return _result, _err
27293 }
27294
27295 // Summary:
27296 //
27297 // # Update WAF Ruleset
27298 //
27299 // @param request - UpdateWafRulesetRequest
27300 //
27301 // @return UpdateWafRulesetResponse
27302 func UpdateWafRuleset(client *Client, request *UpdateWafRulesetRequest) (_result *UpdateWafRulesetResponse, _err error) {
27303 runtime := &dara.RuntimeOptions{}
27304 _result = &UpdateWafRulesetResponse{}
27305 _body, _err := UpdateWafRulesetWithOptions(client,request, runtime)
27306 if _err != nil {
27307 return _result, _err
27308 }
27309 _result = _body
27310 return _result, _err
27311 }
27312
27313 // Summary:
27314 //
27315 // Modifies the configurations of a waiting room.
27316 //
27317 // @param tmpReq - UpdateWaitingRoomRequest
27318 //
27319 // @param runtime - runtime options for this request RuntimeOptions
27320 //
27321 // @return UpdateWaitingRoomResponse
27322 func UpdateWaitingRoomWithOptions(client *Client, tmpReq *UpdateWaitingRoomRequest, runtime *dara.RuntimeOptions) (_result *UpdateWaitingRoomResponse, _err error) {
27323 if dara.BoolValue(client.EnableValidate) == true {
27324 _err = tmpReq.Validate()
27325 if _err != nil {
27326 return _result, _err
27327 }
27328 }
27329 request := &UpdateWaitingRoomShrinkRequest{}
27330 openapiutil.Convert(tmpReq, request)
27331 if !dara.IsNil(tmpReq.HostNameAndPath) {
27332 request.HostNameAndPathShrink = openapiutil.ArrayToStringWithSpecifiedStyle(tmpReq.HostNameAndPath, dara.String("HostNameAndPath"), dara.String("json"))
27333 }
27334
27335 query := map[string]interface{}{}
27336 if !dara.IsNil(request.CookieName) {
27337 query["CookieName"] = request.CookieName
27338 }
27339
27340 if !dara.IsNil(request.CustomPageHtml) {
27341 query["CustomPageHtml"] = request.CustomPageHtml
27342 }
27343
27344 if !dara.IsNil(request.Description) {
27345 query["Description"] = request.Description
27346 }
27347
27348 if !dara.IsNil(request.DisableSessionRenewalEnable) {
27349 query["DisableSessionRenewalEnable"] = request.DisableSessionRenewalEnable
27350 }
27351
27352 if !dara.IsNil(request.Enable) {
27353 query["Enable"] = request.Enable
27354 }
27355
27356 if !dara.IsNil(request.HostNameAndPathShrink) {
27357 query["HostNameAndPath"] = request.HostNameAndPathShrink
27358 }
27359
27360 if !dara.IsNil(request.JsonResponseEnable) {
27361 query["JsonResponseEnable"] = request.JsonResponseEnable
27362 }
27363
27364 if !dara.IsNil(request.Language) {
27365 query["Language"] = request.Language
27366 }
27367
27368 if !dara.IsNil(request.Name) {
27369 query["Name"] = request.Name
27370 }
27371
27372 if !dara.IsNil(request.NewUsersPerMinute) {
27373 query["NewUsersPerMinute"] = request.NewUsersPerMinute
27374 }
27375
27376 if !dara.IsNil(request.QueueAllEnable) {
27377 query["QueueAllEnable"] = request.QueueAllEnable
27378 }
27379
27380 if !dara.IsNil(request.QueuingMethod) {
27381 query["QueuingMethod"] = request.QueuingMethod
27382 }
27383
27384 if !dara.IsNil(request.QueuingStatusCode) {
27385 query["QueuingStatusCode"] = request.QueuingStatusCode
27386 }
27387
27388 if !dara.IsNil(request.SessionDuration) {
27389 query["SessionDuration"] = request.SessionDuration
27390 }
27391
27392 if !dara.IsNil(request.SiteId) {
27393 query["SiteId"] = request.SiteId
27394 }
27395
27396 if !dara.IsNil(request.TotalActiveUsers) {
27397 query["TotalActiveUsers"] = request.TotalActiveUsers
27398 }
27399
27400 if !dara.IsNil(request.WaitingRoomId) {
27401 query["WaitingRoomId"] = request.WaitingRoomId
27402 }
27403
27404 if !dara.IsNil(request.WaitingRoomType) {
27405 query["WaitingRoomType"] = request.WaitingRoomType
27406 }
27407
27408 req := &openapiutil.OpenApiRequest{
27409 Query: openapiutil.Query(query),
27410 }
27411 params := &openapiutil.Params{
27412 Action: dara.String("UpdateWaitingRoom"),
27413 Version: dara.String("2024-09-10"),
27414 Protocol: dara.String("HTTPS"),
27415 Pathname: dara.String("/"),
27416 Method: dara.String("POST"),
27417 AuthType: dara.String("AK"),
27418 Style: dara.String("RPC"),
27419 ReqBodyType: dara.String("formData"),
27420 BodyType: dara.String("json"),
27421 }
27422 _result = &UpdateWaitingRoomResponse{}
27423 _body, _err := client.CallApi(params, req, runtime)
27424 if _err != nil {
27425 return _result, _err
27426 }
27427 _err = dara.Convert(_body, &_result)
27428 return _result, _err
27429 }
27430
27431 // Summary:
27432 //
27433 // Modifies the configurations of a waiting room.
27434 //
27435 // @param request - UpdateWaitingRoomRequest
27436 //
27437 // @return UpdateWaitingRoomResponse
27438 func UpdateWaitingRoom(client *Client, request *UpdateWaitingRoomRequest) (_result *UpdateWaitingRoomResponse, _err error) {
27439 runtime := &dara.RuntimeOptions{}
27440 _result = &UpdateWaitingRoomResponse{}
27441 _body, _err := UpdateWaitingRoomWithOptions(client,request, runtime)
27442 if _err != nil {
27443 return _result, _err
27444 }
27445 _result = _body
27446 return _result, _err
27447 }
27448
27449 // Summary:
27450 //
27451 // Modifies the configurations of a waiting room event.
27452 //
27453 // @param request - UpdateWaitingRoomEventRequest
27454 //
27455 // @param runtime - runtime options for this request RuntimeOptions
27456 //
27457 // @return UpdateWaitingRoomEventResponse
27458 func UpdateWaitingRoomEventWithOptions(client *Client, request *UpdateWaitingRoomEventRequest, runtime *dara.RuntimeOptions) (_result *UpdateWaitingRoomEventResponse, _err error) {
27459 if dara.BoolValue(client.EnableValidate) == true {
27460 _err = request.Validate()
27461 if _err != nil {
27462 return _result, _err
27463 }
27464 }
27465 query := map[string]interface{}{}
27466 if !dara.IsNil(request.CustomPageHtml) {
27467 query["CustomPageHtml"] = request.CustomPageHtml
27468 }
27469
27470 if !dara.IsNil(request.Description) {
27471 query["Description"] = request.Description
27472 }
27473
27474 if !dara.IsNil(request.DisableSessionRenewalEnable) {
27475 query["DisableSessionRenewalEnable"] = request.DisableSessionRenewalEnable
27476 }
27477
27478 if !dara.IsNil(request.Enable) {
27479 query["Enable"] = request.Enable
27480 }
27481
27482 if !dara.IsNil(request.EndTime) {
27483 query["EndTime"] = request.EndTime
27484 }
27485
27486 if !dara.IsNil(request.JsonResponseEnable) {
27487 query["JsonResponseEnable"] = request.JsonResponseEnable
27488 }
27489
27490 if !dara.IsNil(request.Language) {
27491 query["Language"] = request.Language
27492 }
27493
27494 if !dara.IsNil(request.Name) {
27495 query["Name"] = request.Name
27496 }
27497
27498 if !dara.IsNil(request.NewUsersPerMinute) {
27499 query["NewUsersPerMinute"] = request.NewUsersPerMinute
27500 }
27501
27502 if !dara.IsNil(request.PreQueueEnable) {
27503 query["PreQueueEnable"] = request.PreQueueEnable
27504 }
27505
27506 if !dara.IsNil(request.PreQueueStartTime) {
27507 query["PreQueueStartTime"] = request.PreQueueStartTime
27508 }
27509
27510 if !dara.IsNil(request.QueuingMethod) {
27511 query["QueuingMethod"] = request.QueuingMethod
27512 }
27513
27514 if !dara.IsNil(request.QueuingStatusCode) {
27515 query["QueuingStatusCode"] = request.QueuingStatusCode
27516 }
27517
27518 if !dara.IsNil(request.RandomPreQueueEnable) {
27519 query["RandomPreQueueEnable"] = request.RandomPreQueueEnable
27520 }
27521
27522 if !dara.IsNil(request.SessionDuration) {
27523 query["SessionDuration"] = request.SessionDuration
27524 }
27525
27526 if !dara.IsNil(request.SiteId) {
27527 query["SiteId"] = request.SiteId
27528 }
27529
27530 if !dara.IsNil(request.StartTime) {
27531 query["StartTime"] = request.StartTime
27532 }
27533
27534 if !dara.IsNil(request.TotalActiveUsers) {
27535 query["TotalActiveUsers"] = request.TotalActiveUsers
27536 }
27537
27538 if !dara.IsNil(request.WaitingRoomEventId) {
27539 query["WaitingRoomEventId"] = request.WaitingRoomEventId
27540 }
27541
27542 if !dara.IsNil(request.WaitingRoomType) {
27543 query["WaitingRoomType"] = request.WaitingRoomType
27544 }
27545
27546 req := &openapiutil.OpenApiRequest{
27547 Query: openapiutil.Query(query),
27548 }
27549 params := &openapiutil.Params{
27550 Action: dara.String("UpdateWaitingRoomEvent"),
27551 Version: dara.String("2024-09-10"),
27552 Protocol: dara.String("HTTPS"),
27553 Pathname: dara.String("/"),
27554 Method: dara.String("POST"),
27555 AuthType: dara.String("AK"),
27556 Style: dara.String("RPC"),
27557 ReqBodyType: dara.String("formData"),
27558 BodyType: dara.String("json"),
27559 }
27560 _result = &UpdateWaitingRoomEventResponse{}
27561 _body, _err := client.CallApi(params, req, runtime)
27562 if _err != nil {
27563 return _result, _err
27564 }
27565 _err = dara.Convert(_body, &_result)
27566 return _result, _err
27567 }
27568
27569 // Summary:
27570 //
27571 // Modifies the configurations of a waiting room event.
27572 //
27573 // @param request - UpdateWaitingRoomEventRequest
27574 //
27575 // @return UpdateWaitingRoomEventResponse
27576 func UpdateWaitingRoomEvent(client *Client, request *UpdateWaitingRoomEventRequest) (_result *UpdateWaitingRoomEventResponse, _err error) {
27577 runtime := &dara.RuntimeOptions{}
27578 _result = &UpdateWaitingRoomEventResponse{}
27579 _body, _err := UpdateWaitingRoomEventWithOptions(client,request, runtime)
27580 if _err != nil {
27581 return _result, _err
27582 }
27583 _result = _body
27584 return _result, _err
27585 }
27586
27587 // Summary:
27588 //
27589 // # Modify Waiting Room Rule
27590 //
27591 // Description:
27592 //
27593 // 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.
27594 //
27595 // @param request - UpdateWaitingRoomRuleRequest
27596 //
27597 // @param runtime - runtime options for this request RuntimeOptions
27598 //
27599 // @return UpdateWaitingRoomRuleResponse
27600 func UpdateWaitingRoomRuleWithOptions(client *Client, request *UpdateWaitingRoomRuleRequest, runtime *dara.RuntimeOptions) (_result *UpdateWaitingRoomRuleResponse, _err error) {
27601 if dara.BoolValue(client.EnableValidate) == true {
27602 _err = request.Validate()
27603 if _err != nil {
27604 return _result, _err
27605 }
27606 }
27607 query := map[string]interface{}{}
27608 if !dara.IsNil(request.Rule) {
27609 query["Rule"] = request.Rule
27610 }
27611
27612 if !dara.IsNil(request.RuleEnable) {
27613 query["RuleEnable"] = request.RuleEnable
27614 }
27615
27616 if !dara.IsNil(request.RuleName) {
27617 query["RuleName"] = request.RuleName
27618 }
27619
27620 if !dara.IsNil(request.SiteId) {
27621 query["SiteId"] = request.SiteId
27622 }
27623
27624 if !dara.IsNil(request.WaitingRoomRuleId) {
27625 query["WaitingRoomRuleId"] = request.WaitingRoomRuleId
27626 }
27627
27628 req := &openapiutil.OpenApiRequest{
27629 Query: openapiutil.Query(query),
27630 }
27631 params := &openapiutil.Params{
27632 Action: dara.String("UpdateWaitingRoomRule"),
27633 Version: dara.String("2024-09-10"),
27634 Protocol: dara.String("HTTPS"),
27635 Pathname: dara.String("/"),
27636 Method: dara.String("POST"),
27637 AuthType: dara.String("AK"),
27638 Style: dara.String("RPC"),
27639 ReqBodyType: dara.String("formData"),
27640 BodyType: dara.String("json"),
27641 }
27642 _result = &UpdateWaitingRoomRuleResponse{}
27643 _body, _err := client.CallApi(params, req, runtime)
27644 if _err != nil {
27645 return _result, _err
27646 }
27647 _err = dara.Convert(_body, &_result)
27648 return _result, _err
27649 }
27650
27651 // Summary:
27652 //
27653 // # Modify Waiting Room Rule
27654 //
27655 // Description:
27656 //
27657 // 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.
27658 //
27659 // @param request - UpdateWaitingRoomRuleRequest
27660 //
27661 // @return UpdateWaitingRoomRuleResponse
27662 func UpdateWaitingRoomRule(client *Client, request *UpdateWaitingRoomRuleRequest) (_result *UpdateWaitingRoomRuleResponse, _err error) {
27663 runtime := &dara.RuntimeOptions{}
27664 _result = &UpdateWaitingRoomRuleResponse{}
27665 _body, _err := UpdateWaitingRoomRuleWithOptions(client,request, runtime)
27666 if _err != nil {
27667 return _result, _err
27668 }
27669 _result = _body
27670 return _result, _err
27671 }
27672
27673 // Summary:
27674 //
27675 // Uploads a client certificate authority (CA) certificate.
27676 //
27677 // @param request - UploadClientCaCertificateRequest
27678 //
27679 // @param runtime - runtime options for this request RuntimeOptions
27680 //
27681 // @return UploadClientCaCertificateResponse
27682 func UploadClientCaCertificateWithOptions(client *Client, request *UploadClientCaCertificateRequest, runtime *dara.RuntimeOptions) (_result *UploadClientCaCertificateResponse, _err error) {
27683 if dara.BoolValue(client.EnableValidate) == true {
27684 _err = request.Validate()
27685 if _err != nil {
27686 return _result, _err
27687 }
27688 }
27689 query := map[string]interface{}{}
27690 if !dara.IsNil(request.SiteId) {
27691 query["SiteId"] = request.SiteId
27692 }
27693
27694 body := map[string]interface{}{}
27695 if !dara.IsNil(request.Certificate) {
27696 body["Certificate"] = request.Certificate
27697 }
27698
27699 if !dara.IsNil(request.Name) {
27700 body["Name"] = request.Name
27701 }
27702
27703 req := &openapiutil.OpenApiRequest{
27704 Query: openapiutil.Query(query),
27705 Body: openapiutil.ParseToMap(body),
27706 }
27707 params := &openapiutil.Params{
27708 Action: dara.String("UploadClientCaCertificate"),
27709 Version: dara.String("2024-09-10"),
27710 Protocol: dara.String("HTTPS"),
27711 Pathname: dara.String("/"),
27712 Method: dara.String("POST"),
27713 AuthType: dara.String("AK"),
27714 Style: dara.String("RPC"),
27715 ReqBodyType: dara.String("formData"),
27716 BodyType: dara.String("json"),
27717 }
27718 _result = &UploadClientCaCertificateResponse{}
27719 _body, _err := client.CallApi(params, req, runtime)
27720 if _err != nil {
27721 return _result, _err
27722 }
27723 _err = dara.Convert(_body, &_result)
27724 return _result, _err
27725 }
27726
27727 // Summary:
27728 //
27729 // Uploads a client certificate authority (CA) certificate.
27730 //
27731 // @param request - UploadClientCaCertificateRequest
27732 //
27733 // @return UploadClientCaCertificateResponse
27734 func UploadClientCaCertificate(client *Client, request *UploadClientCaCertificateRequest) (_result *UploadClientCaCertificateResponse, _err error) {
27735 runtime := &dara.RuntimeOptions{}
27736 _result = &UploadClientCaCertificateResponse{}
27737 _body, _err := UploadClientCaCertificateWithOptions(client,request, runtime)
27738 if _err != nil {
27739 return _result, _err
27740 }
27741 _result = _body
27742 return _result, _err
27743 }
27744
27745 // Summary:
27746 //
27747 // Uploads the file that contains resources to be purged or prefetched.
27748 //
27749 // Description:
27750 //
27751 // >
27752 //
27753 // - The file can be up to 10 MB in size.
27754 //
27755 // @param request - UploadFileRequest
27756 //
27757 // @param runtime - runtime options for this request RuntimeOptions
27758 //
27759 // @return UploadFileResponse
27760 func UploadFileWithOptions(client *Client, request *UploadFileRequest, runtime *dara.RuntimeOptions) (_result *UploadFileResponse, _err error) {
27761 if dara.BoolValue(client.EnableValidate) == true {
27762 _err = request.Validate()
27763 if _err != nil {
27764 return _result, _err
27765 }
27766 }
27767 query := map[string]interface{}{}
27768 if !dara.IsNil(request.SiteId) {
27769 query["SiteId"] = request.SiteId
27770 }
27771
27772 if !dara.IsNil(request.Type) {
27773 query["Type"] = request.Type
27774 }
27775
27776 if !dara.IsNil(request.UploadTaskName) {
27777 query["UploadTaskName"] = request.UploadTaskName
27778 }
27779
27780 if !dara.IsNil(request.Url) {
27781 query["Url"] = request.Url
27782 }
27783
27784 req := &openapiutil.OpenApiRequest{
27785 Query: openapiutil.Query(query),
27786 }
27787 params := &openapiutil.Params{
27788 Action: dara.String("UploadFile"),
27789 Version: dara.String("2024-09-10"),
27790 Protocol: dara.String("HTTPS"),
27791 Pathname: dara.String("/"),
27792 Method: dara.String("POST"),
27793 AuthType: dara.String("AK"),
27794 Style: dara.String("RPC"),
27795 ReqBodyType: dara.String("formData"),
27796 BodyType: dara.String("json"),
27797 }
27798 _result = &UploadFileResponse{}
27799 _body, _err := client.CallApi(params, req, runtime)
27800 if _err != nil {
27801 return _result, _err
27802 }
27803 _err = dara.Convert(_body, &_result)
27804 return _result, _err
27805 }
27806
27807 // Summary:
27808 //
27809 // Uploads the file that contains resources to be purged or prefetched.
27810 //
27811 // Description:
27812 //
27813 // >
27814 //
27815 // - The file can be up to 10 MB in size.
27816 //
27817 // @param request - UploadFileRequest
27818 //
27819 // @return UploadFileResponse
27820 func UploadFile(client *Client, request *UploadFileRequest) (_result *UploadFileResponse, _err error) {
27821 runtime := &dara.RuntimeOptions{}
27822 _result = &UploadFileResponse{}
27823 _body, _err := UploadFileWithOptions(client,request, runtime)
27824 if _err != nil {
27825 return _result, _err
27826 }
27827 _result = _body
27828 return _result, _err
27829 }
27830
27831 func UploadFileAdvance(client *Client, request *UploadFileAdvanceRequest, runtime *dara.RuntimeOptions) (_result *UploadFileResponse, _err error) {
27832 // Step 0: init client
27833 if dara.IsNil(client.Credential) {
27834 _err = &openapi.ClientError{
27835 Code: dara.String("InvalidCredentials"),
27836 Message: dara.String("Please set up the credentials correctly. If you are setting them through environment variables, please ensure that ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECRET are set correctly. See https://help.aliyun.com/zh/sdk/developer-reference/configure-the-alibaba-cloud-accesskey-environment-variable-on-linux-macos-and-windows-systems for more details."),
27837 }
27838 return _result, _err
27839 }
27840
27841 credentialModel, _err := client.Credential.GetCredential()
27842 if _err != nil {
27843 return _result, _err
27844 }
27845
27846 accessKeyId := dara.StringValue(credentialModel.AccessKeyId)
27847 accessKeySecret := dara.StringValue(credentialModel.AccessKeySecret)
27848 securityToken := dara.StringValue(credentialModel.SecurityToken)
27849 credentialType := dara.StringValue(credentialModel.Type)
27850 openPlatformEndpoint := dara.StringValue(client.OpenPlatformEndpoint)
27851 if dara.IsNil(dara.String(openPlatformEndpoint)) || openPlatformEndpoint == "" {
27852 openPlatformEndpoint = "openplatform.aliyuncs.com"
27853 }
27854
27855 if dara.IsNil(dara.String(credentialType)) {
27856 credentialType = "access_key"
27857 }
27858
27859 authConfig := &openapiutil.Config{
27860 AccessKeyId: dara.String(accessKeyId),
27861 AccessKeySecret: dara.String(accessKeySecret),
27862 SecurityToken: dara.String(securityToken),
27863 Type: dara.String(credentialType),
27864 Endpoint: dara.String(openPlatformEndpoint),
27865 Protocol: client.Protocol,
27866 RegionId: client.RegionId,
27867 }
27868 authClient, _err := openapi.NewClient(authConfig)
27869 if _err != nil {
27870 return _result, _err
27871 }
27872
27873 authRequest := map[string]*string{
27874 "Product": dara.String("ESA"),
27875 "RegionId": client.RegionId,
27876 }
27877 authReq := &openapiutil.OpenApiRequest{
27878 Query: openapiutil.Query(authRequest),
27879 }
27880 authParams := &openapiutil.Params{
27881 Action: dara.String("AuthorizeFileUpload"),
27882 Version: dara.String("2019-12-19"),
27883 Protocol: dara.String("HTTPS"),
27884 Pathname: dara.String("/"),
27885 Method: dara.String("GET"),
27886 AuthType: dara.String("AK"),
27887 Style: dara.String("RPC"),
27888 ReqBodyType: dara.String("formData"),
27889 BodyType: dara.String("json"),
27890 }
27891 authResponse := map[string]interface{}{}
27892 fileObj := &dara.FileField{}
27893 ossHeader := map[string]interface{}{}
27894 tmpBody := map[string]interface{}{}
27895 useAccelerate := false
27896 authResponseBody := make(map[string]*string)
27897 uploadFileReq := &UploadFileRequest{}
27898 openapiutil.Convert(request, uploadFileReq)
27899 if !dara.IsNil(request.UrlObject) {
27900 authResponse, _err = authClient.CallApi(authParams, authReq, runtime)
27901 if _err != nil {
27902 return _result, _err
27903 }
27904
27905 tmpBody = dara.ToMap(authResponse["body"])
27906 useAccelerate = dara.ForceBoolean(tmpBody["UseAccelerate"])
27907 authResponseBody = openapiutil.StringifyMapValue(tmpBody)
27908 fileObj = &dara.FileField{
27909 Filename: authResponseBody["ObjectKey"],
27910 Content: request.UrlObject,
27911 ContentType: dara.String(""),
27912 }
27913 ossHeader = map[string]interface{}{
27914 "host": dara.StringValue(authResponseBody["Bucket"]) + "." + dara.StringValue(openapiutil.GetEndpoint(authResponseBody["Endpoint"], dara.Bool(useAccelerate), client.EndpointType)),
27915 "OSSAccessKeyId": dara.StringValue(authResponseBody["AccessKeyId"]),
27916 "policy": dara.StringValue(authResponseBody["EncodedPolicy"]),
27917 "Signature": dara.StringValue(authResponseBody["Signature"]),
27918 "key": dara.StringValue(authResponseBody["ObjectKey"]),
27919 "file": fileObj,
27920 "success_action_status": "201",
27921 }
27922 _, _err = _postOSSObject(client,authResponseBody["Bucket"], ossHeader, runtime)
27923 if _err != nil {
27924 return _result, _err
27925 }
27926 uploadFileReq.Url = dara.String("http://" + dara.StringValue(authResponseBody["Bucket"]) + "." + dara.StringValue(authResponseBody["Endpoint"]) + "/" + dara.StringValue(authResponseBody["ObjectKey"]))
27927 }
27928
27929 uploadFileResp, _err := UploadFileWithOptions(client,uploadFileReq, runtime)
27930 if _err != nil {
27931 return _result, _err
27932 }
27933
27934 _result = uploadFileResp
27935 return _result, _err
27936 }
27937
27938 // Summary:
27939 //
27940 // 上传源服务器CA证书
27941 //
27942 // @param request - UploadOriginCaCertificateRequest
27943 //
27944 // @param runtime - runtime options for this request RuntimeOptions
27945 //
27946 // @return UploadOriginCaCertificateResponse
27947 func UploadOriginCaCertificateWithOptions(client *Client, request *UploadOriginCaCertificateRequest, runtime *dara.RuntimeOptions) (_result *UploadOriginCaCertificateResponse, _err error) {
27948 if dara.BoolValue(client.EnableValidate) == true {
27949 _err = request.Validate()
27950 if _err != nil {
27951 return _result, _err
27952 }
27953 }
27954 body := map[string]interface{}{}
27955 if !dara.IsNil(request.Certificate) {
27956 body["Certificate"] = request.Certificate
27957 }
27958
27959 if !dara.IsNil(request.Name) {
27960 body["Name"] = request.Name
27961 }
27962
27963 if !dara.IsNil(request.SiteId) {
27964 body["SiteId"] = request.SiteId
27965 }
27966
27967 req := &openapiutil.OpenApiRequest{
27968 Body: openapiutil.ParseToMap(body),
27969 }
27970 params := &openapiutil.Params{
27971 Action: dara.String("UploadOriginCaCertificate"),
27972 Version: dara.String("2024-09-10"),
27973 Protocol: dara.String("HTTPS"),
27974 Pathname: dara.String("/"),
27975 Method: dara.String("POST"),
27976 AuthType: dara.String("AK"),
27977 Style: dara.String("RPC"),
27978 ReqBodyType: dara.String("formData"),
27979 BodyType: dara.String("json"),
27980 }
27981 _result = &UploadOriginCaCertificateResponse{}
27982 _body, _err := client.CallApi(params, req, runtime)
27983 if _err != nil {
27984 return _result, _err
27985 }
27986 _err = dara.Convert(_body, &_result)
27987 return _result, _err
27988 }
27989
27990 // Summary:
27991 //
27992 // 上传源服务器CA证书
27993 //
27994 // @param request - UploadOriginCaCertificateRequest
27995 //
27996 // @return UploadOriginCaCertificateResponse
27997 func UploadOriginCaCertificate(client *Client, request *UploadOriginCaCertificateRequest) (_result *UploadOriginCaCertificateResponse, _err error) {
27998 runtime := &dara.RuntimeOptions{}
27999 _result = &UploadOriginCaCertificateResponse{}
28000 _body, _err := UploadOriginCaCertificateWithOptions(client,request, runtime)
28001 if _err != nil {
28002 return _result, _err
28003 }
28004 _result = _body
28005 return _result, _err
28006 }
28007
28008 // Summary:
28009 //
28010 // 上传域名回源客户端证书
28011 //
28012 // @param request - UploadOriginClientCertificateRequest
28013 //
28014 // @param runtime - runtime options for this request RuntimeOptions
28015 //
28016 // @return UploadOriginClientCertificateResponse
28017 func UploadOriginClientCertificateWithOptions(client *Client, request *UploadOriginClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *UploadOriginClientCertificateResponse, _err error) {
28018 if dara.BoolValue(client.EnableValidate) == true {
28019 _err = request.Validate()
28020 if _err != nil {
28021 return _result, _err
28022 }
28023 }
28024 query := map[string]interface{}{}
28025 if !dara.IsNil(request.SiteId) {
28026 query["SiteId"] = request.SiteId
28027 }
28028
28029 body := map[string]interface{}{}
28030 if !dara.IsNil(request.Certificate) {
28031 body["Certificate"] = request.Certificate
28032 }
28033
28034 if !dara.IsNil(request.Name) {
28035 body["Name"] = request.Name
28036 }
28037
28038 if !dara.IsNil(request.PrivateKey) {
28039 body["PrivateKey"] = request.PrivateKey
28040 }
28041
28042 req := &openapiutil.OpenApiRequest{
28043 Query: openapiutil.Query(query),
28044 Body: openapiutil.ParseToMap(body),
28045 }
28046 params := &openapiutil.Params{
28047 Action: dara.String("UploadOriginClientCertificate"),
28048 Version: dara.String("2024-09-10"),
28049 Protocol: dara.String("HTTPS"),
28050 Pathname: dara.String("/"),
28051 Method: dara.String("POST"),
28052 AuthType: dara.String("AK"),
28053 Style: dara.String("RPC"),
28054 ReqBodyType: dara.String("formData"),
28055 BodyType: dara.String("json"),
28056 }
28057 _result = &UploadOriginClientCertificateResponse{}
28058 _body, _err := client.CallApi(params, req, runtime)
28059 if _err != nil {
28060 return _result, _err
28061 }
28062 _err = dara.Convert(_body, &_result)
28063 return _result, _err
28064 }
28065
28066 // Summary:
28067 //
28068 // 上传域名回源客户端证书
28069 //
28070 // @param request - UploadOriginClientCertificateRequest
28071 //
28072 // @return UploadOriginClientCertificateResponse
28073 func UploadOriginClientCertificate(client *Client, request *UploadOriginClientCertificateRequest) (_result *UploadOriginClientCertificateResponse, _err error) {
28074 runtime := &dara.RuntimeOptions{}
28075 _result = &UploadOriginClientCertificateResponse{}
28076 _body, _err := UploadOriginClientCertificateWithOptions(client,request, runtime)
28077 if _err != nil {
28078 return _result, _err
28079 }
28080 _result = _body
28081 return _result, _err
28082 }
28083
28084 // Summary:
28085 //
28086 // # Upload site origin client certificate
28087 //
28088 // @param request - UploadSiteOriginClientCertificateRequest
28089 //
28090 // @param runtime - runtime options for this request RuntimeOptions
28091 //
28092 // @return UploadSiteOriginClientCertificateResponse
28093 func UploadSiteOriginClientCertificateWithOptions(client *Client, request *UploadSiteOriginClientCertificateRequest, runtime *dara.RuntimeOptions) (_result *UploadSiteOriginClientCertificateResponse, _err error) {
28094 if dara.BoolValue(client.EnableValidate) == true {
28095 _err = request.Validate()
28096 if _err != nil {
28097 return _result, _err
28098 }
28099 }
28100 query := map[string]interface{}{}
28101 if !dara.IsNil(request.SiteId) {
28102 query["SiteId"] = request.SiteId
28103 }
28104
28105 body := map[string]interface{}{}
28106 if !dara.IsNil(request.Certificate) {
28107 body["Certificate"] = request.Certificate
28108 }
28109
28110 if !dara.IsNil(request.Name) {
28111 body["Name"] = request.Name
28112 }
28113
28114 if !dara.IsNil(request.PrivateKey) {
28115 body["PrivateKey"] = request.PrivateKey
28116 }
28117
28118 req := &openapiutil.OpenApiRequest{
28119 Query: openapiutil.Query(query),
28120 Body: openapiutil.ParseToMap(body),
28121 }
28122 params := &openapiutil.Params{
28123 Action: dara.String("UploadSiteOriginClientCertificate"),
28124 Version: dara.String("2024-09-10"),
28125 Protocol: dara.String("HTTPS"),
28126 Pathname: dara.String("/"),
28127 Method: dara.String("POST"),
28128 AuthType: dara.String("AK"),
28129 Style: dara.String("RPC"),
28130 ReqBodyType: dara.String("formData"),
28131 BodyType: dara.String("json"),
28132 }
28133 _result = &UploadSiteOriginClientCertificateResponse{}
28134 _body, _err := client.CallApi(params, req, runtime)
28135 if _err != nil {
28136 return _result, _err
28137 }
28138 _err = dara.Convert(_body, &_result)
28139 return _result, _err
28140 }
28141
28142 // Summary:
28143 //
28144 // # Upload site origin client certificate
28145 //
28146 // @param request - UploadSiteOriginClientCertificateRequest
28147 //
28148 // @return UploadSiteOriginClientCertificateResponse
28149 func UploadSiteOriginClientCertificate(client *Client, request *UploadSiteOriginClientCertificateRequest) (_result *UploadSiteOriginClientCertificateResponse, _err error) {
28150 runtime := &dara.RuntimeOptions{}
28151 _result = &UploadSiteOriginClientCertificateResponse{}
28152 _body, _err := UploadSiteOriginClientCertificateWithOptions(client,request, runtime)
28153 if _err != nil {
28154 return _result, _err
28155 }
28156 _result = _body
28157 return _result, _err
28158 }
28159
28160 // Summary:
28161 //
28162 // Verifies the ownership of a website domain. Websites that pass the verification are automatically activated.
28163 //
28164 // Description:
28165 //
28166 // 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.
28167 //
28168 // 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.
28169 //
28170 // @param request - VerifySiteRequest
28171 //
28172 // @param runtime - runtime options for this request RuntimeOptions
28173 //
28174 // @return VerifySiteResponse
28175 func VerifySiteWithOptions(client *Client, request *VerifySiteRequest, runtime *dara.RuntimeOptions) (_result *VerifySiteResponse, _err error) {
28176 if dara.BoolValue(client.EnableValidate) == true {
28177 _err = request.Validate()
28178 if _err != nil {
28179 return _result, _err
28180 }
28181 }
28182 query := map[string]interface{}{}
28183 if !dara.IsNil(request.SiteId) {
28184 query["SiteId"] = request.SiteId
28185 }
28186
28187 req := &openapiutil.OpenApiRequest{
28188 Query: openapiutil.Query(query),
28189 }
28190 params := &openapiutil.Params{
28191 Action: dara.String("VerifySite"),
28192 Version: dara.String("2024-09-10"),
28193 Protocol: dara.String("HTTPS"),
28194 Pathname: dara.String("/"),
28195 Method: dara.String("POST"),
28196 AuthType: dara.String("AK"),
28197 Style: dara.String("RPC"),
28198 ReqBodyType: dara.String("formData"),
28199 BodyType: dara.String("json"),
28200 }
28201 _result = &VerifySiteResponse{}
28202 _body, _err := client.CallApi(params, req, runtime)
28203 if _err != nil {
28204 return _result, _err
28205 }
28206 _err = dara.Convert(_body, &_result)
28207 return _result, _err
28208 }
28209
28210 // Summary:
28211 //
28212 // Verifies the ownership of a website domain. Websites that pass the verification are automatically activated.
28213 //
28214 // Description:
28215 //
28216 // 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.
28217 //
28218 // 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.
28219 //
28220 // @param request - VerifySiteRequest
28221 //
28222 // @return VerifySiteResponse
28223 func VerifySite(client *Client, request *VerifySiteRequest) (_result *VerifySiteResponse, _err error) {
28224 runtime := &dara.RuntimeOptions{}
28225 _result = &VerifySiteResponse{}
28226 _body, _err := VerifySiteWithOptions(client,request, runtime)
28227 if _err != nil {
28228 return _result, _err
28229 }
28230 _result = _body
28231 return _result, _err
28232 }
28233
28234 func _postOSSObject_opResponse(response_ *dara.Response) (_result map[string]interface{}, _err error) {
28235 var respMap map[string]interface{}
28236 bodyStr, _err := dara.ReadAsString(response_.Body)
28237 if _err != nil {
28238 return _result, _err
28239 }
28240
28241 if (dara.IntValue(response_.StatusCode) >= 400) && (dara.IntValue(response_.StatusCode) < 600) {
28242 respMap = dara.ParseXml(bodyStr, nil)
28243 err := dara.ToMap(respMap["Error"])
28244 _err = &openapi.ClientError{
28245 Code: dara.String(dara.ToString(err["Code"])),
28246 Message: dara.String(dara.ToString(err["Message"])),
28247 Data: map[string]interface{}{
28248 "httpCode": dara.IntValue(response_.StatusCode),
28249 "requestId": dara.ToString(err["RequestId"]),
28250 "hostId": dara.ToString(err["HostId"]),
28251 },
28252 }
28253 return _result, _err
28254 }
28255
28256 respMap = dara.ParseXml(bodyStr, nil)
28257 _result = make(map[string]interface{})
28258 _err = dara.Convert(dara.ToMap(respMap), &_result)
28259
28260 return _result, _err
28261 }
28262