Skip to main content

winterbaume_codebuild/
model.rs

1//! Auto-generated types from Smithy models.
2//! Do not edit manually. Regenerate with:
3//!   smithy-codegen gen-serializers winterbaume-codebuild
4
5#![allow(non_camel_case_types, clippy::upper_case_acronyms, dead_code)]
6
7use serde::{Deserialize, Serialize};
8
9#[derive(Debug, Clone, Default, Deserialize, Serialize)]
10pub struct BatchDeleteBuildsInput {
11    #[serde(default)]
12    pub ids: Vec<String>,
13}
14
15#[derive(Debug, Clone, Default, Deserialize, Serialize)]
16pub struct BatchDeleteBuildsOutput {
17    #[serde(rename = "buildsDeleted")]
18    #[serde(default)]
19    #[serde(skip_serializing_if = "Option::is_none")]
20    pub builds_deleted: Option<Vec<String>>,
21    #[serde(rename = "buildsNotDeleted")]
22    #[serde(default)]
23    #[serde(skip_serializing_if = "Option::is_none")]
24    pub builds_not_deleted: Option<Vec<BuildNotDeleted>>,
25}
26
27#[derive(Debug, Clone, Default, Deserialize, Serialize)]
28pub struct BuildNotDeleted {
29    #[serde(default)]
30    #[serde(skip_serializing_if = "Option::is_none")]
31    pub id: Option<String>,
32    #[serde(rename = "statusCode")]
33    #[serde(default)]
34    #[serde(skip_serializing_if = "Option::is_none")]
35    pub status_code: Option<String>,
36}
37
38#[derive(Debug, Clone, Default, Deserialize, Serialize)]
39pub struct BatchGetBuildBatchesInput {
40    #[serde(default)]
41    pub ids: Vec<String>,
42}
43
44#[derive(Debug, Clone, Default, Deserialize, Serialize)]
45pub struct BatchGetBuildBatchesOutput {
46    #[serde(rename = "buildBatches")]
47    #[serde(default)]
48    #[serde(skip_serializing_if = "Option::is_none")]
49    pub build_batches: Option<Vec<BuildBatch>>,
50    #[serde(rename = "buildBatchesNotFound")]
51    #[serde(default)]
52    #[serde(skip_serializing_if = "Option::is_none")]
53    pub build_batches_not_found: Option<Vec<String>>,
54}
55
56#[derive(Debug, Clone, Default, Deserialize, Serialize)]
57pub struct BuildBatch {
58    #[serde(default)]
59    #[serde(skip_serializing_if = "Option::is_none")]
60    pub arn: Option<String>,
61    #[serde(default)]
62    #[serde(skip_serializing_if = "Option::is_none")]
63    pub artifacts: Option<BuildArtifacts>,
64    #[serde(rename = "buildBatchConfig")]
65    #[serde(default)]
66    #[serde(skip_serializing_if = "Option::is_none")]
67    pub build_batch_config: Option<ProjectBuildBatchConfig>,
68    #[serde(rename = "buildBatchNumber")]
69    #[serde(default)]
70    #[serde(skip_serializing_if = "Option::is_none")]
71    pub build_batch_number: Option<i64>,
72    #[serde(rename = "buildBatchStatus")]
73    #[serde(default)]
74    #[serde(skip_serializing_if = "Option::is_none")]
75    pub build_batch_status: Option<String>,
76    #[serde(rename = "buildGroups")]
77    #[serde(default)]
78    #[serde(skip_serializing_if = "Option::is_none")]
79    pub build_groups: Option<Vec<BuildGroup>>,
80    #[serde(rename = "buildTimeoutInMinutes")]
81    #[serde(default)]
82    #[serde(skip_serializing_if = "Option::is_none")]
83    pub build_timeout_in_minutes: Option<i32>,
84    #[serde(default)]
85    #[serde(skip_serializing_if = "Option::is_none")]
86    pub cache: Option<ProjectCache>,
87    #[serde(default)]
88    #[serde(skip_serializing_if = "Option::is_none")]
89    pub complete: Option<bool>,
90    #[serde(rename = "currentPhase")]
91    #[serde(default)]
92    #[serde(skip_serializing_if = "Option::is_none")]
93    pub current_phase: Option<String>,
94    #[serde(rename = "debugSessionEnabled")]
95    #[serde(default)]
96    #[serde(skip_serializing_if = "Option::is_none")]
97    pub debug_session_enabled: Option<bool>,
98    #[serde(rename = "encryptionKey")]
99    #[serde(default)]
100    #[serde(skip_serializing_if = "Option::is_none")]
101    pub encryption_key: Option<String>,
102    #[serde(rename = "endTime")]
103    #[serde(default)]
104    #[serde(skip_serializing_if = "Option::is_none")]
105    pub end_time: Option<f64>,
106    #[serde(default)]
107    #[serde(skip_serializing_if = "Option::is_none")]
108    pub environment: Option<ProjectEnvironment>,
109    #[serde(rename = "fileSystemLocations")]
110    #[serde(default)]
111    #[serde(skip_serializing_if = "Option::is_none")]
112    pub file_system_locations: Option<Vec<ProjectFileSystemLocation>>,
113    #[serde(default)]
114    #[serde(skip_serializing_if = "Option::is_none")]
115    pub id: Option<String>,
116    #[serde(default)]
117    #[serde(skip_serializing_if = "Option::is_none")]
118    pub initiator: Option<String>,
119    #[serde(rename = "logConfig")]
120    #[serde(default)]
121    #[serde(skip_serializing_if = "Option::is_none")]
122    pub log_config: Option<LogsConfig>,
123    #[serde(default)]
124    #[serde(skip_serializing_if = "Option::is_none")]
125    pub phases: Option<Vec<BuildBatchPhase>>,
126    #[serde(rename = "projectName")]
127    #[serde(default)]
128    #[serde(skip_serializing_if = "Option::is_none")]
129    pub project_name: Option<String>,
130    #[serde(rename = "queuedTimeoutInMinutes")]
131    #[serde(default)]
132    #[serde(skip_serializing_if = "Option::is_none")]
133    pub queued_timeout_in_minutes: Option<i32>,
134    #[serde(rename = "reportArns")]
135    #[serde(default)]
136    #[serde(skip_serializing_if = "Option::is_none")]
137    pub report_arns: Option<Vec<String>>,
138    #[serde(rename = "resolvedSourceVersion")]
139    #[serde(default)]
140    #[serde(skip_serializing_if = "Option::is_none")]
141    pub resolved_source_version: Option<String>,
142    #[serde(rename = "secondaryArtifacts")]
143    #[serde(default)]
144    #[serde(skip_serializing_if = "Option::is_none")]
145    pub secondary_artifacts: Option<Vec<BuildArtifacts>>,
146    #[serde(rename = "secondarySourceVersions")]
147    #[serde(default)]
148    #[serde(skip_serializing_if = "Option::is_none")]
149    pub secondary_source_versions: Option<Vec<ProjectSourceVersion>>,
150    #[serde(rename = "secondarySources")]
151    #[serde(default)]
152    #[serde(skip_serializing_if = "Option::is_none")]
153    pub secondary_sources: Option<Vec<ProjectSource>>,
154    #[serde(rename = "serviceRole")]
155    #[serde(default)]
156    #[serde(skip_serializing_if = "Option::is_none")]
157    pub service_role: Option<String>,
158    #[serde(default)]
159    #[serde(skip_serializing_if = "Option::is_none")]
160    pub source: Option<ProjectSource>,
161    #[serde(rename = "sourceVersion")]
162    #[serde(default)]
163    #[serde(skip_serializing_if = "Option::is_none")]
164    pub source_version: Option<String>,
165    #[serde(rename = "startTime")]
166    #[serde(default)]
167    #[serde(skip_serializing_if = "Option::is_none")]
168    pub start_time: Option<f64>,
169    #[serde(rename = "vpcConfig")]
170    #[serde(default)]
171    #[serde(skip_serializing_if = "Option::is_none")]
172    pub vpc_config: Option<VpcConfig>,
173}
174
175#[derive(Debug, Clone, Default, Deserialize, Serialize)]
176pub struct BuildArtifacts {
177    #[serde(rename = "artifactIdentifier")]
178    #[serde(default)]
179    #[serde(skip_serializing_if = "Option::is_none")]
180    pub artifact_identifier: Option<String>,
181    #[serde(rename = "bucketOwnerAccess")]
182    #[serde(default)]
183    #[serde(skip_serializing_if = "Option::is_none")]
184    pub bucket_owner_access: Option<String>,
185    #[serde(rename = "encryptionDisabled")]
186    #[serde(default)]
187    #[serde(skip_serializing_if = "Option::is_none")]
188    pub encryption_disabled: Option<bool>,
189    #[serde(default)]
190    #[serde(skip_serializing_if = "Option::is_none")]
191    pub location: Option<String>,
192    #[serde(default)]
193    #[serde(skip_serializing_if = "Option::is_none")]
194    pub md5sum: Option<String>,
195    #[serde(rename = "overrideArtifactName")]
196    #[serde(default)]
197    #[serde(skip_serializing_if = "Option::is_none")]
198    pub override_artifact_name: Option<bool>,
199    #[serde(default)]
200    #[serde(skip_serializing_if = "Option::is_none")]
201    pub sha256sum: Option<String>,
202}
203
204#[derive(Debug, Clone, Default, Deserialize, Serialize)]
205pub struct ProjectBuildBatchConfig {
206    #[serde(rename = "batchReportMode")]
207    #[serde(default)]
208    #[serde(skip_serializing_if = "Option::is_none")]
209    pub batch_report_mode: Option<String>,
210    #[serde(rename = "combineArtifacts")]
211    #[serde(default)]
212    #[serde(skip_serializing_if = "Option::is_none")]
213    pub combine_artifacts: Option<bool>,
214    #[serde(default)]
215    #[serde(skip_serializing_if = "Option::is_none")]
216    pub restrictions: Option<BatchRestrictions>,
217    #[serde(rename = "serviceRole")]
218    #[serde(default)]
219    #[serde(skip_serializing_if = "Option::is_none")]
220    pub service_role: Option<String>,
221    #[serde(rename = "timeoutInMins")]
222    #[serde(default)]
223    #[serde(skip_serializing_if = "Option::is_none")]
224    pub timeout_in_mins: Option<i32>,
225}
226
227#[derive(Debug, Clone, Default, Deserialize, Serialize)]
228pub struct BatchRestrictions {
229    #[serde(rename = "computeTypesAllowed")]
230    #[serde(default)]
231    #[serde(skip_serializing_if = "Option::is_none")]
232    pub compute_types_allowed: Option<Vec<String>>,
233    #[serde(rename = "fleetsAllowed")]
234    #[serde(default)]
235    #[serde(skip_serializing_if = "Option::is_none")]
236    pub fleets_allowed: Option<Vec<String>>,
237    #[serde(rename = "maximumBuildsAllowed")]
238    #[serde(default)]
239    #[serde(skip_serializing_if = "Option::is_none")]
240    pub maximum_builds_allowed: Option<i32>,
241}
242
243#[derive(Debug, Clone, Default, Deserialize, Serialize)]
244pub struct BuildGroup {
245    #[serde(rename = "currentBuildSummary")]
246    #[serde(default)]
247    #[serde(skip_serializing_if = "Option::is_none")]
248    pub current_build_summary: Option<BuildSummary>,
249    #[serde(rename = "dependsOn")]
250    #[serde(default)]
251    #[serde(skip_serializing_if = "Option::is_none")]
252    pub depends_on: Option<Vec<String>>,
253    #[serde(default)]
254    #[serde(skip_serializing_if = "Option::is_none")]
255    pub identifier: Option<String>,
256    #[serde(rename = "ignoreFailure")]
257    #[serde(default)]
258    #[serde(skip_serializing_if = "Option::is_none")]
259    pub ignore_failure: Option<bool>,
260    #[serde(rename = "priorBuildSummaryList")]
261    #[serde(default)]
262    #[serde(skip_serializing_if = "Option::is_none")]
263    pub prior_build_summary_list: Option<Vec<BuildSummary>>,
264}
265
266#[derive(Debug, Clone, Default, Deserialize, Serialize)]
267pub struct BuildSummary {
268    #[serde(default)]
269    #[serde(skip_serializing_if = "Option::is_none")]
270    pub arn: Option<String>,
271    #[serde(rename = "buildStatus")]
272    #[serde(default)]
273    #[serde(skip_serializing_if = "Option::is_none")]
274    pub build_status: Option<String>,
275    #[serde(rename = "primaryArtifact")]
276    #[serde(default)]
277    #[serde(skip_serializing_if = "Option::is_none")]
278    pub primary_artifact: Option<ResolvedArtifact>,
279    #[serde(rename = "requestedOn")]
280    #[serde(default)]
281    #[serde(skip_serializing_if = "Option::is_none")]
282    pub requested_on: Option<f64>,
283    #[serde(rename = "secondaryArtifacts")]
284    #[serde(default)]
285    #[serde(skip_serializing_if = "Option::is_none")]
286    pub secondary_artifacts: Option<Vec<ResolvedArtifact>>,
287}
288
289#[derive(Debug, Clone, Default, Deserialize, Serialize)]
290pub struct ResolvedArtifact {
291    #[serde(default)]
292    #[serde(skip_serializing_if = "Option::is_none")]
293    pub identifier: Option<String>,
294    #[serde(default)]
295    #[serde(skip_serializing_if = "Option::is_none")]
296    pub location: Option<String>,
297    #[serde(rename = "type")]
298    #[serde(default)]
299    #[serde(skip_serializing_if = "Option::is_none")]
300    pub r#type: Option<String>,
301}
302
303#[derive(Debug, Clone, Default, Deserialize, Serialize)]
304pub struct ProjectCache {
305    #[serde(rename = "cacheNamespace")]
306    #[serde(default)]
307    #[serde(skip_serializing_if = "Option::is_none")]
308    pub cache_namespace: Option<String>,
309    #[serde(default)]
310    #[serde(skip_serializing_if = "Option::is_none")]
311    pub location: Option<String>,
312    #[serde(default)]
313    #[serde(skip_serializing_if = "Option::is_none")]
314    pub modes: Option<Vec<String>>,
315    #[serde(rename = "type")]
316    #[serde(default)]
317    pub r#type: String,
318}
319
320#[derive(Debug, Clone, Default, Deserialize, Serialize)]
321pub struct ProjectEnvironment {
322    #[serde(default)]
323    #[serde(skip_serializing_if = "Option::is_none")]
324    pub certificate: Option<String>,
325    #[serde(rename = "computeConfiguration")]
326    #[serde(default)]
327    #[serde(skip_serializing_if = "Option::is_none")]
328    pub compute_configuration: Option<ComputeConfiguration>,
329    #[serde(rename = "computeType")]
330    #[serde(default)]
331    pub compute_type: String,
332    #[serde(rename = "dockerServer")]
333    #[serde(default)]
334    #[serde(skip_serializing_if = "Option::is_none")]
335    pub docker_server: Option<DockerServer>,
336    #[serde(rename = "environmentVariables")]
337    #[serde(default)]
338    #[serde(skip_serializing_if = "Option::is_none")]
339    pub environment_variables: Option<Vec<EnvironmentVariable>>,
340    #[serde(default)]
341    #[serde(skip_serializing_if = "Option::is_none")]
342    pub fleet: Option<ProjectFleet>,
343    #[serde(default)]
344    pub image: String,
345    #[serde(rename = "imagePullCredentialsType")]
346    #[serde(default)]
347    #[serde(skip_serializing_if = "Option::is_none")]
348    pub image_pull_credentials_type: Option<String>,
349    #[serde(rename = "privilegedMode")]
350    #[serde(default)]
351    #[serde(skip_serializing_if = "Option::is_none")]
352    pub privileged_mode: Option<bool>,
353    #[serde(rename = "registryCredential")]
354    #[serde(default)]
355    #[serde(skip_serializing_if = "Option::is_none")]
356    pub registry_credential: Option<RegistryCredential>,
357    #[serde(rename = "type")]
358    #[serde(default)]
359    pub r#type: String,
360}
361
362#[derive(Debug, Clone, Default, Deserialize, Serialize)]
363pub struct ComputeConfiguration {
364    #[serde(default)]
365    #[serde(skip_serializing_if = "Option::is_none")]
366    pub disk: Option<i64>,
367    #[serde(rename = "instanceType")]
368    #[serde(default)]
369    #[serde(skip_serializing_if = "Option::is_none")]
370    pub instance_type: Option<String>,
371    #[serde(rename = "machineType")]
372    #[serde(default)]
373    #[serde(skip_serializing_if = "Option::is_none")]
374    pub machine_type: Option<String>,
375    #[serde(default)]
376    #[serde(skip_serializing_if = "Option::is_none")]
377    pub memory: Option<i64>,
378    #[serde(rename = "vCpu")]
379    #[serde(default)]
380    #[serde(skip_serializing_if = "Option::is_none")]
381    pub v_cpu: Option<i64>,
382}
383
384#[derive(Debug, Clone, Default, Deserialize, Serialize)]
385pub struct DockerServer {
386    #[serde(rename = "computeType")]
387    #[serde(default)]
388    pub compute_type: String,
389    #[serde(rename = "securityGroupIds")]
390    #[serde(default)]
391    #[serde(skip_serializing_if = "Option::is_none")]
392    pub security_group_ids: Option<Vec<String>>,
393    #[serde(default)]
394    #[serde(skip_serializing_if = "Option::is_none")]
395    pub status: Option<DockerServerStatus>,
396}
397
398#[derive(Debug, Clone, Default, Deserialize, Serialize)]
399pub struct DockerServerStatus {
400    #[serde(default)]
401    #[serde(skip_serializing_if = "Option::is_none")]
402    pub message: Option<String>,
403    #[serde(default)]
404    #[serde(skip_serializing_if = "Option::is_none")]
405    pub status: Option<String>,
406}
407
408#[derive(Debug, Clone, Default, Deserialize, Serialize)]
409pub struct EnvironmentVariable {
410    #[serde(default)]
411    pub name: String,
412    #[serde(rename = "type")]
413    #[serde(default)]
414    #[serde(skip_serializing_if = "Option::is_none")]
415    pub r#type: Option<String>,
416    #[serde(default)]
417    pub value: String,
418}
419
420#[derive(Debug, Clone, Default, Deserialize, Serialize)]
421pub struct ProjectFleet {
422    #[serde(rename = "fleetArn")]
423    #[serde(default)]
424    #[serde(skip_serializing_if = "Option::is_none")]
425    pub fleet_arn: Option<String>,
426}
427
428#[derive(Debug, Clone, Default, Deserialize, Serialize)]
429pub struct RegistryCredential {
430    #[serde(default)]
431    pub credential: String,
432    #[serde(rename = "credentialProvider")]
433    #[serde(default)]
434    pub credential_provider: String,
435}
436
437#[derive(Debug, Clone, Default, Deserialize, Serialize)]
438pub struct ProjectFileSystemLocation {
439    #[serde(default)]
440    #[serde(skip_serializing_if = "Option::is_none")]
441    pub identifier: Option<String>,
442    #[serde(default)]
443    #[serde(skip_serializing_if = "Option::is_none")]
444    pub location: Option<String>,
445    #[serde(rename = "mountOptions")]
446    #[serde(default)]
447    #[serde(skip_serializing_if = "Option::is_none")]
448    pub mount_options: Option<String>,
449    #[serde(rename = "mountPoint")]
450    #[serde(default)]
451    #[serde(skip_serializing_if = "Option::is_none")]
452    pub mount_point: Option<String>,
453    #[serde(rename = "type")]
454    #[serde(default)]
455    #[serde(skip_serializing_if = "Option::is_none")]
456    pub r#type: Option<String>,
457}
458
459#[derive(Debug, Clone, Default, Deserialize, Serialize)]
460pub struct LogsConfig {
461    #[serde(rename = "cloudWatchLogs")]
462    #[serde(default)]
463    #[serde(skip_serializing_if = "Option::is_none")]
464    pub cloud_watch_logs: Option<CloudWatchLogsConfig>,
465    #[serde(rename = "s3Logs")]
466    #[serde(default)]
467    #[serde(skip_serializing_if = "Option::is_none")]
468    pub s3_logs: Option<S3LogsConfig>,
469}
470
471#[derive(Debug, Clone, Default, Deserialize, Serialize)]
472pub struct CloudWatchLogsConfig {
473    #[serde(rename = "groupName")]
474    #[serde(default)]
475    #[serde(skip_serializing_if = "Option::is_none")]
476    pub group_name: Option<String>,
477    #[serde(default)]
478    pub status: String,
479    #[serde(rename = "streamName")]
480    #[serde(default)]
481    #[serde(skip_serializing_if = "Option::is_none")]
482    pub stream_name: Option<String>,
483}
484
485#[derive(Debug, Clone, Default, Deserialize, Serialize)]
486pub struct S3LogsConfig {
487    #[serde(rename = "bucketOwnerAccess")]
488    #[serde(default)]
489    #[serde(skip_serializing_if = "Option::is_none")]
490    pub bucket_owner_access: Option<String>,
491    #[serde(rename = "encryptionDisabled")]
492    #[serde(default)]
493    #[serde(skip_serializing_if = "Option::is_none")]
494    pub encryption_disabled: Option<bool>,
495    #[serde(default)]
496    #[serde(skip_serializing_if = "Option::is_none")]
497    pub location: Option<String>,
498    #[serde(default)]
499    pub status: String,
500}
501
502#[derive(Debug, Clone, Default, Deserialize, Serialize)]
503pub struct BuildBatchPhase {
504    #[serde(default)]
505    #[serde(skip_serializing_if = "Option::is_none")]
506    pub contexts: Option<Vec<PhaseContext>>,
507    #[serde(rename = "durationInSeconds")]
508    #[serde(default)]
509    #[serde(skip_serializing_if = "Option::is_none")]
510    pub duration_in_seconds: Option<i64>,
511    #[serde(rename = "endTime")]
512    #[serde(default)]
513    #[serde(skip_serializing_if = "Option::is_none")]
514    pub end_time: Option<f64>,
515    #[serde(rename = "phaseStatus")]
516    #[serde(default)]
517    #[serde(skip_serializing_if = "Option::is_none")]
518    pub phase_status: Option<String>,
519    #[serde(rename = "phaseType")]
520    #[serde(default)]
521    #[serde(skip_serializing_if = "Option::is_none")]
522    pub phase_type: Option<String>,
523    #[serde(rename = "startTime")]
524    #[serde(default)]
525    #[serde(skip_serializing_if = "Option::is_none")]
526    pub start_time: Option<f64>,
527}
528
529#[derive(Debug, Clone, Default, Deserialize, Serialize)]
530pub struct PhaseContext {
531    #[serde(default)]
532    #[serde(skip_serializing_if = "Option::is_none")]
533    pub message: Option<String>,
534    #[serde(rename = "statusCode")]
535    #[serde(default)]
536    #[serde(skip_serializing_if = "Option::is_none")]
537    pub status_code: Option<String>,
538}
539
540#[derive(Debug, Clone, Default, Deserialize, Serialize)]
541pub struct ProjectSourceVersion {
542    #[serde(rename = "sourceIdentifier")]
543    #[serde(default)]
544    pub source_identifier: String,
545    #[serde(rename = "sourceVersion")]
546    #[serde(default)]
547    pub source_version: String,
548}
549
550#[derive(Debug, Clone, Default, Deserialize, Serialize)]
551pub struct ProjectSource {
552    #[serde(default)]
553    #[serde(skip_serializing_if = "Option::is_none")]
554    pub auth: Option<SourceAuth>,
555    #[serde(rename = "buildStatusConfig")]
556    #[serde(default)]
557    #[serde(skip_serializing_if = "Option::is_none")]
558    pub build_status_config: Option<BuildStatusConfig>,
559    #[serde(default)]
560    #[serde(skip_serializing_if = "Option::is_none")]
561    pub buildspec: Option<String>,
562    #[serde(rename = "gitCloneDepth")]
563    #[serde(default)]
564    #[serde(skip_serializing_if = "Option::is_none")]
565    pub git_clone_depth: Option<i32>,
566    #[serde(rename = "gitSubmodulesConfig")]
567    #[serde(default)]
568    #[serde(skip_serializing_if = "Option::is_none")]
569    pub git_submodules_config: Option<GitSubmodulesConfig>,
570    #[serde(rename = "insecureSsl")]
571    #[serde(default)]
572    #[serde(skip_serializing_if = "Option::is_none")]
573    pub insecure_ssl: Option<bool>,
574    #[serde(default)]
575    #[serde(skip_serializing_if = "Option::is_none")]
576    pub location: Option<String>,
577    #[serde(rename = "reportBuildStatus")]
578    #[serde(default)]
579    #[serde(skip_serializing_if = "Option::is_none")]
580    pub report_build_status: Option<bool>,
581    #[serde(rename = "sourceIdentifier")]
582    #[serde(default)]
583    #[serde(skip_serializing_if = "Option::is_none")]
584    pub source_identifier: Option<String>,
585    #[serde(rename = "type")]
586    #[serde(default)]
587    pub r#type: String,
588}
589
590#[derive(Debug, Clone, Default, Deserialize, Serialize)]
591pub struct SourceAuth {
592    #[serde(default)]
593    #[serde(skip_serializing_if = "Option::is_none")]
594    pub resource: Option<String>,
595    #[serde(rename = "type")]
596    #[serde(default)]
597    pub r#type: String,
598}
599
600#[derive(Debug, Clone, Default, Deserialize, Serialize)]
601pub struct BuildStatusConfig {
602    #[serde(default)]
603    #[serde(skip_serializing_if = "Option::is_none")]
604    pub context: Option<String>,
605    #[serde(rename = "targetUrl")]
606    #[serde(default)]
607    #[serde(skip_serializing_if = "Option::is_none")]
608    pub target_url: Option<String>,
609}
610
611#[derive(Debug, Clone, Default, Deserialize, Serialize)]
612pub struct GitSubmodulesConfig {
613    #[serde(rename = "fetchSubmodules")]
614    #[serde(default)]
615    pub fetch_submodules: bool,
616}
617
618#[derive(Debug, Clone, Default, Deserialize, Serialize)]
619pub struct VpcConfig {
620    #[serde(rename = "securityGroupIds")]
621    #[serde(default)]
622    #[serde(skip_serializing_if = "Option::is_none")]
623    pub security_group_ids: Option<Vec<String>>,
624    #[serde(default)]
625    #[serde(skip_serializing_if = "Option::is_none")]
626    pub subnets: Option<Vec<String>>,
627    #[serde(rename = "vpcId")]
628    #[serde(default)]
629    #[serde(skip_serializing_if = "Option::is_none")]
630    pub vpc_id: Option<String>,
631}
632
633#[derive(Debug, Clone, Default, Deserialize, Serialize)]
634pub struct BatchGetBuildsInput {
635    #[serde(default)]
636    pub ids: Vec<String>,
637}
638
639#[derive(Debug, Clone, Default, Deserialize, Serialize)]
640pub struct BatchGetBuildsOutput {
641    #[serde(default)]
642    #[serde(skip_serializing_if = "Option::is_none")]
643    pub builds: Option<Vec<Build>>,
644    #[serde(rename = "buildsNotFound")]
645    #[serde(default)]
646    #[serde(skip_serializing_if = "Option::is_none")]
647    pub builds_not_found: Option<Vec<String>>,
648}
649
650#[derive(Debug, Clone, Default, Deserialize, Serialize)]
651pub struct Build {
652    #[serde(default)]
653    #[serde(skip_serializing_if = "Option::is_none")]
654    pub arn: Option<String>,
655    #[serde(default)]
656    #[serde(skip_serializing_if = "Option::is_none")]
657    pub artifacts: Option<BuildArtifacts>,
658    #[serde(rename = "autoRetryConfig")]
659    #[serde(default)]
660    #[serde(skip_serializing_if = "Option::is_none")]
661    pub auto_retry_config: Option<AutoRetryConfig>,
662    #[serde(rename = "buildBatchArn")]
663    #[serde(default)]
664    #[serde(skip_serializing_if = "Option::is_none")]
665    pub build_batch_arn: Option<String>,
666    #[serde(rename = "buildComplete")]
667    #[serde(default)]
668    #[serde(skip_serializing_if = "Option::is_none")]
669    pub build_complete: Option<bool>,
670    #[serde(rename = "buildNumber")]
671    #[serde(default)]
672    #[serde(skip_serializing_if = "Option::is_none")]
673    pub build_number: Option<i64>,
674    #[serde(rename = "buildStatus")]
675    #[serde(default)]
676    #[serde(skip_serializing_if = "Option::is_none")]
677    pub build_status: Option<String>,
678    #[serde(default)]
679    #[serde(skip_serializing_if = "Option::is_none")]
680    pub cache: Option<ProjectCache>,
681    #[serde(rename = "currentPhase")]
682    #[serde(default)]
683    #[serde(skip_serializing_if = "Option::is_none")]
684    pub current_phase: Option<String>,
685    #[serde(rename = "debugSession")]
686    #[serde(default)]
687    #[serde(skip_serializing_if = "Option::is_none")]
688    pub debug_session: Option<DebugSession>,
689    #[serde(rename = "encryptionKey")]
690    #[serde(default)]
691    #[serde(skip_serializing_if = "Option::is_none")]
692    pub encryption_key: Option<String>,
693    #[serde(rename = "endTime")]
694    #[serde(default)]
695    #[serde(skip_serializing_if = "Option::is_none")]
696    pub end_time: Option<f64>,
697    #[serde(default)]
698    #[serde(skip_serializing_if = "Option::is_none")]
699    pub environment: Option<ProjectEnvironment>,
700    #[serde(rename = "exportedEnvironmentVariables")]
701    #[serde(default)]
702    #[serde(skip_serializing_if = "Option::is_none")]
703    pub exported_environment_variables: Option<Vec<ExportedEnvironmentVariable>>,
704    #[serde(rename = "fileSystemLocations")]
705    #[serde(default)]
706    #[serde(skip_serializing_if = "Option::is_none")]
707    pub file_system_locations: Option<Vec<ProjectFileSystemLocation>>,
708    #[serde(default)]
709    #[serde(skip_serializing_if = "Option::is_none")]
710    pub id: Option<String>,
711    #[serde(default)]
712    #[serde(skip_serializing_if = "Option::is_none")]
713    pub initiator: Option<String>,
714    #[serde(default)]
715    #[serde(skip_serializing_if = "Option::is_none")]
716    pub logs: Option<LogsLocation>,
717    #[serde(rename = "networkInterface")]
718    #[serde(default)]
719    #[serde(skip_serializing_if = "Option::is_none")]
720    pub network_interface: Option<NetworkInterface>,
721    #[serde(default)]
722    #[serde(skip_serializing_if = "Option::is_none")]
723    pub phases: Option<Vec<BuildPhase>>,
724    #[serde(rename = "projectName")]
725    #[serde(default)]
726    #[serde(skip_serializing_if = "Option::is_none")]
727    pub project_name: Option<String>,
728    #[serde(rename = "queuedTimeoutInMinutes")]
729    #[serde(default)]
730    #[serde(skip_serializing_if = "Option::is_none")]
731    pub queued_timeout_in_minutes: Option<i32>,
732    #[serde(rename = "reportArns")]
733    #[serde(default)]
734    #[serde(skip_serializing_if = "Option::is_none")]
735    pub report_arns: Option<Vec<String>>,
736    #[serde(rename = "resolvedSourceVersion")]
737    #[serde(default)]
738    #[serde(skip_serializing_if = "Option::is_none")]
739    pub resolved_source_version: Option<String>,
740    #[serde(rename = "secondaryArtifacts")]
741    #[serde(default)]
742    #[serde(skip_serializing_if = "Option::is_none")]
743    pub secondary_artifacts: Option<Vec<BuildArtifacts>>,
744    #[serde(rename = "secondarySourceVersions")]
745    #[serde(default)]
746    #[serde(skip_serializing_if = "Option::is_none")]
747    pub secondary_source_versions: Option<Vec<ProjectSourceVersion>>,
748    #[serde(rename = "secondarySources")]
749    #[serde(default)]
750    #[serde(skip_serializing_if = "Option::is_none")]
751    pub secondary_sources: Option<Vec<ProjectSource>>,
752    #[serde(rename = "serviceRole")]
753    #[serde(default)]
754    #[serde(skip_serializing_if = "Option::is_none")]
755    pub service_role: Option<String>,
756    #[serde(default)]
757    #[serde(skip_serializing_if = "Option::is_none")]
758    pub source: Option<ProjectSource>,
759    #[serde(rename = "sourceVersion")]
760    #[serde(default)]
761    #[serde(skip_serializing_if = "Option::is_none")]
762    pub source_version: Option<String>,
763    #[serde(rename = "startTime")]
764    #[serde(default)]
765    #[serde(skip_serializing_if = "Option::is_none")]
766    pub start_time: Option<f64>,
767    #[serde(rename = "timeoutInMinutes")]
768    #[serde(default)]
769    #[serde(skip_serializing_if = "Option::is_none")]
770    pub timeout_in_minutes: Option<i32>,
771    #[serde(rename = "vpcConfig")]
772    #[serde(default)]
773    #[serde(skip_serializing_if = "Option::is_none")]
774    pub vpc_config: Option<VpcConfig>,
775}
776
777#[derive(Debug, Clone, Default, Deserialize, Serialize)]
778pub struct AutoRetryConfig {
779    #[serde(rename = "autoRetryLimit")]
780    #[serde(default)]
781    #[serde(skip_serializing_if = "Option::is_none")]
782    pub auto_retry_limit: Option<i32>,
783    #[serde(rename = "autoRetryNumber")]
784    #[serde(default)]
785    #[serde(skip_serializing_if = "Option::is_none")]
786    pub auto_retry_number: Option<i32>,
787    #[serde(rename = "nextAutoRetry")]
788    #[serde(default)]
789    #[serde(skip_serializing_if = "Option::is_none")]
790    pub next_auto_retry: Option<String>,
791    #[serde(rename = "previousAutoRetry")]
792    #[serde(default)]
793    #[serde(skip_serializing_if = "Option::is_none")]
794    pub previous_auto_retry: Option<String>,
795}
796
797#[derive(Debug, Clone, Default, Deserialize, Serialize)]
798pub struct DebugSession {
799    #[serde(rename = "sessionEnabled")]
800    #[serde(default)]
801    #[serde(skip_serializing_if = "Option::is_none")]
802    pub session_enabled: Option<bool>,
803    #[serde(rename = "sessionTarget")]
804    #[serde(default)]
805    #[serde(skip_serializing_if = "Option::is_none")]
806    pub session_target: Option<String>,
807}
808
809#[derive(Debug, Clone, Default, Deserialize, Serialize)]
810pub struct ExportedEnvironmentVariable {
811    #[serde(default)]
812    #[serde(skip_serializing_if = "Option::is_none")]
813    pub name: Option<String>,
814    #[serde(default)]
815    #[serde(skip_serializing_if = "Option::is_none")]
816    pub value: Option<String>,
817}
818
819#[derive(Debug, Clone, Default, Deserialize, Serialize)]
820pub struct LogsLocation {
821    #[serde(rename = "cloudWatchLogs")]
822    #[serde(default)]
823    #[serde(skip_serializing_if = "Option::is_none")]
824    pub cloud_watch_logs: Option<CloudWatchLogsConfig>,
825    #[serde(rename = "cloudWatchLogsArn")]
826    #[serde(default)]
827    #[serde(skip_serializing_if = "Option::is_none")]
828    pub cloud_watch_logs_arn: Option<String>,
829    #[serde(rename = "deepLink")]
830    #[serde(default)]
831    #[serde(skip_serializing_if = "Option::is_none")]
832    pub deep_link: Option<String>,
833    #[serde(rename = "groupName")]
834    #[serde(default)]
835    #[serde(skip_serializing_if = "Option::is_none")]
836    pub group_name: Option<String>,
837    #[serde(rename = "s3DeepLink")]
838    #[serde(default)]
839    #[serde(skip_serializing_if = "Option::is_none")]
840    pub s3_deep_link: Option<String>,
841    #[serde(rename = "s3Logs")]
842    #[serde(default)]
843    #[serde(skip_serializing_if = "Option::is_none")]
844    pub s3_logs: Option<S3LogsConfig>,
845    #[serde(rename = "s3LogsArn")]
846    #[serde(default)]
847    #[serde(skip_serializing_if = "Option::is_none")]
848    pub s3_logs_arn: Option<String>,
849    #[serde(rename = "streamName")]
850    #[serde(default)]
851    #[serde(skip_serializing_if = "Option::is_none")]
852    pub stream_name: Option<String>,
853}
854
855#[derive(Debug, Clone, Default, Deserialize, Serialize)]
856pub struct NetworkInterface {
857    #[serde(rename = "networkInterfaceId")]
858    #[serde(default)]
859    #[serde(skip_serializing_if = "Option::is_none")]
860    pub network_interface_id: Option<String>,
861    #[serde(rename = "subnetId")]
862    #[serde(default)]
863    #[serde(skip_serializing_if = "Option::is_none")]
864    pub subnet_id: Option<String>,
865}
866
867#[derive(Debug, Clone, Default, Deserialize, Serialize)]
868pub struct BuildPhase {
869    #[serde(default)]
870    #[serde(skip_serializing_if = "Option::is_none")]
871    pub contexts: Option<Vec<PhaseContext>>,
872    #[serde(rename = "durationInSeconds")]
873    #[serde(default)]
874    #[serde(skip_serializing_if = "Option::is_none")]
875    pub duration_in_seconds: Option<i64>,
876    #[serde(rename = "endTime")]
877    #[serde(default)]
878    #[serde(skip_serializing_if = "Option::is_none")]
879    pub end_time: Option<f64>,
880    #[serde(rename = "phaseStatus")]
881    #[serde(default)]
882    #[serde(skip_serializing_if = "Option::is_none")]
883    pub phase_status: Option<String>,
884    #[serde(rename = "phaseType")]
885    #[serde(default)]
886    #[serde(skip_serializing_if = "Option::is_none")]
887    pub phase_type: Option<String>,
888    #[serde(rename = "startTime")]
889    #[serde(default)]
890    #[serde(skip_serializing_if = "Option::is_none")]
891    pub start_time: Option<f64>,
892}
893
894#[derive(Debug, Clone, Default, Deserialize, Serialize)]
895pub struct BatchGetCommandExecutionsInput {
896    #[serde(rename = "commandExecutionIds")]
897    #[serde(default)]
898    pub command_execution_ids: Vec<String>,
899    #[serde(rename = "sandboxId")]
900    #[serde(default)]
901    pub sandbox_id: String,
902}
903
904#[derive(Debug, Clone, Default, Deserialize, Serialize)]
905pub struct BatchGetCommandExecutionsOutput {
906    #[serde(rename = "commandExecutions")]
907    #[serde(default)]
908    #[serde(skip_serializing_if = "Option::is_none")]
909    pub command_executions: Option<Vec<CommandExecution>>,
910    #[serde(rename = "commandExecutionsNotFound")]
911    #[serde(default)]
912    #[serde(skip_serializing_if = "Option::is_none")]
913    pub command_executions_not_found: Option<Vec<String>>,
914}
915
916#[derive(Debug, Clone, Default, Deserialize, Serialize)]
917pub struct CommandExecution {
918    #[serde(default)]
919    #[serde(skip_serializing_if = "Option::is_none")]
920    pub command: Option<String>,
921    #[serde(rename = "endTime")]
922    #[serde(default)]
923    #[serde(skip_serializing_if = "Option::is_none")]
924    pub end_time: Option<f64>,
925    #[serde(rename = "exitCode")]
926    #[serde(default)]
927    #[serde(skip_serializing_if = "Option::is_none")]
928    pub exit_code: Option<String>,
929    #[serde(default)]
930    #[serde(skip_serializing_if = "Option::is_none")]
931    pub id: Option<String>,
932    #[serde(default)]
933    #[serde(skip_serializing_if = "Option::is_none")]
934    pub logs: Option<LogsLocation>,
935    #[serde(rename = "sandboxArn")]
936    #[serde(default)]
937    #[serde(skip_serializing_if = "Option::is_none")]
938    pub sandbox_arn: Option<String>,
939    #[serde(rename = "sandboxId")]
940    #[serde(default)]
941    #[serde(skip_serializing_if = "Option::is_none")]
942    pub sandbox_id: Option<String>,
943    #[serde(rename = "standardErrContent")]
944    #[serde(default)]
945    #[serde(skip_serializing_if = "Option::is_none")]
946    pub standard_err_content: Option<String>,
947    #[serde(rename = "standardOutputContent")]
948    #[serde(default)]
949    #[serde(skip_serializing_if = "Option::is_none")]
950    pub standard_output_content: Option<String>,
951    #[serde(rename = "startTime")]
952    #[serde(default)]
953    #[serde(skip_serializing_if = "Option::is_none")]
954    pub start_time: Option<f64>,
955    #[serde(default)]
956    #[serde(skip_serializing_if = "Option::is_none")]
957    pub status: Option<String>,
958    #[serde(rename = "submitTime")]
959    #[serde(default)]
960    #[serde(skip_serializing_if = "Option::is_none")]
961    pub submit_time: Option<f64>,
962    #[serde(rename = "type")]
963    #[serde(default)]
964    #[serde(skip_serializing_if = "Option::is_none")]
965    pub r#type: Option<String>,
966}
967
968#[derive(Debug, Clone, Default, Deserialize, Serialize)]
969pub struct BatchGetFleetsInput {
970    #[serde(default)]
971    pub names: Vec<String>,
972}
973
974#[derive(Debug, Clone, Default, Deserialize, Serialize)]
975pub struct BatchGetFleetsOutput {
976    #[serde(default)]
977    #[serde(skip_serializing_if = "Option::is_none")]
978    pub fleets: Option<Vec<Fleet>>,
979    #[serde(rename = "fleetsNotFound")]
980    #[serde(default)]
981    #[serde(skip_serializing_if = "Option::is_none")]
982    pub fleets_not_found: Option<Vec<String>>,
983}
984
985#[derive(Debug, Clone, Default, Deserialize, Serialize)]
986pub struct Fleet {
987    #[serde(default)]
988    #[serde(skip_serializing_if = "Option::is_none")]
989    pub arn: Option<String>,
990    #[serde(rename = "baseCapacity")]
991    #[serde(default)]
992    #[serde(skip_serializing_if = "Option::is_none")]
993    pub base_capacity: Option<i32>,
994    #[serde(rename = "computeConfiguration")]
995    #[serde(default)]
996    #[serde(skip_serializing_if = "Option::is_none")]
997    pub compute_configuration: Option<ComputeConfiguration>,
998    #[serde(rename = "computeType")]
999    #[serde(default)]
1000    #[serde(skip_serializing_if = "Option::is_none")]
1001    pub compute_type: Option<String>,
1002    #[serde(default)]
1003    #[serde(skip_serializing_if = "Option::is_none")]
1004    pub created: Option<f64>,
1005    #[serde(rename = "environmentType")]
1006    #[serde(default)]
1007    #[serde(skip_serializing_if = "Option::is_none")]
1008    pub environment_type: Option<String>,
1009    #[serde(rename = "fleetServiceRole")]
1010    #[serde(default)]
1011    #[serde(skip_serializing_if = "Option::is_none")]
1012    pub fleet_service_role: Option<String>,
1013    #[serde(default)]
1014    #[serde(skip_serializing_if = "Option::is_none")]
1015    pub id: Option<String>,
1016    #[serde(rename = "imageId")]
1017    #[serde(default)]
1018    #[serde(skip_serializing_if = "Option::is_none")]
1019    pub image_id: Option<String>,
1020    #[serde(rename = "lastModified")]
1021    #[serde(default)]
1022    #[serde(skip_serializing_if = "Option::is_none")]
1023    pub last_modified: Option<f64>,
1024    #[serde(default)]
1025    #[serde(skip_serializing_if = "Option::is_none")]
1026    pub name: Option<String>,
1027    #[serde(rename = "overflowBehavior")]
1028    #[serde(default)]
1029    #[serde(skip_serializing_if = "Option::is_none")]
1030    pub overflow_behavior: Option<String>,
1031    #[serde(rename = "proxyConfiguration")]
1032    #[serde(default)]
1033    #[serde(skip_serializing_if = "Option::is_none")]
1034    pub proxy_configuration: Option<ProxyConfiguration>,
1035    #[serde(rename = "scalingConfiguration")]
1036    #[serde(default)]
1037    #[serde(skip_serializing_if = "Option::is_none")]
1038    pub scaling_configuration: Option<ScalingConfigurationOutput>,
1039    #[serde(default)]
1040    #[serde(skip_serializing_if = "Option::is_none")]
1041    pub status: Option<FleetStatus>,
1042    #[serde(default)]
1043    #[serde(skip_serializing_if = "Option::is_none")]
1044    pub tags: Option<Vec<Tag>>,
1045    #[serde(rename = "vpcConfig")]
1046    #[serde(default)]
1047    #[serde(skip_serializing_if = "Option::is_none")]
1048    pub vpc_config: Option<VpcConfig>,
1049}
1050
1051#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1052pub struct ProxyConfiguration {
1053    #[serde(rename = "defaultBehavior")]
1054    #[serde(default)]
1055    #[serde(skip_serializing_if = "Option::is_none")]
1056    pub default_behavior: Option<String>,
1057    #[serde(rename = "orderedProxyRules")]
1058    #[serde(default)]
1059    #[serde(skip_serializing_if = "Option::is_none")]
1060    pub ordered_proxy_rules: Option<Vec<FleetProxyRule>>,
1061}
1062
1063#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1064pub struct FleetProxyRule {
1065    #[serde(default)]
1066    pub effect: String,
1067    #[serde(default)]
1068    pub entities: Vec<String>,
1069    #[serde(rename = "type")]
1070    #[serde(default)]
1071    pub r#type: String,
1072}
1073
1074#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1075pub struct ScalingConfigurationOutput {
1076    #[serde(rename = "desiredCapacity")]
1077    #[serde(default)]
1078    #[serde(skip_serializing_if = "Option::is_none")]
1079    pub desired_capacity: Option<i32>,
1080    #[serde(rename = "maxCapacity")]
1081    #[serde(default)]
1082    #[serde(skip_serializing_if = "Option::is_none")]
1083    pub max_capacity: Option<i32>,
1084    #[serde(rename = "scalingType")]
1085    #[serde(default)]
1086    #[serde(skip_serializing_if = "Option::is_none")]
1087    pub scaling_type: Option<String>,
1088    #[serde(rename = "targetTrackingScalingConfigs")]
1089    #[serde(default)]
1090    #[serde(skip_serializing_if = "Option::is_none")]
1091    pub target_tracking_scaling_configs: Option<Vec<TargetTrackingScalingConfiguration>>,
1092}
1093
1094#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1095pub struct TargetTrackingScalingConfiguration {
1096    #[serde(rename = "metricType")]
1097    #[serde(default)]
1098    #[serde(skip_serializing_if = "Option::is_none")]
1099    pub metric_type: Option<String>,
1100    #[serde(rename = "targetValue")]
1101    #[serde(default)]
1102    #[serde(skip_serializing_if = "Option::is_none")]
1103    pub target_value: Option<f64>,
1104}
1105
1106#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1107pub struct FleetStatus {
1108    #[serde(default)]
1109    #[serde(skip_serializing_if = "Option::is_none")]
1110    pub context: Option<String>,
1111    #[serde(default)]
1112    #[serde(skip_serializing_if = "Option::is_none")]
1113    pub message: Option<String>,
1114    #[serde(rename = "statusCode")]
1115    #[serde(default)]
1116    #[serde(skip_serializing_if = "Option::is_none")]
1117    pub status_code: Option<String>,
1118}
1119
1120#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1121pub struct Tag {
1122    #[serde(default)]
1123    #[serde(skip_serializing_if = "Option::is_none")]
1124    pub key: Option<String>,
1125    #[serde(default)]
1126    #[serde(skip_serializing_if = "Option::is_none")]
1127    pub value: Option<String>,
1128}
1129
1130#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1131pub struct BatchGetProjectsInput {
1132    #[serde(default)]
1133    pub names: Vec<String>,
1134}
1135
1136#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1137pub struct BatchGetProjectsOutput {
1138    #[serde(default)]
1139    #[serde(skip_serializing_if = "Option::is_none")]
1140    pub projects: Option<Vec<Project>>,
1141    #[serde(rename = "projectsNotFound")]
1142    #[serde(default)]
1143    #[serde(skip_serializing_if = "Option::is_none")]
1144    pub projects_not_found: Option<Vec<String>>,
1145}
1146
1147#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1148pub struct Project {
1149    #[serde(default)]
1150    #[serde(skip_serializing_if = "Option::is_none")]
1151    pub arn: Option<String>,
1152    #[serde(default)]
1153    #[serde(skip_serializing_if = "Option::is_none")]
1154    pub artifacts: Option<ProjectArtifacts>,
1155    #[serde(rename = "autoRetryLimit")]
1156    #[serde(default)]
1157    #[serde(skip_serializing_if = "Option::is_none")]
1158    pub auto_retry_limit: Option<i32>,
1159    #[serde(default)]
1160    #[serde(skip_serializing_if = "Option::is_none")]
1161    pub badge: Option<ProjectBadge>,
1162    #[serde(rename = "buildBatchConfig")]
1163    #[serde(default)]
1164    #[serde(skip_serializing_if = "Option::is_none")]
1165    pub build_batch_config: Option<ProjectBuildBatchConfig>,
1166    #[serde(default)]
1167    #[serde(skip_serializing_if = "Option::is_none")]
1168    pub cache: Option<ProjectCache>,
1169    #[serde(rename = "concurrentBuildLimit")]
1170    #[serde(default)]
1171    #[serde(skip_serializing_if = "Option::is_none")]
1172    pub concurrent_build_limit: Option<i32>,
1173    #[serde(default)]
1174    #[serde(skip_serializing_if = "Option::is_none")]
1175    pub created: Option<f64>,
1176    #[serde(default)]
1177    #[serde(skip_serializing_if = "Option::is_none")]
1178    pub description: Option<String>,
1179    #[serde(rename = "encryptionKey")]
1180    #[serde(default)]
1181    #[serde(skip_serializing_if = "Option::is_none")]
1182    pub encryption_key: Option<String>,
1183    #[serde(default)]
1184    #[serde(skip_serializing_if = "Option::is_none")]
1185    pub environment: Option<ProjectEnvironment>,
1186    #[serde(rename = "fileSystemLocations")]
1187    #[serde(default)]
1188    #[serde(skip_serializing_if = "Option::is_none")]
1189    pub file_system_locations: Option<Vec<ProjectFileSystemLocation>>,
1190    #[serde(rename = "lastModified")]
1191    #[serde(default)]
1192    #[serde(skip_serializing_if = "Option::is_none")]
1193    pub last_modified: Option<f64>,
1194    #[serde(rename = "logsConfig")]
1195    #[serde(default)]
1196    #[serde(skip_serializing_if = "Option::is_none")]
1197    pub logs_config: Option<LogsConfig>,
1198    #[serde(default)]
1199    #[serde(skip_serializing_if = "Option::is_none")]
1200    pub name: Option<String>,
1201    #[serde(rename = "projectVisibility")]
1202    #[serde(default)]
1203    #[serde(skip_serializing_if = "Option::is_none")]
1204    pub project_visibility: Option<String>,
1205    #[serde(rename = "publicProjectAlias")]
1206    #[serde(default)]
1207    #[serde(skip_serializing_if = "Option::is_none")]
1208    pub public_project_alias: Option<String>,
1209    #[serde(rename = "queuedTimeoutInMinutes")]
1210    #[serde(default)]
1211    #[serde(skip_serializing_if = "Option::is_none")]
1212    pub queued_timeout_in_minutes: Option<i32>,
1213    #[serde(rename = "resourceAccessRole")]
1214    #[serde(default)]
1215    #[serde(skip_serializing_if = "Option::is_none")]
1216    pub resource_access_role: Option<String>,
1217    #[serde(rename = "secondaryArtifacts")]
1218    #[serde(default)]
1219    #[serde(skip_serializing_if = "Option::is_none")]
1220    pub secondary_artifacts: Option<Vec<ProjectArtifacts>>,
1221    #[serde(rename = "secondarySourceVersions")]
1222    #[serde(default)]
1223    #[serde(skip_serializing_if = "Option::is_none")]
1224    pub secondary_source_versions: Option<Vec<ProjectSourceVersion>>,
1225    #[serde(rename = "secondarySources")]
1226    #[serde(default)]
1227    #[serde(skip_serializing_if = "Option::is_none")]
1228    pub secondary_sources: Option<Vec<ProjectSource>>,
1229    #[serde(rename = "serviceRole")]
1230    #[serde(default)]
1231    #[serde(skip_serializing_if = "Option::is_none")]
1232    pub service_role: Option<String>,
1233    #[serde(default)]
1234    #[serde(skip_serializing_if = "Option::is_none")]
1235    pub source: Option<ProjectSource>,
1236    #[serde(rename = "sourceVersion")]
1237    #[serde(default)]
1238    #[serde(skip_serializing_if = "Option::is_none")]
1239    pub source_version: Option<String>,
1240    #[serde(default)]
1241    #[serde(skip_serializing_if = "Option::is_none")]
1242    pub tags: Option<Vec<Tag>>,
1243    #[serde(rename = "timeoutInMinutes")]
1244    #[serde(default)]
1245    #[serde(skip_serializing_if = "Option::is_none")]
1246    pub timeout_in_minutes: Option<i32>,
1247    #[serde(rename = "vpcConfig")]
1248    #[serde(default)]
1249    #[serde(skip_serializing_if = "Option::is_none")]
1250    pub vpc_config: Option<VpcConfig>,
1251    #[serde(default)]
1252    #[serde(skip_serializing_if = "Option::is_none")]
1253    pub webhook: Option<Webhook>,
1254}
1255
1256#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1257pub struct ProjectArtifacts {
1258    #[serde(rename = "artifactIdentifier")]
1259    #[serde(default)]
1260    #[serde(skip_serializing_if = "Option::is_none")]
1261    pub artifact_identifier: Option<String>,
1262    #[serde(rename = "bucketOwnerAccess")]
1263    #[serde(default)]
1264    #[serde(skip_serializing_if = "Option::is_none")]
1265    pub bucket_owner_access: Option<String>,
1266    #[serde(rename = "encryptionDisabled")]
1267    #[serde(default)]
1268    #[serde(skip_serializing_if = "Option::is_none")]
1269    pub encryption_disabled: Option<bool>,
1270    #[serde(default)]
1271    #[serde(skip_serializing_if = "Option::is_none")]
1272    pub location: Option<String>,
1273    #[serde(default)]
1274    #[serde(skip_serializing_if = "Option::is_none")]
1275    pub name: Option<String>,
1276    #[serde(rename = "namespaceType")]
1277    #[serde(default)]
1278    #[serde(skip_serializing_if = "Option::is_none")]
1279    pub namespace_type: Option<String>,
1280    #[serde(rename = "overrideArtifactName")]
1281    #[serde(default)]
1282    #[serde(skip_serializing_if = "Option::is_none")]
1283    pub override_artifact_name: Option<bool>,
1284    #[serde(default)]
1285    #[serde(skip_serializing_if = "Option::is_none")]
1286    pub packaging: Option<String>,
1287    #[serde(default)]
1288    #[serde(skip_serializing_if = "Option::is_none")]
1289    pub path: Option<String>,
1290    #[serde(rename = "type")]
1291    #[serde(default)]
1292    pub r#type: String,
1293}
1294
1295#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1296pub struct ProjectBadge {
1297    #[serde(rename = "badgeEnabled")]
1298    #[serde(default)]
1299    #[serde(skip_serializing_if = "Option::is_none")]
1300    pub badge_enabled: Option<bool>,
1301    #[serde(rename = "badgeRequestUrl")]
1302    #[serde(default)]
1303    #[serde(skip_serializing_if = "Option::is_none")]
1304    pub badge_request_url: Option<String>,
1305}
1306
1307#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1308pub struct Webhook {
1309    #[serde(rename = "branchFilter")]
1310    #[serde(default)]
1311    #[serde(skip_serializing_if = "Option::is_none")]
1312    pub branch_filter: Option<String>,
1313    #[serde(rename = "buildType")]
1314    #[serde(default)]
1315    #[serde(skip_serializing_if = "Option::is_none")]
1316    pub build_type: Option<String>,
1317    #[serde(rename = "filterGroups")]
1318    #[serde(default)]
1319    #[serde(skip_serializing_if = "Option::is_none")]
1320    pub filter_groups: Option<Vec<Vec<WebhookFilter>>>,
1321    #[serde(rename = "lastModifiedSecret")]
1322    #[serde(default)]
1323    #[serde(skip_serializing_if = "Option::is_none")]
1324    pub last_modified_secret: Option<f64>,
1325    #[serde(rename = "manualCreation")]
1326    #[serde(default)]
1327    #[serde(skip_serializing_if = "Option::is_none")]
1328    pub manual_creation: Option<bool>,
1329    #[serde(rename = "payloadUrl")]
1330    #[serde(default)]
1331    #[serde(skip_serializing_if = "Option::is_none")]
1332    pub payload_url: Option<String>,
1333    #[serde(rename = "pullRequestBuildPolicy")]
1334    #[serde(default)]
1335    #[serde(skip_serializing_if = "Option::is_none")]
1336    pub pull_request_build_policy: Option<PullRequestBuildPolicy>,
1337    #[serde(rename = "scopeConfiguration")]
1338    #[serde(default)]
1339    #[serde(skip_serializing_if = "Option::is_none")]
1340    pub scope_configuration: Option<ScopeConfiguration>,
1341    #[serde(default)]
1342    #[serde(skip_serializing_if = "Option::is_none")]
1343    pub secret: Option<String>,
1344    #[serde(default)]
1345    #[serde(skip_serializing_if = "Option::is_none")]
1346    pub status: Option<String>,
1347    #[serde(rename = "statusMessage")]
1348    #[serde(default)]
1349    #[serde(skip_serializing_if = "Option::is_none")]
1350    pub status_message: Option<String>,
1351    #[serde(default)]
1352    #[serde(skip_serializing_if = "Option::is_none")]
1353    pub url: Option<String>,
1354}
1355
1356#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1357pub struct WebhookFilter {
1358    #[serde(rename = "excludeMatchedPattern")]
1359    #[serde(default)]
1360    #[serde(skip_serializing_if = "Option::is_none")]
1361    pub exclude_matched_pattern: Option<bool>,
1362    #[serde(default)]
1363    pub pattern: String,
1364    #[serde(rename = "type")]
1365    #[serde(default)]
1366    pub r#type: String,
1367}
1368
1369#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1370pub struct PullRequestBuildPolicy {
1371    #[serde(rename = "approverRoles")]
1372    #[serde(default)]
1373    #[serde(skip_serializing_if = "Option::is_none")]
1374    pub approver_roles: Option<Vec<String>>,
1375    #[serde(rename = "requiresCommentApproval")]
1376    #[serde(default)]
1377    pub requires_comment_approval: String,
1378}
1379
1380#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1381pub struct ScopeConfiguration {
1382    #[serde(default)]
1383    #[serde(skip_serializing_if = "Option::is_none")]
1384    pub domain: Option<String>,
1385    #[serde(default)]
1386    pub name: String,
1387    #[serde(default)]
1388    pub scope: String,
1389}
1390
1391#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1392pub struct BatchGetReportGroupsInput {
1393    #[serde(rename = "reportGroupArns")]
1394    #[serde(default)]
1395    pub report_group_arns: Vec<String>,
1396}
1397
1398#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1399pub struct BatchGetReportGroupsOutput {
1400    #[serde(rename = "reportGroups")]
1401    #[serde(default)]
1402    #[serde(skip_serializing_if = "Option::is_none")]
1403    pub report_groups: Option<Vec<ReportGroup>>,
1404    #[serde(rename = "reportGroupsNotFound")]
1405    #[serde(default)]
1406    #[serde(skip_serializing_if = "Option::is_none")]
1407    pub report_groups_not_found: Option<Vec<String>>,
1408}
1409
1410#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1411pub struct ReportGroup {
1412    #[serde(default)]
1413    #[serde(skip_serializing_if = "Option::is_none")]
1414    pub arn: Option<String>,
1415    #[serde(default)]
1416    #[serde(skip_serializing_if = "Option::is_none")]
1417    pub created: Option<f64>,
1418    #[serde(rename = "exportConfig")]
1419    #[serde(default)]
1420    #[serde(skip_serializing_if = "Option::is_none")]
1421    pub export_config: Option<ReportExportConfig>,
1422    #[serde(rename = "lastModified")]
1423    #[serde(default)]
1424    #[serde(skip_serializing_if = "Option::is_none")]
1425    pub last_modified: Option<f64>,
1426    #[serde(default)]
1427    #[serde(skip_serializing_if = "Option::is_none")]
1428    pub name: Option<String>,
1429    #[serde(default)]
1430    #[serde(skip_serializing_if = "Option::is_none")]
1431    pub status: Option<String>,
1432    #[serde(default)]
1433    #[serde(skip_serializing_if = "Option::is_none")]
1434    pub tags: Option<Vec<Tag>>,
1435    #[serde(rename = "type")]
1436    #[serde(default)]
1437    #[serde(skip_serializing_if = "Option::is_none")]
1438    pub r#type: Option<String>,
1439}
1440
1441#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1442pub struct ReportExportConfig {
1443    #[serde(rename = "exportConfigType")]
1444    #[serde(default)]
1445    #[serde(skip_serializing_if = "Option::is_none")]
1446    pub export_config_type: Option<String>,
1447    #[serde(rename = "s3Destination")]
1448    #[serde(default)]
1449    #[serde(skip_serializing_if = "Option::is_none")]
1450    pub s3_destination: Option<S3ReportExportConfig>,
1451}
1452
1453#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1454pub struct S3ReportExportConfig {
1455    #[serde(default)]
1456    #[serde(skip_serializing_if = "Option::is_none")]
1457    pub bucket: Option<String>,
1458    #[serde(rename = "bucketOwner")]
1459    #[serde(default)]
1460    #[serde(skip_serializing_if = "Option::is_none")]
1461    pub bucket_owner: Option<String>,
1462    #[serde(rename = "encryptionDisabled")]
1463    #[serde(default)]
1464    #[serde(skip_serializing_if = "Option::is_none")]
1465    pub encryption_disabled: Option<bool>,
1466    #[serde(rename = "encryptionKey")]
1467    #[serde(default)]
1468    #[serde(skip_serializing_if = "Option::is_none")]
1469    pub encryption_key: Option<String>,
1470    #[serde(default)]
1471    #[serde(skip_serializing_if = "Option::is_none")]
1472    pub packaging: Option<String>,
1473    #[serde(default)]
1474    #[serde(skip_serializing_if = "Option::is_none")]
1475    pub path: Option<String>,
1476}
1477
1478#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1479pub struct BatchGetReportsInput {
1480    #[serde(rename = "reportArns")]
1481    #[serde(default)]
1482    pub report_arns: Vec<String>,
1483}
1484
1485#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1486pub struct BatchGetReportsOutput {
1487    #[serde(default)]
1488    #[serde(skip_serializing_if = "Option::is_none")]
1489    pub reports: Option<Vec<Report>>,
1490    #[serde(rename = "reportsNotFound")]
1491    #[serde(default)]
1492    #[serde(skip_serializing_if = "Option::is_none")]
1493    pub reports_not_found: Option<Vec<String>>,
1494}
1495
1496#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1497pub struct Report {
1498    #[serde(default)]
1499    #[serde(skip_serializing_if = "Option::is_none")]
1500    pub arn: Option<String>,
1501    #[serde(rename = "codeCoverageSummary")]
1502    #[serde(default)]
1503    #[serde(skip_serializing_if = "Option::is_none")]
1504    pub code_coverage_summary: Option<CodeCoverageReportSummary>,
1505    #[serde(default)]
1506    #[serde(skip_serializing_if = "Option::is_none")]
1507    pub created: Option<f64>,
1508    #[serde(rename = "executionId")]
1509    #[serde(default)]
1510    #[serde(skip_serializing_if = "Option::is_none")]
1511    pub execution_id: Option<String>,
1512    #[serde(default)]
1513    #[serde(skip_serializing_if = "Option::is_none")]
1514    pub expired: Option<f64>,
1515    #[serde(rename = "exportConfig")]
1516    #[serde(default)]
1517    #[serde(skip_serializing_if = "Option::is_none")]
1518    pub export_config: Option<ReportExportConfig>,
1519    #[serde(default)]
1520    #[serde(skip_serializing_if = "Option::is_none")]
1521    pub name: Option<String>,
1522    #[serde(rename = "reportGroupArn")]
1523    #[serde(default)]
1524    #[serde(skip_serializing_if = "Option::is_none")]
1525    pub report_group_arn: Option<String>,
1526    #[serde(default)]
1527    #[serde(skip_serializing_if = "Option::is_none")]
1528    pub status: Option<String>,
1529    #[serde(rename = "testSummary")]
1530    #[serde(default)]
1531    #[serde(skip_serializing_if = "Option::is_none")]
1532    pub test_summary: Option<TestReportSummary>,
1533    #[serde(default)]
1534    #[serde(skip_serializing_if = "Option::is_none")]
1535    pub truncated: Option<bool>,
1536    #[serde(rename = "type")]
1537    #[serde(default)]
1538    #[serde(skip_serializing_if = "Option::is_none")]
1539    pub r#type: Option<String>,
1540}
1541
1542#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1543pub struct CodeCoverageReportSummary {
1544    #[serde(rename = "branchCoveragePercentage")]
1545    #[serde(default)]
1546    #[serde(skip_serializing_if = "Option::is_none")]
1547    pub branch_coverage_percentage: Option<f64>,
1548    #[serde(rename = "branchesCovered")]
1549    #[serde(default)]
1550    #[serde(skip_serializing_if = "Option::is_none")]
1551    pub branches_covered: Option<i32>,
1552    #[serde(rename = "branchesMissed")]
1553    #[serde(default)]
1554    #[serde(skip_serializing_if = "Option::is_none")]
1555    pub branches_missed: Option<i32>,
1556    #[serde(rename = "lineCoveragePercentage")]
1557    #[serde(default)]
1558    #[serde(skip_serializing_if = "Option::is_none")]
1559    pub line_coverage_percentage: Option<f64>,
1560    #[serde(rename = "linesCovered")]
1561    #[serde(default)]
1562    #[serde(skip_serializing_if = "Option::is_none")]
1563    pub lines_covered: Option<i32>,
1564    #[serde(rename = "linesMissed")]
1565    #[serde(default)]
1566    #[serde(skip_serializing_if = "Option::is_none")]
1567    pub lines_missed: Option<i32>,
1568}
1569
1570#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1571pub struct TestReportSummary {
1572    #[serde(rename = "durationInNanoSeconds")]
1573    #[serde(default)]
1574    #[serde(skip_serializing_if = "Option::is_none")]
1575    pub duration_in_nano_seconds: Option<i64>,
1576    #[serde(rename = "statusCounts")]
1577    #[serde(default)]
1578    #[serde(skip_serializing_if = "Option::is_none")]
1579    pub status_counts: Option<std::collections::HashMap<String, i32>>,
1580    #[serde(default)]
1581    #[serde(skip_serializing_if = "Option::is_none")]
1582    pub total: Option<i32>,
1583}
1584
1585#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1586pub struct BatchGetSandboxesInput {
1587    #[serde(default)]
1588    pub ids: Vec<String>,
1589}
1590
1591#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1592pub struct BatchGetSandboxesOutput {
1593    #[serde(default)]
1594    #[serde(skip_serializing_if = "Option::is_none")]
1595    pub sandboxes: Option<Vec<Sandbox>>,
1596    #[serde(rename = "sandboxesNotFound")]
1597    #[serde(default)]
1598    #[serde(skip_serializing_if = "Option::is_none")]
1599    pub sandboxes_not_found: Option<Vec<String>>,
1600}
1601
1602#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1603pub struct Sandbox {
1604    #[serde(default)]
1605    #[serde(skip_serializing_if = "Option::is_none")]
1606    pub arn: Option<String>,
1607    #[serde(rename = "currentSession")]
1608    #[serde(default)]
1609    #[serde(skip_serializing_if = "Option::is_none")]
1610    pub current_session: Option<SandboxSession>,
1611    #[serde(rename = "encryptionKey")]
1612    #[serde(default)]
1613    #[serde(skip_serializing_if = "Option::is_none")]
1614    pub encryption_key: Option<String>,
1615    #[serde(rename = "endTime")]
1616    #[serde(default)]
1617    #[serde(skip_serializing_if = "Option::is_none")]
1618    pub end_time: Option<f64>,
1619    #[serde(default)]
1620    #[serde(skip_serializing_if = "Option::is_none")]
1621    pub environment: Option<ProjectEnvironment>,
1622    #[serde(rename = "fileSystemLocations")]
1623    #[serde(default)]
1624    #[serde(skip_serializing_if = "Option::is_none")]
1625    pub file_system_locations: Option<Vec<ProjectFileSystemLocation>>,
1626    #[serde(default)]
1627    #[serde(skip_serializing_if = "Option::is_none")]
1628    pub id: Option<String>,
1629    #[serde(rename = "logConfig")]
1630    #[serde(default)]
1631    #[serde(skip_serializing_if = "Option::is_none")]
1632    pub log_config: Option<LogsConfig>,
1633    #[serde(rename = "projectName")]
1634    #[serde(default)]
1635    #[serde(skip_serializing_if = "Option::is_none")]
1636    pub project_name: Option<String>,
1637    #[serde(rename = "queuedTimeoutInMinutes")]
1638    #[serde(default)]
1639    #[serde(skip_serializing_if = "Option::is_none")]
1640    pub queued_timeout_in_minutes: Option<i32>,
1641    #[serde(rename = "requestTime")]
1642    #[serde(default)]
1643    #[serde(skip_serializing_if = "Option::is_none")]
1644    pub request_time: Option<f64>,
1645    #[serde(rename = "secondarySourceVersions")]
1646    #[serde(default)]
1647    #[serde(skip_serializing_if = "Option::is_none")]
1648    pub secondary_source_versions: Option<Vec<ProjectSourceVersion>>,
1649    #[serde(rename = "secondarySources")]
1650    #[serde(default)]
1651    #[serde(skip_serializing_if = "Option::is_none")]
1652    pub secondary_sources: Option<Vec<ProjectSource>>,
1653    #[serde(rename = "serviceRole")]
1654    #[serde(default)]
1655    #[serde(skip_serializing_if = "Option::is_none")]
1656    pub service_role: Option<String>,
1657    #[serde(default)]
1658    #[serde(skip_serializing_if = "Option::is_none")]
1659    pub source: Option<ProjectSource>,
1660    #[serde(rename = "sourceVersion")]
1661    #[serde(default)]
1662    #[serde(skip_serializing_if = "Option::is_none")]
1663    pub source_version: Option<String>,
1664    #[serde(rename = "startTime")]
1665    #[serde(default)]
1666    #[serde(skip_serializing_if = "Option::is_none")]
1667    pub start_time: Option<f64>,
1668    #[serde(default)]
1669    #[serde(skip_serializing_if = "Option::is_none")]
1670    pub status: Option<String>,
1671    #[serde(rename = "timeoutInMinutes")]
1672    #[serde(default)]
1673    #[serde(skip_serializing_if = "Option::is_none")]
1674    pub timeout_in_minutes: Option<i32>,
1675    #[serde(rename = "vpcConfig")]
1676    #[serde(default)]
1677    #[serde(skip_serializing_if = "Option::is_none")]
1678    pub vpc_config: Option<VpcConfig>,
1679}
1680
1681#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1682pub struct SandboxSession {
1683    #[serde(rename = "currentPhase")]
1684    #[serde(default)]
1685    #[serde(skip_serializing_if = "Option::is_none")]
1686    pub current_phase: Option<String>,
1687    #[serde(rename = "endTime")]
1688    #[serde(default)]
1689    #[serde(skip_serializing_if = "Option::is_none")]
1690    pub end_time: Option<f64>,
1691    #[serde(default)]
1692    #[serde(skip_serializing_if = "Option::is_none")]
1693    pub id: Option<String>,
1694    #[serde(default)]
1695    #[serde(skip_serializing_if = "Option::is_none")]
1696    pub logs: Option<LogsLocation>,
1697    #[serde(rename = "networkInterface")]
1698    #[serde(default)]
1699    #[serde(skip_serializing_if = "Option::is_none")]
1700    pub network_interface: Option<NetworkInterface>,
1701    #[serde(default)]
1702    #[serde(skip_serializing_if = "Option::is_none")]
1703    pub phases: Option<Vec<SandboxSessionPhase>>,
1704    #[serde(rename = "resolvedSourceVersion")]
1705    #[serde(default)]
1706    #[serde(skip_serializing_if = "Option::is_none")]
1707    pub resolved_source_version: Option<String>,
1708    #[serde(rename = "startTime")]
1709    #[serde(default)]
1710    #[serde(skip_serializing_if = "Option::is_none")]
1711    pub start_time: Option<f64>,
1712    #[serde(default)]
1713    #[serde(skip_serializing_if = "Option::is_none")]
1714    pub status: Option<String>,
1715}
1716
1717#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1718pub struct SandboxSessionPhase {
1719    #[serde(default)]
1720    #[serde(skip_serializing_if = "Option::is_none")]
1721    pub contexts: Option<Vec<PhaseContext>>,
1722    #[serde(rename = "durationInSeconds")]
1723    #[serde(default)]
1724    #[serde(skip_serializing_if = "Option::is_none")]
1725    pub duration_in_seconds: Option<i64>,
1726    #[serde(rename = "endTime")]
1727    #[serde(default)]
1728    #[serde(skip_serializing_if = "Option::is_none")]
1729    pub end_time: Option<f64>,
1730    #[serde(rename = "phaseStatus")]
1731    #[serde(default)]
1732    #[serde(skip_serializing_if = "Option::is_none")]
1733    pub phase_status: Option<String>,
1734    #[serde(rename = "phaseType")]
1735    #[serde(default)]
1736    #[serde(skip_serializing_if = "Option::is_none")]
1737    pub phase_type: Option<String>,
1738    #[serde(rename = "startTime")]
1739    #[serde(default)]
1740    #[serde(skip_serializing_if = "Option::is_none")]
1741    pub start_time: Option<f64>,
1742}
1743
1744#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1745pub struct CreateFleetInput {
1746    #[serde(rename = "baseCapacity")]
1747    #[serde(default)]
1748    pub base_capacity: i32,
1749    #[serde(rename = "computeConfiguration")]
1750    #[serde(default)]
1751    #[serde(skip_serializing_if = "Option::is_none")]
1752    pub compute_configuration: Option<ComputeConfiguration>,
1753    #[serde(rename = "computeType")]
1754    #[serde(default)]
1755    pub compute_type: String,
1756    #[serde(rename = "environmentType")]
1757    #[serde(default)]
1758    pub environment_type: String,
1759    #[serde(rename = "fleetServiceRole")]
1760    #[serde(default)]
1761    #[serde(skip_serializing_if = "Option::is_none")]
1762    pub fleet_service_role: Option<String>,
1763    #[serde(rename = "imageId")]
1764    #[serde(default)]
1765    #[serde(skip_serializing_if = "Option::is_none")]
1766    pub image_id: Option<String>,
1767    #[serde(default)]
1768    pub name: String,
1769    #[serde(rename = "overflowBehavior")]
1770    #[serde(default)]
1771    #[serde(skip_serializing_if = "Option::is_none")]
1772    pub overflow_behavior: Option<String>,
1773    #[serde(rename = "proxyConfiguration")]
1774    #[serde(default)]
1775    #[serde(skip_serializing_if = "Option::is_none")]
1776    pub proxy_configuration: Option<ProxyConfiguration>,
1777    #[serde(rename = "scalingConfiguration")]
1778    #[serde(default)]
1779    #[serde(skip_serializing_if = "Option::is_none")]
1780    pub scaling_configuration: Option<ScalingConfigurationInput>,
1781    #[serde(default)]
1782    #[serde(skip_serializing_if = "Option::is_none")]
1783    pub tags: Option<Vec<Tag>>,
1784    #[serde(rename = "vpcConfig")]
1785    #[serde(default)]
1786    #[serde(skip_serializing_if = "Option::is_none")]
1787    pub vpc_config: Option<VpcConfig>,
1788}
1789
1790#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1791pub struct ScalingConfigurationInput {
1792    #[serde(rename = "maxCapacity")]
1793    #[serde(default)]
1794    #[serde(skip_serializing_if = "Option::is_none")]
1795    pub max_capacity: Option<i32>,
1796    #[serde(rename = "scalingType")]
1797    #[serde(default)]
1798    #[serde(skip_serializing_if = "Option::is_none")]
1799    pub scaling_type: Option<String>,
1800    #[serde(rename = "targetTrackingScalingConfigs")]
1801    #[serde(default)]
1802    #[serde(skip_serializing_if = "Option::is_none")]
1803    pub target_tracking_scaling_configs: Option<Vec<TargetTrackingScalingConfiguration>>,
1804}
1805
1806#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1807pub struct CreateFleetOutput {
1808    #[serde(default)]
1809    #[serde(skip_serializing_if = "Option::is_none")]
1810    pub fleet: Option<Fleet>,
1811}
1812
1813#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1814pub struct CreateProjectInput {
1815    #[serde(default)]
1816    pub artifacts: ProjectArtifacts,
1817    #[serde(rename = "autoRetryLimit")]
1818    #[serde(default)]
1819    #[serde(skip_serializing_if = "Option::is_none")]
1820    pub auto_retry_limit: Option<i32>,
1821    #[serde(rename = "badgeEnabled")]
1822    #[serde(default)]
1823    #[serde(skip_serializing_if = "Option::is_none")]
1824    pub badge_enabled: Option<bool>,
1825    #[serde(rename = "buildBatchConfig")]
1826    #[serde(default)]
1827    #[serde(skip_serializing_if = "Option::is_none")]
1828    pub build_batch_config: Option<ProjectBuildBatchConfig>,
1829    #[serde(default)]
1830    #[serde(skip_serializing_if = "Option::is_none")]
1831    pub cache: Option<ProjectCache>,
1832    #[serde(rename = "concurrentBuildLimit")]
1833    #[serde(default)]
1834    #[serde(skip_serializing_if = "Option::is_none")]
1835    pub concurrent_build_limit: Option<i32>,
1836    #[serde(default)]
1837    #[serde(skip_serializing_if = "Option::is_none")]
1838    pub description: Option<String>,
1839    #[serde(rename = "encryptionKey")]
1840    #[serde(default)]
1841    #[serde(skip_serializing_if = "Option::is_none")]
1842    pub encryption_key: Option<String>,
1843    #[serde(default)]
1844    pub environment: ProjectEnvironment,
1845    #[serde(rename = "fileSystemLocations")]
1846    #[serde(default)]
1847    #[serde(skip_serializing_if = "Option::is_none")]
1848    pub file_system_locations: Option<Vec<ProjectFileSystemLocation>>,
1849    #[serde(rename = "logsConfig")]
1850    #[serde(default)]
1851    #[serde(skip_serializing_if = "Option::is_none")]
1852    pub logs_config: Option<LogsConfig>,
1853    #[serde(default)]
1854    pub name: String,
1855    #[serde(rename = "queuedTimeoutInMinutes")]
1856    #[serde(default)]
1857    #[serde(skip_serializing_if = "Option::is_none")]
1858    pub queued_timeout_in_minutes: Option<i32>,
1859    #[serde(rename = "secondaryArtifacts")]
1860    #[serde(default)]
1861    #[serde(skip_serializing_if = "Option::is_none")]
1862    pub secondary_artifacts: Option<Vec<ProjectArtifacts>>,
1863    #[serde(rename = "secondarySourceVersions")]
1864    #[serde(default)]
1865    #[serde(skip_serializing_if = "Option::is_none")]
1866    pub secondary_source_versions: Option<Vec<ProjectSourceVersion>>,
1867    #[serde(rename = "secondarySources")]
1868    #[serde(default)]
1869    #[serde(skip_serializing_if = "Option::is_none")]
1870    pub secondary_sources: Option<Vec<ProjectSource>>,
1871    #[serde(rename = "serviceRole")]
1872    #[serde(default)]
1873    pub service_role: String,
1874    #[serde(default)]
1875    pub source: ProjectSource,
1876    #[serde(rename = "sourceVersion")]
1877    #[serde(default)]
1878    #[serde(skip_serializing_if = "Option::is_none")]
1879    pub source_version: Option<String>,
1880    #[serde(default)]
1881    #[serde(skip_serializing_if = "Option::is_none")]
1882    pub tags: Option<Vec<Tag>>,
1883    #[serde(rename = "timeoutInMinutes")]
1884    #[serde(default)]
1885    #[serde(skip_serializing_if = "Option::is_none")]
1886    pub timeout_in_minutes: Option<i32>,
1887    #[serde(rename = "vpcConfig")]
1888    #[serde(default)]
1889    #[serde(skip_serializing_if = "Option::is_none")]
1890    pub vpc_config: Option<VpcConfig>,
1891}
1892
1893#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1894pub struct CreateProjectOutput {
1895    #[serde(default)]
1896    #[serde(skip_serializing_if = "Option::is_none")]
1897    pub project: Option<Project>,
1898}
1899
1900#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1901pub struct CreateReportGroupInput {
1902    #[serde(rename = "exportConfig")]
1903    #[serde(default)]
1904    pub export_config: ReportExportConfig,
1905    #[serde(default)]
1906    pub name: String,
1907    #[serde(default)]
1908    #[serde(skip_serializing_if = "Option::is_none")]
1909    pub tags: Option<Vec<Tag>>,
1910    #[serde(rename = "type")]
1911    #[serde(default)]
1912    pub r#type: String,
1913}
1914
1915#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1916pub struct CreateReportGroupOutput {
1917    #[serde(rename = "reportGroup")]
1918    #[serde(default)]
1919    #[serde(skip_serializing_if = "Option::is_none")]
1920    pub report_group: Option<ReportGroup>,
1921}
1922
1923#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1924pub struct CreateWebhookInput {
1925    #[serde(rename = "branchFilter")]
1926    #[serde(default)]
1927    #[serde(skip_serializing_if = "Option::is_none")]
1928    pub branch_filter: Option<String>,
1929    #[serde(rename = "buildType")]
1930    #[serde(default)]
1931    #[serde(skip_serializing_if = "Option::is_none")]
1932    pub build_type: Option<String>,
1933    #[serde(rename = "filterGroups")]
1934    #[serde(default)]
1935    #[serde(skip_serializing_if = "Option::is_none")]
1936    pub filter_groups: Option<Vec<Vec<WebhookFilter>>>,
1937    #[serde(rename = "manualCreation")]
1938    #[serde(default)]
1939    #[serde(skip_serializing_if = "Option::is_none")]
1940    pub manual_creation: Option<bool>,
1941    #[serde(rename = "projectName")]
1942    #[serde(default)]
1943    pub project_name: String,
1944    #[serde(rename = "pullRequestBuildPolicy")]
1945    #[serde(default)]
1946    #[serde(skip_serializing_if = "Option::is_none")]
1947    pub pull_request_build_policy: Option<PullRequestBuildPolicy>,
1948    #[serde(rename = "scopeConfiguration")]
1949    #[serde(default)]
1950    #[serde(skip_serializing_if = "Option::is_none")]
1951    pub scope_configuration: Option<ScopeConfiguration>,
1952}
1953
1954#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1955pub struct CreateWebhookOutput {
1956    #[serde(default)]
1957    #[serde(skip_serializing_if = "Option::is_none")]
1958    pub webhook: Option<Webhook>,
1959}
1960
1961#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1962pub struct DeleteBuildBatchInput {
1963    #[serde(default)]
1964    pub id: String,
1965}
1966
1967#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1968pub struct DeleteBuildBatchOutput {
1969    #[serde(rename = "buildsDeleted")]
1970    #[serde(default)]
1971    #[serde(skip_serializing_if = "Option::is_none")]
1972    pub builds_deleted: Option<Vec<String>>,
1973    #[serde(rename = "buildsNotDeleted")]
1974    #[serde(default)]
1975    #[serde(skip_serializing_if = "Option::is_none")]
1976    pub builds_not_deleted: Option<Vec<BuildNotDeleted>>,
1977    #[serde(rename = "statusCode")]
1978    #[serde(default)]
1979    #[serde(skip_serializing_if = "Option::is_none")]
1980    pub status_code: Option<String>,
1981}
1982
1983#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1984pub struct DeleteFleetInput {
1985    #[serde(default)]
1986    pub arn: String,
1987}
1988
1989#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1990pub struct DeleteFleetOutput {}
1991
1992#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1993pub struct DeleteProjectInput {
1994    #[serde(default)]
1995    pub name: String,
1996}
1997
1998#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1999pub struct DeleteProjectOutput {}
2000
2001#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2002pub struct DeleteReportGroupInput {
2003    #[serde(default)]
2004    pub arn: String,
2005    #[serde(rename = "deleteReports")]
2006    #[serde(default)]
2007    #[serde(skip_serializing_if = "Option::is_none")]
2008    pub delete_reports: Option<bool>,
2009}
2010
2011#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2012pub struct DeleteReportGroupOutput {}
2013
2014#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2015pub struct DeleteReportInput {
2016    #[serde(default)]
2017    pub arn: String,
2018}
2019
2020#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2021pub struct DeleteReportOutput {}
2022
2023#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2024pub struct DeleteResourcePolicyInput {
2025    #[serde(rename = "resourceArn")]
2026    #[serde(default)]
2027    pub resource_arn: String,
2028}
2029
2030#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2031pub struct DeleteResourcePolicyOutput {}
2032
2033#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2034pub struct DeleteSourceCredentialsInput {
2035    #[serde(default)]
2036    pub arn: String,
2037}
2038
2039#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2040pub struct DeleteSourceCredentialsOutput {
2041    #[serde(default)]
2042    #[serde(skip_serializing_if = "Option::is_none")]
2043    pub arn: Option<String>,
2044}
2045
2046#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2047pub struct DeleteWebhookInput {
2048    #[serde(rename = "projectName")]
2049    #[serde(default)]
2050    pub project_name: String,
2051}
2052
2053#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2054pub struct DeleteWebhookOutput {}
2055
2056#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2057pub struct DescribeCodeCoveragesInput {
2058    #[serde(rename = "maxLineCoveragePercentage")]
2059    #[serde(default)]
2060    #[serde(skip_serializing_if = "Option::is_none")]
2061    pub max_line_coverage_percentage: Option<f64>,
2062    #[serde(rename = "maxResults")]
2063    #[serde(default)]
2064    #[serde(skip_serializing_if = "Option::is_none")]
2065    pub max_results: Option<i32>,
2066    #[serde(rename = "minLineCoveragePercentage")]
2067    #[serde(default)]
2068    #[serde(skip_serializing_if = "Option::is_none")]
2069    pub min_line_coverage_percentage: Option<f64>,
2070    #[serde(rename = "nextToken")]
2071    #[serde(default)]
2072    #[serde(skip_serializing_if = "Option::is_none")]
2073    pub next_token: Option<String>,
2074    #[serde(rename = "reportArn")]
2075    #[serde(default)]
2076    pub report_arn: String,
2077    #[serde(rename = "sortBy")]
2078    #[serde(default)]
2079    #[serde(skip_serializing_if = "Option::is_none")]
2080    pub sort_by: Option<String>,
2081    #[serde(rename = "sortOrder")]
2082    #[serde(default)]
2083    #[serde(skip_serializing_if = "Option::is_none")]
2084    pub sort_order: Option<String>,
2085}
2086
2087#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2088pub struct DescribeCodeCoveragesOutput {
2089    #[serde(rename = "codeCoverages")]
2090    #[serde(default)]
2091    #[serde(skip_serializing_if = "Option::is_none")]
2092    pub code_coverages: Option<Vec<CodeCoverage>>,
2093    #[serde(rename = "nextToken")]
2094    #[serde(default)]
2095    #[serde(skip_serializing_if = "Option::is_none")]
2096    pub next_token: Option<String>,
2097}
2098
2099#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2100pub struct CodeCoverage {
2101    #[serde(rename = "branchCoveragePercentage")]
2102    #[serde(default)]
2103    #[serde(skip_serializing_if = "Option::is_none")]
2104    pub branch_coverage_percentage: Option<f64>,
2105    #[serde(rename = "branchesCovered")]
2106    #[serde(default)]
2107    #[serde(skip_serializing_if = "Option::is_none")]
2108    pub branches_covered: Option<i32>,
2109    #[serde(rename = "branchesMissed")]
2110    #[serde(default)]
2111    #[serde(skip_serializing_if = "Option::is_none")]
2112    pub branches_missed: Option<i32>,
2113    #[serde(default)]
2114    #[serde(skip_serializing_if = "Option::is_none")]
2115    pub expired: Option<f64>,
2116    #[serde(rename = "filePath")]
2117    #[serde(default)]
2118    #[serde(skip_serializing_if = "Option::is_none")]
2119    pub file_path: Option<String>,
2120    #[serde(default)]
2121    #[serde(skip_serializing_if = "Option::is_none")]
2122    pub id: Option<String>,
2123    #[serde(rename = "lineCoveragePercentage")]
2124    #[serde(default)]
2125    #[serde(skip_serializing_if = "Option::is_none")]
2126    pub line_coverage_percentage: Option<f64>,
2127    #[serde(rename = "linesCovered")]
2128    #[serde(default)]
2129    #[serde(skip_serializing_if = "Option::is_none")]
2130    pub lines_covered: Option<i32>,
2131    #[serde(rename = "linesMissed")]
2132    #[serde(default)]
2133    #[serde(skip_serializing_if = "Option::is_none")]
2134    pub lines_missed: Option<i32>,
2135    #[serde(rename = "reportARN")]
2136    #[serde(default)]
2137    #[serde(skip_serializing_if = "Option::is_none")]
2138    pub report_a_r_n: Option<String>,
2139}
2140
2141#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2142pub struct DescribeTestCasesInput {
2143    #[serde(default)]
2144    #[serde(skip_serializing_if = "Option::is_none")]
2145    pub filter: Option<TestCaseFilter>,
2146    #[serde(rename = "maxResults")]
2147    #[serde(default)]
2148    #[serde(skip_serializing_if = "Option::is_none")]
2149    pub max_results: Option<i32>,
2150    #[serde(rename = "nextToken")]
2151    #[serde(default)]
2152    #[serde(skip_serializing_if = "Option::is_none")]
2153    pub next_token: Option<String>,
2154    #[serde(rename = "reportArn")]
2155    #[serde(default)]
2156    pub report_arn: String,
2157}
2158
2159#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2160pub struct TestCaseFilter {
2161    #[serde(default)]
2162    #[serde(skip_serializing_if = "Option::is_none")]
2163    pub keyword: Option<String>,
2164    #[serde(default)]
2165    #[serde(skip_serializing_if = "Option::is_none")]
2166    pub status: Option<String>,
2167}
2168
2169#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2170pub struct DescribeTestCasesOutput {
2171    #[serde(rename = "nextToken")]
2172    #[serde(default)]
2173    #[serde(skip_serializing_if = "Option::is_none")]
2174    pub next_token: Option<String>,
2175    #[serde(rename = "testCases")]
2176    #[serde(default)]
2177    #[serde(skip_serializing_if = "Option::is_none")]
2178    pub test_cases: Option<Vec<TestCase>>,
2179}
2180
2181#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2182pub struct TestCase {
2183    #[serde(rename = "durationInNanoSeconds")]
2184    #[serde(default)]
2185    #[serde(skip_serializing_if = "Option::is_none")]
2186    pub duration_in_nano_seconds: Option<i64>,
2187    #[serde(default)]
2188    #[serde(skip_serializing_if = "Option::is_none")]
2189    pub expired: Option<f64>,
2190    #[serde(default)]
2191    #[serde(skip_serializing_if = "Option::is_none")]
2192    pub message: Option<String>,
2193    #[serde(default)]
2194    #[serde(skip_serializing_if = "Option::is_none")]
2195    pub name: Option<String>,
2196    #[serde(default)]
2197    #[serde(skip_serializing_if = "Option::is_none")]
2198    pub prefix: Option<String>,
2199    #[serde(rename = "reportArn")]
2200    #[serde(default)]
2201    #[serde(skip_serializing_if = "Option::is_none")]
2202    pub report_arn: Option<String>,
2203    #[serde(default)]
2204    #[serde(skip_serializing_if = "Option::is_none")]
2205    pub status: Option<String>,
2206    #[serde(rename = "testRawDataPath")]
2207    #[serde(default)]
2208    #[serde(skip_serializing_if = "Option::is_none")]
2209    pub test_raw_data_path: Option<String>,
2210    #[serde(rename = "testSuiteName")]
2211    #[serde(default)]
2212    #[serde(skip_serializing_if = "Option::is_none")]
2213    pub test_suite_name: Option<String>,
2214}
2215
2216#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2217pub struct GetReportGroupTrendInput {
2218    #[serde(rename = "numOfReports")]
2219    #[serde(default)]
2220    #[serde(skip_serializing_if = "Option::is_none")]
2221    pub num_of_reports: Option<i32>,
2222    #[serde(rename = "reportGroupArn")]
2223    #[serde(default)]
2224    pub report_group_arn: String,
2225    #[serde(rename = "trendField")]
2226    #[serde(default)]
2227    pub trend_field: String,
2228}
2229
2230#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2231pub struct GetReportGroupTrendOutput {
2232    #[serde(rename = "rawData")]
2233    #[serde(default)]
2234    #[serde(skip_serializing_if = "Option::is_none")]
2235    pub raw_data: Option<Vec<ReportWithRawData>>,
2236    #[serde(default)]
2237    #[serde(skip_serializing_if = "Option::is_none")]
2238    pub stats: Option<ReportGroupTrendStats>,
2239}
2240
2241#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2242pub struct ReportWithRawData {
2243    #[serde(default)]
2244    #[serde(skip_serializing_if = "Option::is_none")]
2245    pub data: Option<String>,
2246    #[serde(rename = "reportArn")]
2247    #[serde(default)]
2248    #[serde(skip_serializing_if = "Option::is_none")]
2249    pub report_arn: Option<String>,
2250}
2251
2252#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2253pub struct ReportGroupTrendStats {
2254    #[serde(default)]
2255    #[serde(skip_serializing_if = "Option::is_none")]
2256    pub average: Option<String>,
2257    #[serde(default)]
2258    #[serde(skip_serializing_if = "Option::is_none")]
2259    pub max: Option<String>,
2260    #[serde(default)]
2261    #[serde(skip_serializing_if = "Option::is_none")]
2262    pub min: Option<String>,
2263}
2264
2265#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2266pub struct GetResourcePolicyInput {
2267    #[serde(rename = "resourceArn")]
2268    #[serde(default)]
2269    pub resource_arn: String,
2270}
2271
2272#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2273pub struct GetResourcePolicyOutput {
2274    #[serde(default)]
2275    #[serde(skip_serializing_if = "Option::is_none")]
2276    pub policy: Option<String>,
2277}
2278
2279#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2280pub struct ImportSourceCredentialsInput {
2281    #[serde(rename = "authType")]
2282    #[serde(default)]
2283    pub auth_type: String,
2284    #[serde(rename = "serverType")]
2285    #[serde(default)]
2286    pub server_type: String,
2287    #[serde(rename = "shouldOverwrite")]
2288    #[serde(default)]
2289    #[serde(skip_serializing_if = "Option::is_none")]
2290    pub should_overwrite: Option<bool>,
2291    #[serde(default)]
2292    pub token: String,
2293    #[serde(default)]
2294    #[serde(skip_serializing_if = "Option::is_none")]
2295    pub username: Option<String>,
2296}
2297
2298#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2299pub struct ImportSourceCredentialsOutput {
2300    #[serde(default)]
2301    #[serde(skip_serializing_if = "Option::is_none")]
2302    pub arn: Option<String>,
2303}
2304
2305#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2306pub struct InvalidateProjectCacheInput {
2307    #[serde(rename = "projectName")]
2308    #[serde(default)]
2309    pub project_name: String,
2310}
2311
2312#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2313pub struct InvalidateProjectCacheOutput {}
2314
2315#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2316pub struct ListBuildBatchesForProjectInput {
2317    #[serde(default)]
2318    #[serde(skip_serializing_if = "Option::is_none")]
2319    pub filter: Option<BuildBatchFilter>,
2320    #[serde(rename = "maxResults")]
2321    #[serde(default)]
2322    #[serde(skip_serializing_if = "Option::is_none")]
2323    pub max_results: Option<i32>,
2324    #[serde(rename = "nextToken")]
2325    #[serde(default)]
2326    #[serde(skip_serializing_if = "Option::is_none")]
2327    pub next_token: Option<String>,
2328    #[serde(rename = "projectName")]
2329    #[serde(default)]
2330    #[serde(skip_serializing_if = "Option::is_none")]
2331    pub project_name: Option<String>,
2332    #[serde(rename = "sortOrder")]
2333    #[serde(default)]
2334    #[serde(skip_serializing_if = "Option::is_none")]
2335    pub sort_order: Option<String>,
2336}
2337
2338#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2339pub struct BuildBatchFilter {
2340    #[serde(default)]
2341    #[serde(skip_serializing_if = "Option::is_none")]
2342    pub status: Option<String>,
2343}
2344
2345#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2346pub struct ListBuildBatchesForProjectOutput {
2347    #[serde(default)]
2348    #[serde(skip_serializing_if = "Option::is_none")]
2349    pub ids: Option<Vec<String>>,
2350    #[serde(rename = "nextToken")]
2351    #[serde(default)]
2352    #[serde(skip_serializing_if = "Option::is_none")]
2353    pub next_token: Option<String>,
2354}
2355
2356#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2357pub struct ListBuildBatchesInput {
2358    #[serde(default)]
2359    #[serde(skip_serializing_if = "Option::is_none")]
2360    pub filter: Option<BuildBatchFilter>,
2361    #[serde(rename = "maxResults")]
2362    #[serde(default)]
2363    #[serde(skip_serializing_if = "Option::is_none")]
2364    pub max_results: Option<i32>,
2365    #[serde(rename = "nextToken")]
2366    #[serde(default)]
2367    #[serde(skip_serializing_if = "Option::is_none")]
2368    pub next_token: Option<String>,
2369    #[serde(rename = "sortOrder")]
2370    #[serde(default)]
2371    #[serde(skip_serializing_if = "Option::is_none")]
2372    pub sort_order: Option<String>,
2373}
2374
2375#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2376pub struct ListBuildBatchesOutput {
2377    #[serde(default)]
2378    #[serde(skip_serializing_if = "Option::is_none")]
2379    pub ids: Option<Vec<String>>,
2380    #[serde(rename = "nextToken")]
2381    #[serde(default)]
2382    #[serde(skip_serializing_if = "Option::is_none")]
2383    pub next_token: Option<String>,
2384}
2385
2386#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2387pub struct ListBuildsForProjectInput {
2388    #[serde(rename = "nextToken")]
2389    #[serde(default)]
2390    #[serde(skip_serializing_if = "Option::is_none")]
2391    pub next_token: Option<String>,
2392    #[serde(rename = "projectName")]
2393    #[serde(default)]
2394    pub project_name: String,
2395    #[serde(rename = "sortOrder")]
2396    #[serde(default)]
2397    #[serde(skip_serializing_if = "Option::is_none")]
2398    pub sort_order: Option<String>,
2399}
2400
2401#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2402pub struct ListBuildsForProjectOutput {
2403    #[serde(default)]
2404    #[serde(skip_serializing_if = "Option::is_none")]
2405    pub ids: Option<Vec<String>>,
2406    #[serde(rename = "nextToken")]
2407    #[serde(default)]
2408    #[serde(skip_serializing_if = "Option::is_none")]
2409    pub next_token: Option<String>,
2410}
2411
2412#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2413pub struct ListBuildsInput {
2414    #[serde(rename = "nextToken")]
2415    #[serde(default)]
2416    #[serde(skip_serializing_if = "Option::is_none")]
2417    pub next_token: Option<String>,
2418    #[serde(rename = "sortOrder")]
2419    #[serde(default)]
2420    #[serde(skip_serializing_if = "Option::is_none")]
2421    pub sort_order: Option<String>,
2422}
2423
2424#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2425pub struct ListBuildsOutput {
2426    #[serde(default)]
2427    #[serde(skip_serializing_if = "Option::is_none")]
2428    pub ids: Option<Vec<String>>,
2429    #[serde(rename = "nextToken")]
2430    #[serde(default)]
2431    #[serde(skip_serializing_if = "Option::is_none")]
2432    pub next_token: Option<String>,
2433}
2434
2435#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2436pub struct ListCommandExecutionsForSandboxInput {
2437    #[serde(rename = "maxResults")]
2438    #[serde(default)]
2439    #[serde(skip_serializing_if = "Option::is_none")]
2440    pub max_results: Option<i32>,
2441    #[serde(rename = "nextToken")]
2442    #[serde(default)]
2443    #[serde(skip_serializing_if = "Option::is_none")]
2444    pub next_token: Option<String>,
2445    #[serde(rename = "sandboxId")]
2446    #[serde(default)]
2447    pub sandbox_id: String,
2448    #[serde(rename = "sortOrder")]
2449    #[serde(default)]
2450    #[serde(skip_serializing_if = "Option::is_none")]
2451    pub sort_order: Option<String>,
2452}
2453
2454#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2455pub struct ListCommandExecutionsForSandboxOutput {
2456    #[serde(rename = "commandExecutions")]
2457    #[serde(default)]
2458    #[serde(skip_serializing_if = "Option::is_none")]
2459    pub command_executions: Option<Vec<CommandExecution>>,
2460    #[serde(rename = "nextToken")]
2461    #[serde(default)]
2462    #[serde(skip_serializing_if = "Option::is_none")]
2463    pub next_token: Option<String>,
2464}
2465
2466#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2467pub struct ListCuratedEnvironmentImagesInput {}
2468
2469#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2470pub struct ListCuratedEnvironmentImagesOutput {
2471    #[serde(default)]
2472    #[serde(skip_serializing_if = "Option::is_none")]
2473    pub platforms: Option<Vec<EnvironmentPlatform>>,
2474}
2475
2476#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2477pub struct EnvironmentPlatform {
2478    #[serde(default)]
2479    #[serde(skip_serializing_if = "Option::is_none")]
2480    pub languages: Option<Vec<EnvironmentLanguage>>,
2481    #[serde(default)]
2482    #[serde(skip_serializing_if = "Option::is_none")]
2483    pub platform: Option<String>,
2484}
2485
2486#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2487pub struct EnvironmentLanguage {
2488    #[serde(default)]
2489    #[serde(skip_serializing_if = "Option::is_none")]
2490    pub images: Option<Vec<EnvironmentImage>>,
2491    #[serde(default)]
2492    #[serde(skip_serializing_if = "Option::is_none")]
2493    pub language: Option<String>,
2494}
2495
2496#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2497pub struct EnvironmentImage {
2498    #[serde(default)]
2499    #[serde(skip_serializing_if = "Option::is_none")]
2500    pub description: Option<String>,
2501    #[serde(default)]
2502    #[serde(skip_serializing_if = "Option::is_none")]
2503    pub name: Option<String>,
2504    #[serde(default)]
2505    #[serde(skip_serializing_if = "Option::is_none")]
2506    pub versions: Option<Vec<String>>,
2507}
2508
2509#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2510pub struct ListFleetsInput {
2511    #[serde(rename = "maxResults")]
2512    #[serde(default)]
2513    #[serde(skip_serializing_if = "Option::is_none")]
2514    pub max_results: Option<i32>,
2515    #[serde(rename = "nextToken")]
2516    #[serde(default)]
2517    #[serde(skip_serializing_if = "Option::is_none")]
2518    pub next_token: Option<String>,
2519    #[serde(rename = "sortBy")]
2520    #[serde(default)]
2521    #[serde(skip_serializing_if = "Option::is_none")]
2522    pub sort_by: Option<String>,
2523    #[serde(rename = "sortOrder")]
2524    #[serde(default)]
2525    #[serde(skip_serializing_if = "Option::is_none")]
2526    pub sort_order: Option<String>,
2527}
2528
2529#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2530pub struct ListFleetsOutput {
2531    #[serde(default)]
2532    #[serde(skip_serializing_if = "Option::is_none")]
2533    pub fleets: Option<Vec<String>>,
2534    #[serde(rename = "nextToken")]
2535    #[serde(default)]
2536    #[serde(skip_serializing_if = "Option::is_none")]
2537    pub next_token: Option<String>,
2538}
2539
2540#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2541pub struct ListProjectsInput {
2542    #[serde(rename = "nextToken")]
2543    #[serde(default)]
2544    #[serde(skip_serializing_if = "Option::is_none")]
2545    pub next_token: Option<String>,
2546    #[serde(rename = "sortBy")]
2547    #[serde(default)]
2548    #[serde(skip_serializing_if = "Option::is_none")]
2549    pub sort_by: Option<String>,
2550    #[serde(rename = "sortOrder")]
2551    #[serde(default)]
2552    #[serde(skip_serializing_if = "Option::is_none")]
2553    pub sort_order: Option<String>,
2554}
2555
2556#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2557pub struct ListProjectsOutput {
2558    #[serde(rename = "nextToken")]
2559    #[serde(default)]
2560    #[serde(skip_serializing_if = "Option::is_none")]
2561    pub next_token: Option<String>,
2562    #[serde(default)]
2563    #[serde(skip_serializing_if = "Option::is_none")]
2564    pub projects: Option<Vec<String>>,
2565}
2566
2567#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2568pub struct ListReportGroupsInput {
2569    #[serde(rename = "maxResults")]
2570    #[serde(default)]
2571    #[serde(skip_serializing_if = "Option::is_none")]
2572    pub max_results: Option<i32>,
2573    #[serde(rename = "nextToken")]
2574    #[serde(default)]
2575    #[serde(skip_serializing_if = "Option::is_none")]
2576    pub next_token: Option<String>,
2577    #[serde(rename = "sortBy")]
2578    #[serde(default)]
2579    #[serde(skip_serializing_if = "Option::is_none")]
2580    pub sort_by: Option<String>,
2581    #[serde(rename = "sortOrder")]
2582    #[serde(default)]
2583    #[serde(skip_serializing_if = "Option::is_none")]
2584    pub sort_order: Option<String>,
2585}
2586
2587#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2588pub struct ListReportGroupsOutput {
2589    #[serde(rename = "nextToken")]
2590    #[serde(default)]
2591    #[serde(skip_serializing_if = "Option::is_none")]
2592    pub next_token: Option<String>,
2593    #[serde(rename = "reportGroups")]
2594    #[serde(default)]
2595    #[serde(skip_serializing_if = "Option::is_none")]
2596    pub report_groups: Option<Vec<String>>,
2597}
2598
2599#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2600pub struct ListReportsForReportGroupInput {
2601    #[serde(default)]
2602    #[serde(skip_serializing_if = "Option::is_none")]
2603    pub filter: Option<ReportFilter>,
2604    #[serde(rename = "maxResults")]
2605    #[serde(default)]
2606    #[serde(skip_serializing_if = "Option::is_none")]
2607    pub max_results: Option<i32>,
2608    #[serde(rename = "nextToken")]
2609    #[serde(default)]
2610    #[serde(skip_serializing_if = "Option::is_none")]
2611    pub next_token: Option<String>,
2612    #[serde(rename = "reportGroupArn")]
2613    #[serde(default)]
2614    pub report_group_arn: String,
2615    #[serde(rename = "sortOrder")]
2616    #[serde(default)]
2617    #[serde(skip_serializing_if = "Option::is_none")]
2618    pub sort_order: Option<String>,
2619}
2620
2621#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2622pub struct ReportFilter {
2623    #[serde(default)]
2624    #[serde(skip_serializing_if = "Option::is_none")]
2625    pub status: Option<String>,
2626}
2627
2628#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2629pub struct ListReportsForReportGroupOutput {
2630    #[serde(rename = "nextToken")]
2631    #[serde(default)]
2632    #[serde(skip_serializing_if = "Option::is_none")]
2633    pub next_token: Option<String>,
2634    #[serde(default)]
2635    #[serde(skip_serializing_if = "Option::is_none")]
2636    pub reports: Option<Vec<String>>,
2637}
2638
2639#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2640pub struct ListReportsInput {
2641    #[serde(default)]
2642    #[serde(skip_serializing_if = "Option::is_none")]
2643    pub filter: Option<ReportFilter>,
2644    #[serde(rename = "maxResults")]
2645    #[serde(default)]
2646    #[serde(skip_serializing_if = "Option::is_none")]
2647    pub max_results: Option<i32>,
2648    #[serde(rename = "nextToken")]
2649    #[serde(default)]
2650    #[serde(skip_serializing_if = "Option::is_none")]
2651    pub next_token: Option<String>,
2652    #[serde(rename = "sortOrder")]
2653    #[serde(default)]
2654    #[serde(skip_serializing_if = "Option::is_none")]
2655    pub sort_order: Option<String>,
2656}
2657
2658#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2659pub struct ListReportsOutput {
2660    #[serde(rename = "nextToken")]
2661    #[serde(default)]
2662    #[serde(skip_serializing_if = "Option::is_none")]
2663    pub next_token: Option<String>,
2664    #[serde(default)]
2665    #[serde(skip_serializing_if = "Option::is_none")]
2666    pub reports: Option<Vec<String>>,
2667}
2668
2669#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2670pub struct ListSandboxesForProjectInput {
2671    #[serde(rename = "maxResults")]
2672    #[serde(default)]
2673    #[serde(skip_serializing_if = "Option::is_none")]
2674    pub max_results: Option<i32>,
2675    #[serde(rename = "nextToken")]
2676    #[serde(default)]
2677    #[serde(skip_serializing_if = "Option::is_none")]
2678    pub next_token: Option<String>,
2679    #[serde(rename = "projectName")]
2680    #[serde(default)]
2681    pub project_name: String,
2682    #[serde(rename = "sortOrder")]
2683    #[serde(default)]
2684    #[serde(skip_serializing_if = "Option::is_none")]
2685    pub sort_order: Option<String>,
2686}
2687
2688#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2689pub struct ListSandboxesForProjectOutput {
2690    #[serde(default)]
2691    #[serde(skip_serializing_if = "Option::is_none")]
2692    pub ids: Option<Vec<String>>,
2693    #[serde(rename = "nextToken")]
2694    #[serde(default)]
2695    #[serde(skip_serializing_if = "Option::is_none")]
2696    pub next_token: Option<String>,
2697}
2698
2699#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2700pub struct ListSandboxesInput {
2701    #[serde(rename = "maxResults")]
2702    #[serde(default)]
2703    #[serde(skip_serializing_if = "Option::is_none")]
2704    pub max_results: Option<i32>,
2705    #[serde(rename = "nextToken")]
2706    #[serde(default)]
2707    #[serde(skip_serializing_if = "Option::is_none")]
2708    pub next_token: Option<String>,
2709    #[serde(rename = "sortOrder")]
2710    #[serde(default)]
2711    #[serde(skip_serializing_if = "Option::is_none")]
2712    pub sort_order: Option<String>,
2713}
2714
2715#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2716pub struct ListSandboxesOutput {
2717    #[serde(default)]
2718    #[serde(skip_serializing_if = "Option::is_none")]
2719    pub ids: Option<Vec<String>>,
2720    #[serde(rename = "nextToken")]
2721    #[serde(default)]
2722    #[serde(skip_serializing_if = "Option::is_none")]
2723    pub next_token: Option<String>,
2724}
2725
2726#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2727pub struct ListSharedProjectsInput {
2728    #[serde(rename = "maxResults")]
2729    #[serde(default)]
2730    #[serde(skip_serializing_if = "Option::is_none")]
2731    pub max_results: Option<i32>,
2732    #[serde(rename = "nextToken")]
2733    #[serde(default)]
2734    #[serde(skip_serializing_if = "Option::is_none")]
2735    pub next_token: Option<String>,
2736    #[serde(rename = "sortBy")]
2737    #[serde(default)]
2738    #[serde(skip_serializing_if = "Option::is_none")]
2739    pub sort_by: Option<String>,
2740    #[serde(rename = "sortOrder")]
2741    #[serde(default)]
2742    #[serde(skip_serializing_if = "Option::is_none")]
2743    pub sort_order: Option<String>,
2744}
2745
2746#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2747pub struct ListSharedProjectsOutput {
2748    #[serde(rename = "nextToken")]
2749    #[serde(default)]
2750    #[serde(skip_serializing_if = "Option::is_none")]
2751    pub next_token: Option<String>,
2752    #[serde(default)]
2753    #[serde(skip_serializing_if = "Option::is_none")]
2754    pub projects: Option<Vec<String>>,
2755}
2756
2757#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2758pub struct ListSharedReportGroupsInput {
2759    #[serde(rename = "maxResults")]
2760    #[serde(default)]
2761    #[serde(skip_serializing_if = "Option::is_none")]
2762    pub max_results: Option<i32>,
2763    #[serde(rename = "nextToken")]
2764    #[serde(default)]
2765    #[serde(skip_serializing_if = "Option::is_none")]
2766    pub next_token: Option<String>,
2767    #[serde(rename = "sortBy")]
2768    #[serde(default)]
2769    #[serde(skip_serializing_if = "Option::is_none")]
2770    pub sort_by: Option<String>,
2771    #[serde(rename = "sortOrder")]
2772    #[serde(default)]
2773    #[serde(skip_serializing_if = "Option::is_none")]
2774    pub sort_order: Option<String>,
2775}
2776
2777#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2778pub struct ListSharedReportGroupsOutput {
2779    #[serde(rename = "nextToken")]
2780    #[serde(default)]
2781    #[serde(skip_serializing_if = "Option::is_none")]
2782    pub next_token: Option<String>,
2783    #[serde(rename = "reportGroups")]
2784    #[serde(default)]
2785    #[serde(skip_serializing_if = "Option::is_none")]
2786    pub report_groups: Option<Vec<String>>,
2787}
2788
2789#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2790pub struct ListSourceCredentialsInput {}
2791
2792#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2793pub struct ListSourceCredentialsOutput {
2794    #[serde(rename = "sourceCredentialsInfos")]
2795    #[serde(default)]
2796    #[serde(skip_serializing_if = "Option::is_none")]
2797    pub source_credentials_infos: Option<Vec<SourceCredentialsInfo>>,
2798}
2799
2800#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2801pub struct SourceCredentialsInfo {
2802    #[serde(default)]
2803    #[serde(skip_serializing_if = "Option::is_none")]
2804    pub arn: Option<String>,
2805    #[serde(rename = "authType")]
2806    #[serde(default)]
2807    #[serde(skip_serializing_if = "Option::is_none")]
2808    pub auth_type: Option<String>,
2809    #[serde(default)]
2810    #[serde(skip_serializing_if = "Option::is_none")]
2811    pub resource: Option<String>,
2812    #[serde(rename = "serverType")]
2813    #[serde(default)]
2814    #[serde(skip_serializing_if = "Option::is_none")]
2815    pub server_type: Option<String>,
2816}
2817
2818#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2819pub struct PutResourcePolicyInput {
2820    #[serde(default)]
2821    pub policy: String,
2822    #[serde(rename = "resourceArn")]
2823    #[serde(default)]
2824    pub resource_arn: String,
2825}
2826
2827#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2828pub struct PutResourcePolicyOutput {
2829    #[serde(rename = "resourceArn")]
2830    #[serde(default)]
2831    #[serde(skip_serializing_if = "Option::is_none")]
2832    pub resource_arn: Option<String>,
2833}
2834
2835#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2836pub struct RetryBuildBatchInput {
2837    #[serde(default)]
2838    #[serde(skip_serializing_if = "Option::is_none")]
2839    pub id: Option<String>,
2840    #[serde(rename = "idempotencyToken")]
2841    #[serde(default)]
2842    #[serde(skip_serializing_if = "Option::is_none")]
2843    pub idempotency_token: Option<String>,
2844    #[serde(rename = "retryType")]
2845    #[serde(default)]
2846    #[serde(skip_serializing_if = "Option::is_none")]
2847    pub retry_type: Option<String>,
2848}
2849
2850#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2851pub struct RetryBuildBatchOutput {
2852    #[serde(rename = "buildBatch")]
2853    #[serde(default)]
2854    #[serde(skip_serializing_if = "Option::is_none")]
2855    pub build_batch: Option<BuildBatch>,
2856}
2857
2858#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2859pub struct RetryBuildInput {
2860    #[serde(default)]
2861    #[serde(skip_serializing_if = "Option::is_none")]
2862    pub id: Option<String>,
2863    #[serde(rename = "idempotencyToken")]
2864    #[serde(default)]
2865    #[serde(skip_serializing_if = "Option::is_none")]
2866    pub idempotency_token: Option<String>,
2867}
2868
2869#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2870pub struct RetryBuildOutput {
2871    #[serde(default)]
2872    #[serde(skip_serializing_if = "Option::is_none")]
2873    pub build: Option<Build>,
2874}
2875
2876#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2877pub struct StartBuildBatchInput {
2878    #[serde(rename = "artifactsOverride")]
2879    #[serde(default)]
2880    #[serde(skip_serializing_if = "Option::is_none")]
2881    pub artifacts_override: Option<ProjectArtifacts>,
2882    #[serde(rename = "buildBatchConfigOverride")]
2883    #[serde(default)]
2884    #[serde(skip_serializing_if = "Option::is_none")]
2885    pub build_batch_config_override: Option<ProjectBuildBatchConfig>,
2886    #[serde(rename = "buildTimeoutInMinutesOverride")]
2887    #[serde(default)]
2888    #[serde(skip_serializing_if = "Option::is_none")]
2889    pub build_timeout_in_minutes_override: Option<i32>,
2890    #[serde(rename = "buildspecOverride")]
2891    #[serde(default)]
2892    #[serde(skip_serializing_if = "Option::is_none")]
2893    pub buildspec_override: Option<String>,
2894    #[serde(rename = "cacheOverride")]
2895    #[serde(default)]
2896    #[serde(skip_serializing_if = "Option::is_none")]
2897    pub cache_override: Option<ProjectCache>,
2898    #[serde(rename = "certificateOverride")]
2899    #[serde(default)]
2900    #[serde(skip_serializing_if = "Option::is_none")]
2901    pub certificate_override: Option<String>,
2902    #[serde(rename = "computeTypeOverride")]
2903    #[serde(default)]
2904    #[serde(skip_serializing_if = "Option::is_none")]
2905    pub compute_type_override: Option<String>,
2906    #[serde(rename = "debugSessionEnabled")]
2907    #[serde(default)]
2908    #[serde(skip_serializing_if = "Option::is_none")]
2909    pub debug_session_enabled: Option<bool>,
2910    #[serde(rename = "encryptionKeyOverride")]
2911    #[serde(default)]
2912    #[serde(skip_serializing_if = "Option::is_none")]
2913    pub encryption_key_override: Option<String>,
2914    #[serde(rename = "environmentTypeOverride")]
2915    #[serde(default)]
2916    #[serde(skip_serializing_if = "Option::is_none")]
2917    pub environment_type_override: Option<String>,
2918    #[serde(rename = "environmentVariablesOverride")]
2919    #[serde(default)]
2920    #[serde(skip_serializing_if = "Option::is_none")]
2921    pub environment_variables_override: Option<Vec<EnvironmentVariable>>,
2922    #[serde(rename = "gitCloneDepthOverride")]
2923    #[serde(default)]
2924    #[serde(skip_serializing_if = "Option::is_none")]
2925    pub git_clone_depth_override: Option<i32>,
2926    #[serde(rename = "gitSubmodulesConfigOverride")]
2927    #[serde(default)]
2928    #[serde(skip_serializing_if = "Option::is_none")]
2929    pub git_submodules_config_override: Option<GitSubmodulesConfig>,
2930    #[serde(rename = "idempotencyToken")]
2931    #[serde(default)]
2932    #[serde(skip_serializing_if = "Option::is_none")]
2933    pub idempotency_token: Option<String>,
2934    #[serde(rename = "imageOverride")]
2935    #[serde(default)]
2936    #[serde(skip_serializing_if = "Option::is_none")]
2937    pub image_override: Option<String>,
2938    #[serde(rename = "imagePullCredentialsTypeOverride")]
2939    #[serde(default)]
2940    #[serde(skip_serializing_if = "Option::is_none")]
2941    pub image_pull_credentials_type_override: Option<String>,
2942    #[serde(rename = "insecureSslOverride")]
2943    #[serde(default)]
2944    #[serde(skip_serializing_if = "Option::is_none")]
2945    pub insecure_ssl_override: Option<bool>,
2946    #[serde(rename = "logsConfigOverride")]
2947    #[serde(default)]
2948    #[serde(skip_serializing_if = "Option::is_none")]
2949    pub logs_config_override: Option<LogsConfig>,
2950    #[serde(rename = "privilegedModeOverride")]
2951    #[serde(default)]
2952    #[serde(skip_serializing_if = "Option::is_none")]
2953    pub privileged_mode_override: Option<bool>,
2954    #[serde(rename = "projectName")]
2955    #[serde(default)]
2956    pub project_name: String,
2957    #[serde(rename = "queuedTimeoutInMinutesOverride")]
2958    #[serde(default)]
2959    #[serde(skip_serializing_if = "Option::is_none")]
2960    pub queued_timeout_in_minutes_override: Option<i32>,
2961    #[serde(rename = "registryCredentialOverride")]
2962    #[serde(default)]
2963    #[serde(skip_serializing_if = "Option::is_none")]
2964    pub registry_credential_override: Option<RegistryCredential>,
2965    #[serde(rename = "reportBuildBatchStatusOverride")]
2966    #[serde(default)]
2967    #[serde(skip_serializing_if = "Option::is_none")]
2968    pub report_build_batch_status_override: Option<bool>,
2969    #[serde(rename = "secondaryArtifactsOverride")]
2970    #[serde(default)]
2971    #[serde(skip_serializing_if = "Option::is_none")]
2972    pub secondary_artifacts_override: Option<Vec<ProjectArtifacts>>,
2973    #[serde(rename = "secondarySourcesOverride")]
2974    #[serde(default)]
2975    #[serde(skip_serializing_if = "Option::is_none")]
2976    pub secondary_sources_override: Option<Vec<ProjectSource>>,
2977    #[serde(rename = "secondarySourcesVersionOverride")]
2978    #[serde(default)]
2979    #[serde(skip_serializing_if = "Option::is_none")]
2980    pub secondary_sources_version_override: Option<Vec<ProjectSourceVersion>>,
2981    #[serde(rename = "serviceRoleOverride")]
2982    #[serde(default)]
2983    #[serde(skip_serializing_if = "Option::is_none")]
2984    pub service_role_override: Option<String>,
2985    #[serde(rename = "sourceAuthOverride")]
2986    #[serde(default)]
2987    #[serde(skip_serializing_if = "Option::is_none")]
2988    pub source_auth_override: Option<SourceAuth>,
2989    #[serde(rename = "sourceLocationOverride")]
2990    #[serde(default)]
2991    #[serde(skip_serializing_if = "Option::is_none")]
2992    pub source_location_override: Option<String>,
2993    #[serde(rename = "sourceTypeOverride")]
2994    #[serde(default)]
2995    #[serde(skip_serializing_if = "Option::is_none")]
2996    pub source_type_override: Option<String>,
2997    #[serde(rename = "sourceVersion")]
2998    #[serde(default)]
2999    #[serde(skip_serializing_if = "Option::is_none")]
3000    pub source_version: Option<String>,
3001}
3002
3003#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3004pub struct StartBuildBatchOutput {
3005    #[serde(rename = "buildBatch")]
3006    #[serde(default)]
3007    #[serde(skip_serializing_if = "Option::is_none")]
3008    pub build_batch: Option<BuildBatch>,
3009}
3010
3011#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3012pub struct StartBuildInput {
3013    #[serde(rename = "artifactsOverride")]
3014    #[serde(default)]
3015    #[serde(skip_serializing_if = "Option::is_none")]
3016    pub artifacts_override: Option<ProjectArtifacts>,
3017    #[serde(rename = "autoRetryLimitOverride")]
3018    #[serde(default)]
3019    #[serde(skip_serializing_if = "Option::is_none")]
3020    pub auto_retry_limit_override: Option<i32>,
3021    #[serde(rename = "buildStatusConfigOverride")]
3022    #[serde(default)]
3023    #[serde(skip_serializing_if = "Option::is_none")]
3024    pub build_status_config_override: Option<BuildStatusConfig>,
3025    #[serde(rename = "buildspecOverride")]
3026    #[serde(default)]
3027    #[serde(skip_serializing_if = "Option::is_none")]
3028    pub buildspec_override: Option<String>,
3029    #[serde(rename = "cacheOverride")]
3030    #[serde(default)]
3031    #[serde(skip_serializing_if = "Option::is_none")]
3032    pub cache_override: Option<ProjectCache>,
3033    #[serde(rename = "certificateOverride")]
3034    #[serde(default)]
3035    #[serde(skip_serializing_if = "Option::is_none")]
3036    pub certificate_override: Option<String>,
3037    #[serde(rename = "computeTypeOverride")]
3038    #[serde(default)]
3039    #[serde(skip_serializing_if = "Option::is_none")]
3040    pub compute_type_override: Option<String>,
3041    #[serde(rename = "debugSessionEnabled")]
3042    #[serde(default)]
3043    #[serde(skip_serializing_if = "Option::is_none")]
3044    pub debug_session_enabled: Option<bool>,
3045    #[serde(rename = "encryptionKeyOverride")]
3046    #[serde(default)]
3047    #[serde(skip_serializing_if = "Option::is_none")]
3048    pub encryption_key_override: Option<String>,
3049    #[serde(rename = "environmentTypeOverride")]
3050    #[serde(default)]
3051    #[serde(skip_serializing_if = "Option::is_none")]
3052    pub environment_type_override: Option<String>,
3053    #[serde(rename = "environmentVariablesOverride")]
3054    #[serde(default)]
3055    #[serde(skip_serializing_if = "Option::is_none")]
3056    pub environment_variables_override: Option<Vec<EnvironmentVariable>>,
3057    #[serde(rename = "fleetOverride")]
3058    #[serde(default)]
3059    #[serde(skip_serializing_if = "Option::is_none")]
3060    pub fleet_override: Option<ProjectFleet>,
3061    #[serde(rename = "gitCloneDepthOverride")]
3062    #[serde(default)]
3063    #[serde(skip_serializing_if = "Option::is_none")]
3064    pub git_clone_depth_override: Option<i32>,
3065    #[serde(rename = "gitSubmodulesConfigOverride")]
3066    #[serde(default)]
3067    #[serde(skip_serializing_if = "Option::is_none")]
3068    pub git_submodules_config_override: Option<GitSubmodulesConfig>,
3069    #[serde(rename = "idempotencyToken")]
3070    #[serde(default)]
3071    #[serde(skip_serializing_if = "Option::is_none")]
3072    pub idempotency_token: Option<String>,
3073    #[serde(rename = "imageOverride")]
3074    #[serde(default)]
3075    #[serde(skip_serializing_if = "Option::is_none")]
3076    pub image_override: Option<String>,
3077    #[serde(rename = "imagePullCredentialsTypeOverride")]
3078    #[serde(default)]
3079    #[serde(skip_serializing_if = "Option::is_none")]
3080    pub image_pull_credentials_type_override: Option<String>,
3081    #[serde(rename = "insecureSslOverride")]
3082    #[serde(default)]
3083    #[serde(skip_serializing_if = "Option::is_none")]
3084    pub insecure_ssl_override: Option<bool>,
3085    #[serde(rename = "logsConfigOverride")]
3086    #[serde(default)]
3087    #[serde(skip_serializing_if = "Option::is_none")]
3088    pub logs_config_override: Option<LogsConfig>,
3089    #[serde(rename = "privilegedModeOverride")]
3090    #[serde(default)]
3091    #[serde(skip_serializing_if = "Option::is_none")]
3092    pub privileged_mode_override: Option<bool>,
3093    #[serde(rename = "projectName")]
3094    #[serde(default)]
3095    pub project_name: String,
3096    #[serde(rename = "queuedTimeoutInMinutesOverride")]
3097    #[serde(default)]
3098    #[serde(skip_serializing_if = "Option::is_none")]
3099    pub queued_timeout_in_minutes_override: Option<i32>,
3100    #[serde(rename = "registryCredentialOverride")]
3101    #[serde(default)]
3102    #[serde(skip_serializing_if = "Option::is_none")]
3103    pub registry_credential_override: Option<RegistryCredential>,
3104    #[serde(rename = "reportBuildStatusOverride")]
3105    #[serde(default)]
3106    #[serde(skip_serializing_if = "Option::is_none")]
3107    pub report_build_status_override: Option<bool>,
3108    #[serde(rename = "secondaryArtifactsOverride")]
3109    #[serde(default)]
3110    #[serde(skip_serializing_if = "Option::is_none")]
3111    pub secondary_artifacts_override: Option<Vec<ProjectArtifacts>>,
3112    #[serde(rename = "secondarySourcesOverride")]
3113    #[serde(default)]
3114    #[serde(skip_serializing_if = "Option::is_none")]
3115    pub secondary_sources_override: Option<Vec<ProjectSource>>,
3116    #[serde(rename = "secondarySourcesVersionOverride")]
3117    #[serde(default)]
3118    #[serde(skip_serializing_if = "Option::is_none")]
3119    pub secondary_sources_version_override: Option<Vec<ProjectSourceVersion>>,
3120    #[serde(rename = "serviceRoleOverride")]
3121    #[serde(default)]
3122    #[serde(skip_serializing_if = "Option::is_none")]
3123    pub service_role_override: Option<String>,
3124    #[serde(rename = "sourceAuthOverride")]
3125    #[serde(default)]
3126    #[serde(skip_serializing_if = "Option::is_none")]
3127    pub source_auth_override: Option<SourceAuth>,
3128    #[serde(rename = "sourceLocationOverride")]
3129    #[serde(default)]
3130    #[serde(skip_serializing_if = "Option::is_none")]
3131    pub source_location_override: Option<String>,
3132    #[serde(rename = "sourceTypeOverride")]
3133    #[serde(default)]
3134    #[serde(skip_serializing_if = "Option::is_none")]
3135    pub source_type_override: Option<String>,
3136    #[serde(rename = "sourceVersion")]
3137    #[serde(default)]
3138    #[serde(skip_serializing_if = "Option::is_none")]
3139    pub source_version: Option<String>,
3140    #[serde(rename = "timeoutInMinutesOverride")]
3141    #[serde(default)]
3142    #[serde(skip_serializing_if = "Option::is_none")]
3143    pub timeout_in_minutes_override: Option<i32>,
3144}
3145
3146#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3147pub struct StartBuildOutput {
3148    #[serde(default)]
3149    #[serde(skip_serializing_if = "Option::is_none")]
3150    pub build: Option<Build>,
3151}
3152
3153#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3154pub struct StartCommandExecutionInput {
3155    #[serde(default)]
3156    pub command: String,
3157    #[serde(rename = "sandboxId")]
3158    #[serde(default)]
3159    pub sandbox_id: String,
3160    #[serde(rename = "type")]
3161    #[serde(default)]
3162    #[serde(skip_serializing_if = "Option::is_none")]
3163    pub r#type: Option<String>,
3164}
3165
3166#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3167pub struct StartCommandExecutionOutput {
3168    #[serde(rename = "commandExecution")]
3169    #[serde(default)]
3170    #[serde(skip_serializing_if = "Option::is_none")]
3171    pub command_execution: Option<CommandExecution>,
3172}
3173
3174#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3175pub struct StartSandboxConnectionInput {
3176    #[serde(rename = "sandboxId")]
3177    #[serde(default)]
3178    pub sandbox_id: String,
3179}
3180
3181#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3182pub struct StartSandboxConnectionOutput {
3183    #[serde(rename = "ssmSession")]
3184    #[serde(default)]
3185    #[serde(skip_serializing_if = "Option::is_none")]
3186    pub ssm_session: Option<SSMSession>,
3187}
3188
3189#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3190pub struct SSMSession {
3191    #[serde(rename = "sessionId")]
3192    #[serde(default)]
3193    #[serde(skip_serializing_if = "Option::is_none")]
3194    pub session_id: Option<String>,
3195    #[serde(rename = "streamUrl")]
3196    #[serde(default)]
3197    #[serde(skip_serializing_if = "Option::is_none")]
3198    pub stream_url: Option<String>,
3199    #[serde(rename = "tokenValue")]
3200    #[serde(default)]
3201    #[serde(skip_serializing_if = "Option::is_none")]
3202    pub token_value: Option<String>,
3203}
3204
3205#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3206pub struct StartSandboxInput {
3207    #[serde(rename = "idempotencyToken")]
3208    #[serde(default)]
3209    #[serde(skip_serializing_if = "Option::is_none")]
3210    pub idempotency_token: Option<String>,
3211    #[serde(rename = "projectName")]
3212    #[serde(default)]
3213    #[serde(skip_serializing_if = "Option::is_none")]
3214    pub project_name: Option<String>,
3215}
3216
3217#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3218pub struct StartSandboxOutput {
3219    #[serde(default)]
3220    #[serde(skip_serializing_if = "Option::is_none")]
3221    pub sandbox: Option<Sandbox>,
3222}
3223
3224#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3225pub struct StopBuildBatchInput {
3226    #[serde(default)]
3227    pub id: String,
3228}
3229
3230#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3231pub struct StopBuildBatchOutput {
3232    #[serde(rename = "buildBatch")]
3233    #[serde(default)]
3234    #[serde(skip_serializing_if = "Option::is_none")]
3235    pub build_batch: Option<BuildBatch>,
3236}
3237
3238#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3239pub struct StopBuildInput {
3240    #[serde(default)]
3241    pub id: String,
3242}
3243
3244#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3245pub struct StopBuildOutput {
3246    #[serde(default)]
3247    #[serde(skip_serializing_if = "Option::is_none")]
3248    pub build: Option<Build>,
3249}
3250
3251#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3252pub struct StopSandboxInput {
3253    #[serde(default)]
3254    pub id: String,
3255}
3256
3257#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3258pub struct StopSandboxOutput {
3259    #[serde(default)]
3260    #[serde(skip_serializing_if = "Option::is_none")]
3261    pub sandbox: Option<Sandbox>,
3262}
3263
3264#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3265pub struct UpdateFleetInput {
3266    #[serde(default)]
3267    pub arn: String,
3268    #[serde(rename = "baseCapacity")]
3269    #[serde(default)]
3270    #[serde(skip_serializing_if = "Option::is_none")]
3271    pub base_capacity: Option<i32>,
3272    #[serde(rename = "computeConfiguration")]
3273    #[serde(default)]
3274    #[serde(skip_serializing_if = "Option::is_none")]
3275    pub compute_configuration: Option<ComputeConfiguration>,
3276    #[serde(rename = "computeType")]
3277    #[serde(default)]
3278    #[serde(skip_serializing_if = "Option::is_none")]
3279    pub compute_type: Option<String>,
3280    #[serde(rename = "environmentType")]
3281    #[serde(default)]
3282    #[serde(skip_serializing_if = "Option::is_none")]
3283    pub environment_type: Option<String>,
3284    #[serde(rename = "fleetServiceRole")]
3285    #[serde(default)]
3286    #[serde(skip_serializing_if = "Option::is_none")]
3287    pub fleet_service_role: Option<String>,
3288    #[serde(rename = "imageId")]
3289    #[serde(default)]
3290    #[serde(skip_serializing_if = "Option::is_none")]
3291    pub image_id: Option<String>,
3292    #[serde(rename = "overflowBehavior")]
3293    #[serde(default)]
3294    #[serde(skip_serializing_if = "Option::is_none")]
3295    pub overflow_behavior: Option<String>,
3296    #[serde(rename = "proxyConfiguration")]
3297    #[serde(default)]
3298    #[serde(skip_serializing_if = "Option::is_none")]
3299    pub proxy_configuration: Option<ProxyConfiguration>,
3300    #[serde(rename = "scalingConfiguration")]
3301    #[serde(default)]
3302    #[serde(skip_serializing_if = "Option::is_none")]
3303    pub scaling_configuration: Option<ScalingConfigurationInput>,
3304    #[serde(default)]
3305    #[serde(skip_serializing_if = "Option::is_none")]
3306    pub tags: Option<Vec<Tag>>,
3307    #[serde(rename = "vpcConfig")]
3308    #[serde(default)]
3309    #[serde(skip_serializing_if = "Option::is_none")]
3310    pub vpc_config: Option<VpcConfig>,
3311}
3312
3313#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3314pub struct UpdateFleetOutput {
3315    #[serde(default)]
3316    #[serde(skip_serializing_if = "Option::is_none")]
3317    pub fleet: Option<Fleet>,
3318}
3319
3320#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3321pub struct UpdateProjectInput {
3322    #[serde(default)]
3323    #[serde(skip_serializing_if = "Option::is_none")]
3324    pub artifacts: Option<ProjectArtifacts>,
3325    #[serde(rename = "autoRetryLimit")]
3326    #[serde(default)]
3327    #[serde(skip_serializing_if = "Option::is_none")]
3328    pub auto_retry_limit: Option<i32>,
3329    #[serde(rename = "badgeEnabled")]
3330    #[serde(default)]
3331    #[serde(skip_serializing_if = "Option::is_none")]
3332    pub badge_enabled: Option<bool>,
3333    #[serde(rename = "buildBatchConfig")]
3334    #[serde(default)]
3335    #[serde(skip_serializing_if = "Option::is_none")]
3336    pub build_batch_config: Option<ProjectBuildBatchConfig>,
3337    #[serde(default)]
3338    #[serde(skip_serializing_if = "Option::is_none")]
3339    pub cache: Option<ProjectCache>,
3340    #[serde(rename = "concurrentBuildLimit")]
3341    #[serde(default)]
3342    #[serde(skip_serializing_if = "Option::is_none")]
3343    pub concurrent_build_limit: Option<i32>,
3344    #[serde(default)]
3345    #[serde(skip_serializing_if = "Option::is_none")]
3346    pub description: Option<String>,
3347    #[serde(rename = "encryptionKey")]
3348    #[serde(default)]
3349    #[serde(skip_serializing_if = "Option::is_none")]
3350    pub encryption_key: Option<String>,
3351    #[serde(default)]
3352    #[serde(skip_serializing_if = "Option::is_none")]
3353    pub environment: Option<ProjectEnvironment>,
3354    #[serde(rename = "fileSystemLocations")]
3355    #[serde(default)]
3356    #[serde(skip_serializing_if = "Option::is_none")]
3357    pub file_system_locations: Option<Vec<ProjectFileSystemLocation>>,
3358    #[serde(rename = "logsConfig")]
3359    #[serde(default)]
3360    #[serde(skip_serializing_if = "Option::is_none")]
3361    pub logs_config: Option<LogsConfig>,
3362    #[serde(default)]
3363    pub name: String,
3364    #[serde(rename = "queuedTimeoutInMinutes")]
3365    #[serde(default)]
3366    #[serde(skip_serializing_if = "Option::is_none")]
3367    pub queued_timeout_in_minutes: Option<i32>,
3368    #[serde(rename = "secondaryArtifacts")]
3369    #[serde(default)]
3370    #[serde(skip_serializing_if = "Option::is_none")]
3371    pub secondary_artifacts: Option<Vec<ProjectArtifacts>>,
3372    #[serde(rename = "secondarySourceVersions")]
3373    #[serde(default)]
3374    #[serde(skip_serializing_if = "Option::is_none")]
3375    pub secondary_source_versions: Option<Vec<ProjectSourceVersion>>,
3376    #[serde(rename = "secondarySources")]
3377    #[serde(default)]
3378    #[serde(skip_serializing_if = "Option::is_none")]
3379    pub secondary_sources: Option<Vec<ProjectSource>>,
3380    #[serde(rename = "serviceRole")]
3381    #[serde(default)]
3382    #[serde(skip_serializing_if = "Option::is_none")]
3383    pub service_role: Option<String>,
3384    #[serde(default)]
3385    #[serde(skip_serializing_if = "Option::is_none")]
3386    pub source: Option<ProjectSource>,
3387    #[serde(rename = "sourceVersion")]
3388    #[serde(default)]
3389    #[serde(skip_serializing_if = "Option::is_none")]
3390    pub source_version: Option<String>,
3391    #[serde(default)]
3392    #[serde(skip_serializing_if = "Option::is_none")]
3393    pub tags: Option<Vec<Tag>>,
3394    #[serde(rename = "timeoutInMinutes")]
3395    #[serde(default)]
3396    #[serde(skip_serializing_if = "Option::is_none")]
3397    pub timeout_in_minutes: Option<i32>,
3398    #[serde(rename = "vpcConfig")]
3399    #[serde(default)]
3400    #[serde(skip_serializing_if = "Option::is_none")]
3401    pub vpc_config: Option<VpcConfig>,
3402}
3403
3404#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3405pub struct UpdateProjectOutput {
3406    #[serde(default)]
3407    #[serde(skip_serializing_if = "Option::is_none")]
3408    pub project: Option<Project>,
3409}
3410
3411#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3412pub struct UpdateProjectVisibilityInput {
3413    #[serde(rename = "projectArn")]
3414    #[serde(default)]
3415    pub project_arn: String,
3416    #[serde(rename = "projectVisibility")]
3417    #[serde(default)]
3418    pub project_visibility: String,
3419    #[serde(rename = "resourceAccessRole")]
3420    #[serde(default)]
3421    #[serde(skip_serializing_if = "Option::is_none")]
3422    pub resource_access_role: Option<String>,
3423}
3424
3425#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3426pub struct UpdateProjectVisibilityOutput {
3427    #[serde(rename = "projectArn")]
3428    #[serde(default)]
3429    #[serde(skip_serializing_if = "Option::is_none")]
3430    pub project_arn: Option<String>,
3431    #[serde(rename = "projectVisibility")]
3432    #[serde(default)]
3433    #[serde(skip_serializing_if = "Option::is_none")]
3434    pub project_visibility: Option<String>,
3435    #[serde(rename = "publicProjectAlias")]
3436    #[serde(default)]
3437    #[serde(skip_serializing_if = "Option::is_none")]
3438    pub public_project_alias: Option<String>,
3439}
3440
3441#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3442pub struct UpdateReportGroupInput {
3443    #[serde(default)]
3444    pub arn: String,
3445    #[serde(rename = "exportConfig")]
3446    #[serde(default)]
3447    #[serde(skip_serializing_if = "Option::is_none")]
3448    pub export_config: Option<ReportExportConfig>,
3449    #[serde(default)]
3450    #[serde(skip_serializing_if = "Option::is_none")]
3451    pub tags: Option<Vec<Tag>>,
3452}
3453
3454#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3455pub struct UpdateReportGroupOutput {
3456    #[serde(rename = "reportGroup")]
3457    #[serde(default)]
3458    #[serde(skip_serializing_if = "Option::is_none")]
3459    pub report_group: Option<ReportGroup>,
3460}
3461
3462#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3463pub struct UpdateWebhookInput {
3464    #[serde(rename = "branchFilter")]
3465    #[serde(default)]
3466    #[serde(skip_serializing_if = "Option::is_none")]
3467    pub branch_filter: Option<String>,
3468    #[serde(rename = "buildType")]
3469    #[serde(default)]
3470    #[serde(skip_serializing_if = "Option::is_none")]
3471    pub build_type: Option<String>,
3472    #[serde(rename = "filterGroups")]
3473    #[serde(default)]
3474    #[serde(skip_serializing_if = "Option::is_none")]
3475    pub filter_groups: Option<Vec<Vec<WebhookFilter>>>,
3476    #[serde(rename = "projectName")]
3477    #[serde(default)]
3478    pub project_name: String,
3479    #[serde(rename = "pullRequestBuildPolicy")]
3480    #[serde(default)]
3481    #[serde(skip_serializing_if = "Option::is_none")]
3482    pub pull_request_build_policy: Option<PullRequestBuildPolicy>,
3483    #[serde(rename = "rotateSecret")]
3484    #[serde(default)]
3485    #[serde(skip_serializing_if = "Option::is_none")]
3486    pub rotate_secret: Option<bool>,
3487}
3488
3489#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3490pub struct UpdateWebhookOutput {
3491    #[serde(default)]
3492    #[serde(skip_serializing_if = "Option::is_none")]
3493    pub webhook: Option<Webhook>,
3494}