Skip to main content

rust_cnb/
models.rs

1//! 数据模型定义
2
3use serde::{Deserialize, Serialize};
4
5/// DtoUpdateGroupReq 模型
6#[derive(Debug, Clone, Serialize, Deserialize)]
7pub struct DtoUpdateGroupReq {
8    #[serde(skip_serializing_if = "Option::is_none")]
9    pub readme_repo_id: Option<i64>,
10    #[serde(skip_serializing_if = "Option::is_none")]
11    pub description: Option<String>,
12    #[serde(skip_serializing_if = "Option::is_none")]
13    pub site: Option<String>,
14    #[serde(skip_serializing_if = "Option::is_none")]
15    pub wechat_mp: Option<String>,
16    #[serde(skip_serializing_if = "Option::is_none")]
17    pub email: Option<String>,
18    #[serde(skip_serializing_if = "Option::is_none")]
19    pub remark: Option<String>,
20    #[serde(skip_serializing_if = "Option::is_none")]
21    pub domain: Option<String>,
22    #[serde(skip_serializing_if = "Option::is_none")]
23    pub readme_repo_path: Option<String>,
24}
25
26/// DtoUpdateUserInfoPayload 模型
27#[derive(Debug, Clone, Serialize, Deserialize)]
28pub struct DtoUpdateUserInfoPayload {
29    #[serde(skip_serializing_if = "Option::is_none")]
30    pub location: Option<String>,
31    #[serde(skip_serializing_if = "Option::is_none")]
32    pub nickname: Option<String>,
33    #[serde(skip_serializing_if = "Option::is_none")]
34    pub readme_repo_id: Option<i64>,
35    #[serde(skip_serializing_if = "Option::is_none")]
36    pub site: Option<String>,
37    #[serde(skip_serializing_if = "Option::is_none")]
38    pub wechat_mp: Option<String>,
39    #[serde(skip_serializing_if = "Option::is_none")]
40    pub company: Option<String>,
41    #[serde(skip_serializing_if = "Option::is_none")]
42    pub name: Option<String>,
43    #[serde(skip_serializing_if = "Option::is_none")]
44    pub bio: Option<String>,
45    #[serde(skip_serializing_if = "Option::is_none")]
46    pub wechat_mp_qrcode: Option<String>,
47    #[serde(skip_serializing_if = "Option::is_none")]
48    pub readme_repo_path: Option<String>,
49    #[serde(skip_serializing_if = "Option::is_none")]
50    pub address: Option<String>,
51}
52
53/// OpenapiPostReleaseAssetUploadUrlForm 模型
54#[derive(Debug, Clone, Serialize, Deserialize)]
55pub struct OpenapiPostReleaseAssetUploadUrlForm {
56    #[serde(skip_serializing_if = "Option::is_none")]
57    pub asset_name: Option<String>,
58    #[serde(skip_serializing_if = "Option::is_none")]
59    pub size: Option<i64>,
60    #[serde(skip_serializing_if = "Option::is_none")]
61    pub overwrite: Option<bool>,
62}
63
64/// ApiPullRequest 模型
65#[derive(Debug, Clone, Serialize, Deserialize)]
66pub struct ApiPullRequest {
67    #[serde(skip_serializing_if = "Option::is_none")]
68    pub title: Option<String>,
69    #[serde(skip_serializing_if = "Option::is_none")]
70    pub merged_by: Option<serde_json::Value>,
71    #[serde(skip_serializing_if = "Option::is_none")]
72    pub created_at: Option<String>,
73    #[serde(skip_serializing_if = "Option::is_none")]
74    pub review_count: Option<i64>,
75    #[serde(skip_serializing_if = "Option::is_none")]
76    pub comment_count: Option<i64>,
77    #[serde(skip_serializing_if = "Option::is_none")]
78    pub updated_at: Option<String>,
79    #[serde(skip_serializing_if = "Option::is_none")]
80    pub state: Option<String>,
81    #[serde(skip_serializing_if = "Option::is_none")]
82    pub author: Option<serde_json::Value>,
83    #[serde(skip_serializing_if = "Option::is_none")]
84    pub assignees: Option<Vec<serde_json::Value>>,
85    #[serde(skip_serializing_if = "Option::is_none")]
86    pub base: Option<serde_json::Value>,
87    #[serde(skip_serializing_if = "Option::is_none")]
88    pub mergeable_state: Option<String>,
89    #[serde(skip_serializing_if = "Option::is_none")]
90    pub head: Option<serde_json::Value>,
91    #[serde(skip_serializing_if = "Option::is_none")]
92    pub is_wip: Option<bool>,
93    #[serde(skip_serializing_if = "Option::is_none")]
94    pub repo: Option<serde_json::Value>,
95    #[serde(skip_serializing_if = "Option::is_none")]
96    pub last_acted_at: Option<String>,
97    #[serde(skip_serializing_if = "Option::is_none")]
98    pub blocked_on: Option<String>,
99    #[serde(skip_serializing_if = "Option::is_none")]
100    pub number: Option<String>,
101}
102
103/// DtoListBadgeReq 模型
104#[derive(Debug, Clone, Serialize, Deserialize)]
105pub struct DtoListBadgeReq {
106}
107
108/// ApiPullRequestComment 模型
109#[derive(Debug, Clone, Serialize, Deserialize)]
110pub struct ApiPullRequestComment {
111    #[serde(skip_serializing_if = "Option::is_none")]
112    pub created_at: Option<String>,
113    #[serde(skip_serializing_if = "Option::is_none")]
114    pub updated_at: Option<String>,
115    #[serde(skip_serializing_if = "Option::is_none")]
116    pub author: Option<serde_json::Value>,
117    #[serde(skip_serializing_if = "Option::is_none")]
118    pub id: Option<String>,
119    #[serde(skip_serializing_if = "Option::is_none")]
120    pub body: Option<String>,
121}
122
123/// DtoAiAutoPrResult 模型
124#[derive(Debug, Clone, Serialize, Deserialize)]
125pub struct DtoAiAutoPrResult {
126    #[serde(skip_serializing_if = "Option::is_none")]
127    pub message: Option<String>,
128    #[serde(skip_serializing_if = "Option::is_none")]
129    pub sn: Option<String>,
130    #[serde(skip_serializing_if = "Option::is_none")]
131    pub build_log_url: Option<String>,
132}
133
134/// DtoAiChatCompletionsChoice 模型
135#[derive(Debug, Clone, Serialize, Deserialize)]
136pub struct DtoAiChatCompletionsChoice {
137    #[serde(skip_serializing_if = "Option::is_none")]
138    pub message: Option<serde_json::Value>,
139    #[serde(skip_serializing_if = "Option::is_none")]
140    pub finish_reason: Option<String>,
141    #[serde(skip_serializing_if = "Option::is_none")]
142    pub index: Option<i64>,
143}
144
145/// ApiPullReview 模型
146#[derive(Debug, Clone, Serialize, Deserialize)]
147pub struct ApiPullReview {
148    #[serde(skip_serializing_if = "Option::is_none")]
149    pub author: Option<serde_json::Value>,
150    #[serde(skip_serializing_if = "Option::is_none")]
151    pub id: Option<String>,
152    #[serde(skip_serializing_if = "Option::is_none")]
153    pub body: Option<String>,
154    #[serde(skip_serializing_if = "Option::is_none")]
155    pub state: Option<String>,
156    #[serde(skip_serializing_if = "Option::is_none")]
157    pub updated_at: Option<String>,
158    #[serde(skip_serializing_if = "Option::is_none")]
159    pub created_at: Option<String>,
160}
161
162/// ApiPatchIssueForm 模型
163#[derive(Debug, Clone, Serialize, Deserialize)]
164pub struct ApiPatchIssueForm {
165    #[serde(skip_serializing_if = "Option::is_none")]
166    pub end_date: Option<String>,
167    #[serde(skip_serializing_if = "Option::is_none")]
168    pub state: Option<String>,
169    #[serde(skip_serializing_if = "Option::is_none")]
170    pub state_reason: Option<String>,
171    #[serde(skip_serializing_if = "Option::is_none")]
172    pub body: Option<String>,
173    #[serde(skip_serializing_if = "Option::is_none")]
174    pub start_date: Option<String>,
175    #[serde(skip_serializing_if = "Option::is_none")]
176    pub priority: Option<String>,
177    #[serde(skip_serializing_if = "Option::is_none")]
178    pub title: Option<String>,
179}
180
181/// DtoDockerModelTag 模型
182#[derive(Debug, Clone, Serialize, Deserialize)]
183pub struct DtoDockerModelTag {
184    #[serde(skip_serializing_if = "Option::is_none")]
185    pub docker_model_descriptor: Option<serde_json::Value>,
186    #[serde(skip_serializing_if = "Option::is_none")]
187    pub docker_model_config: Option<serde_json::Value>,
188    #[serde(skip_serializing_if = "Option::is_none")]
189    pub name: Option<String>,
190    #[serde(skip_serializing_if = "Option::is_none")]
191    pub address: Option<String>,
192    #[serde(skip_serializing_if = "Option::is_none")]
193    pub pull_count: Option<i64>,
194    #[serde(skip_serializing_if = "Option::is_none")]
195    pub recent_pull_count: Option<i64>,
196    #[serde(skip_serializing_if = "Option::is_none")]
197    pub last_pusher: Option<serde_json::Value>,
198}
199
200/// DtoEmbeddingModels 模型
201#[derive(Debug, Clone, Serialize, Deserialize)]
202pub struct DtoEmbeddingModels {
203    #[serde(skip_serializing_if = "Option::is_none")]
204    pub name: Option<String>,
205    #[serde(skip_serializing_if = "Option::is_none")]
206    pub dimension: Option<i64>,
207}
208
209/// DtoKnowledgeBaseInfoRes 模型
210#[derive(Debug, Clone, Serialize, Deserialize)]
211pub struct DtoKnowledgeBaseInfoRes {
212    #[serde(skip_serializing_if = "Option::is_none")]
213    pub exclude: Option<String>,
214    #[serde(skip_serializing_if = "Option::is_none")]
215    pub include: Option<String>,
216    #[serde(skip_serializing_if = "Option::is_none")]
217    pub last_commit_sha: Option<String>,
218    #[serde(skip_serializing_if = "Option::is_none")]
219    pub issue_sync_enabled: Option<bool>,
220    #[serde(skip_serializing_if = "Option::is_none")]
221    pub id: Option<i64>,
222    #[serde(skip_serializing_if = "Option::is_none")]
223    pub embedding_model: Option<serde_json::Value>,
224    #[serde(skip_serializing_if = "Option::is_none")]
225    pub issue_last_sync_time: Option<String>,
226    #[serde(skip_serializing_if = "Option::is_none")]
227    pub statistics: Option<serde_json::Value>,
228    #[serde(skip_serializing_if = "Option::is_none")]
229    pub metadata: Option<serde_json::Value>,
230}
231
232/// DtoBadge 模型
233#[derive(Debug, Clone, Serialize, Deserialize)]
234pub struct DtoBadge {
235    #[serde(skip_serializing_if = "Option::is_none")]
236    pub url_data: Option<String>,
237    #[serde(skip_serializing_if = "Option::is_none")]
238    pub group: Option<serde_json::Value>,
239    #[serde(skip_serializing_if = "Option::is_none")]
240    pub name: Option<String>,
241    #[serde(skip_serializing_if = "Option::is_none")]
242    pub r#type: Option<String>,
243    #[serde(skip_serializing_if = "Option::is_none")]
244    pub desc: Option<String>,
245    #[serde(skip_serializing_if = "Option::is_none")]
246    pub link: Option<String>,
247}
248
249/// DtoCommonRegistryTag 模型
250#[derive(Debug, Clone, Serialize, Deserialize)]
251pub struct DtoCommonRegistryTag {
252    #[serde(skip_serializing_if = "Option::is_none")]
253    pub desc: Option<String>,
254    #[serde(skip_serializing_if = "Option::is_none")]
255    pub last_pusher: Option<serde_json::Value>,
256    #[serde(skip_serializing_if = "Option::is_none")]
257    pub size: Option<i64>,
258    #[serde(skip_serializing_if = "Option::is_none")]
259    pub pull_count: Option<i64>,
260    #[serde(skip_serializing_if = "Option::is_none")]
261    pub status: Option<String>,
262    #[serde(skip_serializing_if = "Option::is_none")]
263    pub recent_pull_count: Option<i64>,
264    #[serde(skip_serializing_if = "Option::is_none")]
265    pub name: Option<String>,
266    #[serde(skip_serializing_if = "Option::is_none")]
267    pub digest: Option<String>,
268}
269
270/// DtoQueryKnowledgeBaseRes 模型
271#[derive(Debug, Clone, Serialize, Deserialize)]
272pub struct DtoQueryKnowledgeBaseRes {
273    #[serde(skip_serializing_if = "Option::is_none")]
274    pub chunk: Option<String>,
275    #[serde(skip_serializing_if = "Option::is_none")]
276    pub metadata: Option<serde_json::Value>,
277    #[serde(skip_serializing_if = "Option::is_none")]
278    pub score: Option<f64>,
279}
280
281/// ChartDependency 模型
282#[derive(Debug, Clone, Serialize, Deserialize)]
283pub struct ChartDependency {
284    #[serde(skip_serializing_if = "Option::is_none")]
285    pub version: Option<String>,
286    #[serde(skip_serializing_if = "Option::is_none")]
287    pub repository: Option<String>,
288    #[serde(skip_serializing_if = "Option::is_none")]
289    pub condition: Option<String>,
290    #[serde(skip_serializing_if = "Option::is_none")]
291    pub alias: Option<String>,
292    #[serde(skip_serializing_if = "Option::is_none")]
293    pub enabled: Option<bool>,
294    #[serde(skip_serializing_if = "Option::is_none")]
295    pub import_values: Option<Vec<serde_json::Value>>,
296    #[serde(skip_serializing_if = "Option::is_none")]
297    pub name: Option<String>,
298    #[serde(skip_serializing_if = "Option::is_none")]
299    pub tags: Option<Vec<String>>,
300}
301
302/// ConstantVisibility 模型
303#[derive(Debug, Clone, Serialize, Deserialize)]
304pub struct ConstantVisibility {
305}
306
307/// ApiCommitObjectVerification 模型
308#[derive(Debug, Clone, Serialize, Deserialize)]
309pub struct ApiCommitObjectVerification {
310    #[serde(skip_serializing_if = "Option::is_none")]
311    pub payload: Option<String>,
312    #[serde(skip_serializing_if = "Option::is_none")]
313    pub verified: Option<bool>,
314    #[serde(skip_serializing_if = "Option::is_none")]
315    pub verified_at: Option<String>,
316    #[serde(skip_serializing_if = "Option::is_none")]
317    pub signature: Option<String>,
318    #[serde(skip_serializing_if = "Option::is_none")]
319    pub reason: Option<String>,
320}
321
322/// ChartMaintainer 模型
323#[derive(Debug, Clone, Serialize, Deserialize)]
324pub struct ChartMaintainer {
325    #[serde(skip_serializing_if = "Option::is_none")]
326    pub name: Option<String>,
327    #[serde(skip_serializing_if = "Option::is_none")]
328    pub url_data: Option<String>,
329    #[serde(skip_serializing_if = "Option::is_none")]
330    pub email: Option<String>,
331}
332
333/// DtoChartTagDetail 模型
334#[derive(Debug, Clone, Serialize, Deserialize)]
335pub struct DtoChartTagDetail {
336    #[serde(skip_serializing_if = "Option::is_none")]
337    pub metadata: Option<serde_json::Value>,
338    #[serde(skip_serializing_if = "Option::is_none")]
339    pub pull_count: Option<i64>,
340    #[serde(skip_serializing_if = "Option::is_none")]
341    pub address: Option<String>,
342    #[serde(skip_serializing_if = "Option::is_none")]
343    pub package: Option<String>,
344    #[serde(skip_serializing_if = "Option::is_none")]
345    pub size: Option<i64>,
346    #[serde(skip_serializing_if = "Option::is_none")]
347    pub is_deprecated: Option<bool>,
348    #[serde(skip_serializing_if = "Option::is_none")]
349    pub last_pusher: Option<serde_json::Value>,
350    #[serde(skip_serializing_if = "Option::is_none")]
351    pub recent_pull_count: Option<i64>,
352    #[serde(skip_serializing_if = "Option::is_none")]
353    pub slug: Option<String>,
354    #[serde(skip_serializing_if = "Option::is_none")]
355    pub tag: Option<String>,
356}
357
358/// DtoOrganizationUnion 模型
359#[derive(Debug, Clone, Serialize, Deserialize)]
360pub struct DtoOrganizationUnion {
361    #[serde(skip_serializing_if = "Option::is_none")]
362    pub all_sub_registry_count: Option<i64>,
363    #[serde(skip_serializing_if = "Option::is_none")]
364    pub path: Option<String>,
365    #[serde(skip_serializing_if = "Option::is_none")]
366    pub follow_count: Option<i64>,
367    #[serde(skip_serializing_if = "Option::is_none")]
368    pub pinned: Option<bool>,
369    #[serde(skip_serializing_if = "Option::is_none")]
370    pub readme_repo_path: Option<String>,
371    #[serde(skip_serializing_if = "Option::is_none")]
372    pub sub_group_count: Option<i64>,
373    #[serde(skip_serializing_if = "Option::is_none")]
374    pub sub_registry_count: Option<i64>,
375    #[serde(skip_serializing_if = "Option::is_none")]
376    pub name: Option<String>,
377    #[serde(skip_serializing_if = "Option::is_none")]
378    pub all_sub_group_count: Option<i64>,
379    #[serde(skip_serializing_if = "Option::is_none")]
380    pub sub_mission_count: Option<i64>,
381    #[serde(skip_serializing_if = "Option::is_none")]
382    pub sub_repo_count: Option<i64>,
383    #[serde(skip_serializing_if = "Option::is_none")]
384    pub freeze: Option<bool>,
385    #[serde(skip_serializing_if = "Option::is_none")]
386    pub updated_at: Option<String>,
387    #[serde(skip_serializing_if = "Option::is_none")]
388    pub wechat_mp: Option<String>,
389    #[serde(skip_serializing_if = "Option::is_none")]
390    pub member_count: Option<i64>,
391    #[serde(skip_serializing_if = "Option::is_none")]
392    pub all_sub_repo_count: Option<i64>,
393    #[serde(skip_serializing_if = "Option::is_none")]
394    pub all_member_count: Option<i64>,
395    #[serde(skip_serializing_if = "Option::is_none")]
396    pub pinned_time: Option<String>,
397    #[serde(skip_serializing_if = "Option::is_none")]
398    pub remark: Option<String>,
399    #[serde(skip_serializing_if = "Option::is_none")]
400    pub id: Option<i64>,
401    #[serde(skip_serializing_if = "Option::is_none")]
402    pub created_at: Option<String>,
403    #[serde(skip_serializing_if = "Option::is_none")]
404    pub email: Option<String>,
405    #[serde(skip_serializing_if = "Option::is_none")]
406    pub has_sub_group: Option<bool>,
407    #[serde(skip_serializing_if = "Option::is_none")]
408    pub site: Option<String>,
409    #[serde(skip_serializing_if = "Option::is_none")]
410    pub description: Option<String>,
411    #[serde(skip_serializing_if = "Option::is_none")]
412    pub all_sub_mission_count: Option<i64>,
413    #[serde(skip_serializing_if = "Option::is_none")]
414    pub domain: Option<String>,
415}
416
417/// DtoUploadBadgeReq 模型
418#[derive(Debug, Clone, Serialize, Deserialize)]
419pub struct DtoUploadBadgeReq {
420    #[serde(skip_serializing_if = "Option::is_none")]
421    pub key: Option<String>,
422    #[serde(skip_serializing_if = "Option::is_none")]
423    pub latest: Option<bool>,
424    #[serde(skip_serializing_if = "Option::is_none")]
425    pub sha: Option<String>,
426    #[serde(skip_serializing_if = "Option::is_none")]
427    pub value: Option<i64>,
428    #[serde(skip_serializing_if = "Option::is_none")]
429    pub message: Option<String>,
430    #[serde(skip_serializing_if = "Option::is_none")]
431    pub link: Option<String>,
432}
433
434/// GitWoaComCnbMonorepoGitInternalAppGitServiceBffApiUserInfo 模型
435#[derive(Debug, Clone, Serialize, Deserialize)]
436pub struct GitWoaComCnbMonorepoGitInternalAppGitServiceBffApiUserInfo {
437    #[serde(skip_serializing_if = "Option::is_none")]
438    pub freeze: Option<bool>,
439    #[serde(skip_serializing_if = "Option::is_none")]
440    pub username: Option<String>,
441    #[serde(skip_serializing_if = "Option::is_none")]
442    pub nickname: Option<String>,
443    #[serde(skip_serializing_if = "Option::is_none")]
444    pub email: Option<String>,
445}
446
447/// ApiTagObjectVerification 模型
448#[derive(Debug, Clone, Serialize, Deserialize)]
449pub struct ApiTagObjectVerification {
450    #[serde(skip_serializing_if = "Option::is_none")]
451    pub verified_at: Option<String>,
452    #[serde(skip_serializing_if = "Option::is_none")]
453    pub payload: Option<String>,
454    #[serde(skip_serializing_if = "Option::is_none")]
455    pub reason: Option<String>,
456    #[serde(skip_serializing_if = "Option::is_none")]
457    pub signature: Option<String>,
458    #[serde(skip_serializing_if = "Option::is_none")]
459    pub verified: Option<bool>,
460}
461
462/// ApiTreeEntry 模型
463#[derive(Debug, Clone, Serialize, Deserialize)]
464pub struct ApiTreeEntry {
465    #[serde(skip_serializing_if = "Option::is_none")]
466    pub path: Option<String>,
467    #[serde(skip_serializing_if = "Option::is_none")]
468    pub name: Option<String>,
469    #[serde(skip_serializing_if = "Option::is_none")]
470    pub sha: Option<String>,
471    #[serde(skip_serializing_if = "Option::is_none")]
472    pub r#type: Option<String>,
473}
474
475/// ApiPostPullLabelsForm 模型
476#[derive(Debug, Clone, Serialize, Deserialize)]
477pub struct ApiPostPullLabelsForm {
478    #[serde(skip_serializing_if = "Option::is_none")]
479    pub labels: Option<Vec<String>>,
480}
481
482/// ApiPullRequestInfo 模型
483#[derive(Debug, Clone, Serialize, Deserialize)]
484pub struct ApiPullRequestInfo {
485    #[serde(skip_serializing_if = "Option::is_none")]
486    pub number: Option<String>,
487    #[serde(skip_serializing_if = "Option::is_none")]
488    pub reviewers: Option<Vec<serde_json::Value>>,
489    #[serde(skip_serializing_if = "Option::is_none")]
490    pub assignees: Option<Vec<serde_json::Value>>,
491    #[serde(skip_serializing_if = "Option::is_none")]
492    pub updated_at: Option<String>,
493    #[serde(skip_serializing_if = "Option::is_none")]
494    pub blocked_on: Option<String>,
495    #[serde(skip_serializing_if = "Option::is_none")]
496    pub title: Option<String>,
497    #[serde(skip_serializing_if = "Option::is_none")]
498    pub mergeable_state: Option<String>,
499    #[serde(skip_serializing_if = "Option::is_none")]
500    pub merged_by: Option<serde_json::Value>,
501    #[serde(skip_serializing_if = "Option::is_none")]
502    pub last_acted_at: Option<String>,
503    #[serde(skip_serializing_if = "Option::is_none")]
504    pub state: Option<String>,
505    #[serde(skip_serializing_if = "Option::is_none")]
506    pub repo: Option<serde_json::Value>,
507    #[serde(skip_serializing_if = "Option::is_none")]
508    pub head: Option<serde_json::Value>,
509    #[serde(skip_serializing_if = "Option::is_none")]
510    pub created_at: Option<String>,
511    #[serde(skip_serializing_if = "Option::is_none")]
512    pub author: Option<serde_json::Value>,
513    #[serde(skip_serializing_if = "Option::is_none")]
514    pub base: Option<serde_json::Value>,
515}
516
517/// ConvertNullTime 模型
518#[derive(Debug, Clone, Serialize, Deserialize)]
519pub struct ConvertNullTime {
520    #[serde(skip_serializing_if = "Option::is_none")]
521    pub valid: Option<bool>,
522    #[serde(skip_serializing_if = "Option::is_none")]
523    pub time: Option<String>,
524}
525
526/// DtoActivityRepoDetail 模型
527#[derive(Debug, Clone, Serialize, Deserialize)]
528pub struct DtoActivityRepoDetail {
529    #[serde(skip_serializing_if = "Option::is_none")]
530    pub repo_unaccessible: Option<bool>,
531    #[serde(skip_serializing_if = "Option::is_none")]
532    pub detail: Option<serde_json::Value>,
533    #[serde(skip_serializing_if = "Option::is_none")]
534    pub freeze: Option<bool>,
535    #[serde(skip_serializing_if = "Option::is_none")]
536    pub time: Option<f64>,
537    #[serde(skip_serializing_if = "Option::is_none")]
538    pub visibility_level: Option<serde_json::Value>,
539    #[serde(skip_serializing_if = "Option::is_none")]
540    pub exposed_repo_path: Option<String>,
541}
542
543/// ApiRepo 模型
544#[derive(Debug, Clone, Serialize, Deserialize)]
545pub struct ApiRepo {
546    #[serde(skip_serializing_if = "Option::is_none")]
547    pub name: Option<String>,
548    #[serde(skip_serializing_if = "Option::is_none")]
549    pub web_url: Option<String>,
550    #[serde(skip_serializing_if = "Option::is_none")]
551    pub id: Option<String>,
552    #[serde(skip_serializing_if = "Option::is_none")]
553    pub path: Option<String>,
554}
555
556/// DtoCommonRegistryTagDetail 模型
557#[derive(Debug, Clone, Serialize, Deserialize)]
558pub struct DtoCommonRegistryTagDetail {
559    #[serde(skip_serializing_if = "Option::is_none")]
560    pub metadata: Option<serde_json::Value>,
561    #[serde(skip_serializing_if = "Option::is_none")]
562    pub recent_pull_count: Option<i64>,
563    #[serde(skip_serializing_if = "Option::is_none")]
564    pub size: Option<i64>,
565    #[serde(skip_serializing_if = "Option::is_none")]
566    pub dependencies: Option<Vec<serde_json::Value>>,
567    #[serde(skip_serializing_if = "Option::is_none")]
568    pub files: Option<Vec<serde_json::Value>>,
569    #[serde(skip_serializing_if = "Option::is_none")]
570    pub pull_count: Option<i64>,
571    #[serde(skip_serializing_if = "Option::is_none")]
572    pub slug: Option<String>,
573    #[serde(skip_serializing_if = "Option::is_none")]
574    pub status: Option<String>,
575    #[serde(skip_serializing_if = "Option::is_none")]
576    pub tags: Option<Vec<serde_json::Value>>,
577    #[serde(skip_serializing_if = "Option::is_none")]
578    pub package: Option<String>,
579    #[serde(skip_serializing_if = "Option::is_none")]
580    pub desc: Option<String>,
581    #[serde(skip_serializing_if = "Option::is_none")]
582    pub last_pusher: Option<serde_json::Value>,
583    #[serde(skip_serializing_if = "Option::is_none")]
584    pub address: Option<String>,
585    #[serde(skip_serializing_if = "Option::is_none")]
586    pub tag: Option<String>,
587}
588
589/// DtoGguf 模型
590#[derive(Debug, Clone, Serialize, Deserialize)]
591pub struct DtoGguf {
592}
593
594/// DtoMissionViewType 模型
595#[derive(Debug, Clone, Serialize, Deserialize)]
596pub struct DtoMissionViewType {
597}
598
599/// ApiCommitObjectTree 模型
600#[derive(Debug, Clone, Serialize, Deserialize)]
601pub struct ApiCommitObjectTree {
602    #[serde(skip_serializing_if = "Option::is_none")]
603    pub sha: Option<String>,
604}
605
606/// ApiPostIssueAssigneesForm 模型
607#[derive(Debug, Clone, Serialize, Deserialize)]
608pub struct ApiPostIssueAssigneesForm {
609    #[serde(skip_serializing_if = "Option::is_none")]
610    pub assignees: Option<Vec<String>>,
611}
612
613/// ApiPatchIssueCommentForm 模型
614#[derive(Debug, Clone, Serialize, Deserialize)]
615pub struct ApiPatchIssueCommentForm {
616    #[serde(skip_serializing_if = "Option::is_none")]
617    pub body: Option<String>,
618}
619
620/// ConstantRepoStatus 模型
621#[derive(Debug, Clone, Serialize, Deserialize)]
622pub struct ConstantRepoStatus {
623}
624
625/// GitWoaComCnbMonorepoGitInternalAppGitServiceBffApiCommitStatus 模型
626#[derive(Debug, Clone, Serialize, Deserialize)]
627pub struct GitWoaComCnbMonorepoGitInternalAppGitServiceBffApiCommitStatus {
628    #[serde(skip_serializing_if = "Option::is_none")]
629    pub updated_at: Option<String>,
630    #[serde(skip_serializing_if = "Option::is_none")]
631    pub state: Option<String>,
632    #[serde(skip_serializing_if = "Option::is_none")]
633    pub context: Option<String>,
634    #[serde(skip_serializing_if = "Option::is_none")]
635    pub target_url: Option<String>,
636    #[serde(skip_serializing_if = "Option::is_none")]
637    pub description: Option<String>,
638    #[serde(skip_serializing_if = "Option::is_none")]
639    pub created_at: Option<String>,
640}
641
642/// GitWoaComCnbMonorepoGitInternalAppVcsServiceBffApiUserInfo 模型
643#[derive(Debug, Clone, Serialize, Deserialize)]
644pub struct GitWoaComCnbMonorepoGitInternalAppVcsServiceBffApiUserInfo {
645    #[serde(skip_serializing_if = "Option::is_none")]
646    pub nickname: Option<String>,
647    #[serde(skip_serializing_if = "Option::is_none")]
648    pub username: Option<String>,
649}
650
651/// ApiRepoInfo 模型
652#[derive(Debug, Clone, Serialize, Deserialize)]
653pub struct ApiRepoInfo {
654    #[serde(skip_serializing_if = "Option::is_none")]
655    pub id: Option<String>,
656    #[serde(skip_serializing_if = "Option::is_none")]
657    pub name: Option<String>,
658    #[serde(skip_serializing_if = "Option::is_none")]
659    pub path: Option<String>,
660    #[serde(skip_serializing_if = "Option::is_none")]
661    pub web_url: Option<String>,
662}
663
664/// DtoDockerModelTagDetail 模型
665#[derive(Debug, Clone, Serialize, Deserialize)]
666pub struct DtoDockerModelTagDetail {
667    #[serde(skip_serializing_if = "Option::is_none")]
668    pub slug: Option<String>,
669    #[serde(skip_serializing_if = "Option::is_none")]
670    pub docker_model_descriptor: Option<serde_json::Value>,
671    #[serde(skip_serializing_if = "Option::is_none")]
672    pub last_pusher: Option<serde_json::Value>,
673    #[serde(skip_serializing_if = "Option::is_none")]
674    pub recent_pull_count: Option<i64>,
675    #[serde(skip_serializing_if = "Option::is_none")]
676    pub tag: Option<String>,
677    #[serde(skip_serializing_if = "Option::is_none")]
678    pub address: Option<String>,
679    #[serde(skip_serializing_if = "Option::is_none")]
680    pub package: Option<String>,
681    #[serde(skip_serializing_if = "Option::is_none")]
682    pub pull_count: Option<i64>,
683    #[serde(skip_serializing_if = "Option::is_none")]
684    pub docker_model_config: Option<serde_json::Value>,
685}
686
687/// DtoCodeRepoQuotaRsp 模型
688#[derive(Debug, Clone, Serialize, Deserialize)]
689pub struct DtoCodeRepoQuotaRsp {
690    #[serde(skip_serializing_if = "Option::is_none")]
691    pub docker: Option<serde_json::Value>,
692    #[serde(skip_serializing_if = "Option::is_none")]
693    pub docker_model: Option<serde_json::Value>,
694    #[serde(skip_serializing_if = "Option::is_none")]
695    pub helm: Option<serde_json::Value>,
696}
697
698/// DtoConanMetaData 模型
699#[derive(Debug, Clone, Serialize, Deserialize)]
700pub struct DtoConanMetaData {
701    #[serde(skip_serializing_if = "Option::is_none")]
702    pub home_page: Option<String>,
703    #[serde(skip_serializing_if = "Option::is_none")]
704    pub conan_recipe_revision: Option<String>,
705    #[serde(skip_serializing_if = "Option::is_none")]
706    pub package_tag: Option<String>,
707    #[serde(skip_serializing_if = "Option::is_none")]
708    pub package_type: Option<String>,
709    #[serde(skip_serializing_if = "Option::is_none")]
710    pub readme: Option<String>,
711    #[serde(skip_serializing_if = "Option::is_none")]
712    pub repository_url: Option<String>,
713    #[serde(skip_serializing_if = "Option::is_none")]
714    pub author: Option<String>,
715    #[serde(skip_serializing_if = "Option::is_none")]
716    pub license_url: Option<String>,
717    #[serde(skip_serializing_if = "Option::is_none")]
718    pub conan_packages: Option<Vec<serde_json::Value>>,
719    #[serde(skip_serializing_if = "Option::is_none")]
720    pub package_name: Option<String>,
721}
722
723/// GitWoaComCnbMonorepoGitInternalAppVcsServiceBffApiCommitStatus 模型
724#[derive(Debug, Clone, Serialize, Deserialize)]
725pub struct GitWoaComCnbMonorepoGitInternalAppVcsServiceBffApiCommitStatus {
726    #[serde(skip_serializing_if = "Option::is_none")]
727    pub context: Option<String>,
728    #[serde(skip_serializing_if = "Option::is_none")]
729    pub created_at: Option<String>,
730    #[serde(skip_serializing_if = "Option::is_none")]
731    pub target_url: Option<String>,
732    #[serde(skip_serializing_if = "Option::is_none")]
733    pub updated_at: Option<String>,
734    #[serde(skip_serializing_if = "Option::is_none")]
735    pub description: Option<String>,
736    #[serde(skip_serializing_if = "Option::is_none")]
737    pub state: Option<String>,
738}
739
740/// WebGetCommitAnnotationsInBatchForm 模型
741#[derive(Debug, Clone, Serialize, Deserialize)]
742pub struct WebGetCommitAnnotationsInBatchForm {
743    #[serde(skip_serializing_if = "Option::is_none")]
744    pub commit_hashes: Option<Vec<String>>,
745    #[serde(skip_serializing_if = "Option::is_none")]
746    pub keys: Option<Vec<String>>,
747}
748
749/// ApiBranch 模型
750#[derive(Debug, Clone, Serialize, Deserialize)]
751pub struct ApiBranch {
752    #[serde(skip_serializing_if = "Option::is_none")]
753    pub commit: Option<serde_json::Value>,
754    #[serde(skip_serializing_if = "Option::is_none")]
755    pub name: Option<String>,
756    #[serde(skip_serializing_if = "Option::is_none")]
757    pub protected: Option<bool>,
758}
759
760/// ApiDiffLine 模型
761#[derive(Debug, Clone, Serialize, Deserialize)]
762pub struct ApiDiffLine {
763    #[serde(skip_serializing_if = "Option::is_none")]
764    pub left_line_number: Option<i64>,
765    #[serde(skip_serializing_if = "Option::is_none")]
766    pub content: Option<String>,
767    #[serde(skip_serializing_if = "Option::is_none")]
768    pub right_line_number: Option<i64>,
769    #[serde(skip_serializing_if = "Option::is_none")]
770    pub prefix: Option<String>,
771    #[serde(skip_serializing_if = "Option::is_none")]
772    pub r#type: Option<String>,
773}
774
775/// DtoMissionViewConfig 模型
776#[derive(Debug, Clone, Serialize, Deserialize)]
777pub struct DtoMissionViewConfig {
778    #[serde(skip_serializing_if = "Option::is_none")]
779    pub sorts: Option<Vec<serde_json::Value>>,
780    #[serde(skip_serializing_if = "Option::is_none")]
781    pub r#type: Option<serde_json::Value>,
782    #[serde(skip_serializing_if = "Option::is_none")]
783    pub id: Option<String>,
784    #[serde(skip_serializing_if = "Option::is_none")]
785    pub selectors: Option<Vec<serde_json::Value>>,
786    #[serde(skip_serializing_if = "Option::is_none")]
787    pub fields: Option<Vec<serde_json::Value>>,
788    #[serde(skip_serializing_if = "Option::is_none")]
789    pub group: Option<serde_json::Value>,
790}
791
792/// DtoContainerTagDetail 模型
793#[derive(Debug, Clone, Serialize, Deserialize)]
794pub struct DtoContainerTagDetail {
795    #[serde(skip_serializing_if = "Option::is_none")]
796    pub package: Option<String>,
797    #[serde(skip_serializing_if = "Option::is_none")]
798    pub annotations: Option<serde_json::Value>,
799    #[serde(skip_serializing_if = "Option::is_none")]
800    pub address: Option<String>,
801    #[serde(skip_serializing_if = "Option::is_none")]
802    pub pull_count: Option<i64>,
803    #[serde(skip_serializing_if = "Option::is_none")]
804    pub last_pusher: Option<serde_json::Value>,
805    #[serde(skip_serializing_if = "Option::is_none")]
806    pub recent_pull_count: Option<i64>,
807    #[serde(skip_serializing_if = "Option::is_none")]
808    pub slug: Option<String>,
809    #[serde(skip_serializing_if = "Option::is_none")]
810    pub image: Option<serde_json::Value>,
811    #[serde(skip_serializing_if = "Option::is_none")]
812    pub options: Option<Vec<serde_json::Value>>,
813    #[serde(skip_serializing_if = "Option::is_none")]
814    pub tag: Option<String>,
815    #[serde(skip_serializing_if = "Option::is_none")]
816    pub matches_requested_arch: Option<bool>,
817}
818
819/// ApiPostIssueLabelsForm 模型
820#[derive(Debug, Clone, Serialize, Deserialize)]
821pub struct ApiPostIssueLabelsForm {
822    #[serde(skip_serializing_if = "Option::is_none")]
823    pub labels: Option<Vec<String>>,
824}
825
826/// ApiPullFile 模型
827#[derive(Debug, Clone, Serialize, Deserialize)]
828pub struct ApiPullFile {
829    #[serde(skip_serializing_if = "Option::is_none")]
830    pub filename: Option<String>,
831    #[serde(skip_serializing_if = "Option::is_none")]
832    pub additions: Option<i64>,
833    #[serde(skip_serializing_if = "Option::is_none")]
834    pub deletions: Option<i64>,
835    #[serde(skip_serializing_if = "Option::is_none")]
836    pub status: Option<String>,
837    #[serde(skip_serializing_if = "Option::is_none")]
838    pub blob_url: Option<String>,
839    #[serde(skip_serializing_if = "Option::is_none")]
840    pub contents_url: Option<String>,
841    #[serde(skip_serializing_if = "Option::is_none")]
842    pub patch: Option<String>,
843    #[serde(skip_serializing_if = "Option::is_none")]
844    pub sha: Option<String>,
845    #[serde(skip_serializing_if = "Option::is_none")]
846    pub raw_url: Option<String>,
847}
848
849/// ApiBranchProtection 模型
850#[derive(Debug, Clone, Serialize, Deserialize)]
851pub struct ApiBranchProtection {
852    #[serde(skip_serializing_if = "Option::is_none")]
853    pub required_approved_review_ratio: Option<i64>,
854    #[serde(skip_serializing_if = "Option::is_none")]
855    pub required_must_push_via_pull_request: Option<bool>,
856    #[serde(skip_serializing_if = "Option::is_none")]
857    pub allow_master_force_pushes: Option<bool>,
858    #[serde(skip_serializing_if = "Option::is_none")]
859    pub allow_creation: Option<bool>,
860    #[serde(skip_serializing_if = "Option::is_none")]
861    pub required_approved_review_count: Option<i64>,
862    #[serde(skip_serializing_if = "Option::is_none")]
863    pub allow_pushes: Option<bool>,
864    #[serde(skip_serializing_if = "Option::is_none")]
865    pub allow_master_deletions: Option<bool>,
866    #[serde(skip_serializing_if = "Option::is_none")]
867    pub required_status_checks: Option<bool>,
868    #[serde(skip_serializing_if = "Option::is_none")]
869    pub allow_deletions: Option<bool>,
870    #[serde(skip_serializing_if = "Option::is_none")]
871    pub allow_master_manual_merge: Option<bool>,
872    #[serde(skip_serializing_if = "Option::is_none")]
873    pub id: Option<String>,
874    #[serde(skip_serializing_if = "Option::is_none")]
875    pub required_master_approve: Option<bool>,
876    #[serde(skip_serializing_if = "Option::is_none")]
877    pub required_linear_history: Option<bool>,
878    #[serde(skip_serializing_if = "Option::is_none")]
879    pub required_must_auto_merge: Option<bool>,
880    #[serde(skip_serializing_if = "Option::is_none")]
881    pub required_pull_request_reviews: Option<bool>,
882    #[serde(skip_serializing_if = "Option::is_none")]
883    pub allow_master_creation: Option<bool>,
884    #[serde(skip_serializing_if = "Option::is_none")]
885    pub allow_master_pushes: Option<bool>,
886    #[serde(skip_serializing_if = "Option::is_none")]
887    pub allow_force_pushes: Option<bool>,
888    #[serde(skip_serializing_if = "Option::is_none")]
889    pub rule: Option<String>,
890}
891
892/// ConstantUserEditable 模型
893#[derive(Debug, Clone, Serialize, Deserialize)]
894pub struct ConstantUserEditable {
895}
896
897/// DtoAssets 模型
898#[derive(Debug, Clone, Serialize, Deserialize)]
899pub struct DtoAssets {
900    #[serde(skip_serializing_if = "Option::is_none")]
901    pub name: Option<String>,
902    #[serde(skip_serializing_if = "Option::is_none")]
903    pub size: Option<i64>,
904    #[serde(skip_serializing_if = "Option::is_none")]
905    pub content_type: Option<String>,
906    #[serde(skip_serializing_if = "Option::is_none")]
907    pub ext: Option<serde_json::Value>,
908    #[serde(skip_serializing_if = "Option::is_none")]
909    pub path: Option<String>,
910}
911
912/// DtoMissionViewSort 模型
913#[derive(Debug, Clone, Serialize, Deserialize)]
914pub struct DtoMissionViewSort {
915    #[serde(skip_serializing_if = "Option::is_none")]
916    pub order: Option<serde_json::Value>,
917    #[serde(skip_serializing_if = "Option::is_none")]
918    pub field: Option<String>,
919}
920
921/// ApiPushLimitSettings 模型
922#[derive(Debug, Clone, Serialize, Deserialize)]
923pub struct ApiPushLimitSettings {
924    #[serde(skip_serializing_if = "Option::is_none")]
925    pub check_single_push_number: Option<bool>,
926    #[serde(skip_serializing_if = "Option::is_none")]
927    pub only_master_can_push_tag: Option<bool>,
928    #[serde(skip_serializing_if = "Option::is_none")]
929    pub push_commit_must_be: Option<String>,
930    #[serde(skip_serializing_if = "Option::is_none")]
931    pub allow_single_push_number: Option<i64>,
932}
933
934/// ChartMetadata 模型
935#[derive(Debug, Clone, Serialize, Deserialize)]
936pub struct ChartMetadata {
937    #[serde(skip_serializing_if = "Option::is_none")]
938    pub kube_version: Option<String>,
939    #[serde(skip_serializing_if = "Option::is_none")]
940    pub description: Option<String>,
941    #[serde(skip_serializing_if = "Option::is_none")]
942    pub r#type: Option<String>,
943    #[serde(skip_serializing_if = "Option::is_none")]
944    pub icon: Option<String>,
945    #[serde(skip_serializing_if = "Option::is_none")]
946    pub sources: Option<Vec<String>>,
947    #[serde(skip_serializing_if = "Option::is_none")]
948    pub version: Option<String>,
949    #[serde(skip_serializing_if = "Option::is_none")]
950    pub name: Option<String>,
951    #[serde(skip_serializing_if = "Option::is_none")]
952    pub app_version: Option<String>,
953    #[serde(skip_serializing_if = "Option::is_none")]
954    pub condition: Option<String>,
955    #[serde(skip_serializing_if = "Option::is_none")]
956    pub dependencies: Option<Vec<serde_json::Value>>,
957    #[serde(skip_serializing_if = "Option::is_none")]
958    pub home: Option<String>,
959    #[serde(skip_serializing_if = "Option::is_none")]
960    pub keywords: Option<Vec<String>>,
961    #[serde(skip_serializing_if = "Option::is_none")]
962    pub api_version: Option<String>,
963    #[serde(skip_serializing_if = "Option::is_none")]
964    pub tags: Option<String>,
965    #[serde(skip_serializing_if = "Option::is_none")]
966    pub deprecated: Option<bool>,
967    #[serde(skip_serializing_if = "Option::is_none")]
968    pub maintainers: Option<Vec<serde_json::Value>>,
969    #[serde(skip_serializing_if = "Option::is_none")]
970    pub annotations: Option<serde_json::Value>,
971}
972
973/// DtoActivitySlugDetail 模型
974#[derive(Debug, Clone, Serialize, Deserialize)]
975pub struct DtoActivitySlugDetail {
976    #[serde(skip_serializing_if = "Option::is_none")]
977    pub path: Option<String>,
978}
979
980/// ApiContent 模型
981#[derive(Debug, Clone, Serialize, Deserialize)]
982pub struct ApiContent {
983    #[serde(skip_serializing_if = "Option::is_none")]
984    pub lfs_size: Option<i64>,
985    #[serde(skip_serializing_if = "Option::is_none")]
986    pub lfs_download_url: Option<String>,
987    #[serde(skip_serializing_if = "Option::is_none")]
988    pub encoding: Option<String>,
989    #[serde(skip_serializing_if = "Option::is_none")]
990    pub r#type: Option<String>,
991    #[serde(skip_serializing_if = "Option::is_none")]
992    pub content: Option<String>,
993    #[serde(skip_serializing_if = "Option::is_none")]
994    pub entries: Option<Vec<serde_json::Value>>,
995    #[serde(skip_serializing_if = "Option::is_none")]
996    pub sha: Option<String>,
997    #[serde(skip_serializing_if = "Option::is_none")]
998    pub name: Option<String>,
999    #[serde(skip_serializing_if = "Option::is_none")]
1000    pub lfs_oid: Option<String>,
1001    #[serde(skip_serializing_if = "Option::is_none")]
1002    pub size: Option<i64>,
1003    #[serde(skip_serializing_if = "Option::is_none")]
1004    pub path: Option<String>,
1005}
1006
1007/// DtoAiChatCompletionsReq 模型
1008#[derive(Debug, Clone, Serialize, Deserialize)]
1009pub struct DtoAiChatCompletionsReq {
1010    #[serde(skip_serializing_if = "Option::is_none")]
1011    pub messages: Option<Vec<serde_json::Value>>,
1012    #[serde(skip_serializing_if = "Option::is_none")]
1013    pub model: Option<String>,
1014    #[serde(skip_serializing_if = "Option::is_none")]
1015    pub stream: Option<bool>,
1016}
1017
1018/// DtoContainerAnnotation 模型
1019#[derive(Debug, Clone, Serialize, Deserialize)]
1020pub struct DtoContainerAnnotation {
1021    #[serde(skip_serializing_if = "Option::is_none")]
1022    pub version: Option<String>,
1023    #[serde(skip_serializing_if = "Option::is_none")]
1024    pub sn: Option<String>,
1025    #[serde(skip_serializing_if = "Option::is_none")]
1026    pub revision: Option<String>,
1027}
1028
1029/// DtoPackageDetail 模型
1030#[derive(Debug, Clone, Serialize, Deserialize)]
1031pub struct DtoPackageDetail {
1032    #[serde(skip_serializing_if = "Option::is_none")]
1033    pub composer: Option<serde_json::Value>,
1034    #[serde(skip_serializing_if = "Option::is_none")]
1035    pub conan: Option<serde_json::Value>,
1036    #[serde(skip_serializing_if = "Option::is_none")]
1037    pub ohpm: Option<serde_json::Value>,
1038    #[serde(skip_serializing_if = "Option::is_none")]
1039    pub pypi: Option<serde_json::Value>,
1040    #[serde(skip_serializing_if = "Option::is_none")]
1041    pub cargo: Option<serde_json::Value>,
1042    #[serde(skip_serializing_if = "Option::is_none")]
1043    pub helm: Option<serde_json::Value>,
1044    #[serde(skip_serializing_if = "Option::is_none")]
1045    pub nuget: Option<serde_json::Value>,
1046    #[serde(skip_serializing_if = "Option::is_none")]
1047    pub docker_model: Option<serde_json::Value>,
1048    #[serde(skip_serializing_if = "Option::is_none")]
1049    pub maven: Option<serde_json::Value>,
1050    #[serde(skip_serializing_if = "Option::is_none")]
1051    pub npm: Option<serde_json::Value>,
1052    #[serde(skip_serializing_if = "Option::is_none")]
1053    pub docker: Option<serde_json::Value>,
1054}
1055
1056/// ApiReleaseAsset 模型
1057#[derive(Debug, Clone, Serialize, Deserialize)]
1058pub struct ApiReleaseAsset {
1059    #[serde(skip_serializing_if = "Option::is_none")]
1060    pub uploader: Option<serde_json::Value>,
1061    #[serde(skip_serializing_if = "Option::is_none")]
1062    pub updated_at: Option<String>,
1063    #[serde(skip_serializing_if = "Option::is_none")]
1064    pub content_type: Option<String>,
1065    #[serde(skip_serializing_if = "Option::is_none")]
1066    pub path: Option<String>,
1067    #[serde(skip_serializing_if = "Option::is_none")]
1068    pub id: Option<String>,
1069    #[serde(skip_serializing_if = "Option::is_none")]
1070    pub created_at: Option<String>,
1071    #[serde(skip_serializing_if = "Option::is_none")]
1072    pub name: Option<String>,
1073    #[serde(skip_serializing_if = "Option::is_none")]
1074    pub size: Option<i64>,
1075}
1076
1077/// ConstantRepoDisplayModule 模型
1078#[derive(Debug, Clone, Serialize, Deserialize)]
1079pub struct ConstantRepoDisplayModule {
1080}
1081
1082/// DtoRepoLanguage 模型
1083#[derive(Debug, Clone, Serialize, Deserialize)]
1084pub struct DtoRepoLanguage {
1085    #[serde(skip_serializing_if = "Option::is_none")]
1086    pub language: Option<String>,
1087    #[serde(skip_serializing_if = "Option::is_none")]
1088    pub color: Option<String>,
1089}
1090
1091/// ApiPostIssueCommentForm 模型
1092#[derive(Debug, Clone, Serialize, Deserialize)]
1093pub struct ApiPostIssueCommentForm {
1094    #[serde(skip_serializing_if = "Option::is_none")]
1095    pub body: Option<String>,
1096}
1097
1098/// DtoStartWorkspaceResult 模型
1099#[derive(Debug, Clone, Serialize, Deserialize)]
1100pub struct DtoStartWorkspaceResult {
1101    #[serde(skip_serializing_if = "Option::is_none")]
1102    pub build_log_url: Option<String>,
1103    #[serde(skip_serializing_if = "Option::is_none")]
1104    pub url_data: Option<String>,
1105    #[serde(skip_serializing_if = "Option::is_none")]
1106    pub message: Option<String>,
1107    #[serde(skip_serializing_if = "Option::is_none")]
1108    pub sn: Option<String>,
1109}
1110
1111/// DtoUploadBadgeResult 模型
1112#[derive(Debug, Clone, Serialize, Deserialize)]
1113pub struct DtoUploadBadgeResult {
1114    #[serde(skip_serializing_if = "Option::is_none")]
1115    pub url_data: Option<String>,
1116    #[serde(skip_serializing_if = "Option::is_none")]
1117    pub latest_url: Option<String>,
1118}
1119
1120/// ApiPullReviewer 模型
1121#[derive(Debug, Clone, Serialize, Deserialize)]
1122pub struct ApiPullReviewer {
1123    #[serde(skip_serializing_if = "Option::is_none")]
1124    pub user: Option<serde_json::Value>,
1125    #[serde(skip_serializing_if = "Option::is_none")]
1126    pub review_state: Option<String>,
1127}
1128
1129/// DtoMetaData 模型
1130#[derive(Debug, Clone, Serialize, Deserialize)]
1131pub struct DtoMetaData {
1132    #[serde(skip_serializing_if = "Option::is_none")]
1133    pub license_url: Option<String>,
1134    #[serde(skip_serializing_if = "Option::is_none")]
1135    pub package_name: Option<String>,
1136    #[serde(skip_serializing_if = "Option::is_none")]
1137    pub package_type: Option<String>,
1138    #[serde(skip_serializing_if = "Option::is_none")]
1139    pub readme: Option<String>,
1140    #[serde(skip_serializing_if = "Option::is_none")]
1141    pub author: Option<String>,
1142    #[serde(skip_serializing_if = "Option::is_none")]
1143    pub package_tag: Option<String>,
1144    #[serde(skip_serializing_if = "Option::is_none")]
1145    pub repository_url: Option<String>,
1146    #[serde(skip_serializing_if = "Option::is_none")]
1147    pub home_page: Option<String>,
1148}
1149
1150/// DtoKnowledgeBaseMetadata 模型
1151#[derive(Debug, Clone, Serialize, Deserialize)]
1152pub struct DtoKnowledgeBaseMetadata {
1153    #[serde(skip_serializing_if = "Option::is_none")]
1154    pub processing: Option<serde_json::Value>,
1155    #[serde(skip_serializing_if = "Option::is_none")]
1156    pub version: Option<String>,
1157    #[serde(skip_serializing_if = "Option::is_none")]
1158    pub issue: Option<serde_json::Value>,
1159}
1160
1161/// DtoCodeVulOverview 模型
1162#[derive(Debug, Clone, Serialize, Deserialize)]
1163pub struct DtoCodeVulOverview {
1164    #[serde(skip_serializing_if = "Option::is_none")]
1165    pub medium_vul_open_cnt: Option<i64>,
1166    #[serde(skip_serializing_if = "Option::is_none")]
1167    pub open: Option<i64>,
1168    #[serde(skip_serializing_if = "Option::is_none")]
1169    pub high_vul_open_cnt: Option<i64>,
1170    #[serde(skip_serializing_if = "Option::is_none")]
1171    pub ignored: Option<i64>,
1172    #[serde(skip_serializing_if = "Option::is_none")]
1173    pub critical_vul_open_cnt: Option<i64>,
1174    #[serde(skip_serializing_if = "Option::is_none")]
1175    pub low_vul_open_cnt: Option<i64>,
1176    #[serde(skip_serializing_if = "Option::is_none")]
1177    pub critical_vul_ignore_cnt: Option<i64>,
1178    #[serde(skip_serializing_if = "Option::is_none")]
1179    pub enable: Option<bool>,
1180    #[serde(skip_serializing_if = "Option::is_none")]
1181    pub low_vul_ignore_cnt: Option<i64>,
1182    #[serde(skip_serializing_if = "Option::is_none")]
1183    pub high_vul_ignore_cnt: Option<i64>,
1184    #[serde(skip_serializing_if = "Option::is_none")]
1185    pub medium_vul_ignore_cnt: Option<i64>,
1186}
1187
1188/// ApiRelease 模型
1189#[derive(Debug, Clone, Serialize, Deserialize)]
1190pub struct ApiRelease {
1191    #[serde(skip_serializing_if = "Option::is_none")]
1192    pub body: Option<String>,
1193    #[serde(skip_serializing_if = "Option::is_none")]
1194    pub created_at: Option<String>,
1195    #[serde(skip_serializing_if = "Option::is_none")]
1196    pub author: Option<serde_json::Value>,
1197    #[serde(skip_serializing_if = "Option::is_none")]
1198    pub published_at: Option<String>,
1199    #[serde(skip_serializing_if = "Option::is_none")]
1200    pub tag_commitish: Option<String>,
1201    #[serde(skip_serializing_if = "Option::is_none")]
1202    pub is_latest: Option<bool>,
1203    #[serde(skip_serializing_if = "Option::is_none")]
1204    pub prerelease: Option<bool>,
1205    #[serde(skip_serializing_if = "Option::is_none")]
1206    pub tag_name: Option<String>,
1207    #[serde(skip_serializing_if = "Option::is_none")]
1208    pub updated_at: Option<String>,
1209    #[serde(skip_serializing_if = "Option::is_none")]
1210    pub name: Option<String>,
1211    #[serde(skip_serializing_if = "Option::is_none")]
1212    pub assets: Option<Vec<serde_json::Value>>,
1213    #[serde(skip_serializing_if = "Option::is_none")]
1214    pub id: Option<String>,
1215    #[serde(skip_serializing_if = "Option::is_none")]
1216    pub draft: Option<bool>,
1217}
1218
1219/// DtoStage 模型
1220#[derive(Debug, Clone, Serialize, Deserialize)]
1221pub struct DtoStage {
1222    #[serde(skip_serializing_if = "Option::is_none")]
1223    pub duration: Option<i64>,
1224    #[serde(skip_serializing_if = "Option::is_none")]
1225    pub id: Option<String>,
1226    #[serde(skip_serializing_if = "Option::is_none")]
1227    pub status: Option<String>,
1228}
1229
1230/// DtoWorkspaceListResult 模型
1231#[derive(Debug, Clone, Serialize, Deserialize)]
1232pub struct DtoWorkspaceListResult {
1233    #[serde(skip_serializing_if = "Option::is_none")]
1234    pub list: Option<Vec<serde_json::Value>>,
1235    #[serde(skip_serializing_if = "Option::is_none")]
1236    pub has_more: Option<bool>,
1237    #[serde(skip_serializing_if = "Option::is_none")]
1238    pub page_info: Option<serde_json::Value>,
1239    #[serde(skip_serializing_if = "Option::is_none")]
1240    pub total: Option<i64>,
1241}
1242
1243/// ApiSignature 模型
1244#[derive(Debug, Clone, Serialize, Deserialize)]
1245pub struct ApiSignature {
1246    #[serde(skip_serializing_if = "Option::is_none")]
1247    pub date: Option<String>,
1248    #[serde(skip_serializing_if = "Option::is_none")]
1249    pub name: Option<String>,
1250    #[serde(skip_serializing_if = "Option::is_none")]
1251    pub email: Option<String>,
1252}
1253
1254/// DtoWorkspaceStopReq 模型
1255#[derive(Debug, Clone, Serialize, Deserialize)]
1256pub struct DtoWorkspaceStopReq {
1257    #[serde(skip_serializing_if = "Option::is_none")]
1258    pub sn: Option<String>,
1259    #[serde(skip_serializing_if = "Option::is_none")]
1260    pub pipeline_id: Option<String>,
1261}
1262
1263/// DtoWorkspaceStopResult 模型
1264#[derive(Debug, Clone, Serialize, Deserialize)]
1265pub struct DtoWorkspaceStopResult {
1266    #[serde(skip_serializing_if = "Option::is_none")]
1267    pub message: Option<String>,
1268    #[serde(skip_serializing_if = "Option::is_none")]
1269    pub build_log_url: Option<String>,
1270    #[serde(skip_serializing_if = "Option::is_none")]
1271    pub sn: Option<String>,
1272}
1273
1274/// OpenapiHeadRef 模型
1275#[derive(Debug, Clone, Serialize, Deserialize)]
1276pub struct OpenapiHeadRef {
1277    #[serde(skip_serializing_if = "Option::is_none")]
1278    pub name: Option<String>,
1279    #[serde(skip_serializing_if = "Option::is_none")]
1280    pub protected: Option<bool>,
1281}
1282
1283/// ApiIssueDetail 模型
1284#[derive(Debug, Clone, Serialize, Deserialize)]
1285pub struct ApiIssueDetail {
1286    #[serde(skip_serializing_if = "Option::is_none")]
1287    pub body: Option<String>,
1288    #[serde(skip_serializing_if = "Option::is_none")]
1289    pub updated_at: Option<String>,
1290    #[serde(skip_serializing_if = "Option::is_none")]
1291    pub comment_count: Option<i64>,
1292    #[serde(skip_serializing_if = "Option::is_none")]
1293    pub priority: Option<String>,
1294    #[serde(skip_serializing_if = "Option::is_none")]
1295    pub started_at: Option<String>,
1296    #[serde(skip_serializing_if = "Option::is_none")]
1297    pub author: Option<serde_json::Value>,
1298    #[serde(skip_serializing_if = "Option::is_none")]
1299    pub labels: Option<Vec<serde_json::Value>>,
1300    #[serde(skip_serializing_if = "Option::is_none")]
1301    pub last_acted_at: Option<String>,
1302    #[serde(skip_serializing_if = "Option::is_none")]
1303    pub state: Option<String>,
1304    #[serde(skip_serializing_if = "Option::is_none")]
1305    pub number: Option<String>,
1306    #[serde(skip_serializing_if = "Option::is_none")]
1307    pub ended_at: Option<String>,
1308    #[serde(skip_serializing_if = "Option::is_none")]
1309    pub assignees: Option<Vec<serde_json::Value>>,
1310    #[serde(skip_serializing_if = "Option::is_none")]
1311    pub title: Option<String>,
1312    #[serde(skip_serializing_if = "Option::is_none")]
1313    pub state_reason: Option<String>,
1314    #[serde(skip_serializing_if = "Option::is_none")]
1315    pub created_at: Option<String>,
1316}
1317
1318/// ApiPostLabelForm 模型
1319#[derive(Debug, Clone, Serialize, Deserialize)]
1320pub struct ApiPostLabelForm {
1321    #[serde(skip_serializing_if = "Option::is_none")]
1322    pub color: Option<String>,
1323    #[serde(skip_serializing_if = "Option::is_none")]
1324    pub description: Option<String>,
1325    #[serde(skip_serializing_if = "Option::is_none")]
1326    pub name: Option<String>,
1327}
1328
1329/// DtoUserFollowResult 模型
1330#[derive(Debug, Clone, Serialize, Deserialize)]
1331pub struct DtoUserFollowResult {
1332    #[serde(skip_serializing_if = "Option::is_none")]
1333    pub username: Option<String>,
1334    #[serde(skip_serializing_if = "Option::is_none")]
1335    pub freeze: Option<bool>,
1336    #[serde(skip_serializing_if = "Option::is_none")]
1337    pub locked: Option<bool>,
1338    #[serde(skip_serializing_if = "Option::is_none")]
1339    pub nickname: Option<String>,
1340    #[serde(skip_serializing_if = "Option::is_none")]
1341    pub is_following: Option<bool>,
1342}
1343
1344/// DtoTagDetail 模型
1345#[derive(Debug, Clone, Serialize, Deserialize)]
1346pub struct DtoTagDetail {
1347    #[serde(skip_serializing_if = "Option::is_none")]
1348    pub maven: Option<serde_json::Value>,
1349    #[serde(skip_serializing_if = "Option::is_none")]
1350    pub npm: Option<serde_json::Value>,
1351    #[serde(skip_serializing_if = "Option::is_none")]
1352    pub ohpm: Option<serde_json::Value>,
1353    #[serde(skip_serializing_if = "Option::is_none")]
1354    pub nuget: Option<serde_json::Value>,
1355    #[serde(skip_serializing_if = "Option::is_none")]
1356    pub composer: Option<serde_json::Value>,
1357    #[serde(skip_serializing_if = "Option::is_none")]
1358    pub conan: Option<serde_json::Value>,
1359    #[serde(skip_serializing_if = "Option::is_none")]
1360    pub docker: Option<serde_json::Value>,
1361    #[serde(skip_serializing_if = "Option::is_none")]
1362    pub pypi: Option<serde_json::Value>,
1363    #[serde(skip_serializing_if = "Option::is_none")]
1364    pub helm: Option<serde_json::Value>,
1365    #[serde(skip_serializing_if = "Option::is_none")]
1366    pub docker_model: Option<serde_json::Value>,
1367    #[serde(skip_serializing_if = "Option::is_none")]
1368    pub cargo: Option<serde_json::Value>,
1369}
1370
1371/// DtoContainerImage 模型
1372#[derive(Debug, Clone, Serialize, Deserialize)]
1373pub struct DtoContainerImage {
1374    #[serde(skip_serializing_if = "Option::is_none")]
1375    pub size: Option<i64>,
1376    #[serde(skip_serializing_if = "Option::is_none")]
1377    pub layers: Option<Vec<serde_json::Value>>,
1378    #[serde(skip_serializing_if = "Option::is_none")]
1379    pub digest: Option<String>,
1380    #[serde(skip_serializing_if = "Option::is_none")]
1381    pub arch: Option<String>,
1382    #[serde(skip_serializing_if = "Option::is_none")]
1383    pub os: Option<String>,
1384}
1385
1386/// OpenapiCreateBranchForm 模型
1387#[derive(Debug, Clone, Serialize, Deserialize)]
1388pub struct OpenapiCreateBranchForm {
1389    #[serde(skip_serializing_if = "Option::is_none")]
1390    pub name: Option<String>,
1391    #[serde(skip_serializing_if = "Option::is_none")]
1392    pub start_point: Option<String>,
1393}
1394
1395/// OpenapiPostReleaseForm 模型
1396#[derive(Debug, Clone, Serialize, Deserialize)]
1397pub struct OpenapiPostReleaseForm {
1398    #[serde(skip_serializing_if = "Option::is_none")]
1399    pub name: Option<String>,
1400    #[serde(skip_serializing_if = "Option::is_none")]
1401    pub tag_name: Option<String>,
1402    #[serde(skip_serializing_if = "Option::is_none")]
1403    pub target_commitish: Option<String>,
1404    #[serde(skip_serializing_if = "Option::is_none")]
1405    pub make_latest: Option<String>,
1406    #[serde(skip_serializing_if = "Option::is_none")]
1407    pub prerelease: Option<bool>,
1408    #[serde(skip_serializing_if = "Option::is_none")]
1409    pub body: Option<String>,
1410    #[serde(skip_serializing_if = "Option::is_none")]
1411    pub draft: Option<bool>,
1412}
1413
1414/// OpenapiReleaseAssetUploadUrl 模型
1415#[derive(Debug, Clone, Serialize, Deserialize)]
1416pub struct OpenapiReleaseAssetUploadUrl {
1417    #[serde(skip_serializing_if = "Option::is_none")]
1418    pub upload_url: Option<String>,
1419    #[serde(skip_serializing_if = "Option::is_none")]
1420    pub expires_in_sec: Option<i64>,
1421    #[serde(skip_serializing_if = "Option::is_none")]
1422    pub verify_url: Option<String>,
1423}
1424
1425/// DtoPackageType 模型
1426#[derive(Debug, Clone, Serialize, Deserialize)]
1427pub struct DtoPackageType {
1428}
1429
1430/// WebCommitAnnotationInBatch 模型
1431#[derive(Debug, Clone, Serialize, Deserialize)]
1432pub struct WebCommitAnnotationInBatch {
1433    #[serde(skip_serializing_if = "Option::is_none")]
1434    pub commit_hash: Option<String>,
1435    #[serde(skip_serializing_if = "Option::is_none")]
1436    pub annotations: Option<Vec<serde_json::Value>>,
1437}
1438
1439/// DtoCreateGroupReq 模型
1440#[derive(Debug, Clone, Serialize, Deserialize)]
1441pub struct DtoCreateGroupReq {
1442    #[serde(skip_serializing_if = "Option::is_none")]
1443    pub description: Option<String>,
1444    #[serde(skip_serializing_if = "Option::is_none")]
1445    pub bind_domain: Option<String>,
1446    #[serde(skip_serializing_if = "Option::is_none")]
1447    pub path: Option<String>,
1448    #[serde(skip_serializing_if = "Option::is_none")]
1449    pub remark: Option<String>,
1450}
1451
1452/// ApiPullRequestSettings 模型
1453#[derive(Debug, Clone, Serialize, Deserialize)]
1454pub struct ApiPullRequestSettings {
1455    #[serde(skip_serializing_if = "Option::is_none")]
1456    pub allow_merge_commit_merge: Option<bool>,
1457    #[serde(skip_serializing_if = "Option::is_none")]
1458    pub allow_squash_merge: Option<bool>,
1459    #[serde(skip_serializing_if = "Option::is_none")]
1460    pub allow_rebase_merge: Option<bool>,
1461    #[serde(skip_serializing_if = "Option::is_none")]
1462    pub master_auto_as_reviewer: Option<bool>,
1463    #[serde(skip_serializing_if = "Option::is_none")]
1464    pub squash_commit_message_style: Option<String>,
1465    #[serde(skip_serializing_if = "Option::is_none")]
1466    pub merge_commit_message_style: Option<String>,
1467}
1468
1469/// DtoRepoPatch 模型
1470#[derive(Debug, Clone, Serialize, Deserialize)]
1471pub struct DtoRepoPatch {
1472    #[serde(skip_serializing_if = "Option::is_none")]
1473    pub site: Option<String>,
1474    #[serde(skip_serializing_if = "Option::is_none")]
1475    pub license: Option<String>,
1476    #[serde(skip_serializing_if = "Option::is_none")]
1477    pub description: Option<String>,
1478    #[serde(skip_serializing_if = "Option::is_none")]
1479    pub topics: Option<Vec<String>>,
1480}
1481
1482/// ApiLabel 模型
1483#[derive(Debug, Clone, Serialize, Deserialize)]
1484pub struct ApiLabel {
1485    #[serde(skip_serializing_if = "Option::is_none")]
1486    pub description: Option<String>,
1487    #[serde(skip_serializing_if = "Option::is_none")]
1488    pub name: Option<String>,
1489    #[serde(skip_serializing_if = "Option::is_none")]
1490    pub color: Option<String>,
1491    #[serde(skip_serializing_if = "Option::is_none")]
1492    pub id: Option<String>,
1493}
1494
1495/// DtoRegistryLevelQuotaRsp 模型
1496#[derive(Debug, Clone, Serialize, Deserialize)]
1497pub struct DtoRegistryLevelQuotaRsp {
1498    #[serde(skip_serializing_if = "Option::is_none")]
1499    pub code_repo: Option<serde_json::Value>,
1500    #[serde(skip_serializing_if = "Option::is_none")]
1501    pub common_registry: Option<serde_json::Value>,
1502}
1503
1504/// ApiBlob 模型
1505#[derive(Debug, Clone, Serialize, Deserialize)]
1506pub struct ApiBlob {
1507    #[serde(skip_serializing_if = "Option::is_none")]
1508    pub sha: Option<String>,
1509}
1510
1511/// DtoLastPusher 模型
1512#[derive(Debug, Clone, Serialize, Deserialize)]
1513pub struct DtoLastPusher {
1514    #[serde(skip_serializing_if = "Option::is_none")]
1515    pub is_frozen: Option<bool>,
1516    #[serde(skip_serializing_if = "Option::is_none")]
1517    pub name: Option<String>,
1518    #[serde(skip_serializing_if = "Option::is_none")]
1519    pub push_at: Option<String>,
1520    #[serde(skip_serializing_if = "Option::is_none")]
1521    pub is_lock: Option<bool>,
1522    #[serde(skip_serializing_if = "Option::is_none")]
1523    pub nickname: Option<String>,
1524}
1525
1526/// DtoWorkspaceDeleteResult 模型
1527#[derive(Debug, Clone, Serialize, Deserialize)]
1528pub struct DtoWorkspaceDeleteResult {
1529    #[serde(skip_serializing_if = "Option::is_none")]
1530    pub message: Option<String>,
1531    #[serde(skip_serializing_if = "Option::is_none")]
1532    pub code: Option<i64>,
1533}
1534
1535/// OpenapiPutCommitAnnotationsForm 模型
1536#[derive(Debug, Clone, Serialize, Deserialize)]
1537pub struct OpenapiPutCommitAnnotationsForm {
1538    #[serde(skip_serializing_if = "Option::is_none")]
1539    pub annotations: Option<Vec<serde_json::Value>>,
1540}
1541
1542/// OpenapiCommitAssetUploadUrl 模型
1543#[derive(Debug, Clone, Serialize, Deserialize)]
1544pub struct OpenapiCommitAssetUploadUrl {
1545    #[serde(skip_serializing_if = "Option::is_none")]
1546    pub upload_url: Option<String>,
1547    #[serde(skip_serializing_if = "Option::is_none")]
1548    pub verify_url: Option<String>,
1549    #[serde(skip_serializing_if = "Option::is_none")]
1550    pub expires_in_sec: Option<i64>,
1551}
1552
1553/// ApiPutIssueLabelsForm 模型
1554#[derive(Debug, Clone, Serialize, Deserialize)]
1555pub struct ApiPutIssueLabelsForm {
1556    #[serde(skip_serializing_if = "Option::is_none")]
1557    pub labels: Option<Vec<String>>,
1558}
1559
1560/// DtoContainerImageLayer 模型
1561#[derive(Debug, Clone, Serialize, Deserialize)]
1562pub struct DtoContainerImageLayer {
1563    #[serde(skip_serializing_if = "Option::is_none")]
1564    pub instruction: Option<String>,
1565    #[serde(skip_serializing_if = "Option::is_none")]
1566    pub size: Option<i64>,
1567}
1568
1569/// DtoRepos4UserBase 模型
1570#[derive(Debug, Clone, Serialize, Deserialize)]
1571pub struct DtoRepos4UserBase {
1572    #[serde(skip_serializing_if = "Option::is_none")]
1573    pub mark_count: Option<i64>,
1574    #[serde(skip_serializing_if = "Option::is_none")]
1575    pub languages: Option<serde_json::Value>,
1576    #[serde(skip_serializing_if = "Option::is_none")]
1577    pub path: Option<String>,
1578    #[serde(skip_serializing_if = "Option::is_none")]
1579    pub description: Option<String>,
1580    #[serde(skip_serializing_if = "Option::is_none")]
1581    pub display_module: Option<serde_json::Value>,
1582    #[serde(skip_serializing_if = "Option::is_none")]
1583    pub flags: Option<serde_json::Value>,
1584    #[serde(skip_serializing_if = "Option::is_none")]
1585    pub web_url: Option<String>,
1586    #[serde(skip_serializing_if = "Option::is_none")]
1587    pub site: Option<String>,
1588    #[serde(skip_serializing_if = "Option::is_none")]
1589    pub id: Option<String>,
1590    #[serde(skip_serializing_if = "Option::is_none")]
1591    pub language: Option<String>,
1592    #[serde(skip_serializing_if = "Option::is_none")]
1593    pub name: Option<String>,
1594    #[serde(skip_serializing_if = "Option::is_none")]
1595    pub license: Option<String>,
1596    #[serde(skip_serializing_if = "Option::is_none")]
1597    pub freeze: Option<bool>,
1598    #[serde(skip_serializing_if = "Option::is_none")]
1599    pub last_update_username: Option<String>,
1600    #[serde(skip_serializing_if = "Option::is_none")]
1601    pub open_pull_request_count: Option<i64>,
1602    #[serde(skip_serializing_if = "Option::is_none")]
1603    pub created_at: Option<String>,
1604    #[serde(skip_serializing_if = "Option::is_none")]
1605    pub second_languages: Option<serde_json::Value>,
1606    #[serde(skip_serializing_if = "Option::is_none")]
1607    pub tags: Option<Vec<serde_json::Value>>,
1608    #[serde(skip_serializing_if = "Option::is_none")]
1609    pub fork_count: Option<i64>,
1610    #[serde(skip_serializing_if = "Option::is_none")]
1611    pub open_issue_count: Option<i64>,
1612    #[serde(skip_serializing_if = "Option::is_none")]
1613    pub star_count: Option<i64>,
1614    #[serde(skip_serializing_if = "Option::is_none")]
1615    pub updated_at: Option<String>,
1616    #[serde(skip_serializing_if = "Option::is_none")]
1617    pub forked_from_repo: Option<serde_json::Value>,
1618    #[serde(skip_serializing_if = "Option::is_none")]
1619    pub last_updated_at: Option<serde_json::Value>,
1620    #[serde(skip_serializing_if = "Option::is_none")]
1621    pub topics: Option<String>,
1622    #[serde(skip_serializing_if = "Option::is_none")]
1623    pub status: Option<serde_json::Value>,
1624    #[serde(skip_serializing_if = "Option::is_none")]
1625    pub visibility_level: Option<serde_json::Value>,
1626    #[serde(skip_serializing_if = "Option::is_none")]
1627    pub last_update_nickname: Option<String>,
1628}
1629
1630/// DtoDockerModelDescriptor 模型
1631#[derive(Debug, Clone, Serialize, Deserialize)]
1632pub struct DtoDockerModelDescriptor {
1633    #[serde(skip_serializing_if = "Option::is_none")]
1634    pub created: Option<String>,
1635}
1636
1637/// DtoGetBadgeReq 模型
1638#[derive(Debug, Clone, Serialize, Deserialize)]
1639pub struct DtoGetBadgeReq {
1640    #[serde(skip_serializing_if = "Option::is_none")]
1641    pub branch: Option<String>,
1642}
1643
1644/// DtoMissionViewSelector 模型
1645#[derive(Debug, Clone, Serialize, Deserialize)]
1646pub struct DtoMissionViewSelector {
1647    #[serde(skip_serializing_if = "Option::is_none")]
1648    pub field: Option<String>,
1649    #[serde(skip_serializing_if = "Option::is_none")]
1650    pub operator: Option<serde_json::Value>,
1651    #[serde(skip_serializing_if = "Option::is_none")]
1652    pub value: Option<Vec<String>>,
1653}
1654
1655/// DtoTag 模型
1656#[derive(Debug, Clone, Serialize, Deserialize)]
1657pub struct DtoTag {
1658    #[serde(skip_serializing_if = "Option::is_none")]
1659    pub docker_model: Option<Vec<serde_json::Value>>,
1660    #[serde(skip_serializing_if = "Option::is_none")]
1661    pub package: Option<String>,
1662    #[serde(skip_serializing_if = "Option::is_none")]
1663    pub docker: Option<Vec<serde_json::Value>>,
1664    #[serde(skip_serializing_if = "Option::is_none")]
1665    pub nuget: Option<Vec<serde_json::Value>>,
1666    #[serde(skip_serializing_if = "Option::is_none")]
1667    pub composer: Option<Vec<serde_json::Value>>,
1668    #[serde(skip_serializing_if = "Option::is_none")]
1669    pub cargo: Option<Vec<serde_json::Value>>,
1670    #[serde(skip_serializing_if = "Option::is_none")]
1671    pub conan: Option<Vec<serde_json::Value>>,
1672    #[serde(skip_serializing_if = "Option::is_none")]
1673    pub npm: Option<Vec<serde_json::Value>>,
1674    #[serde(skip_serializing_if = "Option::is_none")]
1675    pub helm: Option<Vec<serde_json::Value>>,
1676    #[serde(skip_serializing_if = "Option::is_none")]
1677    pub ohpm: Option<Vec<serde_json::Value>>,
1678    #[serde(skip_serializing_if = "Option::is_none")]
1679    pub maven: Option<Vec<serde_json::Value>>,
1680    #[serde(skip_serializing_if = "Option::is_none")]
1681    pub pypi: Option<Vec<serde_json::Value>>,
1682}
1683
1684/// DtoUploadRequestParams 模型
1685#[derive(Debug, Clone, Serialize, Deserialize)]
1686pub struct DtoUploadRequestParams {
1687    #[serde(skip_serializing_if = "Option::is_none")]
1688    pub name: Option<String>,
1689    #[serde(skip_serializing_if = "Option::is_none")]
1690    pub ext: Option<serde_json::Value>,
1691    #[serde(skip_serializing_if = "Option::is_none")]
1692    pub size: Option<i64>,
1693}
1694
1695/// FlagsRepo 模型
1696#[derive(Debug, Clone, Serialize, Deserialize)]
1697pub struct FlagsRepo {
1698}
1699
1700/// DtoMissionViewGroup 模型
1701#[derive(Debug, Clone, Serialize, Deserialize)]
1702pub struct DtoMissionViewGroup {
1703    #[serde(skip_serializing_if = "Option::is_none")]
1704    pub order: Option<serde_json::Value>,
1705    #[serde(skip_serializing_if = "Option::is_none")]
1706    pub custom_orders: Option<serde_json::Value>,
1707    #[serde(skip_serializing_if = "Option::is_none")]
1708    pub custom_visible: Option<serde_json::Value>,
1709    #[serde(skip_serializing_if = "Option::is_none")]
1710    pub expended_list: Option<Vec<serde_json::Value>>,
1711    #[serde(skip_serializing_if = "Option::is_none")]
1712    pub field: Option<String>,
1713}
1714
1715/// ConstantUserType 模型
1716#[derive(Debug, Clone, Serialize, Deserialize)]
1717pub struct ConstantUserType {
1718}
1719
1720/// DtoBuildResult 模型
1721#[derive(Debug, Clone, Serialize, Deserialize)]
1722pub struct DtoBuildResult {
1723    #[serde(skip_serializing_if = "Option::is_none")]
1724    pub message: Option<String>,
1725    #[serde(skip_serializing_if = "Option::is_none")]
1726    pub build_log_url: Option<String>,
1727    #[serde(skip_serializing_if = "Option::is_none")]
1728    pub sn: Option<String>,
1729}
1730
1731/// ApiIssue 模型
1732#[derive(Debug, Clone, Serialize, Deserialize)]
1733pub struct ApiIssue {
1734    #[serde(skip_serializing_if = "Option::is_none")]
1735    pub state: Option<String>,
1736    #[serde(skip_serializing_if = "Option::is_none")]
1737    pub state_reason: Option<String>,
1738    #[serde(skip_serializing_if = "Option::is_none")]
1739    pub title: Option<String>,
1740    #[serde(skip_serializing_if = "Option::is_none")]
1741    pub updated_at: Option<String>,
1742    #[serde(skip_serializing_if = "Option::is_none")]
1743    pub last_acted_at: Option<String>,
1744    #[serde(skip_serializing_if = "Option::is_none")]
1745    pub ended_at: Option<String>,
1746    #[serde(skip_serializing_if = "Option::is_none")]
1747    pub assignees: Option<Vec<serde_json::Value>>,
1748    #[serde(skip_serializing_if = "Option::is_none")]
1749    pub author: Option<serde_json::Value>,
1750    #[serde(skip_serializing_if = "Option::is_none")]
1751    pub comment_count: Option<i64>,
1752    #[serde(skip_serializing_if = "Option::is_none")]
1753    pub priority: Option<String>,
1754    #[serde(skip_serializing_if = "Option::is_none")]
1755    pub created_at: Option<String>,
1756    #[serde(skip_serializing_if = "Option::is_none")]
1757    pub labels: Option<Vec<serde_json::Value>>,
1758    #[serde(skip_serializing_if = "Option::is_none")]
1759    pub number: Option<String>,
1760    #[serde(skip_serializing_if = "Option::is_none")]
1761    pub started_at: Option<String>,
1762}
1763
1764/// ApiPatchPullRequest 模型
1765#[derive(Debug, Clone, Serialize, Deserialize)]
1766pub struct ApiPatchPullRequest {
1767    #[serde(skip_serializing_if = "Option::is_none")]
1768    pub state: Option<String>,
1769    #[serde(skip_serializing_if = "Option::is_none")]
1770    pub title: Option<String>,
1771    #[serde(skip_serializing_if = "Option::is_none")]
1772    pub body: Option<String>,
1773}
1774
1775/// ApiPullRef 模型
1776#[derive(Debug, Clone, Serialize, Deserialize)]
1777pub struct ApiPullRef {
1778    #[serde(skip_serializing_if = "Option::is_none")]
1779    pub repo: Option<serde_json::Value>,
1780    #[serde(skip_serializing_if = "Option::is_none")]
1781    pub sha: Option<String>,
1782    #[serde(skip_serializing_if = "Option::is_none")]
1783    pub r#ref: Option<String>,
1784}
1785
1786/// DtoBadgeGroup 模型
1787#[derive(Debug, Clone, Serialize, Deserialize)]
1788pub struct DtoBadgeGroup {
1789    #[serde(skip_serializing_if = "Option::is_none")]
1790    pub status: Option<String>,
1791    #[serde(skip_serializing_if = "Option::is_none")]
1792    pub r#type: Option<String>,
1793    #[serde(skip_serializing_if = "Option::is_none")]
1794    pub type_en: Option<String>,
1795}
1796
1797/// DtoSlugs 模型
1798#[derive(Debug, Clone, Serialize, Deserialize)]
1799pub struct DtoSlugs {
1800    #[serde(skip_serializing_if = "Option::is_none")]
1801    pub created_at: Option<String>,
1802    #[serde(skip_serializing_if = "Option::is_none")]
1803    pub freeze: Option<bool>,
1804    #[serde(skip_serializing_if = "Option::is_none")]
1805    pub root_id: Option<i64>,
1806    #[serde(skip_serializing_if = "Option::is_none")]
1807    pub path: Option<String>,
1808    #[serde(skip_serializing_if = "Option::is_none")]
1809    pub resource_id: Option<i64>,
1810    #[serde(skip_serializing_if = "Option::is_none")]
1811    pub resource_type: Option<serde_json::Value>,
1812    #[serde(skip_serializing_if = "Option::is_none")]
1813    pub updated_at: Option<String>,
1814    #[serde(skip_serializing_if = "Option::is_none")]
1815    pub root_freeze: Option<bool>,
1816}
1817
1818/// DtoUsersResultForSelf 模型
1819#[derive(Debug, Clone, Serialize, Deserialize)]
1820pub struct DtoUsersResultForSelf {
1821    #[serde(skip_serializing_if = "Option::is_none")]
1822    pub editable: Option<serde_json::Value>,
1823    #[serde(skip_serializing_if = "Option::is_none")]
1824    pub gender: Option<i64>,
1825    #[serde(skip_serializing_if = "Option::is_none")]
1826    pub address: Option<String>,
1827    #[serde(skip_serializing_if = "Option::is_none")]
1828    pub reward_amount: Option<i64>,
1829    #[serde(skip_serializing_if = "Option::is_none")]
1830    pub updated_name_at: Option<String>,
1831    #[serde(skip_serializing_if = "Option::is_none")]
1832    pub username: Option<String>,
1833    #[serde(skip_serializing_if = "Option::is_none")]
1834    pub appreciate_status: Option<i64>,
1835    #[serde(skip_serializing_if = "Option::is_none")]
1836    pub follower_count: Option<i64>,
1837    #[serde(skip_serializing_if = "Option::is_none")]
1838    pub registry_count: Option<i64>,
1839    #[serde(skip_serializing_if = "Option::is_none")]
1840    pub last_login_ip: Option<String>,
1841    #[serde(skip_serializing_if = "Option::is_none")]
1842    pub next_updated_name_at: Option<String>,
1843    #[serde(skip_serializing_if = "Option::is_none")]
1844    pub repo_count: Option<i64>,
1845    #[serde(skip_serializing_if = "Option::is_none")]
1846    pub r#type: Option<serde_json::Value>,
1847    #[serde(skip_serializing_if = "Option::is_none")]
1848    pub bio: Option<String>,
1849    #[serde(skip_serializing_if = "Option::is_none")]
1850    pub avatar: Option<String>,
1851    #[serde(skip_serializing_if = "Option::is_none")]
1852    pub email: Option<String>,
1853    #[serde(skip_serializing_if = "Option::is_none")]
1854    pub verified: Option<i64>,
1855    #[serde(skip_serializing_if = "Option::is_none")]
1856    pub follow_count: Option<i64>,
1857    #[serde(skip_serializing_if = "Option::is_none")]
1858    pub last_login_at: Option<String>,
1859    #[serde(skip_serializing_if = "Option::is_none")]
1860    pub created_at: Option<String>,
1861    #[serde(skip_serializing_if = "Option::is_none")]
1862    pub verified_expire_in: Option<String>,
1863    #[serde(skip_serializing_if = "Option::is_none")]
1864    pub group_count: Option<i64>,
1865    #[serde(skip_serializing_if = "Option::is_none")]
1866    pub location: Option<String>,
1867    #[serde(skip_serializing_if = "Option::is_none")]
1868    pub updated_nick_at: Option<String>,
1869    #[serde(skip_serializing_if = "Option::is_none")]
1870    pub company: Option<String>,
1871    #[serde(skip_serializing_if = "Option::is_none")]
1872    pub freeze: Option<bool>,
1873    #[serde(skip_serializing_if = "Option::is_none")]
1874    pub mission_count: Option<i64>,
1875    #[serde(skip_serializing_if = "Option::is_none")]
1876    pub nickname: Option<String>,
1877    #[serde(skip_serializing_if = "Option::is_none")]
1878    pub public_repo_count: Option<i64>,
1879    #[serde(skip_serializing_if = "Option::is_none")]
1880    pub follow_repo_count: Option<i64>,
1881    #[serde(skip_serializing_if = "Option::is_none")]
1882    pub appearance: Option<String>,
1883    #[serde(skip_serializing_if = "Option::is_none")]
1884    pub public_registry_count: Option<i64>,
1885    #[serde(skip_serializing_if = "Option::is_none")]
1886    pub locked: Option<bool>,
1887    #[serde(skip_serializing_if = "Option::is_none")]
1888    pub readme_repo_path: Option<String>,
1889    #[serde(skip_serializing_if = "Option::is_none")]
1890    pub reward_count: Option<i64>,
1891    #[serde(skip_serializing_if = "Option::is_none")]
1892    pub public_mission_count: Option<i64>,
1893    #[serde(skip_serializing_if = "Option::is_none")]
1894    pub stars_count: Option<i64>,
1895    #[serde(skip_serializing_if = "Option::is_none")]
1896    pub wechat_mp_qrcode: Option<String>,
1897    #[serde(skip_serializing_if = "Option::is_none")]
1898    pub wechat_mp: Option<String>,
1899    #[serde(skip_serializing_if = "Option::is_none")]
1900    pub follow_mission_count: Option<i64>,
1901    #[serde(skip_serializing_if = "Option::is_none")]
1902    pub site: Option<String>,
1903    #[serde(skip_serializing_if = "Option::is_none")]
1904    pub language: Option<String>,
1905    #[serde(skip_serializing_if = "Option::is_none")]
1906    pub id: Option<String>,
1907}
1908
1909/// DtoWorkspaceInfo 模型
1910#[derive(Debug, Clone, Serialize, Deserialize)]
1911pub struct DtoWorkspaceInfo {
1912    #[serde(skip_serializing_if = "Option::is_none")]
1913    pub create_time: Option<String>,
1914    #[serde(skip_serializing_if = "Option::is_none")]
1915    pub pipeline_id: Option<String>,
1916    #[serde(skip_serializing_if = "Option::is_none")]
1917    pub commit_count: Option<i64>,
1918    #[serde(skip_serializing_if = "Option::is_none")]
1919    pub file_count: Option<i64>,
1920    #[serde(skip_serializing_if = "Option::is_none")]
1921    pub ssh: Option<bool>,
1922    #[serde(skip_serializing_if = "Option::is_none")]
1923    pub restore_id: Option<String>,
1924    #[serde(skip_serializing_if = "Option::is_none")]
1925    pub latest_sha: Option<String>,
1926    #[serde(skip_serializing_if = "Option::is_none")]
1927    pub slug: Option<String>,
1928    #[serde(skip_serializing_if = "Option::is_none")]
1929    pub sn: Option<String>,
1930    #[serde(skip_serializing_if = "Option::is_none")]
1931    pub remote_stash_count: Option<i64>,
1932    #[serde(skip_serializing_if = "Option::is_none")]
1933    pub workspace: Option<String>,
1934    #[serde(skip_serializing_if = "Option::is_none")]
1935    pub branch: Option<String>,
1936    #[serde(skip_serializing_if = "Option::is_none")]
1937    pub duration: Option<i64>,
1938    #[serde(skip_serializing_if = "Option::is_none")]
1939    pub file_list: Option<String>,
1940    #[serde(skip_serializing_if = "Option::is_none")]
1941    pub repo_url: Option<String>,
1942    #[serde(skip_serializing_if = "Option::is_none")]
1943    pub status: Option<String>,
1944}
1945
1946/// ApiPostIssueForm 模型
1947#[derive(Debug, Clone, Serialize, Deserialize)]
1948pub struct ApiPostIssueForm {
1949    #[serde(skip_serializing_if = "Option::is_none")]
1950    pub labels: Option<Vec<String>>,
1951    #[serde(skip_serializing_if = "Option::is_none")]
1952    pub priority: Option<String>,
1953    #[serde(skip_serializing_if = "Option::is_none")]
1954    pub assignees: Option<Vec<String>>,
1955    #[serde(skip_serializing_if = "Option::is_none")]
1956    pub body: Option<String>,
1957    #[serde(skip_serializing_if = "Option::is_none")]
1958    pub end_date: Option<String>,
1959    #[serde(skip_serializing_if = "Option::is_none")]
1960    pub start_date: Option<String>,
1961    #[serde(skip_serializing_if = "Option::is_none")]
1962    pub title: Option<String>,
1963}
1964
1965/// ApiIssueComment 模型
1966#[derive(Debug, Clone, Serialize, Deserialize)]
1967pub struct ApiIssueComment {
1968    #[serde(skip_serializing_if = "Option::is_none")]
1969    pub updated_at: Option<String>,
1970    #[serde(skip_serializing_if = "Option::is_none")]
1971    pub body: Option<String>,
1972    #[serde(skip_serializing_if = "Option::is_none")]
1973    pub author: Option<serde_json::Value>,
1974    #[serde(skip_serializing_if = "Option::is_none")]
1975    pub created_at: Option<String>,
1976    #[serde(skip_serializing_if = "Option::is_none")]
1977    pub id: Option<String>,
1978}
1979
1980/// WebPipelineSettings 模型
1981#[derive(Debug, Clone, Serialize, Deserialize)]
1982pub struct WebPipelineSettings {
1983    #[serde(skip_serializing_if = "Option::is_none")]
1984    pub auto_trigger: Option<bool>,
1985    #[serde(skip_serializing_if = "Option::is_none")]
1986    pub forked_repo_auto_trigger: Option<bool>,
1987}
1988
1989/// DtoConanRegistryTagDetail 模型
1990#[derive(Debug, Clone, Serialize, Deserialize)]
1991pub struct DtoConanRegistryTagDetail {
1992    #[serde(skip_serializing_if = "Option::is_none")]
1993    pub package: Option<String>,
1994    #[serde(skip_serializing_if = "Option::is_none")]
1995    pub tag: Option<String>,
1996    #[serde(skip_serializing_if = "Option::is_none")]
1997    pub files: Option<Vec<serde_json::Value>>,
1998    #[serde(skip_serializing_if = "Option::is_none")]
1999    pub address: Option<String>,
2000    #[serde(skip_serializing_if = "Option::is_none")]
2001    pub recent_pull_count: Option<i64>,
2002    #[serde(skip_serializing_if = "Option::is_none")]
2003    pub last_pusher: Option<serde_json::Value>,
2004    #[serde(skip_serializing_if = "Option::is_none")]
2005    pub status: Option<String>,
2006    #[serde(skip_serializing_if = "Option::is_none")]
2007    pub metadata: Option<serde_json::Value>,
2008    #[serde(skip_serializing_if = "Option::is_none")]
2009    pub slug: Option<String>,
2010    #[serde(skip_serializing_if = "Option::is_none")]
2011    pub size: Option<i64>,
2012    #[serde(skip_serializing_if = "Option::is_none")]
2013    pub pull_count: Option<i64>,
2014    #[serde(skip_serializing_if = "Option::is_none")]
2015    pub tags: Option<Vec<serde_json::Value>>,
2016    #[serde(skip_serializing_if = "Option::is_none")]
2017    pub dependencies: Option<Vec<serde_json::Value>>,
2018    #[serde(skip_serializing_if = "Option::is_none")]
2019    pub desc: Option<String>,
2020}
2021
2022/// DtoOrganizationAccess 模型
2023#[derive(Debug, Clone, Serialize, Deserialize)]
2024pub struct DtoOrganizationAccess {
2025    #[serde(skip_serializing_if = "Option::is_none")]
2026    pub email: Option<String>,
2027    #[serde(skip_serializing_if = "Option::is_none")]
2028    pub sub_registry_count: Option<i64>,
2029    #[serde(skip_serializing_if = "Option::is_none")]
2030    pub all_member_count: Option<i64>,
2031    #[serde(skip_serializing_if = "Option::is_none")]
2032    pub name: Option<String>,
2033    #[serde(skip_serializing_if = "Option::is_none")]
2034    pub all_sub_mission_count: Option<i64>,
2035    #[serde(skip_serializing_if = "Option::is_none")]
2036    pub member_count: Option<i64>,
2037    #[serde(skip_serializing_if = "Option::is_none")]
2038    pub all_sub_registry_count: Option<i64>,
2039    #[serde(skip_serializing_if = "Option::is_none")]
2040    pub follow_count: Option<i64>,
2041    #[serde(skip_serializing_if = "Option::is_none")]
2042    pub id: Option<i64>,
2043    #[serde(skip_serializing_if = "Option::is_none")]
2044    pub path: Option<String>,
2045    #[serde(skip_serializing_if = "Option::is_none")]
2046    pub pinned_time: Option<String>,
2047    #[serde(skip_serializing_if = "Option::is_none")]
2048    pub site: Option<String>,
2049    #[serde(skip_serializing_if = "Option::is_none")]
2050    pub domain: Option<String>,
2051    #[serde(skip_serializing_if = "Option::is_none")]
2052    pub remark: Option<String>,
2053    #[serde(skip_serializing_if = "Option::is_none")]
2054    pub has_sub_group: Option<bool>,
2055    #[serde(skip_serializing_if = "Option::is_none")]
2056    pub sub_repo_count: Option<i64>,
2057    #[serde(skip_serializing_if = "Option::is_none")]
2058    pub access_role: Option<serde_json::Value>,
2059    #[serde(skip_serializing_if = "Option::is_none")]
2060    pub sub_group_count: Option<i64>,
2061    #[serde(skip_serializing_if = "Option::is_none")]
2062    pub wechat_mp: Option<String>,
2063    #[serde(skip_serializing_if = "Option::is_none")]
2064    pub readme_repo_path: Option<String>,
2065    #[serde(skip_serializing_if = "Option::is_none")]
2066    pub all_sub_repo_count: Option<i64>,
2067    #[serde(skip_serializing_if = "Option::is_none")]
2068    pub description: Option<String>,
2069    #[serde(skip_serializing_if = "Option::is_none")]
2070    pub created_at: Option<String>,
2071    #[serde(skip_serializing_if = "Option::is_none")]
2072    pub sub_mission_count: Option<i64>,
2073    #[serde(skip_serializing_if = "Option::is_none")]
2074    pub freeze: Option<bool>,
2075    #[serde(skip_serializing_if = "Option::is_none")]
2076    pub updated_at: Option<String>,
2077    #[serde(skip_serializing_if = "Option::is_none")]
2078    pub pinned: Option<bool>,
2079    #[serde(skip_serializing_if = "Option::is_none")]
2080    pub all_sub_group_count: Option<i64>,
2081}
2082
2083/// ConstantSlugType 模型
2084#[derive(Debug, Clone, Serialize, Deserialize)]
2085pub struct ConstantSlugType {
2086}
2087
2088/// DieWebError 模型
2089#[derive(Debug, Clone, Serialize, Deserialize)]
2090pub struct DieWebError {
2091    #[serde(skip_serializing_if = "Option::is_none")]
2092    pub errcode: Option<i64>,
2093    #[serde(skip_serializing_if = "Option::is_none")]
2094    pub errmsg: Option<String>,
2095    #[serde(skip_serializing_if = "Option::is_none")]
2096    pub errparam: Option<serde_json::Value>,
2097}
2098
2099/// DtoMissionPostViewReq 模型
2100#[derive(Debug, Clone, Serialize, Deserialize)]
2101pub struct DtoMissionPostViewReq {
2102    #[serde(skip_serializing_if = "Option::is_none")]
2103    pub ids: Option<Vec<String>>,
2104}
2105
2106/// DtoMissionViewFieldConfig 模型
2107#[derive(Debug, Clone, Serialize, Deserialize)]
2108pub struct DtoMissionViewFieldConfig {
2109    #[serde(skip_serializing_if = "Option::is_none")]
2110    pub field: Option<String>,
2111    #[serde(skip_serializing_if = "Option::is_none")]
2112    pub width: Option<i64>,
2113}
2114
2115/// DtoRepoSecurityRiskCnt 模型
2116#[derive(Debug, Clone, Serialize, Deserialize)]
2117pub struct DtoRepoSecurityRiskCnt {
2118    #[serde(skip_serializing_if = "Option::is_none")]
2119    pub code_vulnerability_risk_cnt: Option<i64>,
2120    #[serde(skip_serializing_if = "Option::is_none")]
2121    pub total: Option<i64>,
2122    #[serde(skip_serializing_if = "Option::is_none")]
2123    pub enable: Option<bool>,
2124    #[serde(skip_serializing_if = "Option::is_none")]
2125    pub code_sensitive_risk_cnt: Option<i64>,
2126}
2127
2128/// DtoStartBuildReq 模型
2129#[derive(Debug, Clone, Serialize, Deserialize)]
2130pub struct DtoStartBuildReq {
2131    #[serde(skip_serializing_if = "Option::is_none")]
2132    pub branch: Option<String>,
2133    #[serde(skip_serializing_if = "Option::is_none")]
2134    pub sha: Option<String>,
2135    #[serde(skip_serializing_if = "Option::is_none")]
2136    pub config: Option<String>,
2137    #[serde(skip_serializing_if = "Option::is_none")]
2138    pub event: Option<String>,
2139    #[serde(skip_serializing_if = "Option::is_none")]
2140    pub sync: Option<String>,
2141    #[serde(skip_serializing_if = "Option::is_none")]
2142    pub tag: Option<String>,
2143    #[serde(skip_serializing_if = "Option::is_none")]
2144    pub env: Option<serde_json::Value>,
2145}
2146
2147/// DtoStartWorkspaceReq 模型
2148#[derive(Debug, Clone, Serialize, Deserialize)]
2149pub struct DtoStartWorkspaceReq {
2150    #[serde(skip_serializing_if = "Option::is_none")]
2151    pub branch: Option<String>,
2152    #[serde(skip_serializing_if = "Option::is_none")]
2153    pub r#ref: Option<String>,
2154}
2155
2156/// Dtostorage 模型
2157#[derive(Debug, Clone, Serialize, Deserialize)]
2158pub struct Dtostorage {
2159    #[serde(skip_serializing_if = "Option::is_none")]
2160    pub storage: Option<i64>,
2161}
2162
2163/// DtoListBadgeResult 模型
2164#[derive(Debug, Clone, Serialize, Deserialize)]
2165pub struct DtoListBadgeResult {
2166    #[serde(skip_serializing_if = "Option::is_none")]
2167    pub badges: Option<Vec<serde_json::Value>>,
2168}
2169
2170/// DtoActivityJoinGroupDetail 模型
2171#[derive(Debug, Clone, Serialize, Deserialize)]
2172pub struct DtoActivityJoinGroupDetail {
2173    #[serde(skip_serializing_if = "Option::is_none")]
2174    pub remark: Option<String>,
2175    #[serde(skip_serializing_if = "Option::is_none")]
2176    pub detail: Option<serde_json::Value>,
2177    #[serde(skip_serializing_if = "Option::is_none")]
2178    pub create_at: Option<String>,
2179}
2180
2181/// DtoOperatorType 模型
2182#[derive(Debug, Clone, Serialize, Deserialize)]
2183pub struct DtoOperatorType {
2184}
2185
2186/// DtoPyPiMetaData 模型
2187#[derive(Debug, Clone, Serialize, Deserialize)]
2188pub struct DtoPyPiMetaData {
2189    #[serde(skip_serializing_if = "Option::is_none")]
2190    pub package_tag: Option<String>,
2191    #[serde(skip_serializing_if = "Option::is_none")]
2192    pub author: Option<String>,
2193    #[serde(skip_serializing_if = "Option::is_none")]
2194    pub package_name: Option<String>,
2195    #[serde(skip_serializing_if = "Option::is_none")]
2196    pub repository_url: Option<String>,
2197    #[serde(skip_serializing_if = "Option::is_none")]
2198    pub readme: Option<String>,
2199    #[serde(skip_serializing_if = "Option::is_none")]
2200    pub home_page: Option<String>,
2201    #[serde(skip_serializing_if = "Option::is_none")]
2202    pub license_url: Option<String>,
2203    #[serde(skip_serializing_if = "Option::is_none")]
2204    pub minimum_stability: Option<String>,
2205    #[serde(skip_serializing_if = "Option::is_none")]
2206    pub package_type: Option<String>,
2207}
2208
2209/// ApiMergePullRequest 模型
2210#[derive(Debug, Clone, Serialize, Deserialize)]
2211pub struct ApiMergePullRequest {
2212    #[serde(skip_serializing_if = "Option::is_none")]
2213    pub commit_message: Option<String>,
2214    #[serde(skip_serializing_if = "Option::is_none")]
2215    pub commit_title: Option<String>,
2216    #[serde(skip_serializing_if = "Option::is_none")]
2217    pub merge_style: Option<String>,
2218}
2219
2220/// ApiCommitAsset 模型
2221#[derive(Debug, Clone, Serialize, Deserialize)]
2222pub struct ApiCommitAsset {
2223    #[serde(skip_serializing_if = "Option::is_none")]
2224    pub created_at: Option<String>,
2225    #[serde(skip_serializing_if = "Option::is_none")]
2226    pub id: Option<String>,
2227    #[serde(skip_serializing_if = "Option::is_none")]
2228    pub size_in_byte: Option<i64>,
2229    #[serde(skip_serializing_if = "Option::is_none")]
2230    pub content_type: Option<String>,
2231    #[serde(skip_serializing_if = "Option::is_none")]
2232    pub name: Option<String>,
2233    #[serde(skip_serializing_if = "Option::is_none")]
2234    pub updated_at: Option<String>,
2235    #[serde(skip_serializing_if = "Option::is_none")]
2236    pub path: Option<String>,
2237    #[serde(skip_serializing_if = "Option::is_none")]
2238    pub author: Option<serde_json::Value>,
2239}
2240
2241/// ApiPutPullLabelsForm 模型
2242#[derive(Debug, Clone, Serialize, Deserialize)]
2243pub struct ApiPutPullLabelsForm {
2244    #[serde(skip_serializing_if = "Option::is_none")]
2245    pub labels: Option<Vec<String>>,
2246}
2247
2248/// DtoActivityDate 模型
2249#[derive(Debug, Clone, Serialize, Deserialize)]
2250pub struct DtoActivityDate {
2251    #[serde(skip_serializing_if = "Option::is_none")]
2252    pub code_review_count: Option<i64>,
2253    #[serde(skip_serializing_if = "Option::is_none")]
2254    pub code_reviews: Option<Vec<serde_json::Value>>,
2255    #[serde(skip_serializing_if = "Option::is_none")]
2256    pub issues_count: Option<i64>,
2257    #[serde(skip_serializing_if = "Option::is_none")]
2258    pub commits: Option<Vec<serde_json::Value>>,
2259    #[serde(skip_serializing_if = "Option::is_none")]
2260    pub pull_request_count: Option<i64>,
2261    #[serde(skip_serializing_if = "Option::is_none")]
2262    pub repo_count: Option<i64>,
2263    #[serde(skip_serializing_if = "Option::is_none")]
2264    pub commit_count: Option<i64>,
2265    #[serde(skip_serializing_if = "Option::is_none")]
2266    pub group_count: Option<i64>,
2267    #[serde(skip_serializing_if = "Option::is_none")]
2268    pub repos: Option<Vec<serde_json::Value>>,
2269    #[serde(skip_serializing_if = "Option::is_none")]
2270    pub private_score: Option<i64>,
2271    #[serde(skip_serializing_if = "Option::is_none")]
2272    pub issues: Option<Vec<serde_json::Value>>,
2273    #[serde(skip_serializing_if = "Option::is_none")]
2274    pub pull_requests: Option<Vec<serde_json::Value>>,
2275    #[serde(skip_serializing_if = "Option::is_none")]
2276    pub groups: Option<Vec<serde_json::Value>>,
2277}
2278
2279/// DtoChartPackageDetail 模型
2280#[derive(Debug, Clone, Serialize, Deserialize)]
2281pub struct DtoChartPackageDetail {
2282    #[serde(skip_serializing_if = "Option::is_none")]
2283    pub tag_total: Option<i64>,
2284    #[serde(skip_serializing_if = "Option::is_none")]
2285    pub recent_pull_count: Option<i64>,
2286    #[serde(skip_serializing_if = "Option::is_none")]
2287    pub address: Option<String>,
2288    #[serde(skip_serializing_if = "Option::is_none")]
2289    pub desc: Option<String>,
2290    #[serde(skip_serializing_if = "Option::is_none")]
2291    pub last_pusher: Option<serde_json::Value>,
2292    #[serde(skip_serializing_if = "Option::is_none")]
2293    pub tags: Option<Vec<serde_json::Value>>,
2294    #[serde(skip_serializing_if = "Option::is_none")]
2295    pub slug: Option<String>,
2296    #[serde(skip_serializing_if = "Option::is_none")]
2297    pub package: Option<String>,
2298    #[serde(skip_serializing_if = "Option::is_none")]
2299    pub pull_count: Option<i64>,
2300}
2301
2302/// DtoCommonRegistryPackageDetail 模型
2303#[derive(Debug, Clone, Serialize, Deserialize)]
2304pub struct DtoCommonRegistryPackageDetail {
2305    #[serde(skip_serializing_if = "Option::is_none")]
2306    pub slug: Option<String>,
2307    #[serde(skip_serializing_if = "Option::is_none")]
2308    pub recent_pull_count: Option<i64>,
2309    #[serde(skip_serializing_if = "Option::is_none")]
2310    pub desc: Option<String>,
2311    #[serde(skip_serializing_if = "Option::is_none")]
2312    pub tag_total: Option<i64>,
2313    #[serde(skip_serializing_if = "Option::is_none")]
2314    pub last_pusher: Option<serde_json::Value>,
2315    #[serde(skip_serializing_if = "Option::is_none")]
2316    pub pull_count: Option<i64>,
2317    #[serde(skip_serializing_if = "Option::is_none")]
2318    pub tags: Option<Vec<serde_json::Value>>,
2319    #[serde(skip_serializing_if = "Option::is_none")]
2320    pub address: Option<String>,
2321    #[serde(skip_serializing_if = "Option::is_none")]
2322    pub package: Option<String>,
2323}
2324
2325/// DtoDependency 模型
2326#[derive(Debug, Clone, Serialize, Deserialize)]
2327pub struct DtoDependency {
2328    #[serde(skip_serializing_if = "Option::is_none")]
2329    pub artifact: Option<String>,
2330    #[serde(skip_serializing_if = "Option::is_none")]
2331    pub framework_name: Option<String>,
2332    #[serde(skip_serializing_if = "Option::is_none")]
2333    pub name: Option<String>,
2334}
2335
2336/// DtoDockerModelConfig 模型
2337#[derive(Debug, Clone, Serialize, Deserialize)]
2338pub struct DtoDockerModelConfig {
2339    #[serde(skip_serializing_if = "Option::is_none")]
2340    pub gguf: Option<serde_json::Value>,
2341    #[serde(skip_serializing_if = "Option::is_none")]
2342    pub format_version: Option<String>,
2343    #[serde(skip_serializing_if = "Option::is_none")]
2344    pub size: Option<String>,
2345    #[serde(skip_serializing_if = "Option::is_none")]
2346    pub parameters: Option<String>,
2347    #[serde(skip_serializing_if = "Option::is_none")]
2348    pub architecture: Option<String>,
2349    #[serde(skip_serializing_if = "Option::is_none")]
2350    pub format: Option<String>,
2351    #[serde(skip_serializing_if = "Option::is_none")]
2352    pub quantization: Option<String>,
2353}
2354
2355/// DtoLogInfo 模型
2356#[derive(Debug, Clone, Serialize, Deserialize)]
2357pub struct DtoLogInfo {
2358    #[serde(skip_serializing_if = "Option::is_none")]
2359    pub source_slug: Option<String>,
2360    #[serde(skip_serializing_if = "Option::is_none")]
2361    pub pipeline_total_count: Option<i64>,
2362    #[serde(skip_serializing_if = "Option::is_none")]
2363    pub title: Option<String>,
2364    #[serde(skip_serializing_if = "Option::is_none")]
2365    pub build_log_url: Option<String>,
2366    #[serde(skip_serializing_if = "Option::is_none")]
2367    pub slug: Option<String>,
2368    #[serde(skip_serializing_if = "Option::is_none")]
2369    pub duration: Option<i64>,
2370    #[serde(skip_serializing_if = "Option::is_none")]
2371    pub pipeline_fail_count: Option<i64>,
2372    #[serde(skip_serializing_if = "Option::is_none")]
2373    pub labels: Option<String>,
2374    #[serde(skip_serializing_if = "Option::is_none")]
2375    pub create_time: Option<String>,
2376    #[serde(skip_serializing_if = "Option::is_none")]
2377    pub event: Option<String>,
2378    #[serde(skip_serializing_if = "Option::is_none")]
2379    pub group_name: Option<String>,
2380    #[serde(skip_serializing_if = "Option::is_none")]
2381    pub nick_name: Option<String>,
2382    #[serde(skip_serializing_if = "Option::is_none")]
2383    pub sha: Option<String>,
2384    #[serde(skip_serializing_if = "Option::is_none")]
2385    pub sn: Option<String>,
2386    #[serde(skip_serializing_if = "Option::is_none")]
2387    pub event_url: Option<String>,
2388    #[serde(skip_serializing_if = "Option::is_none")]
2389    pub freeze: Option<bool>,
2390    #[serde(skip_serializing_if = "Option::is_none")]
2391    pub status: Option<String>,
2392    #[serde(skip_serializing_if = "Option::is_none")]
2393    pub source_ref: Option<String>,
2394    #[serde(skip_serializing_if = "Option::is_none")]
2395    pub pipeline_success_count: Option<i64>,
2396    #[serde(skip_serializing_if = "Option::is_none")]
2397    pub user_name: Option<String>,
2398    #[serde(skip_serializing_if = "Option::is_none")]
2399    pub target_ref: Option<String>,
2400    #[serde(skip_serializing_if = "Option::is_none")]
2401    pub commit_title: Option<String>,
2402}
2403
2404/// DtoPipelineLabel 模型
2405#[derive(Debug, Clone, Serialize, Deserialize)]
2406pub struct DtoPipelineLabel {
2407    #[serde(skip_serializing_if = "Option::is_none")]
2408    pub value: Option<Vec<String>>,
2409    #[serde(skip_serializing_if = "Option::is_none")]
2410    pub key: Option<String>,
2411}
2412
2413/// ApiCommit 模型
2414#[derive(Debug, Clone, Serialize, Deserialize)]
2415pub struct ApiCommit {
2416    #[serde(skip_serializing_if = "Option::is_none")]
2417    pub parents: Option<Vec<serde_json::Value>>,
2418    #[serde(skip_serializing_if = "Option::is_none")]
2419    pub author: Option<serde_json::Value>,
2420    #[serde(skip_serializing_if = "Option::is_none")]
2421    pub commit: Option<serde_json::Value>,
2422    #[serde(skip_serializing_if = "Option::is_none")]
2423    pub sha: Option<String>,
2424    #[serde(skip_serializing_if = "Option::is_none")]
2425    pub committer: Option<serde_json::Value>,
2426}
2427
2428/// DtoAiAutoPrReq 模型
2429#[derive(Debug, Clone, Serialize, Deserialize)]
2430pub struct DtoAiAutoPrReq {
2431    #[serde(skip_serializing_if = "Option::is_none")]
2432    pub body: Option<String>,
2433    #[serde(skip_serializing_if = "Option::is_none")]
2434    pub branch: Option<String>,
2435    #[serde(skip_serializing_if = "Option::is_none")]
2436    pub title: Option<String>,
2437}
2438
2439/// DtoActivityCreateRepoDetail 模型
2440#[derive(Debug, Clone, Serialize, Deserialize)]
2441pub struct DtoActivityCreateRepoDetail {
2442    #[serde(skip_serializing_if = "Option::is_none")]
2443    pub detail: Option<serde_json::Value>,
2444    #[serde(skip_serializing_if = "Option::is_none")]
2445    pub exposed_repo_path: Option<String>,
2446    #[serde(skip_serializing_if = "Option::is_none")]
2447    pub repo_unaccessible: Option<bool>,
2448    #[serde(skip_serializing_if = "Option::is_none")]
2449    pub visibility_level: Option<serde_json::Value>,
2450    #[serde(skip_serializing_if = "Option::is_none")]
2451    pub create_at: Option<String>,
2452    #[serde(skip_serializing_if = "Option::is_none")]
2453    pub freeze: Option<bool>,
2454}
2455
2456/// DtoUploadAssetsResponse 模型
2457#[derive(Debug, Clone, Serialize, Deserialize)]
2458pub struct DtoUploadAssetsResponse {
2459    #[serde(skip_serializing_if = "Option::is_none")]
2460    pub assets: Option<serde_json::Value>,
2461    #[serde(skip_serializing_if = "Option::is_none")]
2462    pub form: Option<serde_json::Value>,
2463    #[serde(skip_serializing_if = "Option::is_none")]
2464    pub token: Option<String>,
2465    #[serde(skip_serializing_if = "Option::is_none")]
2466    pub upload_url: Option<String>,
2467}
2468
2469/// DtoGetBadgeResult 模型
2470#[derive(Debug, Clone, Serialize, Deserialize)]
2471pub struct DtoGetBadgeResult {
2472    #[serde(skip_serializing_if = "Option::is_none")]
2473    pub message: Option<String>,
2474    #[serde(skip_serializing_if = "Option::is_none")]
2475    pub color: Option<String>,
2476    #[serde(skip_serializing_if = "Option::is_none")]
2477    pub link: Option<String>,
2478    #[serde(skip_serializing_if = "Option::is_none")]
2479    pub label: Option<String>,
2480    #[serde(skip_serializing_if = "Option::is_none")]
2481    pub links: Option<Vec<String>>,
2482}
2483
2484/// DtoChartTag 模型
2485#[derive(Debug, Clone, Serialize, Deserialize)]
2486pub struct DtoChartTag {
2487    #[serde(skip_serializing_if = "Option::is_none")]
2488    pub metadata: Option<serde_json::Value>,
2489    #[serde(skip_serializing_if = "Option::is_none")]
2490    pub pull_count: Option<i64>,
2491    #[serde(skip_serializing_if = "Option::is_none")]
2492    pub digest: Option<String>,
2493    #[serde(skip_serializing_if = "Option::is_none")]
2494    pub name: Option<String>,
2495    #[serde(skip_serializing_if = "Option::is_none")]
2496    pub size: Option<i64>,
2497    #[serde(skip_serializing_if = "Option::is_none")]
2498    pub address: Option<String>,
2499    #[serde(skip_serializing_if = "Option::is_none")]
2500    pub is_deprecated: Option<bool>,
2501    #[serde(skip_serializing_if = "Option::is_none")]
2502    pub recent_pull_count: Option<i64>,
2503    #[serde(skip_serializing_if = "Option::is_none")]
2504    pub last_pusher: Option<serde_json::Value>,
2505}
2506
2507/// ConstantAccessRole 模型
2508#[derive(Debug, Clone, Serialize, Deserialize)]
2509pub struct ConstantAccessRole {
2510}
2511
2512/// DtoContainerPackageDetail 模型
2513#[derive(Debug, Clone, Serialize, Deserialize)]
2514pub struct DtoContainerPackageDetail {
2515    #[serde(skip_serializing_if = "Option::is_none")]
2516    pub tags: Option<Vec<serde_json::Value>>,
2517    #[serde(skip_serializing_if = "Option::is_none")]
2518    pub last_pusher: Option<serde_json::Value>,
2519    #[serde(skip_serializing_if = "Option::is_none")]
2520    pub desc: Option<String>,
2521    #[serde(skip_serializing_if = "Option::is_none")]
2522    pub package: Option<String>,
2523    #[serde(skip_serializing_if = "Option::is_none")]
2524    pub recent_pull_count: Option<i64>,
2525    #[serde(skip_serializing_if = "Option::is_none")]
2526    pub slug: Option<String>,
2527    #[serde(skip_serializing_if = "Option::is_none")]
2528    pub tag_total: Option<i64>,
2529    #[serde(skip_serializing_if = "Option::is_none")]
2530    pub address: Option<String>,
2531    #[serde(skip_serializing_if = "Option::is_none")]
2532    pub pull_count: Option<i64>,
2533}
2534
2535/// ApiCommitStatuses 模型
2536#[derive(Debug, Clone, Serialize, Deserialize)]
2537pub struct ApiCommitStatuses {
2538    #[serde(skip_serializing_if = "Option::is_none")]
2539    pub state: Option<String>,
2540    #[serde(skip_serializing_if = "Option::is_none")]
2541    pub sha: Option<String>,
2542    #[serde(skip_serializing_if = "Option::is_none")]
2543    pub statuses: Option<Vec<serde_json::Value>>,
2544}
2545
2546/// DtoMessage 模型
2547#[derive(Debug, Clone, Serialize, Deserialize)]
2548pub struct DtoMessage {
2549    #[serde(skip_serializing_if = "Option::is_none")]
2550    pub content: Option<String>,
2551    #[serde(skip_serializing_if = "Option::is_none")]
2552    pub role: Option<String>,
2553}
2554
2555/// DtoProcessingConfig 模型
2556#[derive(Debug, Clone, Serialize, Deserialize)]
2557pub struct DtoProcessingConfig {
2558    #[serde(skip_serializing_if = "Option::is_none")]
2559    pub text_separator: Option<String>,
2560    #[serde(skip_serializing_if = "Option::is_none")]
2561    pub chunk_size: Option<i64>,
2562    #[serde(skip_serializing_if = "Option::is_none")]
2563    pub chunk_overlap: Option<i64>,
2564}
2565
2566/// ApiCommitObject 模型
2567#[derive(Debug, Clone, Serialize, Deserialize)]
2568pub struct ApiCommitObject {
2569    #[serde(skip_serializing_if = "Option::is_none")]
2570    pub author: Option<serde_json::Value>,
2571    #[serde(skip_serializing_if = "Option::is_none")]
2572    pub committer: Option<serde_json::Value>,
2573    #[serde(skip_serializing_if = "Option::is_none")]
2574    pub verification: Option<serde_json::Value>,
2575    #[serde(skip_serializing_if = "Option::is_none")]
2576    pub message: Option<String>,
2577    #[serde(skip_serializing_if = "Option::is_none")]
2578    pub comment_count: Option<i64>,
2579    #[serde(skip_serializing_if = "Option::is_none")]
2580    pub tree: Option<serde_json::Value>,
2581}
2582
2583/// ApiPatchIssueAssigneesForm 模型
2584#[derive(Debug, Clone, Serialize, Deserialize)]
2585pub struct ApiPatchIssueAssigneesForm {
2586    #[serde(skip_serializing_if = "Option::is_none")]
2587    pub assignees: Option<Vec<String>>,
2588}
2589
2590/// ApiPullReviewCommentCreationForm 模型
2591#[derive(Debug, Clone, Serialize, Deserialize)]
2592pub struct ApiPullReviewCommentCreationForm {
2593    #[serde(skip_serializing_if = "Option::is_none")]
2594    pub start_side: Option<String>,
2595    #[serde(skip_serializing_if = "Option::is_none")]
2596    pub start_line: Option<i64>,
2597    #[serde(skip_serializing_if = "Option::is_none")]
2598    pub end_side: Option<String>,
2599    #[serde(skip_serializing_if = "Option::is_none")]
2600    pub body: Option<String>,
2601    #[serde(skip_serializing_if = "Option::is_none")]
2602    pub path: Option<String>,
2603    #[serde(skip_serializing_if = "Option::is_none")]
2604    pub subject_type: Option<String>,
2605    #[serde(skip_serializing_if = "Option::is_none")]
2606    pub end_line: Option<i64>,
2607}
2608
2609/// ApiPostPullAssigneesForm 模型
2610#[derive(Debug, Clone, Serialize, Deserialize)]
2611pub struct ApiPostPullAssigneesForm {
2612    #[serde(skip_serializing_if = "Option::is_none")]
2613    pub assignees: Option<Vec<String>>,
2614}
2615
2616/// DtoBuildStageResult 模型
2617#[derive(Debug, Clone, Serialize, Deserialize)]
2618pub struct DtoBuildStageResult {
2619    #[serde(skip_serializing_if = "Option::is_none")]
2620    pub status: Option<String>,
2621    #[serde(skip_serializing_if = "Option::is_none")]
2622    pub start_time: Option<i64>,
2623    #[serde(skip_serializing_if = "Option::is_none")]
2624    pub name: Option<String>,
2625    #[serde(skip_serializing_if = "Option::is_none")]
2626    pub duration: Option<i64>,
2627    #[serde(skip_serializing_if = "Option::is_none")]
2628    pub end_time: Option<i64>,
2629    #[serde(skip_serializing_if = "Option::is_none")]
2630    pub id: Option<String>,
2631    #[serde(skip_serializing_if = "Option::is_none")]
2632    pub content: Option<Vec<String>>,
2633    #[serde(skip_serializing_if = "Option::is_none")]
2634    pub error: Option<String>,
2635}
2636
2637/// DtoCodeSensitiveSummary 模型
2638#[derive(Debug, Clone, Serialize, Deserialize)]
2639pub struct DtoCodeSensitiveSummary {
2640    #[serde(skip_serializing_if = "Option::is_none")]
2641    pub ignored: Option<i64>,
2642    #[serde(skip_serializing_if = "Option::is_none")]
2643    pub medium_count: Option<i64>,
2644    #[serde(skip_serializing_if = "Option::is_none")]
2645    pub enable: Option<bool>,
2646    #[serde(skip_serializing_if = "Option::is_none")]
2647    pub high_ignore_count: Option<i64>,
2648    #[serde(skip_serializing_if = "Option::is_none")]
2649    pub medium_ignore_count: Option<i64>,
2650    #[serde(skip_serializing_if = "Option::is_none")]
2651    pub low_count: Option<i64>,
2652    #[serde(skip_serializing_if = "Option::is_none")]
2653    pub low_ignore_count: Option<i64>,
2654    #[serde(skip_serializing_if = "Option::is_none")]
2655    pub high_count: Option<i64>,
2656    #[serde(skip_serializing_if = "Option::is_none")]
2657    pub open: Option<i64>,
2658}
2659
2660/// DtoDocumentStatistics 模型
2661#[derive(Debug, Clone, Serialize, Deserialize)]
2662pub struct DtoDocumentStatistics {
2663    #[serde(skip_serializing_if = "Option::is_none")]
2664    pub count: Option<i64>,
2665    #[serde(skip_serializing_if = "Option::is_none")]
2666    pub size: Option<i64>,
2667}
2668
2669/// DtoMissionView 模型
2670#[derive(Debug, Clone, Serialize, Deserialize)]
2671pub struct DtoMissionView {
2672    #[serde(skip_serializing_if = "Option::is_none")]
2673    pub id: Option<String>,
2674    #[serde(skip_serializing_if = "Option::is_none")]
2675    pub name: Option<String>,
2676    #[serde(skip_serializing_if = "Option::is_none")]
2677    pub r#type: Option<serde_json::Value>,
2678}
2679
2680/// DtoPyPiRegistryTagDetail 模型
2681#[derive(Debug, Clone, Serialize, Deserialize)]
2682pub struct DtoPyPiRegistryTagDetail {
2683    #[serde(skip_serializing_if = "Option::is_none")]
2684    pub desc: Option<String>,
2685    #[serde(skip_serializing_if = "Option::is_none")]
2686    pub files: Option<Vec<serde_json::Value>>,
2687    #[serde(skip_serializing_if = "Option::is_none")]
2688    pub dependencies: Option<Vec<serde_json::Value>>,
2689    #[serde(skip_serializing_if = "Option::is_none")]
2690    pub last_pusher: Option<serde_json::Value>,
2691    #[serde(skip_serializing_if = "Option::is_none")]
2692    pub package: Option<String>,
2693    #[serde(skip_serializing_if = "Option::is_none")]
2694    pub metadata: Option<serde_json::Value>,
2695    #[serde(skip_serializing_if = "Option::is_none")]
2696    pub pull_count: Option<i64>,
2697    #[serde(skip_serializing_if = "Option::is_none")]
2698    pub slug: Option<String>,
2699    #[serde(skip_serializing_if = "Option::is_none")]
2700    pub status: Option<String>,
2701    #[serde(skip_serializing_if = "Option::is_none")]
2702    pub tag: Option<String>,
2703    #[serde(skip_serializing_if = "Option::is_none")]
2704    pub tags: Option<Vec<serde_json::Value>>,
2705    #[serde(skip_serializing_if = "Option::is_none")]
2706    pub address: Option<String>,
2707    #[serde(skip_serializing_if = "Option::is_none")]
2708    pub size: Option<i64>,
2709    #[serde(skip_serializing_if = "Option::is_none")]
2710    pub recent_pull_count: Option<i64>,
2711}
2712
2713/// DtoMissionViewSortOrder 模型
2714#[derive(Debug, Clone, Serialize, Deserialize)]
2715pub struct DtoMissionViewSortOrder {
2716}
2717
2718/// ApiMergePullResponse 模型
2719#[derive(Debug, Clone, Serialize, Deserialize)]
2720pub struct ApiMergePullResponse {
2721    #[serde(skip_serializing_if = "Option::is_none")]
2722    pub message: Option<String>,
2723    #[serde(skip_serializing_if = "Option::is_none")]
2724    pub merged: Option<bool>,
2725    #[serde(skip_serializing_if = "Option::is_none")]
2726    pub sha: Option<String>,
2727}
2728
2729/// DtoWorkspaceDeleteReq 模型
2730#[derive(Debug, Clone, Serialize, Deserialize)]
2731pub struct DtoWorkspaceDeleteReq {
2732    #[serde(skip_serializing_if = "Option::is_none")]
2733    pub pipeline_id: Option<String>,
2734    #[serde(skip_serializing_if = "Option::is_none")]
2735    pub sn: Option<String>,
2736}
2737
2738/// DtoWorkspacePageInfo 模型
2739#[derive(Debug, Clone, Serialize, Deserialize)]
2740pub struct DtoWorkspacePageInfo {
2741    #[serde(skip_serializing_if = "Option::is_none")]
2742    pub page: Option<i64>,
2743    #[serde(skip_serializing_if = "Option::is_none")]
2744    pub page_size: Option<i64>,
2745}
2746
2747/// OpenapiPatchReleaseForm 模型
2748#[derive(Debug, Clone, Serialize, Deserialize)]
2749pub struct OpenapiPatchReleaseForm {
2750    #[serde(skip_serializing_if = "Option::is_none")]
2751    pub prerelease: Option<bool>,
2752    #[serde(skip_serializing_if = "Option::is_none")]
2753    pub draft: Option<bool>,
2754    #[serde(skip_serializing_if = "Option::is_none")]
2755    pub make_latest: Option<String>,
2756    #[serde(skip_serializing_if = "Option::is_none")]
2757    pub body: Option<String>,
2758    #[serde(skip_serializing_if = "Option::is_none")]
2759    pub name: Option<String>,
2760}
2761
2762/// ApiDeleteIssueAssigneesForm 模型
2763#[derive(Debug, Clone, Serialize, Deserialize)]
2764pub struct ApiDeleteIssueAssigneesForm {
2765    #[serde(skip_serializing_if = "Option::is_none")]
2766    pub assignees: Option<Vec<String>>,
2767}
2768
2769/// ApiPullCreationForm 模型
2770#[derive(Debug, Clone, Serialize, Deserialize)]
2771pub struct ApiPullCreationForm {
2772    #[serde(skip_serializing_if = "Option::is_none")]
2773    pub head_repo: Option<String>,
2774    #[serde(skip_serializing_if = "Option::is_none")]
2775    pub base: Option<String>,
2776    #[serde(skip_serializing_if = "Option::is_none")]
2777    pub title: Option<String>,
2778    #[serde(skip_serializing_if = "Option::is_none")]
2779    pub head: Option<String>,
2780    #[serde(skip_serializing_if = "Option::is_none")]
2781    pub body: Option<String>,
2782}
2783
2784/// DtoWorkspaceDetailResult 模型
2785#[derive(Debug, Clone, Serialize, Deserialize)]
2786pub struct DtoWorkspaceDetailResult {
2787    #[serde(skip_serializing_if = "Option::is_none")]
2788    pub codebuddy: Option<String>,
2789    #[serde(skip_serializing_if = "Option::is_none")]
2790    pub vscode: Option<String>,
2791    #[serde(skip_serializing_if = "Option::is_none")]
2792    pub jetbrains: Option<serde_json::Value>,
2793    #[serde(skip_serializing_if = "Option::is_none")]
2794    pub codebuddycn: Option<String>,
2795    #[serde(skip_serializing_if = "Option::is_none")]
2796    pub jump_url: Option<String>,
2797    #[serde(skip_serializing_if = "Option::is_none")]
2798    pub remote_ssh: Option<String>,
2799    #[serde(skip_serializing_if = "Option::is_none")]
2800    pub ssh: Option<String>,
2801    #[serde(skip_serializing_if = "Option::is_none")]
2802    pub vscode_insiders: Option<String>,
2803    #[serde(skip_serializing_if = "Option::is_none")]
2804    pub webide: Option<String>,
2805    #[serde(skip_serializing_if = "Option::is_none")]
2806    pub cursor: Option<String>,
2807}
2808
2809/// ApiPatchPullCommentForm 模型
2810#[derive(Debug, Clone, Serialize, Deserialize)]
2811pub struct ApiPatchPullCommentForm {
2812    #[serde(skip_serializing_if = "Option::is_none")]
2813    pub body: Option<String>,
2814}
2815
2816/// DtoPackage 模型
2817#[derive(Debug, Clone, Serialize, Deserialize)]
2818pub struct DtoPackage {
2819    #[serde(skip_serializing_if = "Option::is_none")]
2820    pub name: Option<String>,
2821    #[serde(skip_serializing_if = "Option::is_none")]
2822    pub recent_pull_count: Option<i64>,
2823    #[serde(skip_serializing_if = "Option::is_none")]
2824    pub labels: Option<Vec<String>>,
2825    #[serde(skip_serializing_if = "Option::is_none")]
2826    pub last_artifact_name: Option<String>,
2827    #[serde(skip_serializing_if = "Option::is_none")]
2828    pub last_pusher: Option<serde_json::Value>,
2829    #[serde(skip_serializing_if = "Option::is_none")]
2830    pub pull_count: Option<i64>,
2831    #[serde(skip_serializing_if = "Option::is_none")]
2832    pub description: Option<String>,
2833    #[serde(skip_serializing_if = "Option::is_none")]
2834    pub package: Option<String>,
2835    #[serde(skip_serializing_if = "Option::is_none")]
2836    pub count: Option<i64>,
2837    #[serde(skip_serializing_if = "Option::is_none")]
2838    pub package_type: Option<serde_json::Value>,
2839}
2840
2841/// OpenapiPutCommitAnnotation 模型
2842#[derive(Debug, Clone, Serialize, Deserialize)]
2843pub struct OpenapiPutCommitAnnotation {
2844    #[serde(skip_serializing_if = "Option::is_none")]
2845    pub key: Option<String>,
2846    #[serde(skip_serializing_if = "Option::is_none")]
2847    pub value: Option<String>,
2848}
2849
2850/// DtoRepoSecurityOverview 模型
2851#[derive(Debug, Clone, Serialize, Deserialize)]
2852pub struct DtoRepoSecurityOverview {
2853    #[serde(skip_serializing_if = "Option::is_none")]
2854    pub risk_cnt: Option<serde_json::Value>,
2855    #[serde(skip_serializing_if = "Option::is_none")]
2856    pub code_sensitive: Option<serde_json::Value>,
2857    #[serde(skip_serializing_if = "Option::is_none")]
2858    pub code_vulnerability: Option<serde_json::Value>,
2859}
2860
2861/// ApiPull 模型
2862#[derive(Debug, Clone, Serialize, Deserialize)]
2863pub struct ApiPull {
2864    #[serde(skip_serializing_if = "Option::is_none")]
2865    pub body: Option<String>,
2866    #[serde(skip_serializing_if = "Option::is_none")]
2867    pub is_wip: Option<bool>,
2868    #[serde(skip_serializing_if = "Option::is_none")]
2869    pub state: Option<String>,
2870    #[serde(skip_serializing_if = "Option::is_none")]
2871    pub blocked_on: Option<String>,
2872    #[serde(skip_serializing_if = "Option::is_none")]
2873    pub base: Option<serde_json::Value>,
2874    #[serde(skip_serializing_if = "Option::is_none")]
2875    pub merged_by: Option<serde_json::Value>,
2876    #[serde(skip_serializing_if = "Option::is_none")]
2877    pub head: Option<serde_json::Value>,
2878    #[serde(skip_serializing_if = "Option::is_none")]
2879    pub title: Option<String>,
2880    #[serde(skip_serializing_if = "Option::is_none")]
2881    pub number: Option<String>,
2882    #[serde(skip_serializing_if = "Option::is_none")]
2883    pub reviewers: Option<Vec<serde_json::Value>>,
2884}
2885
2886/// OpenapiPutTagAnnotationsForm 模型
2887#[derive(Debug, Clone, Serialize, Deserialize)]
2888pub struct OpenapiPutTagAnnotationsForm {
2889    #[serde(skip_serializing_if = "Option::is_none")]
2890    pub annotations: Option<Vec<serde_json::Value>>,
2891}
2892
2893/// ApiPatchLabelForm 模型
2894#[derive(Debug, Clone, Serialize, Deserialize)]
2895pub struct ApiPatchLabelForm {
2896    #[serde(skip_serializing_if = "Option::is_none")]
2897    pub new_name: Option<String>,
2898    #[serde(skip_serializing_if = "Option::is_none")]
2899    pub description: Option<String>,
2900    #[serde(skip_serializing_if = "Option::is_none")]
2901    pub color: Option<String>,
2902}
2903
2904/// DtoContainerTag 模型
2905#[derive(Debug, Clone, Serialize, Deserialize)]
2906pub struct DtoContainerTag {
2907    #[serde(skip_serializing_if = "Option::is_none")]
2908    pub pull_count: Option<i64>,
2909    #[serde(skip_serializing_if = "Option::is_none")]
2910    pub recent_pull_count: Option<i64>,
2911    #[serde(skip_serializing_if = "Option::is_none")]
2912    pub images: Option<Vec<serde_json::Value>>,
2913    #[serde(skip_serializing_if = "Option::is_none")]
2914    pub last_pusher: Option<serde_json::Value>,
2915    #[serde(skip_serializing_if = "Option::is_none")]
2916    pub address: Option<String>,
2917    #[serde(skip_serializing_if = "Option::is_none")]
2918    pub name: Option<String>,
2919    #[serde(skip_serializing_if = "Option::is_none")]
2920    pub annotations: Option<serde_json::Value>,
2921}
2922
2923/// ApiCommitParent 模型
2924#[derive(Debug, Clone, Serialize, Deserialize)]
2925pub struct ApiCommitParent {
2926    #[serde(skip_serializing_if = "Option::is_none")]
2927    pub sha: Option<String>,
2928}
2929
2930/// DtoIssueConfig 模型
2931#[derive(Debug, Clone, Serialize, Deserialize)]
2932pub struct DtoIssueConfig {
2933    #[serde(skip_serializing_if = "Option::is_none")]
2934    pub state: Option<String>,
2935    #[serde(skip_serializing_if = "Option::is_none")]
2936    pub labels: Option<String>,
2937}
2938
2939/// ApiCommitDiffFilePatch 模型
2940#[derive(Debug, Clone, Serialize, Deserialize)]
2941pub struct ApiCommitDiffFilePatch {
2942    #[serde(skip_serializing_if = "Option::is_none")]
2943    pub deletions: Option<i64>,
2944    #[serde(skip_serializing_if = "Option::is_none")]
2945    pub previous_mode: Option<String>,
2946    #[serde(skip_serializing_if = "Option::is_none")]
2947    pub status: Option<String>,
2948    #[serde(skip_serializing_if = "Option::is_none")]
2949    pub path: Option<String>,
2950    #[serde(skip_serializing_if = "Option::is_none")]
2951    pub patch: Option<String>,
2952    #[serde(skip_serializing_if = "Option::is_none")]
2953    pub additions: Option<i64>,
2954    #[serde(skip_serializing_if = "Option::is_none")]
2955    pub previous_filename: Option<String>,
2956    #[serde(skip_serializing_if = "Option::is_none")]
2957    pub mode: Option<String>,
2958    #[serde(skip_serializing_if = "Option::is_none")]
2959    pub name: Option<String>,
2960}
2961
2962/// ApiPostTagFrom 模型
2963#[derive(Debug, Clone, Serialize, Deserialize)]
2964pub struct ApiPostTagFrom {
2965    #[serde(skip_serializing_if = "Option::is_none")]
2966    pub name: Option<String>,
2967    #[serde(skip_serializing_if = "Option::is_none")]
2968    pub target: Option<String>,
2969    #[serde(skip_serializing_if = "Option::is_none")]
2970    pub message: Option<String>,
2971}
2972
2973/// DtoBuildLogsResult 模型
2974#[derive(Debug, Clone, Serialize, Deserialize)]
2975pub struct DtoBuildLogsResult {
2976    #[serde(skip_serializing_if = "Option::is_none")]
2977    pub total: Option<i64>,
2978    #[serde(skip_serializing_if = "Option::is_none")]
2979    pub timestamp: Option<i64>,
2980    #[serde(skip_serializing_if = "Option::is_none")]
2981    pub data: Option<Vec<serde_json::Value>>,
2982    #[serde(skip_serializing_if = "Option::is_none")]
2983    pub init: Option<bool>,
2984}
2985
2986/// OpenapiPutTagAnnotation 模型
2987#[derive(Debug, Clone, Serialize, Deserialize)]
2988pub struct OpenapiPutTagAnnotation {
2989    #[serde(skip_serializing_if = "Option::is_none")]
2990    pub value: Option<String>,
2991    #[serde(skip_serializing_if = "Option::is_none")]
2992    pub key: Option<String>,
2993}
2994
2995/// WebTagAnnotation 模型
2996#[derive(Debug, Clone, Serialize, Deserialize)]
2997pub struct WebTagAnnotation {
2998    #[serde(skip_serializing_if = "Option::is_none")]
2999    pub key: Option<String>,
3000    #[serde(skip_serializing_if = "Option::is_none")]
3001    pub meta: Option<serde_json::Value>,
3002    #[serde(skip_serializing_if = "Option::is_none")]
3003    pub value: Option<String>,
3004}
3005
3006/// DtoPipelineStatus 模型
3007#[derive(Debug, Clone, Serialize, Deserialize)]
3008pub struct DtoPipelineStatus {
3009    #[serde(skip_serializing_if = "Option::is_none")]
3010    pub labels: Option<Vec<serde_json::Value>>,
3011    #[serde(skip_serializing_if = "Option::is_none")]
3012    pub metric_duration: Option<f64>,
3013    #[serde(skip_serializing_if = "Option::is_none")]
3014    pub id: Option<String>,
3015    #[serde(skip_serializing_if = "Option::is_none")]
3016    pub stages: Option<Vec<serde_json::Value>>,
3017    #[serde(skip_serializing_if = "Option::is_none")]
3018    pub duration: Option<i64>,
3019    #[serde(skip_serializing_if = "Option::is_none")]
3020    pub status: Option<String>,
3021    #[serde(skip_serializing_if = "Option::is_none")]
3022    pub metric_core_hours: Option<f64>,
3023}
3024
3025/// ApiPullCommentCreationForm 模型
3026#[derive(Debug, Clone, Serialize, Deserialize)]
3027pub struct ApiPullCommentCreationForm {
3028    #[serde(skip_serializing_if = "Option::is_none")]
3029    pub body: Option<String>,
3030}
3031
3032/// ApiPullReviewCreationForm 模型
3033#[derive(Debug, Clone, Serialize, Deserialize)]
3034pub struct ApiPullReviewCreationForm {
3035    #[serde(skip_serializing_if = "Option::is_none")]
3036    pub body: Option<String>,
3037    #[serde(skip_serializing_if = "Option::is_none")]
3038    pub event: Option<String>,
3039    #[serde(skip_serializing_if = "Option::is_none")]
3040    pub comments: Option<Vec<serde_json::Value>>,
3041}
3042
3043/// ApiTag 模型
3044#[derive(Debug, Clone, Serialize, Deserialize)]
3045pub struct ApiTag {
3046    #[serde(skip_serializing_if = "Option::is_none")]
3047    pub target_type: Option<String>,
3048    #[serde(skip_serializing_if = "Option::is_none")]
3049    pub commit: Option<serde_json::Value>,
3050    #[serde(skip_serializing_if = "Option::is_none")]
3051    pub target: Option<String>,
3052    #[serde(skip_serializing_if = "Option::is_none")]
3053    pub verification: Option<serde_json::Value>,
3054    #[serde(skip_serializing_if = "Option::is_none")]
3055    pub name: Option<String>,
3056}
3057
3058/// DtoQueryKnowledgeBaseReq 模型
3059#[derive(Debug, Clone, Serialize, Deserialize)]
3060pub struct DtoQueryKnowledgeBaseReq {
3061    #[serde(skip_serializing_if = "Option::is_none")]
3062    pub score_threshold: Option<f64>,
3063    #[serde(skip_serializing_if = "Option::is_none")]
3064    pub query: Option<String>,
3065    #[serde(skip_serializing_if = "Option::is_none")]
3066    pub top_k: Option<i64>,
3067}
3068
3069/// DtoAiChatCompletionsResult 模型
3070#[derive(Debug, Clone, Serialize, Deserialize)]
3071pub struct DtoAiChatCompletionsResult {
3072    #[serde(skip_serializing_if = "Option::is_none")]
3073    pub created: Option<i64>,
3074    #[serde(skip_serializing_if = "Option::is_none")]
3075    pub id: Option<String>,
3076    #[serde(skip_serializing_if = "Option::is_none")]
3077    pub model: Option<String>,
3078    #[serde(skip_serializing_if = "Option::is_none")]
3079    pub object: Option<String>,
3080    #[serde(skip_serializing_if = "Option::is_none")]
3081    pub choices: Option<Vec<serde_json::Value>>,
3082}
3083
3084/// DtoConanPackage 模型
3085#[derive(Debug, Clone, Serialize, Deserialize)]
3086pub struct DtoConanPackage {
3087    #[serde(skip_serializing_if = "Option::is_none")]
3088    pub options: Option<serde_json::Value>,
3089    #[serde(skip_serializing_if = "Option::is_none")]
3090    pub requires: Option<Vec<String>>,
3091    #[serde(skip_serializing_if = "Option::is_none")]
3092    pub build_type: Option<String>,
3093    #[serde(skip_serializing_if = "Option::is_none")]
3094    pub package_id: Option<String>,
3095    #[serde(skip_serializing_if = "Option::is_none")]
3096    pub package_revision: Option<String>,
3097    #[serde(skip_serializing_if = "Option::is_none")]
3098    pub compiler: Option<serde_json::Value>,
3099    #[serde(skip_serializing_if = "Option::is_none")]
3100    #[serde(rename = "os/arch")]
3101    pub os_arch: Option<String>,
3102}
3103
3104/// ApiPostBlobForm 模型
3105#[derive(Debug, Clone, Serialize, Deserialize)]
3106pub struct ApiPostBlobForm {
3107    #[serde(skip_serializing_if = "Option::is_none")]
3108    pub content: Option<String>,
3109    #[serde(skip_serializing_if = "Option::is_none")]
3110    pub encoding: Option<String>,
3111}
3112
3113/// OpenapiPostCommitAssetUploadUrlForm 模型
3114#[derive(Debug, Clone, Serialize, Deserialize)]
3115pub struct OpenapiPostCommitAssetUploadUrlForm {
3116    #[serde(skip_serializing_if = "Option::is_none")]
3117    pub asset_name: Option<String>,
3118    #[serde(skip_serializing_if = "Option::is_none")]
3119    pub size: Option<i64>,
3120}
3121
3122/// DtoBuildStatusResult 模型
3123#[derive(Debug, Clone, Serialize, Deserialize)]
3124pub struct DtoBuildStatusResult {
3125    #[serde(skip_serializing_if = "Option::is_none")]
3126    pub raw_config: Option<String>,
3127    #[serde(skip_serializing_if = "Option::is_none")]
3128    pub json_config: Option<String>,
3129    #[serde(skip_serializing_if = "Option::is_none")]
3130    pub pipelines_status: Option<serde_json::Value>,
3131    #[serde(skip_serializing_if = "Option::is_none")]
3132    pub status: Option<String>,
3133}
3134
3135/// ApiCompareResponse 模型
3136#[derive(Debug, Clone, Serialize, Deserialize)]
3137pub struct ApiCompareResponse {
3138    #[serde(skip_serializing_if = "Option::is_none")]
3139    pub head_commit: Option<serde_json::Value>,
3140    #[serde(skip_serializing_if = "Option::is_none")]
3141    pub merge_base_commit: Option<serde_json::Value>,
3142    #[serde(skip_serializing_if = "Option::is_none")]
3143    pub total_commits: Option<i64>,
3144    #[serde(skip_serializing_if = "Option::is_none")]
3145    pub base_commit: Option<serde_json::Value>,
3146    #[serde(skip_serializing_if = "Option::is_none")]
3147    pub commits: Option<Vec<serde_json::Value>>,
3148    #[serde(skip_serializing_if = "Option::is_none")]
3149    pub files: Option<Vec<serde_json::Value>>,
3150}
3151
3152/// ApiDeletePullAssigneesForm 模型
3153#[derive(Debug, Clone, Serialize, Deserialize)]
3154pub struct ApiDeletePullAssigneesForm {
3155    #[serde(skip_serializing_if = "Option::is_none")]
3156    pub assignees: Option<Vec<String>>,
3157}
3158
3159/// DtoFile 模型
3160#[derive(Debug, Clone, Serialize, Deserialize)]
3161pub struct DtoFile {
3162    #[serde(skip_serializing_if = "Option::is_none")]
3163    pub name: Option<String>,
3164    #[serde(skip_serializing_if = "Option::is_none")]
3165    pub size: Option<i64>,
3166}
3167
3168/// DtoRepos4User 模型
3169#[derive(Debug, Clone, Serialize, Deserialize)]
3170pub struct DtoRepos4User {
3171    #[serde(skip_serializing_if = "Option::is_none")]
3172    pub updated_at: Option<String>,
3173    #[serde(skip_serializing_if = "Option::is_none")]
3174    pub last_updated_at: Option<serde_json::Value>,
3175    #[serde(skip_serializing_if = "Option::is_none")]
3176    pub flags: Option<serde_json::Value>,
3177    #[serde(skip_serializing_if = "Option::is_none")]
3178    pub second_languages: Option<serde_json::Value>,
3179    #[serde(skip_serializing_if = "Option::is_none")]
3180    pub display_module: Option<serde_json::Value>,
3181    #[serde(skip_serializing_if = "Option::is_none")]
3182    pub site: Option<String>,
3183    #[serde(skip_serializing_if = "Option::is_none")]
3184    pub fork_count: Option<i64>,
3185    #[serde(skip_serializing_if = "Option::is_none")]
3186    pub name: Option<String>,
3187    #[serde(skip_serializing_if = "Option::is_none")]
3188    pub topics: Option<String>,
3189    #[serde(skip_serializing_if = "Option::is_none")]
3190    pub created_at: Option<String>,
3191    #[serde(skip_serializing_if = "Option::is_none")]
3192    pub languages: Option<serde_json::Value>,
3193    #[serde(skip_serializing_if = "Option::is_none")]
3194    pub pinned_time: Option<String>,
3195    #[serde(skip_serializing_if = "Option::is_none")]
3196    pub star_count: Option<i64>,
3197    #[serde(skip_serializing_if = "Option::is_none")]
3198    pub forked_from_repo: Option<serde_json::Value>,
3199    #[serde(skip_serializing_if = "Option::is_none")]
3200    pub description: Option<String>,
3201    #[serde(skip_serializing_if = "Option::is_none")]
3202    pub mark_count: Option<i64>,
3203    #[serde(skip_serializing_if = "Option::is_none")]
3204    pub last_update_username: Option<String>,
3205    #[serde(skip_serializing_if = "Option::is_none")]
3206    pub open_issue_count: Option<i64>,
3207    #[serde(skip_serializing_if = "Option::is_none")]
3208    pub stared: Option<bool>,
3209    #[serde(skip_serializing_if = "Option::is_none")]
3210    pub license: Option<String>,
3211    #[serde(skip_serializing_if = "Option::is_none")]
3212    pub star_time: Option<String>,
3213    #[serde(skip_serializing_if = "Option::is_none")]
3214    pub tags: Option<Vec<serde_json::Value>>,
3215    #[serde(skip_serializing_if = "Option::is_none")]
3216    pub freeze: Option<bool>,
3217    #[serde(skip_serializing_if = "Option::is_none")]
3218    pub language: Option<String>,
3219    #[serde(skip_serializing_if = "Option::is_none")]
3220    pub id: Option<String>,
3221    #[serde(skip_serializing_if = "Option::is_none")]
3222    pub last_update_nickname: Option<String>,
3223    #[serde(skip_serializing_if = "Option::is_none")]
3224    pub pinned: Option<bool>,
3225    #[serde(skip_serializing_if = "Option::is_none")]
3226    pub visibility_level: Option<serde_json::Value>,
3227    #[serde(skip_serializing_if = "Option::is_none")]
3228    pub web_url: Option<String>,
3229    #[serde(skip_serializing_if = "Option::is_none")]
3230    pub open_pull_request_count: Option<i64>,
3231    #[serde(skip_serializing_if = "Option::is_none")]
3232    pub path: Option<String>,
3233    #[serde(skip_serializing_if = "Option::is_none")]
3234    pub access: Option<serde_json::Value>,
3235    #[serde(skip_serializing_if = "Option::is_none")]
3236    pub status: Option<serde_json::Value>,
3237}
3238
3239/// DtoEmbeddingModel 模型
3240#[derive(Debug, Clone, Serialize, Deserialize)]
3241pub struct DtoEmbeddingModel {
3242    #[serde(skip_serializing_if = "Option::is_none")]
3243    pub dimension: Option<i64>,
3244    #[serde(skip_serializing_if = "Option::is_none")]
3245    pub name: Option<String>,
3246}
3247
3248/// DtoUsersResult 模型
3249#[derive(Debug, Clone, Serialize, Deserialize)]
3250pub struct DtoUsersResult {
3251    #[serde(skip_serializing_if = "Option::is_none")]
3252    pub reward_count: Option<i64>,
3253    #[serde(skip_serializing_if = "Option::is_none")]
3254    pub group_count: Option<i64>,
3255    #[serde(skip_serializing_if = "Option::is_none")]
3256    pub wechat_mp: Option<String>,
3257    #[serde(skip_serializing_if = "Option::is_none")]
3258    pub reward_amount: Option<i64>,
3259    #[serde(skip_serializing_if = "Option::is_none")]
3260    pub username: Option<String>,
3261    #[serde(skip_serializing_if = "Option::is_none")]
3262    pub r#type: Option<serde_json::Value>,
3263    #[serde(skip_serializing_if = "Option::is_none")]
3264    pub stars_count: Option<i64>,
3265    #[serde(skip_serializing_if = "Option::is_none")]
3266    pub email: Option<String>,
3267    #[serde(skip_serializing_if = "Option::is_none")]
3268    pub nickname: Option<String>,
3269    #[serde(skip_serializing_if = "Option::is_none")]
3270    pub bio: Option<String>,
3271    #[serde(skip_serializing_if = "Option::is_none")]
3272    pub public_repo_count: Option<i64>,
3273    #[serde(skip_serializing_if = "Option::is_none")]
3274    pub location: Option<String>,
3275    #[serde(skip_serializing_if = "Option::is_none")]
3276    pub follow_count: Option<i64>,
3277    #[serde(skip_serializing_if = "Option::is_none")]
3278    pub follow_mission_count: Option<i64>,
3279    #[serde(skip_serializing_if = "Option::is_none")]
3280    pub gender: Option<i64>,
3281    #[serde(skip_serializing_if = "Option::is_none")]
3282    pub follower_count: Option<i64>,
3283    #[serde(skip_serializing_if = "Option::is_none")]
3284    pub created_at: Option<String>,
3285    #[serde(skip_serializing_if = "Option::is_none")]
3286    pub site: Option<String>,
3287    #[serde(skip_serializing_if = "Option::is_none")]
3288    pub is_following: Option<bool>,
3289    #[serde(skip_serializing_if = "Option::is_none")]
3290    pub avatar: Option<String>,
3291    #[serde(skip_serializing_if = "Option::is_none")]
3292    pub freeze: Option<bool>,
3293    #[serde(skip_serializing_if = "Option::is_none")]
3294    pub company: Option<String>,
3295    #[serde(skip_serializing_if = "Option::is_none")]
3296    pub verified: Option<i64>,
3297    #[serde(skip_serializing_if = "Option::is_none")]
3298    pub address: Option<String>,
3299    #[serde(skip_serializing_if = "Option::is_none")]
3300    pub registry_count: Option<i64>,
3301    #[serde(skip_serializing_if = "Option::is_none")]
3302    pub repo_count: Option<i64>,
3303    #[serde(skip_serializing_if = "Option::is_none")]
3304    pub public_mission_count: Option<i64>,
3305    #[serde(skip_serializing_if = "Option::is_none")]
3306    pub mission_count: Option<i64>,
3307    #[serde(skip_serializing_if = "Option::is_none")]
3308    pub id: Option<String>,
3309    #[serde(skip_serializing_if = "Option::is_none")]
3310    pub follow_repo_count: Option<i64>,
3311    #[serde(skip_serializing_if = "Option::is_none")]
3312    pub public_registry_count: Option<i64>,
3313    #[serde(skip_serializing_if = "Option::is_none")]
3314    pub verified_expire_in: Option<String>,
3315    #[serde(skip_serializing_if = "Option::is_none")]
3316    pub locked: Option<bool>,
3317    #[serde(skip_serializing_if = "Option::is_none")]
3318    pub appreciate_status: Option<i64>,
3319    #[serde(skip_serializing_if = "Option::is_none")]
3320    pub wechat_mp_qrcode: Option<String>,
3321    #[serde(skip_serializing_if = "Option::is_none")]
3322    pub readme_repo_path: Option<String>,
3323}
3324
3325/// WebCommitAnnotation 模型
3326#[derive(Debug, Clone, Serialize, Deserialize)]
3327pub struct WebCommitAnnotation {
3328    #[serde(skip_serializing_if = "Option::is_none")]
3329    pub value: Option<String>,
3330    #[serde(skip_serializing_if = "Option::is_none")]
3331    pub key: Option<String>,
3332    #[serde(skip_serializing_if = "Option::is_none")]
3333    pub meta: Option<serde_json::Value>,
3334}
3335
3336/// DtoBuildLogsDeleteResult 模型
3337#[derive(Debug, Clone, Serialize, Deserialize)]
3338pub struct DtoBuildLogsDeleteResult {
3339    #[serde(skip_serializing_if = "Option::is_none")]
3340    pub message: Option<String>,
3341    #[serde(skip_serializing_if = "Option::is_none")]
3342    pub code: Option<i64>,
3343}
3344
3345/// DtoQuotaRsp 模型
3346#[derive(Debug, Clone, Serialize, Deserialize)]
3347pub struct DtoQuotaRsp {
3348    #[serde(skip_serializing_if = "Option::is_none")]
3349    pub used: Option<serde_json::Value>,
3350    #[serde(skip_serializing_if = "Option::is_none")]
3351    pub storage_per_project: Option<String>,
3352    #[serde(skip_serializing_if = "Option::is_none")]
3353    pub hard: Option<serde_json::Value>,
3354    #[serde(skip_serializing_if = "Option::is_none")]
3355    pub repository_name: Option<String>,
3356}
3357
3358/// DtoTransferSlugReq 模型
3359#[derive(Debug, Clone, Serialize, Deserialize)]
3360pub struct DtoTransferSlugReq {
3361    #[serde(skip_serializing_if = "Option::is_none")]
3362    pub source: Option<String>,
3363    #[serde(skip_serializing_if = "Option::is_none")]
3364    pub target: Option<String>,
3365}
3366
3367/// ApiPullReviewComment 模型
3368#[derive(Debug, Clone, Serialize, Deserialize)]
3369pub struct ApiPullReviewComment {
3370    #[serde(skip_serializing_if = "Option::is_none")]
3371    pub diff_hunk: Option<Vec<serde_json::Value>>,
3372    #[serde(skip_serializing_if = "Option::is_none")]
3373    pub created_at: Option<String>,
3374    #[serde(skip_serializing_if = "Option::is_none")]
3375    pub body: Option<String>,
3376    #[serde(skip_serializing_if = "Option::is_none")]
3377    pub review_id: Option<String>,
3378    #[serde(skip_serializing_if = "Option::is_none")]
3379    pub start_side: Option<String>,
3380    #[serde(skip_serializing_if = "Option::is_none")]
3381    pub id: Option<String>,
3382    #[serde(skip_serializing_if = "Option::is_none")]
3383    pub subject_type: Option<String>,
3384    #[serde(skip_serializing_if = "Option::is_none")]
3385    pub start_line: Option<i64>,
3386    #[serde(skip_serializing_if = "Option::is_none")]
3387    pub updated_at: Option<String>,
3388    #[serde(skip_serializing_if = "Option::is_none")]
3389    pub commit_hash: Option<String>,
3390    #[serde(skip_serializing_if = "Option::is_none")]
3391    pub end_side: Option<String>,
3392    #[serde(skip_serializing_if = "Option::is_none")]
3393    pub end_line: Option<i64>,
3394    #[serde(skip_serializing_if = "Option::is_none")]
3395    pub reply_to_comment_id: Option<String>,
3396    #[serde(skip_serializing_if = "Option::is_none")]
3397    pub author: Option<serde_json::Value>,
3398    #[serde(skip_serializing_if = "Option::is_none")]
3399    pub path: Option<String>,
3400    #[serde(skip_serializing_if = "Option::is_none")]
3401    pub review_state: Option<String>,
3402}
3403
3404/// DtoDockerModelPackageDetail 模型
3405#[derive(Debug, Clone, Serialize, Deserialize)]
3406pub struct DtoDockerModelPackageDetail {
3407    #[serde(skip_serializing_if = "Option::is_none")]
3408    pub recent_pull_count: Option<i64>,
3409    #[serde(skip_serializing_if = "Option::is_none")]
3410    pub slug: Option<String>,
3411    #[serde(skip_serializing_if = "Option::is_none")]
3412    pub tag_total: Option<i64>,
3413    #[serde(skip_serializing_if = "Option::is_none")]
3414    pub tags: Option<Vec<serde_json::Value>>,
3415    #[serde(skip_serializing_if = "Option::is_none")]
3416    pub desc: Option<String>,
3417    #[serde(skip_serializing_if = "Option::is_none")]
3418    pub package: Option<String>,
3419    #[serde(skip_serializing_if = "Option::is_none")]
3420    pub pull_count: Option<i64>,
3421    #[serde(skip_serializing_if = "Option::is_none")]
3422    pub last_pusher: Option<serde_json::Value>,
3423    #[serde(skip_serializing_if = "Option::is_none")]
3424    pub address: Option<String>,
3425}
3426
3427/// ApiPullRefInfo 模型
3428#[derive(Debug, Clone, Serialize, Deserialize)]
3429pub struct ApiPullRefInfo {
3430    #[serde(skip_serializing_if = "Option::is_none")]
3431    pub r#ref: Option<String>,
3432    #[serde(skip_serializing_if = "Option::is_none")]
3433    pub sha: Option<String>,
3434    #[serde(skip_serializing_if = "Option::is_none")]
3435    pub repo: Option<serde_json::Value>,
3436}
3437
3438/// ApiBranchDetail 模型
3439#[derive(Debug, Clone, Serialize, Deserialize)]
3440pub struct ApiBranchDetail {
3441    #[serde(skip_serializing_if = "Option::is_none")]
3442    pub name: Option<String>,
3443    #[serde(skip_serializing_if = "Option::is_none")]
3444    pub dev_meta: Option<Vec<i64>>,
3445    #[serde(skip_serializing_if = "Option::is_none")]
3446    pub commit: Option<serde_json::Value>,
3447    #[serde(skip_serializing_if = "Option::is_none")]
3448    pub protected: Option<bool>,
3449}
3450
3451/// ApiPipelineSettings 模型
3452#[derive(Debug, Clone, Serialize, Deserialize)]
3453pub struct ApiPipelineSettings {
3454    #[serde(skip_serializing_if = "Option::is_none")]
3455    pub auto_trigger: Option<bool>,
3456    #[serde(skip_serializing_if = "Option::is_none")]
3457    pub forked_repo_auto_trigger: Option<bool>,
3458}
3459
3460/// DtoMissionViewGroupCustom 模型
3461#[derive(Debug, Clone, Serialize, Deserialize)]
3462pub struct DtoMissionViewGroupCustom {
3463    #[serde(skip_serializing_if = "Option::is_none")]
3464    pub field: Option<String>,
3465    #[serde(skip_serializing_if = "Option::is_none")]
3466    pub value: Option<Vec<serde_json::Value>>,
3467}
3468