1
2
5 package client
6
7 import (
8 openapi "github.com/alibabacloud-go/darabonba-openapi/client"
9 endpointutil "github.com/alibabacloud-go/endpoint-util/service"
10 openapiutil "github.com/alibabacloud-go/openapi-util/service"
11 util "github.com/alibabacloud-go/tea-utils/service"
12 "github.com/alibabacloud-go/tea/tea"
13 )
14
15 type CancelRepoBuildResponse struct {
16 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
17 }
18
19 func (s CancelRepoBuildResponse) String() string {
20 return tea.Prettify(s)
21 }
22
23 func (s CancelRepoBuildResponse) GoString() string {
24 return s.String()
25 }
26
27 func (s *CancelRepoBuildResponse) SetHeaders(v map[string]*string) *CancelRepoBuildResponse {
28 s.Headers = v
29 return s
30 }
31
32 type CreateNamespaceResponse struct {
33 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
34 }
35
36 func (s CreateNamespaceResponse) String() string {
37 return tea.Prettify(s)
38 }
39
40 func (s CreateNamespaceResponse) GoString() string {
41 return s.String()
42 }
43
44 func (s *CreateNamespaceResponse) SetHeaders(v map[string]*string) *CreateNamespaceResponse {
45 s.Headers = v
46 return s
47 }
48
49 type CreateRepoResponse struct {
50 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
51 }
52
53 func (s CreateRepoResponse) String() string {
54 return tea.Prettify(s)
55 }
56
57 func (s CreateRepoResponse) GoString() string {
58 return s.String()
59 }
60
61 func (s *CreateRepoResponse) SetHeaders(v map[string]*string) *CreateRepoResponse {
62 s.Headers = v
63 return s
64 }
65
66 type CreateRepoBuildRuleResponse struct {
67 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
68 }
69
70 func (s CreateRepoBuildRuleResponse) String() string {
71 return tea.Prettify(s)
72 }
73
74 func (s CreateRepoBuildRuleResponse) GoString() string {
75 return s.String()
76 }
77
78 func (s *CreateRepoBuildRuleResponse) SetHeaders(v map[string]*string) *CreateRepoBuildRuleResponse {
79 s.Headers = v
80 return s
81 }
82
83 type CreateRepoWebhookResponse struct {
84 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
85 }
86
87 func (s CreateRepoWebhookResponse) String() string {
88 return tea.Prettify(s)
89 }
90
91 func (s CreateRepoWebhookResponse) GoString() string {
92 return s.String()
93 }
94
95 func (s *CreateRepoWebhookResponse) SetHeaders(v map[string]*string) *CreateRepoWebhookResponse {
96 s.Headers = v
97 return s
98 }
99
100 type CreateUserInfoResponse struct {
101 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
102 }
103
104 func (s CreateUserInfoResponse) String() string {
105 return tea.Prettify(s)
106 }
107
108 func (s CreateUserInfoResponse) GoString() string {
109 return s.String()
110 }
111
112 func (s *CreateUserInfoResponse) SetHeaders(v map[string]*string) *CreateUserInfoResponse {
113 s.Headers = v
114 return s
115 }
116
117 type DeleteImageResponse struct {
118 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
119 }
120
121 func (s DeleteImageResponse) String() string {
122 return tea.Prettify(s)
123 }
124
125 func (s DeleteImageResponse) GoString() string {
126 return s.String()
127 }
128
129 func (s *DeleteImageResponse) SetHeaders(v map[string]*string) *DeleteImageResponse {
130 s.Headers = v
131 return s
132 }
133
134 type DeleteNamespaceResponse struct {
135 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
136 }
137
138 func (s DeleteNamespaceResponse) String() string {
139 return tea.Prettify(s)
140 }
141
142 func (s DeleteNamespaceResponse) GoString() string {
143 return s.String()
144 }
145
146 func (s *DeleteNamespaceResponse) SetHeaders(v map[string]*string) *DeleteNamespaceResponse {
147 s.Headers = v
148 return s
149 }
150
151 type DeleteRepoResponse struct {
152 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
153 }
154
155 func (s DeleteRepoResponse) String() string {
156 return tea.Prettify(s)
157 }
158
159 func (s DeleteRepoResponse) GoString() string {
160 return s.String()
161 }
162
163 func (s *DeleteRepoResponse) SetHeaders(v map[string]*string) *DeleteRepoResponse {
164 s.Headers = v
165 return s
166 }
167
168 type DeleteRepoBuildRuleResponse struct {
169 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
170 }
171
172 func (s DeleteRepoBuildRuleResponse) String() string {
173 return tea.Prettify(s)
174 }
175
176 func (s DeleteRepoBuildRuleResponse) GoString() string {
177 return s.String()
178 }
179
180 func (s *DeleteRepoBuildRuleResponse) SetHeaders(v map[string]*string) *DeleteRepoBuildRuleResponse {
181 s.Headers = v
182 return s
183 }
184
185 type DeleteRepoWebhookResponse struct {
186 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
187 }
188
189 func (s DeleteRepoWebhookResponse) String() string {
190 return tea.Prettify(s)
191 }
192
193 func (s DeleteRepoWebhookResponse) GoString() string {
194 return s.String()
195 }
196
197 func (s *DeleteRepoWebhookResponse) SetHeaders(v map[string]*string) *DeleteRepoWebhookResponse {
198 s.Headers = v
199 return s
200 }
201
202 type GetAuthorizationTokenResponse struct {
203 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
204 }
205
206 func (s GetAuthorizationTokenResponse) String() string {
207 return tea.Prettify(s)
208 }
209
210 func (s GetAuthorizationTokenResponse) GoString() string {
211 return s.String()
212 }
213
214 func (s *GetAuthorizationTokenResponse) SetHeaders(v map[string]*string) *GetAuthorizationTokenResponse {
215 s.Headers = v
216 return s
217 }
218
219 type GetImageLayerResponse struct {
220 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
221 }
222
223 func (s GetImageLayerResponse) String() string {
224 return tea.Prettify(s)
225 }
226
227 func (s GetImageLayerResponse) GoString() string {
228 return s.String()
229 }
230
231 func (s *GetImageLayerResponse) SetHeaders(v map[string]*string) *GetImageLayerResponse {
232 s.Headers = v
233 return s
234 }
235
236 type GetImageManifestRequest struct {
237 SchemaVersion *int32 `json:"SchemaVersion,omitempty" xml:"SchemaVersion,omitempty"`
238 }
239
240 func (s GetImageManifestRequest) String() string {
241 return tea.Prettify(s)
242 }
243
244 func (s GetImageManifestRequest) GoString() string {
245 return s.String()
246 }
247
248 func (s *GetImageManifestRequest) SetSchemaVersion(v int32) *GetImageManifestRequest {
249 s.SchemaVersion = &v
250 return s
251 }
252
253 type GetImageManifestResponse struct {
254 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
255 }
256
257 func (s GetImageManifestResponse) String() string {
258 return tea.Prettify(s)
259 }
260
261 func (s GetImageManifestResponse) GoString() string {
262 return s.String()
263 }
264
265 func (s *GetImageManifestResponse) SetHeaders(v map[string]*string) *GetImageManifestResponse {
266 s.Headers = v
267 return s
268 }
269
270 type GetNamespaceResponse struct {
271 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
272 }
273
274 func (s GetNamespaceResponse) String() string {
275 return tea.Prettify(s)
276 }
277
278 func (s GetNamespaceResponse) GoString() string {
279 return s.String()
280 }
281
282 func (s *GetNamespaceResponse) SetHeaders(v map[string]*string) *GetNamespaceResponse {
283 s.Headers = v
284 return s
285 }
286
287 type GetNamespaceListRequest struct {
288 Authorize *string `json:"Authorize,omitempty" xml:"Authorize,omitempty"`
289 Status *string `json:"Status,omitempty" xml:"Status,omitempty"`
290 }
291
292 func (s GetNamespaceListRequest) String() string {
293 return tea.Prettify(s)
294 }
295
296 func (s GetNamespaceListRequest) GoString() string {
297 return s.String()
298 }
299
300 func (s *GetNamespaceListRequest) SetAuthorize(v string) *GetNamespaceListRequest {
301 s.Authorize = &v
302 return s
303 }
304
305 func (s *GetNamespaceListRequest) SetStatus(v string) *GetNamespaceListRequest {
306 s.Status = &v
307 return s
308 }
309
310 type GetNamespaceListResponse struct {
311 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
312 }
313
314 func (s GetNamespaceListResponse) String() string {
315 return tea.Prettify(s)
316 }
317
318 func (s GetNamespaceListResponse) GoString() string {
319 return s.String()
320 }
321
322 func (s *GetNamespaceListResponse) SetHeaders(v map[string]*string) *GetNamespaceListResponse {
323 s.Headers = v
324 return s
325 }
326
327 type GetRegionRequest struct {
328 Domain *string `json:"Domain,omitempty" xml:"Domain,omitempty"`
329 }
330
331 func (s GetRegionRequest) String() string {
332 return tea.Prettify(s)
333 }
334
335 func (s GetRegionRequest) GoString() string {
336 return s.String()
337 }
338
339 func (s *GetRegionRequest) SetDomain(v string) *GetRegionRequest {
340 s.Domain = &v
341 return s
342 }
343
344 type GetRegionResponse struct {
345 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
346 }
347
348 func (s GetRegionResponse) String() string {
349 return tea.Prettify(s)
350 }
351
352 func (s GetRegionResponse) GoString() string {
353 return s.String()
354 }
355
356 func (s *GetRegionResponse) SetHeaders(v map[string]*string) *GetRegionResponse {
357 s.Headers = v
358 return s
359 }
360
361 type GetRegionListResponse struct {
362 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
363 }
364
365 func (s GetRegionListResponse) String() string {
366 return tea.Prettify(s)
367 }
368
369 func (s GetRegionListResponse) GoString() string {
370 return s.String()
371 }
372
373 func (s *GetRegionListResponse) SetHeaders(v map[string]*string) *GetRegionListResponse {
374 s.Headers = v
375 return s
376 }
377
378 type GetRepoResponse struct {
379 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
380 }
381
382 func (s GetRepoResponse) String() string {
383 return tea.Prettify(s)
384 }
385
386 func (s GetRepoResponse) GoString() string {
387 return s.String()
388 }
389
390 func (s *GetRepoResponse) SetHeaders(v map[string]*string) *GetRepoResponse {
391 s.Headers = v
392 return s
393 }
394
395 type GetRepoBuildListRequest struct {
396 Page *int32 `json:"Page,omitempty" xml:"Page,omitempty"`
397 PageSize *int32 `json:"PageSize,omitempty" xml:"PageSize,omitempty"`
398 }
399
400 func (s GetRepoBuildListRequest) String() string {
401 return tea.Prettify(s)
402 }
403
404 func (s GetRepoBuildListRequest) GoString() string {
405 return s.String()
406 }
407
408 func (s *GetRepoBuildListRequest) SetPage(v int32) *GetRepoBuildListRequest {
409 s.Page = &v
410 return s
411 }
412
413 func (s *GetRepoBuildListRequest) SetPageSize(v int32) *GetRepoBuildListRequest {
414 s.PageSize = &v
415 return s
416 }
417
418 type GetRepoBuildListResponse struct {
419 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
420 }
421
422 func (s GetRepoBuildListResponse) String() string {
423 return tea.Prettify(s)
424 }
425
426 func (s GetRepoBuildListResponse) GoString() string {
427 return s.String()
428 }
429
430 func (s *GetRepoBuildListResponse) SetHeaders(v map[string]*string) *GetRepoBuildListResponse {
431 s.Headers = v
432 return s
433 }
434
435 type GetRepoBuildRuleListResponse struct {
436 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
437 }
438
439 func (s GetRepoBuildRuleListResponse) String() string {
440 return tea.Prettify(s)
441 }
442
443 func (s GetRepoBuildRuleListResponse) GoString() string {
444 return s.String()
445 }
446
447 func (s *GetRepoBuildRuleListResponse) SetHeaders(v map[string]*string) *GetRepoBuildRuleListResponse {
448 s.Headers = v
449 return s
450 }
451
452 type GetRepoBuildStatusResponse struct {
453 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
454 }
455
456 func (s GetRepoBuildStatusResponse) String() string {
457 return tea.Prettify(s)
458 }
459
460 func (s GetRepoBuildStatusResponse) GoString() string {
461 return s.String()
462 }
463
464 func (s *GetRepoBuildStatusResponse) SetHeaders(v map[string]*string) *GetRepoBuildStatusResponse {
465 s.Headers = v
466 return s
467 }
468
469 type GetRepoListRequest struct {
470 Page *int32 `json:"Page,omitempty" xml:"Page,omitempty"`
471 PageSize *int32 `json:"PageSize,omitempty" xml:"PageSize,omitempty"`
472 Status *string `json:"Status,omitempty" xml:"Status,omitempty"`
473 }
474
475 func (s GetRepoListRequest) String() string {
476 return tea.Prettify(s)
477 }
478
479 func (s GetRepoListRequest) GoString() string {
480 return s.String()
481 }
482
483 func (s *GetRepoListRequest) SetPage(v int32) *GetRepoListRequest {
484 s.Page = &v
485 return s
486 }
487
488 func (s *GetRepoListRequest) SetPageSize(v int32) *GetRepoListRequest {
489 s.PageSize = &v
490 return s
491 }
492
493 func (s *GetRepoListRequest) SetStatus(v string) *GetRepoListRequest {
494 s.Status = &v
495 return s
496 }
497
498 type GetRepoListResponse struct {
499 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
500 }
501
502 func (s GetRepoListResponse) String() string {
503 return tea.Prettify(s)
504 }
505
506 func (s GetRepoListResponse) GoString() string {
507 return s.String()
508 }
509
510 func (s *GetRepoListResponse) SetHeaders(v map[string]*string) *GetRepoListResponse {
511 s.Headers = v
512 return s
513 }
514
515 type GetRepoListByNamespaceRequest struct {
516 Page *int32 `json:"Page,omitempty" xml:"Page,omitempty"`
517 PageSize *int32 `json:"PageSize,omitempty" xml:"PageSize,omitempty"`
518 Status *string `json:"Status,omitempty" xml:"Status,omitempty"`
519 }
520
521 func (s GetRepoListByNamespaceRequest) String() string {
522 return tea.Prettify(s)
523 }
524
525 func (s GetRepoListByNamespaceRequest) GoString() string {
526 return s.String()
527 }
528
529 func (s *GetRepoListByNamespaceRequest) SetPage(v int32) *GetRepoListByNamespaceRequest {
530 s.Page = &v
531 return s
532 }
533
534 func (s *GetRepoListByNamespaceRequest) SetPageSize(v int32) *GetRepoListByNamespaceRequest {
535 s.PageSize = &v
536 return s
537 }
538
539 func (s *GetRepoListByNamespaceRequest) SetStatus(v string) *GetRepoListByNamespaceRequest {
540 s.Status = &v
541 return s
542 }
543
544 type GetRepoListByNamespaceResponse struct {
545 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
546 }
547
548 func (s GetRepoListByNamespaceResponse) String() string {
549 return tea.Prettify(s)
550 }
551
552 func (s GetRepoListByNamespaceResponse) GoString() string {
553 return s.String()
554 }
555
556 func (s *GetRepoListByNamespaceResponse) SetHeaders(v map[string]*string) *GetRepoListByNamespaceResponse {
557 s.Headers = v
558 return s
559 }
560
561 type GetRepoTagResponseBody struct {
562 Digest *string `json:"digest,omitempty" xml:"digest,omitempty"`
563 ImageCreate *int64 `json:"imageCreate,omitempty" xml:"imageCreate,omitempty"`
564 ImageId *string `json:"imageId,omitempty" xml:"imageId,omitempty"`
565 ImageSize *int64 `json:"imageSize,omitempty" xml:"imageSize,omitempty"`
566 ImageUpdate *int64 `json:"imageUpdate,omitempty" xml:"imageUpdate,omitempty"`
567 RequestId *string `json:"requestId,omitempty" xml:"requestId,omitempty"`
568 Status *string `json:"status,omitempty" xml:"status,omitempty"`
569 Tag *string `json:"tag,omitempty" xml:"tag,omitempty"`
570 }
571
572 func (s GetRepoTagResponseBody) String() string {
573 return tea.Prettify(s)
574 }
575
576 func (s GetRepoTagResponseBody) GoString() string {
577 return s.String()
578 }
579
580 func (s *GetRepoTagResponseBody) SetDigest(v string) *GetRepoTagResponseBody {
581 s.Digest = &v
582 return s
583 }
584
585 func (s *GetRepoTagResponseBody) SetImageCreate(v int64) *GetRepoTagResponseBody {
586 s.ImageCreate = &v
587 return s
588 }
589
590 func (s *GetRepoTagResponseBody) SetImageId(v string) *GetRepoTagResponseBody {
591 s.ImageId = &v
592 return s
593 }
594
595 func (s *GetRepoTagResponseBody) SetImageSize(v int64) *GetRepoTagResponseBody {
596 s.ImageSize = &v
597 return s
598 }
599
600 func (s *GetRepoTagResponseBody) SetImageUpdate(v int64) *GetRepoTagResponseBody {
601 s.ImageUpdate = &v
602 return s
603 }
604
605 func (s *GetRepoTagResponseBody) SetRequestId(v string) *GetRepoTagResponseBody {
606 s.RequestId = &v
607 return s
608 }
609
610 func (s *GetRepoTagResponseBody) SetStatus(v string) *GetRepoTagResponseBody {
611 s.Status = &v
612 return s
613 }
614
615 func (s *GetRepoTagResponseBody) SetTag(v string) *GetRepoTagResponseBody {
616 s.Tag = &v
617 return s
618 }
619
620 type GetRepoTagResponse struct {
621 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
622 Body *GetRepoTagResponseBody `json:"body,omitempty" xml:"body,omitempty" require:"true"`
623 }
624
625 func (s GetRepoTagResponse) String() string {
626 return tea.Prettify(s)
627 }
628
629 func (s GetRepoTagResponse) GoString() string {
630 return s.String()
631 }
632
633 func (s *GetRepoTagResponse) SetHeaders(v map[string]*string) *GetRepoTagResponse {
634 s.Headers = v
635 return s
636 }
637
638 func (s *GetRepoTagResponse) SetBody(v *GetRepoTagResponseBody) *GetRepoTagResponse {
639 s.Body = v
640 return s
641 }
642
643 type GetRepoTagScanListRequest struct {
644 Page *int32 `json:"Page,omitempty" xml:"Page,omitempty"`
645 PageSize *int32 `json:"PageSize,omitempty" xml:"PageSize,omitempty"`
646 Severity *string `json:"Severity,omitempty" xml:"Severity,omitempty"`
647 }
648
649 func (s GetRepoTagScanListRequest) String() string {
650 return tea.Prettify(s)
651 }
652
653 func (s GetRepoTagScanListRequest) GoString() string {
654 return s.String()
655 }
656
657 func (s *GetRepoTagScanListRequest) SetPage(v int32) *GetRepoTagScanListRequest {
658 s.Page = &v
659 return s
660 }
661
662 func (s *GetRepoTagScanListRequest) SetPageSize(v int32) *GetRepoTagScanListRequest {
663 s.PageSize = &v
664 return s
665 }
666
667 func (s *GetRepoTagScanListRequest) SetSeverity(v string) *GetRepoTagScanListRequest {
668 s.Severity = &v
669 return s
670 }
671
672 type GetRepoTagScanListResponse struct {
673 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
674 }
675
676 func (s GetRepoTagScanListResponse) String() string {
677 return tea.Prettify(s)
678 }
679
680 func (s GetRepoTagScanListResponse) GoString() string {
681 return s.String()
682 }
683
684 func (s *GetRepoTagScanListResponse) SetHeaders(v map[string]*string) *GetRepoTagScanListResponse {
685 s.Headers = v
686 return s
687 }
688
689 type GetRepoTagScanStatusResponse struct {
690 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
691 }
692
693 func (s GetRepoTagScanStatusResponse) String() string {
694 return tea.Prettify(s)
695 }
696
697 func (s GetRepoTagScanStatusResponse) GoString() string {
698 return s.String()
699 }
700
701 func (s *GetRepoTagScanStatusResponse) SetHeaders(v map[string]*string) *GetRepoTagScanStatusResponse {
702 s.Headers = v
703 return s
704 }
705
706 type GetRepoTagScanSummaryResponse struct {
707 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
708 }
709
710 func (s GetRepoTagScanSummaryResponse) String() string {
711 return tea.Prettify(s)
712 }
713
714 func (s GetRepoTagScanSummaryResponse) GoString() string {
715 return s.String()
716 }
717
718 func (s *GetRepoTagScanSummaryResponse) SetHeaders(v map[string]*string) *GetRepoTagScanSummaryResponse {
719 s.Headers = v
720 return s
721 }
722
723 type GetRepoTagsRequest struct {
724 Page *int32 `json:"Page,omitempty" xml:"Page,omitempty"`
725 PageSize *int32 `json:"PageSize,omitempty" xml:"PageSize,omitempty"`
726 }
727
728 func (s GetRepoTagsRequest) String() string {
729 return tea.Prettify(s)
730 }
731
732 func (s GetRepoTagsRequest) GoString() string {
733 return s.String()
734 }
735
736 func (s *GetRepoTagsRequest) SetPage(v int32) *GetRepoTagsRequest {
737 s.Page = &v
738 return s
739 }
740
741 func (s *GetRepoTagsRequest) SetPageSize(v int32) *GetRepoTagsRequest {
742 s.PageSize = &v
743 return s
744 }
745
746 type GetRepoTagsResponse struct {
747 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
748 }
749
750 func (s GetRepoTagsResponse) String() string {
751 return tea.Prettify(s)
752 }
753
754 func (s GetRepoTagsResponse) GoString() string {
755 return s.String()
756 }
757
758 func (s *GetRepoTagsResponse) SetHeaders(v map[string]*string) *GetRepoTagsResponse {
759 s.Headers = v
760 return s
761 }
762
763 type GetRepoWebhookResponse struct {
764 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
765 }
766
767 func (s GetRepoWebhookResponse) String() string {
768 return tea.Prettify(s)
769 }
770
771 func (s GetRepoWebhookResponse) GoString() string {
772 return s.String()
773 }
774
775 func (s *GetRepoWebhookResponse) SetHeaders(v map[string]*string) *GetRepoWebhookResponse {
776 s.Headers = v
777 return s
778 }
779
780 type GetResourceQuotaResponse struct {
781 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
782 }
783
784 func (s GetResourceQuotaResponse) String() string {
785 return tea.Prettify(s)
786 }
787
788 func (s GetResourceQuotaResponse) GoString() string {
789 return s.String()
790 }
791
792 func (s *GetResourceQuotaResponse) SetHeaders(v map[string]*string) *GetResourceQuotaResponse {
793 s.Headers = v
794 return s
795 }
796
797 type StartImageScanResponse struct {
798 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
799 }
800
801 func (s StartImageScanResponse) String() string {
802 return tea.Prettify(s)
803 }
804
805 func (s StartImageScanResponse) GoString() string {
806 return s.String()
807 }
808
809 func (s *StartImageScanResponse) SetHeaders(v map[string]*string) *StartImageScanResponse {
810 s.Headers = v
811 return s
812 }
813
814 type StartRepoBuildByRuleResponse struct {
815 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
816 }
817
818 func (s StartRepoBuildByRuleResponse) String() string {
819 return tea.Prettify(s)
820 }
821
822 func (s StartRepoBuildByRuleResponse) GoString() string {
823 return s.String()
824 }
825
826 func (s *StartRepoBuildByRuleResponse) SetHeaders(v map[string]*string) *StartRepoBuildByRuleResponse {
827 s.Headers = v
828 return s
829 }
830
831 type UpdateNamespaceResponse struct {
832 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
833 }
834
835 func (s UpdateNamespaceResponse) String() string {
836 return tea.Prettify(s)
837 }
838
839 func (s UpdateNamespaceResponse) GoString() string {
840 return s.String()
841 }
842
843 func (s *UpdateNamespaceResponse) SetHeaders(v map[string]*string) *UpdateNamespaceResponse {
844 s.Headers = v
845 return s
846 }
847
848 type UpdateRepoResponse struct {
849 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
850 }
851
852 func (s UpdateRepoResponse) String() string {
853 return tea.Prettify(s)
854 }
855
856 func (s UpdateRepoResponse) GoString() string {
857 return s.String()
858 }
859
860 func (s *UpdateRepoResponse) SetHeaders(v map[string]*string) *UpdateRepoResponse {
861 s.Headers = v
862 return s
863 }
864
865 type UpdateRepoBuildRuleResponse struct {
866 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
867 }
868
869 func (s UpdateRepoBuildRuleResponse) String() string {
870 return tea.Prettify(s)
871 }
872
873 func (s UpdateRepoBuildRuleResponse) GoString() string {
874 return s.String()
875 }
876
877 func (s *UpdateRepoBuildRuleResponse) SetHeaders(v map[string]*string) *UpdateRepoBuildRuleResponse {
878 s.Headers = v
879 return s
880 }
881
882 type UpdateRepoWebhookResponse struct {
883 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
884 }
885
886 func (s UpdateRepoWebhookResponse) String() string {
887 return tea.Prettify(s)
888 }
889
890 func (s UpdateRepoWebhookResponse) GoString() string {
891 return s.String()
892 }
893
894 func (s *UpdateRepoWebhookResponse) SetHeaders(v map[string]*string) *UpdateRepoWebhookResponse {
895 s.Headers = v
896 return s
897 }
898
899 type UpdateUserInfoResponse struct {
900 Headers map[string]*string `json:"headers,omitempty" xml:"headers,omitempty" require:"true"`
901 }
902
903 func (s UpdateUserInfoResponse) String() string {
904 return tea.Prettify(s)
905 }
906
907 func (s UpdateUserInfoResponse) GoString() string {
908 return s.String()
909 }
910
911 func (s *UpdateUserInfoResponse) SetHeaders(v map[string]*string) *UpdateUserInfoResponse {
912 s.Headers = v
913 return s
914 }
915
916 type Client struct {
917 openapi.Client
918 }
919
920 func NewClient(config *openapi.Config) (*Client, error) {
921 client := new(Client)
922 err := client.Init(config)
923 return client, err
924 }
925
926 func (client *Client) Init(config *openapi.Config) (_err error) {
927 _err = client.Client.Init(config)
928 if _err != nil {
929 return _err
930 }
931 client.EndpointRule = tea.String("regional")
932 _err = client.CheckConfig(config)
933 if _err != nil {
934 return _err
935 }
936 client.Endpoint, _err = client.GetEndpoint(tea.String("cr"), client.RegionId, client.EndpointRule, client.Network, client.Suffix, client.EndpointMap, client.Endpoint)
937 if _err != nil {
938 return _err
939 }
940
941 return nil
942 }
943
944 func (client *Client) GetEndpoint(productId *string, regionId *string, endpointRule *string, network *string, suffix *string, endpointMap map[string]*string, endpoint *string) (_result *string, _err error) {
945 if !tea.BoolValue(util.Empty(endpoint)) {
946 _result = endpoint
947 return _result, _err
948 }
949
950 if !tea.BoolValue(util.IsUnset(endpointMap)) && !tea.BoolValue(util.Empty(endpointMap[tea.StringValue(regionId)])) {
951 _result = endpointMap[tea.StringValue(regionId)]
952 return _result, _err
953 }
954
955 _body, _err := endpointutil.GetEndpointRules(productId, regionId, endpointRule, network, suffix)
956 if _err != nil {
957 return _result, _err
958 }
959 _result = _body
960 return _result, _err
961 }
962
963 func (client *Client) CancelRepoBuild(RepoNamespace *string, RepoName *string, BuildId *string) (_result *CancelRepoBuildResponse, _err error) {
964 runtime := &util.RuntimeOptions{}
965 headers := make(map[string]*string)
966 _result = &CancelRepoBuildResponse{}
967 _body, _err := client.CancelRepoBuildWithOptions(RepoNamespace, RepoName, BuildId, headers, runtime)
968 if _err != nil {
969 return _result, _err
970 }
971 _result = _body
972 return _result, _err
973 }
974
975 func (client *Client) CancelRepoBuildWithOptions(RepoNamespace *string, RepoName *string, BuildId *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *CancelRepoBuildResponse, _err error) {
976 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
977 RepoName = openapiutil.GetEncodeParam(RepoName)
978 BuildId = openapiutil.GetEncodeParam(BuildId)
979 req := &openapi.OpenApiRequest{
980 Headers: headers,
981 }
982 params := &openapi.Params{
983 Action: tea.String("CancelRepoBuild"),
984 Version: tea.String("2016-06-07"),
985 Protocol: tea.String("HTTPS"),
986 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/build/" + tea.StringValue(BuildId) + "/cancel"),
987 Method: tea.String("POST"),
988 AuthType: tea.String("AK"),
989 Style: tea.String("ROA"),
990 ReqBodyType: tea.String("json"),
991 BodyType: tea.String("none"),
992 }
993 _result = &CancelRepoBuildResponse{}
994 _body, _err := client.CallApi(params, req, runtime)
995 if _err != nil {
996 return _result, _err
997 }
998 _err = tea.Convert(_body, &_result)
999 return _result, _err
1000 }
1001
1002 func (client *Client) CreateNamespace() (_result *CreateNamespaceResponse, _err error) {
1003 runtime := &util.RuntimeOptions{}
1004 headers := make(map[string]*string)
1005 _result = &CreateNamespaceResponse{}
1006 _body, _err := client.CreateNamespaceWithOptions(headers, runtime)
1007 if _err != nil {
1008 return _result, _err
1009 }
1010 _result = _body
1011 return _result, _err
1012 }
1013
1014 func (client *Client) CreateNamespaceWithOptions(headers map[string]*string, runtime *util.RuntimeOptions) (_result *CreateNamespaceResponse, _err error) {
1015 req := &openapi.OpenApiRequest{
1016 Headers: headers,
1017 }
1018 params := &openapi.Params{
1019 Action: tea.String("CreateNamespace"),
1020 Version: tea.String("2016-06-07"),
1021 Protocol: tea.String("HTTPS"),
1022 Pathname: tea.String("/namespace"),
1023 Method: tea.String("PUT"),
1024 AuthType: tea.String("AK"),
1025 Style: tea.String("ROA"),
1026 ReqBodyType: tea.String("json"),
1027 BodyType: tea.String("none"),
1028 }
1029 _result = &CreateNamespaceResponse{}
1030 _body, _err := client.CallApi(params, req, runtime)
1031 if _err != nil {
1032 return _result, _err
1033 }
1034 _err = tea.Convert(_body, &_result)
1035 return _result, _err
1036 }
1037
1038 func (client *Client) CreateRepo() (_result *CreateRepoResponse, _err error) {
1039 runtime := &util.RuntimeOptions{}
1040 headers := make(map[string]*string)
1041 _result = &CreateRepoResponse{}
1042 _body, _err := client.CreateRepoWithOptions(headers, runtime)
1043 if _err != nil {
1044 return _result, _err
1045 }
1046 _result = _body
1047 return _result, _err
1048 }
1049
1050 func (client *Client) CreateRepoWithOptions(headers map[string]*string, runtime *util.RuntimeOptions) (_result *CreateRepoResponse, _err error) {
1051 req := &openapi.OpenApiRequest{
1052 Headers: headers,
1053 }
1054 params := &openapi.Params{
1055 Action: tea.String("CreateRepo"),
1056 Version: tea.String("2016-06-07"),
1057 Protocol: tea.String("HTTPS"),
1058 Pathname: tea.String("/repos"),
1059 Method: tea.String("PUT"),
1060 AuthType: tea.String("AK"),
1061 Style: tea.String("ROA"),
1062 ReqBodyType: tea.String("json"),
1063 BodyType: tea.String("none"),
1064 }
1065 _result = &CreateRepoResponse{}
1066 _body, _err := client.CallApi(params, req, runtime)
1067 if _err != nil {
1068 return _result, _err
1069 }
1070 _err = tea.Convert(_body, &_result)
1071 return _result, _err
1072 }
1073
1074 func (client *Client) CreateRepoBuildRule(RepoNamespace *string, RepoName *string) (_result *CreateRepoBuildRuleResponse, _err error) {
1075 runtime := &util.RuntimeOptions{}
1076 headers := make(map[string]*string)
1077 _result = &CreateRepoBuildRuleResponse{}
1078 _body, _err := client.CreateRepoBuildRuleWithOptions(RepoNamespace, RepoName, headers, runtime)
1079 if _err != nil {
1080 return _result, _err
1081 }
1082 _result = _body
1083 return _result, _err
1084 }
1085
1086 func (client *Client) CreateRepoBuildRuleWithOptions(RepoNamespace *string, RepoName *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *CreateRepoBuildRuleResponse, _err error) {
1087 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1088 RepoName = openapiutil.GetEncodeParam(RepoName)
1089 req := &openapi.OpenApiRequest{
1090 Headers: headers,
1091 }
1092 params := &openapi.Params{
1093 Action: tea.String("CreateRepoBuildRule"),
1094 Version: tea.String("2016-06-07"),
1095 Protocol: tea.String("HTTPS"),
1096 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/rules"),
1097 Method: tea.String("PUT"),
1098 AuthType: tea.String("AK"),
1099 Style: tea.String("ROA"),
1100 ReqBodyType: tea.String("json"),
1101 BodyType: tea.String("none"),
1102 }
1103 _result = &CreateRepoBuildRuleResponse{}
1104 _body, _err := client.CallApi(params, req, runtime)
1105 if _err != nil {
1106 return _result, _err
1107 }
1108 _err = tea.Convert(_body, &_result)
1109 return _result, _err
1110 }
1111
1112 func (client *Client) CreateRepoWebhook(RepoNamespace *string, RepoName *string) (_result *CreateRepoWebhookResponse, _err error) {
1113 runtime := &util.RuntimeOptions{}
1114 headers := make(map[string]*string)
1115 _result = &CreateRepoWebhookResponse{}
1116 _body, _err := client.CreateRepoWebhookWithOptions(RepoNamespace, RepoName, headers, runtime)
1117 if _err != nil {
1118 return _result, _err
1119 }
1120 _result = _body
1121 return _result, _err
1122 }
1123
1124 func (client *Client) CreateRepoWebhookWithOptions(RepoNamespace *string, RepoName *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *CreateRepoWebhookResponse, _err error) {
1125 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1126 RepoName = openapiutil.GetEncodeParam(RepoName)
1127 req := &openapi.OpenApiRequest{
1128 Headers: headers,
1129 }
1130 params := &openapi.Params{
1131 Action: tea.String("CreateRepoWebhook"),
1132 Version: tea.String("2016-06-07"),
1133 Protocol: tea.String("HTTPS"),
1134 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/webhooks"),
1135 Method: tea.String("PUT"),
1136 AuthType: tea.String("AK"),
1137 Style: tea.String("ROA"),
1138 ReqBodyType: tea.String("json"),
1139 BodyType: tea.String("none"),
1140 }
1141 _result = &CreateRepoWebhookResponse{}
1142 _body, _err := client.CallApi(params, req, runtime)
1143 if _err != nil {
1144 return _result, _err
1145 }
1146 _err = tea.Convert(_body, &_result)
1147 return _result, _err
1148 }
1149
1150 func (client *Client) CreateUserInfo() (_result *CreateUserInfoResponse, _err error) {
1151 runtime := &util.RuntimeOptions{}
1152 headers := make(map[string]*string)
1153 _result = &CreateUserInfoResponse{}
1154 _body, _err := client.CreateUserInfoWithOptions(headers, runtime)
1155 if _err != nil {
1156 return _result, _err
1157 }
1158 _result = _body
1159 return _result, _err
1160 }
1161
1162 func (client *Client) CreateUserInfoWithOptions(headers map[string]*string, runtime *util.RuntimeOptions) (_result *CreateUserInfoResponse, _err error) {
1163 req := &openapi.OpenApiRequest{
1164 Headers: headers,
1165 }
1166 params := &openapi.Params{
1167 Action: tea.String("CreateUserInfo"),
1168 Version: tea.String("2016-06-07"),
1169 Protocol: tea.String("HTTPS"),
1170 Pathname: tea.String("/users"),
1171 Method: tea.String("PUT"),
1172 AuthType: tea.String("AK"),
1173 Style: tea.String("ROA"),
1174 ReqBodyType: tea.String("json"),
1175 BodyType: tea.String("none"),
1176 }
1177 _result = &CreateUserInfoResponse{}
1178 _body, _err := client.CallApi(params, req, runtime)
1179 if _err != nil {
1180 return _result, _err
1181 }
1182 _err = tea.Convert(_body, &_result)
1183 return _result, _err
1184 }
1185
1186 func (client *Client) DeleteImage(RepoNamespace *string, RepoName *string, Tag *string) (_result *DeleteImageResponse, _err error) {
1187 runtime := &util.RuntimeOptions{}
1188 headers := make(map[string]*string)
1189 _result = &DeleteImageResponse{}
1190 _body, _err := client.DeleteImageWithOptions(RepoNamespace, RepoName, Tag, headers, runtime)
1191 if _err != nil {
1192 return _result, _err
1193 }
1194 _result = _body
1195 return _result, _err
1196 }
1197
1198 func (client *Client) DeleteImageWithOptions(RepoNamespace *string, RepoName *string, Tag *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *DeleteImageResponse, _err error) {
1199 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1200 RepoName = openapiutil.GetEncodeParam(RepoName)
1201 Tag = openapiutil.GetEncodeParam(Tag)
1202 req := &openapi.OpenApiRequest{
1203 Headers: headers,
1204 }
1205 params := &openapi.Params{
1206 Action: tea.String("DeleteImage"),
1207 Version: tea.String("2016-06-07"),
1208 Protocol: tea.String("HTTPS"),
1209 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/tags/" + tea.StringValue(Tag)),
1210 Method: tea.String("DELETE"),
1211 AuthType: tea.String("AK"),
1212 Style: tea.String("ROA"),
1213 ReqBodyType: tea.String("json"),
1214 BodyType: tea.String("none"),
1215 }
1216 _result = &DeleteImageResponse{}
1217 _body, _err := client.CallApi(params, req, runtime)
1218 if _err != nil {
1219 return _result, _err
1220 }
1221 _err = tea.Convert(_body, &_result)
1222 return _result, _err
1223 }
1224
1225 func (client *Client) DeleteNamespace(Namespace *string) (_result *DeleteNamespaceResponse, _err error) {
1226 runtime := &util.RuntimeOptions{}
1227 headers := make(map[string]*string)
1228 _result = &DeleteNamespaceResponse{}
1229 _body, _err := client.DeleteNamespaceWithOptions(Namespace, headers, runtime)
1230 if _err != nil {
1231 return _result, _err
1232 }
1233 _result = _body
1234 return _result, _err
1235 }
1236
1237 func (client *Client) DeleteNamespaceWithOptions(Namespace *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *DeleteNamespaceResponse, _err error) {
1238 Namespace = openapiutil.GetEncodeParam(Namespace)
1239 req := &openapi.OpenApiRequest{
1240 Headers: headers,
1241 }
1242 params := &openapi.Params{
1243 Action: tea.String("DeleteNamespace"),
1244 Version: tea.String("2016-06-07"),
1245 Protocol: tea.String("HTTPS"),
1246 Pathname: tea.String("/namespace/" + tea.StringValue(Namespace)),
1247 Method: tea.String("DELETE"),
1248 AuthType: tea.String("AK"),
1249 Style: tea.String("ROA"),
1250 ReqBodyType: tea.String("json"),
1251 BodyType: tea.String("none"),
1252 }
1253 _result = &DeleteNamespaceResponse{}
1254 _body, _err := client.CallApi(params, req, runtime)
1255 if _err != nil {
1256 return _result, _err
1257 }
1258 _err = tea.Convert(_body, &_result)
1259 return _result, _err
1260 }
1261
1262 func (client *Client) DeleteRepo(RepoNamespace *string, RepoName *string) (_result *DeleteRepoResponse, _err error) {
1263 runtime := &util.RuntimeOptions{}
1264 headers := make(map[string]*string)
1265 _result = &DeleteRepoResponse{}
1266 _body, _err := client.DeleteRepoWithOptions(RepoNamespace, RepoName, headers, runtime)
1267 if _err != nil {
1268 return _result, _err
1269 }
1270 _result = _body
1271 return _result, _err
1272 }
1273
1274 func (client *Client) DeleteRepoWithOptions(RepoNamespace *string, RepoName *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *DeleteRepoResponse, _err error) {
1275 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1276 RepoName = openapiutil.GetEncodeParam(RepoName)
1277 req := &openapi.OpenApiRequest{
1278 Headers: headers,
1279 }
1280 params := &openapi.Params{
1281 Action: tea.String("DeleteRepo"),
1282 Version: tea.String("2016-06-07"),
1283 Protocol: tea.String("HTTPS"),
1284 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName)),
1285 Method: tea.String("DELETE"),
1286 AuthType: tea.String("AK"),
1287 Style: tea.String("ROA"),
1288 ReqBodyType: tea.String("json"),
1289 BodyType: tea.String("none"),
1290 }
1291 _result = &DeleteRepoResponse{}
1292 _body, _err := client.CallApi(params, req, runtime)
1293 if _err != nil {
1294 return _result, _err
1295 }
1296 _err = tea.Convert(_body, &_result)
1297 return _result, _err
1298 }
1299
1300 func (client *Client) DeleteRepoBuildRule(RepoNamespace *string, RepoName *string, BuildRuleId *string) (_result *DeleteRepoBuildRuleResponse, _err error) {
1301 runtime := &util.RuntimeOptions{}
1302 headers := make(map[string]*string)
1303 _result = &DeleteRepoBuildRuleResponse{}
1304 _body, _err := client.DeleteRepoBuildRuleWithOptions(RepoNamespace, RepoName, BuildRuleId, headers, runtime)
1305 if _err != nil {
1306 return _result, _err
1307 }
1308 _result = _body
1309 return _result, _err
1310 }
1311
1312 func (client *Client) DeleteRepoBuildRuleWithOptions(RepoNamespace *string, RepoName *string, BuildRuleId *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *DeleteRepoBuildRuleResponse, _err error) {
1313 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1314 RepoName = openapiutil.GetEncodeParam(RepoName)
1315 BuildRuleId = openapiutil.GetEncodeParam(BuildRuleId)
1316 req := &openapi.OpenApiRequest{
1317 Headers: headers,
1318 }
1319 params := &openapi.Params{
1320 Action: tea.String("DeleteRepoBuildRule"),
1321 Version: tea.String("2016-06-07"),
1322 Protocol: tea.String("HTTPS"),
1323 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/rules/" + tea.StringValue(BuildRuleId)),
1324 Method: tea.String("DELETE"),
1325 AuthType: tea.String("AK"),
1326 Style: tea.String("ROA"),
1327 ReqBodyType: tea.String("json"),
1328 BodyType: tea.String("none"),
1329 }
1330 _result = &DeleteRepoBuildRuleResponse{}
1331 _body, _err := client.CallApi(params, req, runtime)
1332 if _err != nil {
1333 return _result, _err
1334 }
1335 _err = tea.Convert(_body, &_result)
1336 return _result, _err
1337 }
1338
1339 func (client *Client) DeleteRepoWebhook(RepoNamespace *string, RepoName *string, WebhookId *string) (_result *DeleteRepoWebhookResponse, _err error) {
1340 runtime := &util.RuntimeOptions{}
1341 headers := make(map[string]*string)
1342 _result = &DeleteRepoWebhookResponse{}
1343 _body, _err := client.DeleteRepoWebhookWithOptions(RepoNamespace, RepoName, WebhookId, headers, runtime)
1344 if _err != nil {
1345 return _result, _err
1346 }
1347 _result = _body
1348 return _result, _err
1349 }
1350
1351 func (client *Client) DeleteRepoWebhookWithOptions(RepoNamespace *string, RepoName *string, WebhookId *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *DeleteRepoWebhookResponse, _err error) {
1352 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1353 RepoName = openapiutil.GetEncodeParam(RepoName)
1354 WebhookId = openapiutil.GetEncodeParam(WebhookId)
1355 req := &openapi.OpenApiRequest{
1356 Headers: headers,
1357 }
1358 params := &openapi.Params{
1359 Action: tea.String("DeleteRepoWebhook"),
1360 Version: tea.String("2016-06-07"),
1361 Protocol: tea.String("HTTPS"),
1362 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/webhooks/" + tea.StringValue(WebhookId)),
1363 Method: tea.String("DELETE"),
1364 AuthType: tea.String("AK"),
1365 Style: tea.String("ROA"),
1366 ReqBodyType: tea.String("json"),
1367 BodyType: tea.String("none"),
1368 }
1369 _result = &DeleteRepoWebhookResponse{}
1370 _body, _err := client.CallApi(params, req, runtime)
1371 if _err != nil {
1372 return _result, _err
1373 }
1374 _err = tea.Convert(_body, &_result)
1375 return _result, _err
1376 }
1377
1378 func (client *Client) GetAuthorizationToken() (_result *GetAuthorizationTokenResponse, _err error) {
1379 runtime := &util.RuntimeOptions{}
1380 headers := make(map[string]*string)
1381 _result = &GetAuthorizationTokenResponse{}
1382 _body, _err := client.GetAuthorizationTokenWithOptions(headers, runtime)
1383 if _err != nil {
1384 return _result, _err
1385 }
1386 _result = _body
1387 return _result, _err
1388 }
1389
1390 func (client *Client) GetAuthorizationTokenWithOptions(headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetAuthorizationTokenResponse, _err error) {
1391 req := &openapi.OpenApiRequest{
1392 Headers: headers,
1393 }
1394 params := &openapi.Params{
1395 Action: tea.String("GetAuthorizationToken"),
1396 Version: tea.String("2016-06-07"),
1397 Protocol: tea.String("HTTPS"),
1398 Pathname: tea.String("/tokens"),
1399 Method: tea.String("GET"),
1400 AuthType: tea.String("AK"),
1401 Style: tea.String("ROA"),
1402 ReqBodyType: tea.String("json"),
1403 BodyType: tea.String("none"),
1404 }
1405 _result = &GetAuthorizationTokenResponse{}
1406 _body, _err := client.CallApi(params, req, runtime)
1407 if _err != nil {
1408 return _result, _err
1409 }
1410 _err = tea.Convert(_body, &_result)
1411 return _result, _err
1412 }
1413
1414 func (client *Client) GetImageLayer(RepoNamespace *string, RepoName *string, Tag *string) (_result *GetImageLayerResponse, _err error) {
1415 runtime := &util.RuntimeOptions{}
1416 headers := make(map[string]*string)
1417 _result = &GetImageLayerResponse{}
1418 _body, _err := client.GetImageLayerWithOptions(RepoNamespace, RepoName, Tag, headers, runtime)
1419 if _err != nil {
1420 return _result, _err
1421 }
1422 _result = _body
1423 return _result, _err
1424 }
1425
1426 func (client *Client) GetImageLayerWithOptions(RepoNamespace *string, RepoName *string, Tag *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetImageLayerResponse, _err error) {
1427 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1428 RepoName = openapiutil.GetEncodeParam(RepoName)
1429 Tag = openapiutil.GetEncodeParam(Tag)
1430 req := &openapi.OpenApiRequest{
1431 Headers: headers,
1432 }
1433 params := &openapi.Params{
1434 Action: tea.String("GetImageLayer"),
1435 Version: tea.String("2016-06-07"),
1436 Protocol: tea.String("HTTPS"),
1437 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/tags/" + tea.StringValue(Tag) + "/layers"),
1438 Method: tea.String("GET"),
1439 AuthType: tea.String("AK"),
1440 Style: tea.String("ROA"),
1441 ReqBodyType: tea.String("json"),
1442 BodyType: tea.String("none"),
1443 }
1444 _result = &GetImageLayerResponse{}
1445 _body, _err := client.CallApi(params, req, runtime)
1446 if _err != nil {
1447 return _result, _err
1448 }
1449 _err = tea.Convert(_body, &_result)
1450 return _result, _err
1451 }
1452
1453 func (client *Client) GetImageManifest(RepoNamespace *string, RepoName *string, Tag *string, request *GetImageManifestRequest) (_result *GetImageManifestResponse, _err error) {
1454 runtime := &util.RuntimeOptions{}
1455 headers := make(map[string]*string)
1456 _result = &GetImageManifestResponse{}
1457 _body, _err := client.GetImageManifestWithOptions(RepoNamespace, RepoName, Tag, request, headers, runtime)
1458 if _err != nil {
1459 return _result, _err
1460 }
1461 _result = _body
1462 return _result, _err
1463 }
1464
1465 func (client *Client) GetImageManifestWithOptions(RepoNamespace *string, RepoName *string, Tag *string, request *GetImageManifestRequest, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetImageManifestResponse, _err error) {
1466 _err = util.ValidateModel(request)
1467 if _err != nil {
1468 return _result, _err
1469 }
1470 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1471 RepoName = openapiutil.GetEncodeParam(RepoName)
1472 Tag = openapiutil.GetEncodeParam(Tag)
1473 query := map[string]interface{}{}
1474 if !tea.BoolValue(util.IsUnset(request.SchemaVersion)) {
1475 query["SchemaVersion"] = request.SchemaVersion
1476 }
1477
1478 req := &openapi.OpenApiRequest{
1479 Headers: headers,
1480 Query: openapiutil.Query(query),
1481 }
1482 params := &openapi.Params{
1483 Action: tea.String("GetImageManifest"),
1484 Version: tea.String("2016-06-07"),
1485 Protocol: tea.String("HTTPS"),
1486 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/tags/" + tea.StringValue(Tag) + "/manifest"),
1487 Method: tea.String("GET"),
1488 AuthType: tea.String("AK"),
1489 Style: tea.String("ROA"),
1490 ReqBodyType: tea.String("json"),
1491 BodyType: tea.String("none"),
1492 }
1493 _result = &GetImageManifestResponse{}
1494 _body, _err := client.CallApi(params, req, runtime)
1495 if _err != nil {
1496 return _result, _err
1497 }
1498 _err = tea.Convert(_body, &_result)
1499 return _result, _err
1500 }
1501
1502 func (client *Client) GetNamespace(Namespace *string) (_result *GetNamespaceResponse, _err error) {
1503 runtime := &util.RuntimeOptions{}
1504 headers := make(map[string]*string)
1505 _result = &GetNamespaceResponse{}
1506 _body, _err := client.GetNamespaceWithOptions(Namespace, headers, runtime)
1507 if _err != nil {
1508 return _result, _err
1509 }
1510 _result = _body
1511 return _result, _err
1512 }
1513
1514 func (client *Client) GetNamespaceWithOptions(Namespace *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetNamespaceResponse, _err error) {
1515 Namespace = openapiutil.GetEncodeParam(Namespace)
1516 req := &openapi.OpenApiRequest{
1517 Headers: headers,
1518 }
1519 params := &openapi.Params{
1520 Action: tea.String("GetNamespace"),
1521 Version: tea.String("2016-06-07"),
1522 Protocol: tea.String("HTTPS"),
1523 Pathname: tea.String("/namespace/" + tea.StringValue(Namespace)),
1524 Method: tea.String("GET"),
1525 AuthType: tea.String("AK"),
1526 Style: tea.String("ROA"),
1527 ReqBodyType: tea.String("json"),
1528 BodyType: tea.String("none"),
1529 }
1530 _result = &GetNamespaceResponse{}
1531 _body, _err := client.CallApi(params, req, runtime)
1532 if _err != nil {
1533 return _result, _err
1534 }
1535 _err = tea.Convert(_body, &_result)
1536 return _result, _err
1537 }
1538
1539 func (client *Client) GetNamespaceList(request *GetNamespaceListRequest) (_result *GetNamespaceListResponse, _err error) {
1540 runtime := &util.RuntimeOptions{}
1541 headers := make(map[string]*string)
1542 _result = &GetNamespaceListResponse{}
1543 _body, _err := client.GetNamespaceListWithOptions(request, headers, runtime)
1544 if _err != nil {
1545 return _result, _err
1546 }
1547 _result = _body
1548 return _result, _err
1549 }
1550
1551 func (client *Client) GetNamespaceListWithOptions(request *GetNamespaceListRequest, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetNamespaceListResponse, _err error) {
1552 _err = util.ValidateModel(request)
1553 if _err != nil {
1554 return _result, _err
1555 }
1556 query := map[string]interface{}{}
1557 if !tea.BoolValue(util.IsUnset(request.Authorize)) {
1558 query["Authorize"] = request.Authorize
1559 }
1560
1561 if !tea.BoolValue(util.IsUnset(request.Status)) {
1562 query["Status"] = request.Status
1563 }
1564
1565 req := &openapi.OpenApiRequest{
1566 Headers: headers,
1567 Query: openapiutil.Query(query),
1568 }
1569 params := &openapi.Params{
1570 Action: tea.String("GetNamespaceList"),
1571 Version: tea.String("2016-06-07"),
1572 Protocol: tea.String("HTTPS"),
1573 Pathname: tea.String("/namespace"),
1574 Method: tea.String("GET"),
1575 AuthType: tea.String("AK"),
1576 Style: tea.String("ROA"),
1577 ReqBodyType: tea.String("json"),
1578 BodyType: tea.String("none"),
1579 }
1580 _result = &GetNamespaceListResponse{}
1581 _body, _err := client.CallApi(params, req, runtime)
1582 if _err != nil {
1583 return _result, _err
1584 }
1585 _err = tea.Convert(_body, &_result)
1586 return _result, _err
1587 }
1588
1589 func (client *Client) GetRegion(request *GetRegionRequest) (_result *GetRegionResponse, _err error) {
1590 runtime := &util.RuntimeOptions{}
1591 headers := make(map[string]*string)
1592 _result = &GetRegionResponse{}
1593 _body, _err := client.GetRegionWithOptions(request, headers, runtime)
1594 if _err != nil {
1595 return _result, _err
1596 }
1597 _result = _body
1598 return _result, _err
1599 }
1600
1601 func (client *Client) GetRegionWithOptions(request *GetRegionRequest, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRegionResponse, _err error) {
1602 _err = util.ValidateModel(request)
1603 if _err != nil {
1604 return _result, _err
1605 }
1606 query := map[string]interface{}{}
1607 if !tea.BoolValue(util.IsUnset(request.Domain)) {
1608 query["Domain"] = request.Domain
1609 }
1610
1611 req := &openapi.OpenApiRequest{
1612 Headers: headers,
1613 Query: openapiutil.Query(query),
1614 }
1615 params := &openapi.Params{
1616 Action: tea.String("GetRegion"),
1617 Version: tea.String("2016-06-07"),
1618 Protocol: tea.String("HTTPS"),
1619 Pathname: tea.String("/regions"),
1620 Method: tea.String("GET"),
1621 AuthType: tea.String("AK"),
1622 Style: tea.String("ROA"),
1623 ReqBodyType: tea.String("json"),
1624 BodyType: tea.String("none"),
1625 }
1626 _result = &GetRegionResponse{}
1627 _body, _err := client.CallApi(params, req, runtime)
1628 if _err != nil {
1629 return _result, _err
1630 }
1631 _err = tea.Convert(_body, &_result)
1632 return _result, _err
1633 }
1634
1635 func (client *Client) GetRegionList() (_result *GetRegionListResponse, _err error) {
1636 runtime := &util.RuntimeOptions{}
1637 headers := make(map[string]*string)
1638 _result = &GetRegionListResponse{}
1639 _body, _err := client.GetRegionListWithOptions(headers, runtime)
1640 if _err != nil {
1641 return _result, _err
1642 }
1643 _result = _body
1644 return _result, _err
1645 }
1646
1647 func (client *Client) GetRegionListWithOptions(headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRegionListResponse, _err error) {
1648 req := &openapi.OpenApiRequest{
1649 Headers: headers,
1650 }
1651 params := &openapi.Params{
1652 Action: tea.String("GetRegionList"),
1653 Version: tea.String("2016-06-07"),
1654 Protocol: tea.String("HTTPS"),
1655 Pathname: tea.String("/regions"),
1656 Method: tea.String("GET"),
1657 AuthType: tea.String("AK"),
1658 Style: tea.String("ROA"),
1659 ReqBodyType: tea.String("json"),
1660 BodyType: tea.String("none"),
1661 }
1662 _result = &GetRegionListResponse{}
1663 _body, _err := client.CallApi(params, req, runtime)
1664 if _err != nil {
1665 return _result, _err
1666 }
1667 _err = tea.Convert(_body, &_result)
1668 return _result, _err
1669 }
1670
1671 func (client *Client) GetRepo(RepoNamespace *string, RepoName *string) (_result *GetRepoResponse, _err error) {
1672 runtime := &util.RuntimeOptions{}
1673 headers := make(map[string]*string)
1674 _result = &GetRepoResponse{}
1675 _body, _err := client.GetRepoWithOptions(RepoNamespace, RepoName, headers, runtime)
1676 if _err != nil {
1677 return _result, _err
1678 }
1679 _result = _body
1680 return _result, _err
1681 }
1682
1683 func (client *Client) GetRepoWithOptions(RepoNamespace *string, RepoName *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRepoResponse, _err error) {
1684 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1685 RepoName = openapiutil.GetEncodeParam(RepoName)
1686 req := &openapi.OpenApiRequest{
1687 Headers: headers,
1688 }
1689 params := &openapi.Params{
1690 Action: tea.String("GetRepo"),
1691 Version: tea.String("2016-06-07"),
1692 Protocol: tea.String("HTTPS"),
1693 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName)),
1694 Method: tea.String("GET"),
1695 AuthType: tea.String("AK"),
1696 Style: tea.String("ROA"),
1697 ReqBodyType: tea.String("json"),
1698 BodyType: tea.String("none"),
1699 }
1700 _result = &GetRepoResponse{}
1701 _body, _err := client.CallApi(params, req, runtime)
1702 if _err != nil {
1703 return _result, _err
1704 }
1705 _err = tea.Convert(_body, &_result)
1706 return _result, _err
1707 }
1708
1709 func (client *Client) GetRepoBuildList(RepoNamespace *string, RepoName *string, request *GetRepoBuildListRequest) (_result *GetRepoBuildListResponse, _err error) {
1710 runtime := &util.RuntimeOptions{}
1711 headers := make(map[string]*string)
1712 _result = &GetRepoBuildListResponse{}
1713 _body, _err := client.GetRepoBuildListWithOptions(RepoNamespace, RepoName, request, headers, runtime)
1714 if _err != nil {
1715 return _result, _err
1716 }
1717 _result = _body
1718 return _result, _err
1719 }
1720
1721 func (client *Client) GetRepoBuildListWithOptions(RepoNamespace *string, RepoName *string, request *GetRepoBuildListRequest, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRepoBuildListResponse, _err error) {
1722 _err = util.ValidateModel(request)
1723 if _err != nil {
1724 return _result, _err
1725 }
1726 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1727 RepoName = openapiutil.GetEncodeParam(RepoName)
1728 query := map[string]interface{}{}
1729 if !tea.BoolValue(util.IsUnset(request.Page)) {
1730 query["Page"] = request.Page
1731 }
1732
1733 if !tea.BoolValue(util.IsUnset(request.PageSize)) {
1734 query["PageSize"] = request.PageSize
1735 }
1736
1737 req := &openapi.OpenApiRequest{
1738 Headers: headers,
1739 Query: openapiutil.Query(query),
1740 }
1741 params := &openapi.Params{
1742 Action: tea.String("GetRepoBuildList"),
1743 Version: tea.String("2016-06-07"),
1744 Protocol: tea.String("HTTPS"),
1745 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/build"),
1746 Method: tea.String("GET"),
1747 AuthType: tea.String("AK"),
1748 Style: tea.String("ROA"),
1749 ReqBodyType: tea.String("json"),
1750 BodyType: tea.String("none"),
1751 }
1752 _result = &GetRepoBuildListResponse{}
1753 _body, _err := client.CallApi(params, req, runtime)
1754 if _err != nil {
1755 return _result, _err
1756 }
1757 _err = tea.Convert(_body, &_result)
1758 return _result, _err
1759 }
1760
1761 func (client *Client) GetRepoBuildRuleList(RepoNamespace *string, RepoName *string) (_result *GetRepoBuildRuleListResponse, _err error) {
1762 runtime := &util.RuntimeOptions{}
1763 headers := make(map[string]*string)
1764 _result = &GetRepoBuildRuleListResponse{}
1765 _body, _err := client.GetRepoBuildRuleListWithOptions(RepoNamespace, RepoName, headers, runtime)
1766 if _err != nil {
1767 return _result, _err
1768 }
1769 _result = _body
1770 return _result, _err
1771 }
1772
1773 func (client *Client) GetRepoBuildRuleListWithOptions(RepoNamespace *string, RepoName *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRepoBuildRuleListResponse, _err error) {
1774 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1775 RepoName = openapiutil.GetEncodeParam(RepoName)
1776 req := &openapi.OpenApiRequest{
1777 Headers: headers,
1778 }
1779 params := &openapi.Params{
1780 Action: tea.String("GetRepoBuildRuleList"),
1781 Version: tea.String("2016-06-07"),
1782 Protocol: tea.String("HTTPS"),
1783 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/rules"),
1784 Method: tea.String("GET"),
1785 AuthType: tea.String("AK"),
1786 Style: tea.String("ROA"),
1787 ReqBodyType: tea.String("json"),
1788 BodyType: tea.String("none"),
1789 }
1790 _result = &GetRepoBuildRuleListResponse{}
1791 _body, _err := client.CallApi(params, req, runtime)
1792 if _err != nil {
1793 return _result, _err
1794 }
1795 _err = tea.Convert(_body, &_result)
1796 return _result, _err
1797 }
1798
1799 func (client *Client) GetRepoBuildStatus(RepoNamespace *string, RepoName *string, BuildId *string) (_result *GetRepoBuildStatusResponse, _err error) {
1800 runtime := &util.RuntimeOptions{}
1801 headers := make(map[string]*string)
1802 _result = &GetRepoBuildStatusResponse{}
1803 _body, _err := client.GetRepoBuildStatusWithOptions(RepoNamespace, RepoName, BuildId, headers, runtime)
1804 if _err != nil {
1805 return _result, _err
1806 }
1807 _result = _body
1808 return _result, _err
1809 }
1810
1811 func (client *Client) GetRepoBuildStatusWithOptions(RepoNamespace *string, RepoName *string, BuildId *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRepoBuildStatusResponse, _err error) {
1812 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1813 RepoName = openapiutil.GetEncodeParam(RepoName)
1814 BuildId = openapiutil.GetEncodeParam(BuildId)
1815 req := &openapi.OpenApiRequest{
1816 Headers: headers,
1817 }
1818 params := &openapi.Params{
1819 Action: tea.String("GetRepoBuildStatus"),
1820 Version: tea.String("2016-06-07"),
1821 Protocol: tea.String("HTTPS"),
1822 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/build/" + tea.StringValue(BuildId) + "/status"),
1823 Method: tea.String("GET"),
1824 AuthType: tea.String("AK"),
1825 Style: tea.String("ROA"),
1826 ReqBodyType: tea.String("json"),
1827 BodyType: tea.String("none"),
1828 }
1829 _result = &GetRepoBuildStatusResponse{}
1830 _body, _err := client.CallApi(params, req, runtime)
1831 if _err != nil {
1832 return _result, _err
1833 }
1834 _err = tea.Convert(_body, &_result)
1835 return _result, _err
1836 }
1837
1838 func (client *Client) GetRepoList(request *GetRepoListRequest) (_result *GetRepoListResponse, _err error) {
1839 runtime := &util.RuntimeOptions{}
1840 headers := make(map[string]*string)
1841 _result = &GetRepoListResponse{}
1842 _body, _err := client.GetRepoListWithOptions(request, headers, runtime)
1843 if _err != nil {
1844 return _result, _err
1845 }
1846 _result = _body
1847 return _result, _err
1848 }
1849
1850 func (client *Client) GetRepoListWithOptions(request *GetRepoListRequest, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRepoListResponse, _err error) {
1851 _err = util.ValidateModel(request)
1852 if _err != nil {
1853 return _result, _err
1854 }
1855 query := map[string]interface{}{}
1856 if !tea.BoolValue(util.IsUnset(request.Page)) {
1857 query["Page"] = request.Page
1858 }
1859
1860 if !tea.BoolValue(util.IsUnset(request.PageSize)) {
1861 query["PageSize"] = request.PageSize
1862 }
1863
1864 if !tea.BoolValue(util.IsUnset(request.Status)) {
1865 query["Status"] = request.Status
1866 }
1867
1868 req := &openapi.OpenApiRequest{
1869 Headers: headers,
1870 Query: openapiutil.Query(query),
1871 }
1872 params := &openapi.Params{
1873 Action: tea.String("GetRepoList"),
1874 Version: tea.String("2016-06-07"),
1875 Protocol: tea.String("HTTPS"),
1876 Pathname: tea.String("/repos"),
1877 Method: tea.String("GET"),
1878 AuthType: tea.String("AK"),
1879 Style: tea.String("ROA"),
1880 ReqBodyType: tea.String("json"),
1881 BodyType: tea.String("none"),
1882 }
1883 _result = &GetRepoListResponse{}
1884 _body, _err := client.CallApi(params, req, runtime)
1885 if _err != nil {
1886 return _result, _err
1887 }
1888 _err = tea.Convert(_body, &_result)
1889 return _result, _err
1890 }
1891
1892 func (client *Client) GetRepoListByNamespace(RepoNamespace *string, request *GetRepoListByNamespaceRequest) (_result *GetRepoListByNamespaceResponse, _err error) {
1893 runtime := &util.RuntimeOptions{}
1894 headers := make(map[string]*string)
1895 _result = &GetRepoListByNamespaceResponse{}
1896 _body, _err := client.GetRepoListByNamespaceWithOptions(RepoNamespace, request, headers, runtime)
1897 if _err != nil {
1898 return _result, _err
1899 }
1900 _result = _body
1901 return _result, _err
1902 }
1903
1904 func (client *Client) GetRepoListByNamespaceWithOptions(RepoNamespace *string, request *GetRepoListByNamespaceRequest, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRepoListByNamespaceResponse, _err error) {
1905 _err = util.ValidateModel(request)
1906 if _err != nil {
1907 return _result, _err
1908 }
1909 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1910 query := map[string]interface{}{}
1911 if !tea.BoolValue(util.IsUnset(request.Page)) {
1912 query["Page"] = request.Page
1913 }
1914
1915 if !tea.BoolValue(util.IsUnset(request.PageSize)) {
1916 query["PageSize"] = request.PageSize
1917 }
1918
1919 if !tea.BoolValue(util.IsUnset(request.Status)) {
1920 query["Status"] = request.Status
1921 }
1922
1923 req := &openapi.OpenApiRequest{
1924 Headers: headers,
1925 Query: openapiutil.Query(query),
1926 }
1927 params := &openapi.Params{
1928 Action: tea.String("GetRepoListByNamespace"),
1929 Version: tea.String("2016-06-07"),
1930 Protocol: tea.String("HTTPS"),
1931 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace)),
1932 Method: tea.String("GET"),
1933 AuthType: tea.String("AK"),
1934 Style: tea.String("ROA"),
1935 ReqBodyType: tea.String("json"),
1936 BodyType: tea.String("none"),
1937 }
1938 _result = &GetRepoListByNamespaceResponse{}
1939 _body, _err := client.CallApi(params, req, runtime)
1940 if _err != nil {
1941 return _result, _err
1942 }
1943 _err = tea.Convert(_body, &_result)
1944 return _result, _err
1945 }
1946
1947 func (client *Client) GetRepoTag(RepoNamespace *string, RepoName *string, Tag *string) (_result *GetRepoTagResponse, _err error) {
1948 runtime := &util.RuntimeOptions{}
1949 headers := make(map[string]*string)
1950 _result = &GetRepoTagResponse{}
1951 _body, _err := client.GetRepoTagWithOptions(RepoNamespace, RepoName, Tag, headers, runtime)
1952 if _err != nil {
1953 return _result, _err
1954 }
1955 _result = _body
1956 return _result, _err
1957 }
1958
1959 func (client *Client) GetRepoTagWithOptions(RepoNamespace *string, RepoName *string, Tag *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRepoTagResponse, _err error) {
1960 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
1961 RepoName = openapiutil.GetEncodeParam(RepoName)
1962 Tag = openapiutil.GetEncodeParam(Tag)
1963 req := &openapi.OpenApiRequest{
1964 Headers: headers,
1965 }
1966 params := &openapi.Params{
1967 Action: tea.String("GetRepoTag"),
1968 Version: tea.String("2016-06-07"),
1969 Protocol: tea.String("HTTPS"),
1970 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/tags/" + tea.StringValue(Tag)),
1971 Method: tea.String("GET"),
1972 AuthType: tea.String("AK"),
1973 Style: tea.String("ROA"),
1974 ReqBodyType: tea.String("json"),
1975 BodyType: tea.String("json"),
1976 }
1977 _result = &GetRepoTagResponse{}
1978 _body, _err := client.CallApi(params, req, runtime)
1979 if _err != nil {
1980 return _result, _err
1981 }
1982 _err = tea.Convert(_body, &_result)
1983 return _result, _err
1984 }
1985
1986 func (client *Client) GetRepoTagScanList(RepoNamespace *string, RepoName *string, Tag *string, request *GetRepoTagScanListRequest) (_result *GetRepoTagScanListResponse, _err error) {
1987 runtime := &util.RuntimeOptions{}
1988 headers := make(map[string]*string)
1989 _result = &GetRepoTagScanListResponse{}
1990 _body, _err := client.GetRepoTagScanListWithOptions(RepoNamespace, RepoName, Tag, request, headers, runtime)
1991 if _err != nil {
1992 return _result, _err
1993 }
1994 _result = _body
1995 return _result, _err
1996 }
1997
1998 func (client *Client) GetRepoTagScanListWithOptions(RepoNamespace *string, RepoName *string, Tag *string, request *GetRepoTagScanListRequest, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRepoTagScanListResponse, _err error) {
1999 _err = util.ValidateModel(request)
2000 if _err != nil {
2001 return _result, _err
2002 }
2003 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
2004 RepoName = openapiutil.GetEncodeParam(RepoName)
2005 Tag = openapiutil.GetEncodeParam(Tag)
2006 query := map[string]interface{}{}
2007 if !tea.BoolValue(util.IsUnset(request.Page)) {
2008 query["Page"] = request.Page
2009 }
2010
2011 if !tea.BoolValue(util.IsUnset(request.PageSize)) {
2012 query["PageSize"] = request.PageSize
2013 }
2014
2015 if !tea.BoolValue(util.IsUnset(request.Severity)) {
2016 query["Severity"] = request.Severity
2017 }
2018
2019 req := &openapi.OpenApiRequest{
2020 Headers: headers,
2021 Query: openapiutil.Query(query),
2022 }
2023 params := &openapi.Params{
2024 Action: tea.String("GetRepoTagScanList"),
2025 Version: tea.String("2016-06-07"),
2026 Protocol: tea.String("HTTPS"),
2027 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/tags/" + tea.StringValue(Tag) + "/scanResult"),
2028 Method: tea.String("GET"),
2029 AuthType: tea.String("AK"),
2030 Style: tea.String("ROA"),
2031 ReqBodyType: tea.String("json"),
2032 BodyType: tea.String("none"),
2033 }
2034 _result = &GetRepoTagScanListResponse{}
2035 _body, _err := client.CallApi(params, req, runtime)
2036 if _err != nil {
2037 return _result, _err
2038 }
2039 _err = tea.Convert(_body, &_result)
2040 return _result, _err
2041 }
2042
2043 func (client *Client) GetRepoTagScanStatus(RepoNamespace *string, RepoName *string, Tag *string) (_result *GetRepoTagScanStatusResponse, _err error) {
2044 runtime := &util.RuntimeOptions{}
2045 headers := make(map[string]*string)
2046 _result = &GetRepoTagScanStatusResponse{}
2047 _body, _err := client.GetRepoTagScanStatusWithOptions(RepoNamespace, RepoName, Tag, headers, runtime)
2048 if _err != nil {
2049 return _result, _err
2050 }
2051 _result = _body
2052 return _result, _err
2053 }
2054
2055 func (client *Client) GetRepoTagScanStatusWithOptions(RepoNamespace *string, RepoName *string, Tag *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRepoTagScanStatusResponse, _err error) {
2056 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
2057 RepoName = openapiutil.GetEncodeParam(RepoName)
2058 Tag = openapiutil.GetEncodeParam(Tag)
2059 req := &openapi.OpenApiRequest{
2060 Headers: headers,
2061 }
2062 params := &openapi.Params{
2063 Action: tea.String("GetRepoTagScanStatus"),
2064 Version: tea.String("2016-06-07"),
2065 Protocol: tea.String("HTTPS"),
2066 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/tags/" + tea.StringValue(Tag) + "/scanStatus"),
2067 Method: tea.String("GET"),
2068 AuthType: tea.String("AK"),
2069 Style: tea.String("ROA"),
2070 ReqBodyType: tea.String("json"),
2071 BodyType: tea.String("none"),
2072 }
2073 _result = &GetRepoTagScanStatusResponse{}
2074 _body, _err := client.CallApi(params, req, runtime)
2075 if _err != nil {
2076 return _result, _err
2077 }
2078 _err = tea.Convert(_body, &_result)
2079 return _result, _err
2080 }
2081
2082 func (client *Client) GetRepoTagScanSummary(RepoNamespace *string, RepoName *string, Tag *string) (_result *GetRepoTagScanSummaryResponse, _err error) {
2083 runtime := &util.RuntimeOptions{}
2084 headers := make(map[string]*string)
2085 _result = &GetRepoTagScanSummaryResponse{}
2086 _body, _err := client.GetRepoTagScanSummaryWithOptions(RepoNamespace, RepoName, Tag, headers, runtime)
2087 if _err != nil {
2088 return _result, _err
2089 }
2090 _result = _body
2091 return _result, _err
2092 }
2093
2094 func (client *Client) GetRepoTagScanSummaryWithOptions(RepoNamespace *string, RepoName *string, Tag *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRepoTagScanSummaryResponse, _err error) {
2095 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
2096 RepoName = openapiutil.GetEncodeParam(RepoName)
2097 Tag = openapiutil.GetEncodeParam(Tag)
2098 req := &openapi.OpenApiRequest{
2099 Headers: headers,
2100 }
2101 params := &openapi.Params{
2102 Action: tea.String("GetRepoTagScanSummary"),
2103 Version: tea.String("2016-06-07"),
2104 Protocol: tea.String("HTTPS"),
2105 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/tags/" + tea.StringValue(Tag) + "/scanCount"),
2106 Method: tea.String("GET"),
2107 AuthType: tea.String("AK"),
2108 Style: tea.String("ROA"),
2109 ReqBodyType: tea.String("json"),
2110 BodyType: tea.String("none"),
2111 }
2112 _result = &GetRepoTagScanSummaryResponse{}
2113 _body, _err := client.CallApi(params, req, runtime)
2114 if _err != nil {
2115 return _result, _err
2116 }
2117 _err = tea.Convert(_body, &_result)
2118 return _result, _err
2119 }
2120
2121 func (client *Client) GetRepoTags(RepoNamespace *string, RepoName *string, request *GetRepoTagsRequest) (_result *GetRepoTagsResponse, _err error) {
2122 runtime := &util.RuntimeOptions{}
2123 headers := make(map[string]*string)
2124 _result = &GetRepoTagsResponse{}
2125 _body, _err := client.GetRepoTagsWithOptions(RepoNamespace, RepoName, request, headers, runtime)
2126 if _err != nil {
2127 return _result, _err
2128 }
2129 _result = _body
2130 return _result, _err
2131 }
2132
2133 func (client *Client) GetRepoTagsWithOptions(RepoNamespace *string, RepoName *string, request *GetRepoTagsRequest, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRepoTagsResponse, _err error) {
2134 _err = util.ValidateModel(request)
2135 if _err != nil {
2136 return _result, _err
2137 }
2138 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
2139 RepoName = openapiutil.GetEncodeParam(RepoName)
2140 query := map[string]interface{}{}
2141 if !tea.BoolValue(util.IsUnset(request.Page)) {
2142 query["Page"] = request.Page
2143 }
2144
2145 if !tea.BoolValue(util.IsUnset(request.PageSize)) {
2146 query["PageSize"] = request.PageSize
2147 }
2148
2149 req := &openapi.OpenApiRequest{
2150 Headers: headers,
2151 Query: openapiutil.Query(query),
2152 }
2153 params := &openapi.Params{
2154 Action: tea.String("GetRepoTags"),
2155 Version: tea.String("2016-06-07"),
2156 Protocol: tea.String("HTTPS"),
2157 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/tags"),
2158 Method: tea.String("GET"),
2159 AuthType: tea.String("AK"),
2160 Style: tea.String("ROA"),
2161 ReqBodyType: tea.String("json"),
2162 BodyType: tea.String("none"),
2163 }
2164 _result = &GetRepoTagsResponse{}
2165 _body, _err := client.CallApi(params, req, runtime)
2166 if _err != nil {
2167 return _result, _err
2168 }
2169 _err = tea.Convert(_body, &_result)
2170 return _result, _err
2171 }
2172
2173 func (client *Client) GetRepoWebhook(RepoNamespace *string, RepoName *string) (_result *GetRepoWebhookResponse, _err error) {
2174 runtime := &util.RuntimeOptions{}
2175 headers := make(map[string]*string)
2176 _result = &GetRepoWebhookResponse{}
2177 _body, _err := client.GetRepoWebhookWithOptions(RepoNamespace, RepoName, headers, runtime)
2178 if _err != nil {
2179 return _result, _err
2180 }
2181 _result = _body
2182 return _result, _err
2183 }
2184
2185 func (client *Client) GetRepoWebhookWithOptions(RepoNamespace *string, RepoName *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetRepoWebhookResponse, _err error) {
2186 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
2187 RepoName = openapiutil.GetEncodeParam(RepoName)
2188 req := &openapi.OpenApiRequest{
2189 Headers: headers,
2190 }
2191 params := &openapi.Params{
2192 Action: tea.String("GetRepoWebhook"),
2193 Version: tea.String("2016-06-07"),
2194 Protocol: tea.String("HTTPS"),
2195 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/webhooks"),
2196 Method: tea.String("GET"),
2197 AuthType: tea.String("AK"),
2198 Style: tea.String("ROA"),
2199 ReqBodyType: tea.String("json"),
2200 BodyType: tea.String("none"),
2201 }
2202 _result = &GetRepoWebhookResponse{}
2203 _body, _err := client.CallApi(params, req, runtime)
2204 if _err != nil {
2205 return _result, _err
2206 }
2207 _err = tea.Convert(_body, &_result)
2208 return _result, _err
2209 }
2210
2211 func (client *Client) GetResourceQuota(ResourceName *string) (_result *GetResourceQuotaResponse, _err error) {
2212 runtime := &util.RuntimeOptions{}
2213 headers := make(map[string]*string)
2214 _result = &GetResourceQuotaResponse{}
2215 _body, _err := client.GetResourceQuotaWithOptions(ResourceName, headers, runtime)
2216 if _err != nil {
2217 return _result, _err
2218 }
2219 _result = _body
2220 return _result, _err
2221 }
2222
2223 func (client *Client) GetResourceQuotaWithOptions(ResourceName *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *GetResourceQuotaResponse, _err error) {
2224 ResourceName = openapiutil.GetEncodeParam(ResourceName)
2225 req := &openapi.OpenApiRequest{
2226 Headers: headers,
2227 }
2228 params := &openapi.Params{
2229 Action: tea.String("GetResourceQuota"),
2230 Version: tea.String("2016-06-07"),
2231 Protocol: tea.String("HTTPS"),
2232 Pathname: tea.String("/resource/" + tea.StringValue(ResourceName)),
2233 Method: tea.String("GET"),
2234 AuthType: tea.String("AK"),
2235 Style: tea.String("ROA"),
2236 ReqBodyType: tea.String("json"),
2237 BodyType: tea.String("none"),
2238 }
2239 _result = &GetResourceQuotaResponse{}
2240 _body, _err := client.CallApi(params, req, runtime)
2241 if _err != nil {
2242 return _result, _err
2243 }
2244 _err = tea.Convert(_body, &_result)
2245 return _result, _err
2246 }
2247
2248 func (client *Client) StartImageScan(RepoNamespace *string, RepoName *string, Tag *string) (_result *StartImageScanResponse, _err error) {
2249 runtime := &util.RuntimeOptions{}
2250 headers := make(map[string]*string)
2251 _result = &StartImageScanResponse{}
2252 _body, _err := client.StartImageScanWithOptions(RepoNamespace, RepoName, Tag, headers, runtime)
2253 if _err != nil {
2254 return _result, _err
2255 }
2256 _result = _body
2257 return _result, _err
2258 }
2259
2260 func (client *Client) StartImageScanWithOptions(RepoNamespace *string, RepoName *string, Tag *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *StartImageScanResponse, _err error) {
2261 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
2262 RepoName = openapiutil.GetEncodeParam(RepoName)
2263 Tag = openapiutil.GetEncodeParam(Tag)
2264 req := &openapi.OpenApiRequest{
2265 Headers: headers,
2266 }
2267 params := &openapi.Params{
2268 Action: tea.String("StartImageScan"),
2269 Version: tea.String("2016-06-07"),
2270 Protocol: tea.String("HTTPS"),
2271 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/tags/" + tea.StringValue(Tag) + "/scan"),
2272 Method: tea.String("PUT"),
2273 AuthType: tea.String("AK"),
2274 Style: tea.String("ROA"),
2275 ReqBodyType: tea.String("json"),
2276 BodyType: tea.String("none"),
2277 }
2278 _result = &StartImageScanResponse{}
2279 _body, _err := client.CallApi(params, req, runtime)
2280 if _err != nil {
2281 return _result, _err
2282 }
2283 _err = tea.Convert(_body, &_result)
2284 return _result, _err
2285 }
2286
2287 func (client *Client) StartRepoBuildByRule(RepoNamespace *string, RepoName *string, BuildRuleId *string) (_result *StartRepoBuildByRuleResponse, _err error) {
2288 runtime := &util.RuntimeOptions{}
2289 headers := make(map[string]*string)
2290 _result = &StartRepoBuildByRuleResponse{}
2291 _body, _err := client.StartRepoBuildByRuleWithOptions(RepoNamespace, RepoName, BuildRuleId, headers, runtime)
2292 if _err != nil {
2293 return _result, _err
2294 }
2295 _result = _body
2296 return _result, _err
2297 }
2298
2299 func (client *Client) StartRepoBuildByRuleWithOptions(RepoNamespace *string, RepoName *string, BuildRuleId *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *StartRepoBuildByRuleResponse, _err error) {
2300 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
2301 RepoName = openapiutil.GetEncodeParam(RepoName)
2302 BuildRuleId = openapiutil.GetEncodeParam(BuildRuleId)
2303 req := &openapi.OpenApiRequest{
2304 Headers: headers,
2305 }
2306 params := &openapi.Params{
2307 Action: tea.String("StartRepoBuildByRule"),
2308 Version: tea.String("2016-06-07"),
2309 Protocol: tea.String("HTTPS"),
2310 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/rules/" + tea.StringValue(BuildRuleId) + "/build"),
2311 Method: tea.String("PUT"),
2312 AuthType: tea.String("AK"),
2313 Style: tea.String("ROA"),
2314 ReqBodyType: tea.String("json"),
2315 BodyType: tea.String("none"),
2316 }
2317 _result = &StartRepoBuildByRuleResponse{}
2318 _body, _err := client.CallApi(params, req, runtime)
2319 if _err != nil {
2320 return _result, _err
2321 }
2322 _err = tea.Convert(_body, &_result)
2323 return _result, _err
2324 }
2325
2326 func (client *Client) UpdateNamespace(Namespace *string) (_result *UpdateNamespaceResponse, _err error) {
2327 runtime := &util.RuntimeOptions{}
2328 headers := make(map[string]*string)
2329 _result = &UpdateNamespaceResponse{}
2330 _body, _err := client.UpdateNamespaceWithOptions(Namespace, headers, runtime)
2331 if _err != nil {
2332 return _result, _err
2333 }
2334 _result = _body
2335 return _result, _err
2336 }
2337
2338 func (client *Client) UpdateNamespaceWithOptions(Namespace *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *UpdateNamespaceResponse, _err error) {
2339 Namespace = openapiutil.GetEncodeParam(Namespace)
2340 req := &openapi.OpenApiRequest{
2341 Headers: headers,
2342 }
2343 params := &openapi.Params{
2344 Action: tea.String("UpdateNamespace"),
2345 Version: tea.String("2016-06-07"),
2346 Protocol: tea.String("HTTPS"),
2347 Pathname: tea.String("/namespace/" + tea.StringValue(Namespace)),
2348 Method: tea.String("POST"),
2349 AuthType: tea.String("AK"),
2350 Style: tea.String("ROA"),
2351 ReqBodyType: tea.String("json"),
2352 BodyType: tea.String("none"),
2353 }
2354 _result = &UpdateNamespaceResponse{}
2355 _body, _err := client.CallApi(params, req, runtime)
2356 if _err != nil {
2357 return _result, _err
2358 }
2359 _err = tea.Convert(_body, &_result)
2360 return _result, _err
2361 }
2362
2363 func (client *Client) UpdateRepo(RepoNamespace *string, RepoName *string) (_result *UpdateRepoResponse, _err error) {
2364 runtime := &util.RuntimeOptions{}
2365 headers := make(map[string]*string)
2366 _result = &UpdateRepoResponse{}
2367 _body, _err := client.UpdateRepoWithOptions(RepoNamespace, RepoName, headers, runtime)
2368 if _err != nil {
2369 return _result, _err
2370 }
2371 _result = _body
2372 return _result, _err
2373 }
2374
2375 func (client *Client) UpdateRepoWithOptions(RepoNamespace *string, RepoName *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *UpdateRepoResponse, _err error) {
2376 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
2377 RepoName = openapiutil.GetEncodeParam(RepoName)
2378 req := &openapi.OpenApiRequest{
2379 Headers: headers,
2380 }
2381 params := &openapi.Params{
2382 Action: tea.String("UpdateRepo"),
2383 Version: tea.String("2016-06-07"),
2384 Protocol: tea.String("HTTPS"),
2385 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName)),
2386 Method: tea.String("POST"),
2387 AuthType: tea.String("AK"),
2388 Style: tea.String("ROA"),
2389 ReqBodyType: tea.String("json"),
2390 BodyType: tea.String("none"),
2391 }
2392 _result = &UpdateRepoResponse{}
2393 _body, _err := client.CallApi(params, req, runtime)
2394 if _err != nil {
2395 return _result, _err
2396 }
2397 _err = tea.Convert(_body, &_result)
2398 return _result, _err
2399 }
2400
2401 func (client *Client) UpdateRepoBuildRule(RepoNamespace *string, RepoName *string, BuildRuleId *string) (_result *UpdateRepoBuildRuleResponse, _err error) {
2402 runtime := &util.RuntimeOptions{}
2403 headers := make(map[string]*string)
2404 _result = &UpdateRepoBuildRuleResponse{}
2405 _body, _err := client.UpdateRepoBuildRuleWithOptions(RepoNamespace, RepoName, BuildRuleId, headers, runtime)
2406 if _err != nil {
2407 return _result, _err
2408 }
2409 _result = _body
2410 return _result, _err
2411 }
2412
2413 func (client *Client) UpdateRepoBuildRuleWithOptions(RepoNamespace *string, RepoName *string, BuildRuleId *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *UpdateRepoBuildRuleResponse, _err error) {
2414 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
2415 RepoName = openapiutil.GetEncodeParam(RepoName)
2416 BuildRuleId = openapiutil.GetEncodeParam(BuildRuleId)
2417 req := &openapi.OpenApiRequest{
2418 Headers: headers,
2419 }
2420 params := &openapi.Params{
2421 Action: tea.String("UpdateRepoBuildRule"),
2422 Version: tea.String("2016-06-07"),
2423 Protocol: tea.String("HTTPS"),
2424 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/rules/" + tea.StringValue(BuildRuleId)),
2425 Method: tea.String("POST"),
2426 AuthType: tea.String("AK"),
2427 Style: tea.String("ROA"),
2428 ReqBodyType: tea.String("json"),
2429 BodyType: tea.String("none"),
2430 }
2431 _result = &UpdateRepoBuildRuleResponse{}
2432 _body, _err := client.CallApi(params, req, runtime)
2433 if _err != nil {
2434 return _result, _err
2435 }
2436 _err = tea.Convert(_body, &_result)
2437 return _result, _err
2438 }
2439
2440 func (client *Client) UpdateRepoWebhook(RepoNamespace *string, RepoName *string, WebhookId *string) (_result *UpdateRepoWebhookResponse, _err error) {
2441 runtime := &util.RuntimeOptions{}
2442 headers := make(map[string]*string)
2443 _result = &UpdateRepoWebhookResponse{}
2444 _body, _err := client.UpdateRepoWebhookWithOptions(RepoNamespace, RepoName, WebhookId, headers, runtime)
2445 if _err != nil {
2446 return _result, _err
2447 }
2448 _result = _body
2449 return _result, _err
2450 }
2451
2452 func (client *Client) UpdateRepoWebhookWithOptions(RepoNamespace *string, RepoName *string, WebhookId *string, headers map[string]*string, runtime *util.RuntimeOptions) (_result *UpdateRepoWebhookResponse, _err error) {
2453 RepoNamespace = openapiutil.GetEncodeParam(RepoNamespace)
2454 RepoName = openapiutil.GetEncodeParam(RepoName)
2455 WebhookId = openapiutil.GetEncodeParam(WebhookId)
2456 req := &openapi.OpenApiRequest{
2457 Headers: headers,
2458 }
2459 params := &openapi.Params{
2460 Action: tea.String("UpdateRepoWebhook"),
2461 Version: tea.String("2016-06-07"),
2462 Protocol: tea.String("HTTPS"),
2463 Pathname: tea.String("/repos/" + tea.StringValue(RepoNamespace) + "/" + tea.StringValue(RepoName) + "/webhooks/" + tea.StringValue(WebhookId)),
2464 Method: tea.String("POST"),
2465 AuthType: tea.String("AK"),
2466 Style: tea.String("ROA"),
2467 ReqBodyType: tea.String("json"),
2468 BodyType: tea.String("none"),
2469 }
2470 _result = &UpdateRepoWebhookResponse{}
2471 _body, _err := client.CallApi(params, req, runtime)
2472 if _err != nil {
2473 return _result, _err
2474 }
2475 _err = tea.Convert(_body, &_result)
2476 return _result, _err
2477 }
2478
2479 func (client *Client) UpdateUserInfo() (_result *UpdateUserInfoResponse, _err error) {
2480 runtime := &util.RuntimeOptions{}
2481 headers := make(map[string]*string)
2482 _result = &UpdateUserInfoResponse{}
2483 _body, _err := client.UpdateUserInfoWithOptions(headers, runtime)
2484 if _err != nil {
2485 return _result, _err
2486 }
2487 _result = _body
2488 return _result, _err
2489 }
2490
2491 func (client *Client) UpdateUserInfoWithOptions(headers map[string]*string, runtime *util.RuntimeOptions) (_result *UpdateUserInfoResponse, _err error) {
2492 req := &openapi.OpenApiRequest{
2493 Headers: headers,
2494 }
2495 params := &openapi.Params{
2496 Action: tea.String("UpdateUserInfo"),
2497 Version: tea.String("2016-06-07"),
2498 Protocol: tea.String("HTTPS"),
2499 Pathname: tea.String("/users"),
2500 Method: tea.String("POST"),
2501 AuthType: tea.String("AK"),
2502 Style: tea.String("ROA"),
2503 ReqBodyType: tea.String("json"),
2504 BodyType: tea.String("none"),
2505 }
2506 _result = &UpdateUserInfoResponse{}
2507 _body, _err := client.CallApi(params, req, runtime)
2508 if _err != nil {
2509 return _result, _err
2510 }
2511 _err = tea.Convert(_body, &_result)
2512 return _result, _err
2513 }
2514
View as plain text