Skip to main content

winterbaume_appsync/
model.rs

1//! Auto-generated types from Smithy models.
2//! Do not edit manually. Regenerate with:
3//!   smithy-codegen gen-serializers winterbaume-appsync
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 AssociateApiRequest {
11    #[serde(rename = "apiId")]
12    #[serde(default)]
13    pub api_id: String,
14    #[serde(rename = "domainName")]
15    #[serde(default)]
16    pub domain_name: String,
17}
18
19#[derive(Debug, Clone, Default, Deserialize, Serialize)]
20pub struct AssociateApiResponse {
21    #[serde(rename = "apiAssociation")]
22    #[serde(default)]
23    #[serde(skip_serializing_if = "Option::is_none")]
24    pub api_association: Option<ApiAssociation>,
25}
26
27#[derive(Debug, Clone, Default, Deserialize, Serialize)]
28pub struct ApiAssociation {
29    #[serde(rename = "apiId")]
30    #[serde(default)]
31    #[serde(skip_serializing_if = "Option::is_none")]
32    pub api_id: Option<String>,
33    #[serde(rename = "associationStatus")]
34    #[serde(default)]
35    #[serde(skip_serializing_if = "Option::is_none")]
36    pub association_status: Option<String>,
37    #[serde(rename = "deploymentDetail")]
38    #[serde(default)]
39    #[serde(skip_serializing_if = "Option::is_none")]
40    pub deployment_detail: Option<String>,
41    #[serde(rename = "domainName")]
42    #[serde(default)]
43    #[serde(skip_serializing_if = "Option::is_none")]
44    pub domain_name: Option<String>,
45}
46
47#[derive(Debug, Clone, Default, Deserialize, Serialize)]
48pub struct AssociateMergedGraphqlApiRequest {
49    #[serde(default)]
50    #[serde(skip_serializing_if = "Option::is_none")]
51    pub description: Option<String>,
52    #[serde(rename = "mergedApiIdentifier")]
53    #[serde(default)]
54    pub merged_api_identifier: String,
55    #[serde(rename = "sourceApiAssociationConfig")]
56    #[serde(default)]
57    #[serde(skip_serializing_if = "Option::is_none")]
58    pub source_api_association_config: Option<SourceApiAssociationConfig>,
59    #[serde(rename = "sourceApiIdentifier")]
60    #[serde(default)]
61    pub source_api_identifier: String,
62}
63
64#[derive(Debug, Clone, Default, Deserialize, Serialize)]
65pub struct SourceApiAssociationConfig {
66    #[serde(rename = "mergeType")]
67    #[serde(default)]
68    #[serde(skip_serializing_if = "Option::is_none")]
69    pub merge_type: Option<String>,
70}
71
72#[derive(Debug, Clone, Default, Deserialize, Serialize)]
73pub struct AssociateMergedGraphqlApiResponse {
74    #[serde(rename = "sourceApiAssociation")]
75    #[serde(default)]
76    #[serde(skip_serializing_if = "Option::is_none")]
77    pub source_api_association: Option<SourceApiAssociation>,
78}
79
80#[derive(Debug, Clone, Default, Deserialize, Serialize)]
81pub struct SourceApiAssociation {
82    #[serde(rename = "associationArn")]
83    #[serde(default)]
84    #[serde(skip_serializing_if = "Option::is_none")]
85    pub association_arn: Option<String>,
86    #[serde(rename = "associationId")]
87    #[serde(default)]
88    #[serde(skip_serializing_if = "Option::is_none")]
89    pub association_id: Option<String>,
90    #[serde(default)]
91    #[serde(skip_serializing_if = "Option::is_none")]
92    pub description: Option<String>,
93    #[serde(rename = "lastSuccessfulMergeDate")]
94    #[serde(default)]
95    #[serde(skip_serializing_if = "Option::is_none")]
96    pub last_successful_merge_date: Option<f64>,
97    #[serde(rename = "mergedApiArn")]
98    #[serde(default)]
99    #[serde(skip_serializing_if = "Option::is_none")]
100    pub merged_api_arn: Option<String>,
101    #[serde(rename = "mergedApiId")]
102    #[serde(default)]
103    #[serde(skip_serializing_if = "Option::is_none")]
104    pub merged_api_id: Option<String>,
105    #[serde(rename = "sourceApiArn")]
106    #[serde(default)]
107    #[serde(skip_serializing_if = "Option::is_none")]
108    pub source_api_arn: Option<String>,
109    #[serde(rename = "sourceApiAssociationConfig")]
110    #[serde(default)]
111    #[serde(skip_serializing_if = "Option::is_none")]
112    pub source_api_association_config: Option<SourceApiAssociationConfig>,
113    #[serde(rename = "sourceApiAssociationStatus")]
114    #[serde(default)]
115    #[serde(skip_serializing_if = "Option::is_none")]
116    pub source_api_association_status: Option<String>,
117    #[serde(rename = "sourceApiAssociationStatusDetail")]
118    #[serde(default)]
119    #[serde(skip_serializing_if = "Option::is_none")]
120    pub source_api_association_status_detail: Option<String>,
121    #[serde(rename = "sourceApiId")]
122    #[serde(default)]
123    #[serde(skip_serializing_if = "Option::is_none")]
124    pub source_api_id: Option<String>,
125}
126
127#[derive(Debug, Clone, Default, Deserialize, Serialize)]
128pub struct AssociateSourceGraphqlApiRequest {
129    #[serde(default)]
130    #[serde(skip_serializing_if = "Option::is_none")]
131    pub description: Option<String>,
132    #[serde(rename = "mergedApiIdentifier")]
133    #[serde(default)]
134    pub merged_api_identifier: String,
135    #[serde(rename = "sourceApiAssociationConfig")]
136    #[serde(default)]
137    #[serde(skip_serializing_if = "Option::is_none")]
138    pub source_api_association_config: Option<SourceApiAssociationConfig>,
139    #[serde(rename = "sourceApiIdentifier")]
140    #[serde(default)]
141    pub source_api_identifier: String,
142}
143
144#[derive(Debug, Clone, Default, Deserialize, Serialize)]
145pub struct AssociateSourceGraphqlApiResponse {
146    #[serde(rename = "sourceApiAssociation")]
147    #[serde(default)]
148    #[serde(skip_serializing_if = "Option::is_none")]
149    pub source_api_association: Option<SourceApiAssociation>,
150}
151
152#[derive(Debug, Clone, Default, Deserialize, Serialize)]
153pub struct CreateApiCacheRequest {
154    #[serde(rename = "apiCachingBehavior")]
155    #[serde(default)]
156    pub api_caching_behavior: String,
157    #[serde(rename = "apiId")]
158    #[serde(default)]
159    pub api_id: String,
160    #[serde(rename = "atRestEncryptionEnabled")]
161    #[serde(default)]
162    #[serde(skip_serializing_if = "Option::is_none")]
163    pub at_rest_encryption_enabled: Option<bool>,
164    #[serde(rename = "healthMetricsConfig")]
165    #[serde(default)]
166    #[serde(skip_serializing_if = "Option::is_none")]
167    pub health_metrics_config: Option<String>,
168    #[serde(rename = "transitEncryptionEnabled")]
169    #[serde(default)]
170    #[serde(skip_serializing_if = "Option::is_none")]
171    pub transit_encryption_enabled: Option<bool>,
172    #[serde(default)]
173    pub ttl: i64,
174    #[serde(rename = "type")]
175    #[serde(default)]
176    pub r#type: String,
177}
178
179#[derive(Debug, Clone, Default, Deserialize, Serialize)]
180pub struct CreateApiCacheResponse {
181    #[serde(rename = "apiCache")]
182    #[serde(default)]
183    #[serde(skip_serializing_if = "Option::is_none")]
184    pub api_cache: Option<ApiCache>,
185}
186
187#[derive(Debug, Clone, Default, Deserialize, Serialize)]
188pub struct ApiCache {
189    #[serde(rename = "apiCachingBehavior")]
190    #[serde(default)]
191    #[serde(skip_serializing_if = "Option::is_none")]
192    pub api_caching_behavior: Option<String>,
193    #[serde(rename = "atRestEncryptionEnabled")]
194    #[serde(default)]
195    #[serde(skip_serializing_if = "Option::is_none")]
196    pub at_rest_encryption_enabled: Option<bool>,
197    #[serde(rename = "healthMetricsConfig")]
198    #[serde(default)]
199    #[serde(skip_serializing_if = "Option::is_none")]
200    pub health_metrics_config: Option<String>,
201    #[serde(default)]
202    #[serde(skip_serializing_if = "Option::is_none")]
203    pub status: Option<String>,
204    #[serde(rename = "transitEncryptionEnabled")]
205    #[serde(default)]
206    #[serde(skip_serializing_if = "Option::is_none")]
207    pub transit_encryption_enabled: Option<bool>,
208    #[serde(default)]
209    #[serde(skip_serializing_if = "Option::is_none")]
210    pub ttl: Option<i64>,
211    #[serde(rename = "type")]
212    #[serde(default)]
213    #[serde(skip_serializing_if = "Option::is_none")]
214    pub r#type: Option<String>,
215}
216
217#[derive(Debug, Clone, Default, Deserialize, Serialize)]
218pub struct CreateApiKeyRequest {
219    #[serde(rename = "apiId")]
220    #[serde(default)]
221    pub api_id: String,
222    #[serde(default)]
223    #[serde(skip_serializing_if = "Option::is_none")]
224    pub description: Option<String>,
225    #[serde(default)]
226    #[serde(skip_serializing_if = "Option::is_none")]
227    pub expires: Option<i64>,
228}
229
230#[derive(Debug, Clone, Default, Deserialize, Serialize)]
231pub struct CreateApiKeyResponse {
232    #[serde(rename = "apiKey")]
233    #[serde(default)]
234    #[serde(skip_serializing_if = "Option::is_none")]
235    pub api_key: Option<ApiKey>,
236}
237
238#[derive(Debug, Clone, Default, Deserialize, Serialize)]
239pub struct ApiKey {
240    #[serde(default)]
241    #[serde(skip_serializing_if = "Option::is_none")]
242    pub deletes: Option<i64>,
243    #[serde(default)]
244    #[serde(skip_serializing_if = "Option::is_none")]
245    pub description: Option<String>,
246    #[serde(default)]
247    #[serde(skip_serializing_if = "Option::is_none")]
248    pub expires: Option<i64>,
249    #[serde(default)]
250    #[serde(skip_serializing_if = "Option::is_none")]
251    pub id: Option<String>,
252}
253
254#[derive(Debug, Clone, Default, Deserialize, Serialize)]
255pub struct CreateApiRequest {
256    #[serde(rename = "eventConfig")]
257    #[serde(default)]
258    pub event_config: EventConfig,
259    #[serde(default)]
260    pub name: String,
261    #[serde(rename = "ownerContact")]
262    #[serde(default)]
263    #[serde(skip_serializing_if = "Option::is_none")]
264    pub owner_contact: Option<String>,
265    #[serde(default)]
266    #[serde(skip_serializing_if = "Option::is_none")]
267    pub tags: Option<std::collections::HashMap<String, String>>,
268}
269
270#[derive(Debug, Clone, Default, Deserialize, Serialize)]
271pub struct EventConfig {
272    #[serde(rename = "authProviders")]
273    #[serde(default)]
274    pub auth_providers: Vec<AuthProvider>,
275    #[serde(rename = "connectionAuthModes")]
276    #[serde(default)]
277    pub connection_auth_modes: Vec<AuthMode>,
278    #[serde(rename = "defaultPublishAuthModes")]
279    #[serde(default)]
280    pub default_publish_auth_modes: Vec<AuthMode>,
281    #[serde(rename = "defaultSubscribeAuthModes")]
282    #[serde(default)]
283    pub default_subscribe_auth_modes: Vec<AuthMode>,
284    #[serde(rename = "logConfig")]
285    #[serde(default)]
286    #[serde(skip_serializing_if = "Option::is_none")]
287    pub log_config: Option<EventLogConfig>,
288}
289
290#[derive(Debug, Clone, Default, Deserialize, Serialize)]
291pub struct AuthProvider {
292    #[serde(rename = "authType")]
293    #[serde(default)]
294    pub auth_type: String,
295    #[serde(rename = "cognitoConfig")]
296    #[serde(default)]
297    #[serde(skip_serializing_if = "Option::is_none")]
298    pub cognito_config: Option<CognitoConfig>,
299    #[serde(rename = "lambdaAuthorizerConfig")]
300    #[serde(default)]
301    #[serde(skip_serializing_if = "Option::is_none")]
302    pub lambda_authorizer_config: Option<LambdaAuthorizerConfig>,
303    #[serde(rename = "openIDConnectConfig")]
304    #[serde(default)]
305    #[serde(skip_serializing_if = "Option::is_none")]
306    pub open_i_d_connect_config: Option<OpenIDConnectConfig>,
307}
308
309#[derive(Debug, Clone, Default, Deserialize, Serialize)]
310pub struct CognitoConfig {
311    #[serde(rename = "appIdClientRegex")]
312    #[serde(default)]
313    #[serde(skip_serializing_if = "Option::is_none")]
314    pub app_id_client_regex: Option<String>,
315    #[serde(rename = "awsRegion")]
316    #[serde(default)]
317    pub aws_region: String,
318    #[serde(rename = "userPoolId")]
319    #[serde(default)]
320    pub user_pool_id: String,
321}
322
323#[derive(Debug, Clone, Default, Deserialize, Serialize)]
324pub struct LambdaAuthorizerConfig {
325    #[serde(rename = "authorizerResultTtlInSeconds")]
326    #[serde(default)]
327    #[serde(skip_serializing_if = "Option::is_none")]
328    pub authorizer_result_ttl_in_seconds: Option<i32>,
329    #[serde(rename = "authorizerUri")]
330    #[serde(default)]
331    pub authorizer_uri: String,
332    #[serde(rename = "identityValidationExpression")]
333    #[serde(default)]
334    #[serde(skip_serializing_if = "Option::is_none")]
335    pub identity_validation_expression: Option<String>,
336}
337
338#[derive(Debug, Clone, Default, Deserialize, Serialize)]
339pub struct OpenIDConnectConfig {
340    #[serde(rename = "authTTL")]
341    #[serde(default)]
342    #[serde(skip_serializing_if = "Option::is_none")]
343    pub auth_t_t_l: Option<i64>,
344    #[serde(rename = "clientId")]
345    #[serde(default)]
346    #[serde(skip_serializing_if = "Option::is_none")]
347    pub client_id: Option<String>,
348    #[serde(rename = "iatTTL")]
349    #[serde(default)]
350    #[serde(skip_serializing_if = "Option::is_none")]
351    pub iat_t_t_l: Option<i64>,
352    #[serde(default)]
353    pub issuer: String,
354}
355
356#[derive(Debug, Clone, Default, Deserialize, Serialize)]
357pub struct AuthMode {
358    #[serde(rename = "authType")]
359    #[serde(default)]
360    pub auth_type: String,
361}
362
363#[derive(Debug, Clone, Default, Deserialize, Serialize)]
364pub struct EventLogConfig {
365    #[serde(rename = "cloudWatchLogsRoleArn")]
366    #[serde(default)]
367    pub cloud_watch_logs_role_arn: String,
368    #[serde(rename = "logLevel")]
369    #[serde(default)]
370    pub log_level: String,
371}
372
373#[derive(Debug, Clone, Default, Deserialize, Serialize)]
374pub struct CreateApiResponse {
375    #[serde(default)]
376    #[serde(skip_serializing_if = "Option::is_none")]
377    pub api: Option<Api>,
378}
379
380#[derive(Debug, Clone, Default, Deserialize, Serialize)]
381pub struct Api {
382    #[serde(rename = "apiArn")]
383    #[serde(default)]
384    #[serde(skip_serializing_if = "Option::is_none")]
385    pub api_arn: Option<String>,
386    #[serde(rename = "apiId")]
387    #[serde(default)]
388    #[serde(skip_serializing_if = "Option::is_none")]
389    pub api_id: Option<String>,
390    #[serde(default)]
391    #[serde(skip_serializing_if = "Option::is_none")]
392    pub created: Option<f64>,
393    #[serde(default)]
394    #[serde(skip_serializing_if = "Option::is_none")]
395    pub dns: Option<std::collections::HashMap<String, String>>,
396    #[serde(rename = "eventConfig")]
397    #[serde(default)]
398    #[serde(skip_serializing_if = "Option::is_none")]
399    pub event_config: Option<EventConfig>,
400    #[serde(default)]
401    #[serde(skip_serializing_if = "Option::is_none")]
402    pub name: Option<String>,
403    #[serde(rename = "ownerContact")]
404    #[serde(default)]
405    #[serde(skip_serializing_if = "Option::is_none")]
406    pub owner_contact: Option<String>,
407    #[serde(default)]
408    #[serde(skip_serializing_if = "Option::is_none")]
409    pub tags: Option<std::collections::HashMap<String, String>>,
410    #[serde(rename = "wafWebAclArn")]
411    #[serde(default)]
412    #[serde(skip_serializing_if = "Option::is_none")]
413    pub waf_web_acl_arn: Option<String>,
414    #[serde(rename = "xrayEnabled")]
415    #[serde(default)]
416    #[serde(skip_serializing_if = "Option::is_none")]
417    pub xray_enabled: Option<bool>,
418}
419
420#[derive(Debug, Clone, Default, Deserialize, Serialize)]
421pub struct CreateChannelNamespaceRequest {
422    #[serde(rename = "apiId")]
423    #[serde(default)]
424    pub api_id: String,
425    #[serde(rename = "codeHandlers")]
426    #[serde(default)]
427    #[serde(skip_serializing_if = "Option::is_none")]
428    pub code_handlers: Option<String>,
429    #[serde(rename = "handlerConfigs")]
430    #[serde(default)]
431    #[serde(skip_serializing_if = "Option::is_none")]
432    pub handler_configs: Option<HandlerConfigs>,
433    #[serde(default)]
434    pub name: String,
435    #[serde(rename = "publishAuthModes")]
436    #[serde(default)]
437    #[serde(skip_serializing_if = "Option::is_none")]
438    pub publish_auth_modes: Option<Vec<AuthMode>>,
439    #[serde(rename = "subscribeAuthModes")]
440    #[serde(default)]
441    #[serde(skip_serializing_if = "Option::is_none")]
442    pub subscribe_auth_modes: Option<Vec<AuthMode>>,
443    #[serde(default)]
444    #[serde(skip_serializing_if = "Option::is_none")]
445    pub tags: Option<std::collections::HashMap<String, String>>,
446}
447
448#[derive(Debug, Clone, Default, Deserialize, Serialize)]
449pub struct HandlerConfigs {
450    #[serde(rename = "onPublish")]
451    #[serde(default)]
452    #[serde(skip_serializing_if = "Option::is_none")]
453    pub on_publish: Option<HandlerConfig>,
454    #[serde(rename = "onSubscribe")]
455    #[serde(default)]
456    #[serde(skip_serializing_if = "Option::is_none")]
457    pub on_subscribe: Option<HandlerConfig>,
458}
459
460#[derive(Debug, Clone, Default, Deserialize, Serialize)]
461pub struct HandlerConfig {
462    #[serde(default)]
463    pub behavior: String,
464    #[serde(default)]
465    pub integration: Integration,
466}
467
468#[derive(Debug, Clone, Default, Deserialize, Serialize)]
469pub struct Integration {
470    #[serde(rename = "dataSourceName")]
471    #[serde(default)]
472    pub data_source_name: String,
473    #[serde(rename = "lambdaConfig")]
474    #[serde(default)]
475    #[serde(skip_serializing_if = "Option::is_none")]
476    pub lambda_config: Option<LambdaConfig>,
477}
478
479#[derive(Debug, Clone, Default, Deserialize, Serialize)]
480pub struct LambdaConfig {
481    #[serde(rename = "invokeType")]
482    #[serde(default)]
483    #[serde(skip_serializing_if = "Option::is_none")]
484    pub invoke_type: Option<String>,
485}
486
487#[derive(Debug, Clone, Default, Deserialize, Serialize)]
488pub struct CreateChannelNamespaceResponse {
489    #[serde(rename = "channelNamespace")]
490    #[serde(default)]
491    #[serde(skip_serializing_if = "Option::is_none")]
492    pub channel_namespace: Option<ChannelNamespace>,
493}
494
495#[derive(Debug, Clone, Default, Deserialize, Serialize)]
496pub struct ChannelNamespace {
497    #[serde(rename = "apiId")]
498    #[serde(default)]
499    #[serde(skip_serializing_if = "Option::is_none")]
500    pub api_id: Option<String>,
501    #[serde(rename = "channelNamespaceArn")]
502    #[serde(default)]
503    #[serde(skip_serializing_if = "Option::is_none")]
504    pub channel_namespace_arn: Option<String>,
505    #[serde(rename = "codeHandlers")]
506    #[serde(default)]
507    #[serde(skip_serializing_if = "Option::is_none")]
508    pub code_handlers: Option<String>,
509    #[serde(default)]
510    #[serde(skip_serializing_if = "Option::is_none")]
511    pub created: Option<f64>,
512    #[serde(rename = "handlerConfigs")]
513    #[serde(default)]
514    #[serde(skip_serializing_if = "Option::is_none")]
515    pub handler_configs: Option<HandlerConfigs>,
516    #[serde(rename = "lastModified")]
517    #[serde(default)]
518    #[serde(skip_serializing_if = "Option::is_none")]
519    pub last_modified: Option<f64>,
520    #[serde(default)]
521    #[serde(skip_serializing_if = "Option::is_none")]
522    pub name: Option<String>,
523    #[serde(rename = "publishAuthModes")]
524    #[serde(default)]
525    #[serde(skip_serializing_if = "Option::is_none")]
526    pub publish_auth_modes: Option<Vec<AuthMode>>,
527    #[serde(rename = "subscribeAuthModes")]
528    #[serde(default)]
529    #[serde(skip_serializing_if = "Option::is_none")]
530    pub subscribe_auth_modes: Option<Vec<AuthMode>>,
531    #[serde(default)]
532    #[serde(skip_serializing_if = "Option::is_none")]
533    pub tags: Option<std::collections::HashMap<String, String>>,
534}
535
536#[derive(Debug, Clone, Default, Deserialize, Serialize)]
537pub struct CreateDataSourceRequest {
538    #[serde(rename = "apiId")]
539    #[serde(default)]
540    pub api_id: String,
541    #[serde(default)]
542    #[serde(skip_serializing_if = "Option::is_none")]
543    pub description: Option<String>,
544    #[serde(rename = "dynamodbConfig")]
545    #[serde(default)]
546    #[serde(skip_serializing_if = "Option::is_none")]
547    pub dynamodb_config: Option<DynamodbDataSourceConfig>,
548    #[serde(rename = "elasticsearchConfig")]
549    #[serde(default)]
550    #[serde(skip_serializing_if = "Option::is_none")]
551    pub elasticsearch_config: Option<ElasticsearchDataSourceConfig>,
552    #[serde(rename = "eventBridgeConfig")]
553    #[serde(default)]
554    #[serde(skip_serializing_if = "Option::is_none")]
555    pub event_bridge_config: Option<EventBridgeDataSourceConfig>,
556    #[serde(rename = "httpConfig")]
557    #[serde(default)]
558    #[serde(skip_serializing_if = "Option::is_none")]
559    pub http_config: Option<HttpDataSourceConfig>,
560    #[serde(rename = "lambdaConfig")]
561    #[serde(default)]
562    #[serde(skip_serializing_if = "Option::is_none")]
563    pub lambda_config: Option<LambdaDataSourceConfig>,
564    #[serde(rename = "metricsConfig")]
565    #[serde(default)]
566    #[serde(skip_serializing_if = "Option::is_none")]
567    pub metrics_config: Option<String>,
568    #[serde(default)]
569    pub name: String,
570    #[serde(rename = "openSearchServiceConfig")]
571    #[serde(default)]
572    #[serde(skip_serializing_if = "Option::is_none")]
573    pub open_search_service_config: Option<OpenSearchServiceDataSourceConfig>,
574    #[serde(rename = "relationalDatabaseConfig")]
575    #[serde(default)]
576    #[serde(skip_serializing_if = "Option::is_none")]
577    pub relational_database_config: Option<RelationalDatabaseDataSourceConfig>,
578    #[serde(rename = "serviceRoleArn")]
579    #[serde(default)]
580    #[serde(skip_serializing_if = "Option::is_none")]
581    pub service_role_arn: Option<String>,
582    #[serde(rename = "type")]
583    #[serde(default)]
584    pub r#type: String,
585}
586
587#[derive(Debug, Clone, Default, Deserialize, Serialize)]
588pub struct DynamodbDataSourceConfig {
589    #[serde(rename = "awsRegion")]
590    #[serde(default)]
591    pub aws_region: String,
592    #[serde(rename = "deltaSyncConfig")]
593    #[serde(default)]
594    #[serde(skip_serializing_if = "Option::is_none")]
595    pub delta_sync_config: Option<DeltaSyncConfig>,
596    #[serde(rename = "tableName")]
597    #[serde(default)]
598    pub table_name: String,
599    #[serde(rename = "useCallerCredentials")]
600    #[serde(default)]
601    #[serde(skip_serializing_if = "Option::is_none")]
602    pub use_caller_credentials: Option<bool>,
603    #[serde(default)]
604    #[serde(skip_serializing_if = "Option::is_none")]
605    pub versioned: Option<bool>,
606}
607
608#[derive(Debug, Clone, Default, Deserialize, Serialize)]
609pub struct DeltaSyncConfig {
610    #[serde(rename = "baseTableTTL")]
611    #[serde(default)]
612    #[serde(skip_serializing_if = "Option::is_none")]
613    pub base_table_t_t_l: Option<i64>,
614    #[serde(rename = "deltaSyncTableName")]
615    #[serde(default)]
616    #[serde(skip_serializing_if = "Option::is_none")]
617    pub delta_sync_table_name: Option<String>,
618    #[serde(rename = "deltaSyncTableTTL")]
619    #[serde(default)]
620    #[serde(skip_serializing_if = "Option::is_none")]
621    pub delta_sync_table_t_t_l: Option<i64>,
622}
623
624#[derive(Debug, Clone, Default, Deserialize, Serialize)]
625pub struct ElasticsearchDataSourceConfig {
626    #[serde(rename = "awsRegion")]
627    #[serde(default)]
628    pub aws_region: String,
629    #[serde(default)]
630    pub endpoint: String,
631}
632
633#[derive(Debug, Clone, Default, Deserialize, Serialize)]
634pub struct EventBridgeDataSourceConfig {
635    #[serde(rename = "eventBusArn")]
636    #[serde(default)]
637    pub event_bus_arn: String,
638}
639
640#[derive(Debug, Clone, Default, Deserialize, Serialize)]
641pub struct HttpDataSourceConfig {
642    #[serde(rename = "authorizationConfig")]
643    #[serde(default)]
644    #[serde(skip_serializing_if = "Option::is_none")]
645    pub authorization_config: Option<AuthorizationConfig>,
646    #[serde(default)]
647    #[serde(skip_serializing_if = "Option::is_none")]
648    pub endpoint: Option<String>,
649}
650
651#[derive(Debug, Clone, Default, Deserialize, Serialize)]
652pub struct AuthorizationConfig {
653    #[serde(rename = "authorizationType")]
654    #[serde(default)]
655    pub authorization_type: String,
656    #[serde(rename = "awsIamConfig")]
657    #[serde(default)]
658    #[serde(skip_serializing_if = "Option::is_none")]
659    pub aws_iam_config: Option<AwsIamConfig>,
660}
661
662#[derive(Debug, Clone, Default, Deserialize, Serialize)]
663pub struct AwsIamConfig {
664    #[serde(rename = "signingRegion")]
665    #[serde(default)]
666    #[serde(skip_serializing_if = "Option::is_none")]
667    pub signing_region: Option<String>,
668    #[serde(rename = "signingServiceName")]
669    #[serde(default)]
670    #[serde(skip_serializing_if = "Option::is_none")]
671    pub signing_service_name: Option<String>,
672}
673
674#[derive(Debug, Clone, Default, Deserialize, Serialize)]
675pub struct LambdaDataSourceConfig {
676    #[serde(rename = "lambdaFunctionArn")]
677    #[serde(default)]
678    pub lambda_function_arn: String,
679}
680
681#[derive(Debug, Clone, Default, Deserialize, Serialize)]
682pub struct OpenSearchServiceDataSourceConfig {
683    #[serde(rename = "awsRegion")]
684    #[serde(default)]
685    pub aws_region: String,
686    #[serde(default)]
687    pub endpoint: String,
688}
689
690#[derive(Debug, Clone, Default, Deserialize, Serialize)]
691pub struct RelationalDatabaseDataSourceConfig {
692    #[serde(rename = "rdsHttpEndpointConfig")]
693    #[serde(default)]
694    #[serde(skip_serializing_if = "Option::is_none")]
695    pub rds_http_endpoint_config: Option<RdsHttpEndpointConfig>,
696    #[serde(rename = "relationalDatabaseSourceType")]
697    #[serde(default)]
698    #[serde(skip_serializing_if = "Option::is_none")]
699    pub relational_database_source_type: Option<String>,
700}
701
702#[derive(Debug, Clone, Default, Deserialize, Serialize)]
703pub struct RdsHttpEndpointConfig {
704    #[serde(rename = "awsRegion")]
705    #[serde(default)]
706    #[serde(skip_serializing_if = "Option::is_none")]
707    pub aws_region: Option<String>,
708    #[serde(rename = "awsSecretStoreArn")]
709    #[serde(default)]
710    #[serde(skip_serializing_if = "Option::is_none")]
711    pub aws_secret_store_arn: Option<String>,
712    #[serde(rename = "databaseName")]
713    #[serde(default)]
714    #[serde(skip_serializing_if = "Option::is_none")]
715    pub database_name: Option<String>,
716    #[serde(rename = "dbClusterIdentifier")]
717    #[serde(default)]
718    #[serde(skip_serializing_if = "Option::is_none")]
719    pub db_cluster_identifier: Option<String>,
720    #[serde(default)]
721    #[serde(skip_serializing_if = "Option::is_none")]
722    pub schema: Option<String>,
723}
724
725#[derive(Debug, Clone, Default, Deserialize, Serialize)]
726pub struct CreateDataSourceResponse {
727    #[serde(rename = "dataSource")]
728    #[serde(default)]
729    #[serde(skip_serializing_if = "Option::is_none")]
730    pub data_source: Option<DataSource>,
731}
732
733#[derive(Debug, Clone, Default, Deserialize, Serialize)]
734pub struct DataSource {
735    #[serde(rename = "dataSourceArn")]
736    #[serde(default)]
737    #[serde(skip_serializing_if = "Option::is_none")]
738    pub data_source_arn: Option<String>,
739    #[serde(default)]
740    #[serde(skip_serializing_if = "Option::is_none")]
741    pub description: Option<String>,
742    #[serde(rename = "dynamodbConfig")]
743    #[serde(default)]
744    #[serde(skip_serializing_if = "Option::is_none")]
745    pub dynamodb_config: Option<DynamodbDataSourceConfig>,
746    #[serde(rename = "elasticsearchConfig")]
747    #[serde(default)]
748    #[serde(skip_serializing_if = "Option::is_none")]
749    pub elasticsearch_config: Option<ElasticsearchDataSourceConfig>,
750    #[serde(rename = "eventBridgeConfig")]
751    #[serde(default)]
752    #[serde(skip_serializing_if = "Option::is_none")]
753    pub event_bridge_config: Option<EventBridgeDataSourceConfig>,
754    #[serde(rename = "httpConfig")]
755    #[serde(default)]
756    #[serde(skip_serializing_if = "Option::is_none")]
757    pub http_config: Option<HttpDataSourceConfig>,
758    #[serde(rename = "lambdaConfig")]
759    #[serde(default)]
760    #[serde(skip_serializing_if = "Option::is_none")]
761    pub lambda_config: Option<LambdaDataSourceConfig>,
762    #[serde(rename = "metricsConfig")]
763    #[serde(default)]
764    #[serde(skip_serializing_if = "Option::is_none")]
765    pub metrics_config: Option<String>,
766    #[serde(default)]
767    #[serde(skip_serializing_if = "Option::is_none")]
768    pub name: Option<String>,
769    #[serde(rename = "openSearchServiceConfig")]
770    #[serde(default)]
771    #[serde(skip_serializing_if = "Option::is_none")]
772    pub open_search_service_config: Option<OpenSearchServiceDataSourceConfig>,
773    #[serde(rename = "relationalDatabaseConfig")]
774    #[serde(default)]
775    #[serde(skip_serializing_if = "Option::is_none")]
776    pub relational_database_config: Option<RelationalDatabaseDataSourceConfig>,
777    #[serde(rename = "serviceRoleArn")]
778    #[serde(default)]
779    #[serde(skip_serializing_if = "Option::is_none")]
780    pub service_role_arn: Option<String>,
781    #[serde(rename = "type")]
782    #[serde(default)]
783    #[serde(skip_serializing_if = "Option::is_none")]
784    pub r#type: Option<String>,
785}
786
787#[derive(Debug, Clone, Default, Deserialize, Serialize)]
788pub struct CreateDomainNameRequest {
789    #[serde(rename = "certificateArn")]
790    #[serde(default)]
791    pub certificate_arn: String,
792    #[serde(default)]
793    #[serde(skip_serializing_if = "Option::is_none")]
794    pub description: Option<String>,
795    #[serde(rename = "domainName")]
796    #[serde(default)]
797    pub domain_name: String,
798    #[serde(default)]
799    #[serde(skip_serializing_if = "Option::is_none")]
800    pub tags: Option<std::collections::HashMap<String, String>>,
801}
802
803#[derive(Debug, Clone, Default, Deserialize, Serialize)]
804pub struct CreateDomainNameResponse {
805    #[serde(rename = "domainNameConfig")]
806    #[serde(default)]
807    #[serde(skip_serializing_if = "Option::is_none")]
808    pub domain_name_config: Option<DomainNameConfig>,
809}
810
811#[derive(Debug, Clone, Default, Deserialize, Serialize)]
812pub struct DomainNameConfig {
813    #[serde(rename = "appsyncDomainName")]
814    #[serde(default)]
815    #[serde(skip_serializing_if = "Option::is_none")]
816    pub appsync_domain_name: Option<String>,
817    #[serde(rename = "certificateArn")]
818    #[serde(default)]
819    #[serde(skip_serializing_if = "Option::is_none")]
820    pub certificate_arn: Option<String>,
821    #[serde(default)]
822    #[serde(skip_serializing_if = "Option::is_none")]
823    pub description: Option<String>,
824    #[serde(rename = "domainName")]
825    #[serde(default)]
826    #[serde(skip_serializing_if = "Option::is_none")]
827    pub domain_name: Option<String>,
828    #[serde(rename = "domainNameArn")]
829    #[serde(default)]
830    #[serde(skip_serializing_if = "Option::is_none")]
831    pub domain_name_arn: Option<String>,
832    #[serde(rename = "hostedZoneId")]
833    #[serde(default)]
834    #[serde(skip_serializing_if = "Option::is_none")]
835    pub hosted_zone_id: Option<String>,
836    #[serde(default)]
837    #[serde(skip_serializing_if = "Option::is_none")]
838    pub tags: Option<std::collections::HashMap<String, String>>,
839}
840
841#[derive(Debug, Clone, Default, Deserialize, Serialize)]
842pub struct CreateFunctionRequest {
843    #[serde(rename = "apiId")]
844    #[serde(default)]
845    pub api_id: String,
846    #[serde(default)]
847    #[serde(skip_serializing_if = "Option::is_none")]
848    pub code: Option<String>,
849    #[serde(rename = "dataSourceName")]
850    #[serde(default)]
851    pub data_source_name: String,
852    #[serde(default)]
853    #[serde(skip_serializing_if = "Option::is_none")]
854    pub description: Option<String>,
855    #[serde(rename = "functionVersion")]
856    #[serde(default)]
857    #[serde(skip_serializing_if = "Option::is_none")]
858    pub function_version: Option<String>,
859    #[serde(rename = "maxBatchSize")]
860    #[serde(default)]
861    #[serde(skip_serializing_if = "Option::is_none")]
862    pub max_batch_size: Option<i32>,
863    #[serde(default)]
864    pub name: String,
865    #[serde(rename = "requestMappingTemplate")]
866    #[serde(default)]
867    #[serde(skip_serializing_if = "Option::is_none")]
868    pub request_mapping_template: Option<String>,
869    #[serde(rename = "responseMappingTemplate")]
870    #[serde(default)]
871    #[serde(skip_serializing_if = "Option::is_none")]
872    pub response_mapping_template: Option<String>,
873    #[serde(default)]
874    #[serde(skip_serializing_if = "Option::is_none")]
875    pub runtime: Option<AppSyncRuntime>,
876    #[serde(rename = "syncConfig")]
877    #[serde(default)]
878    #[serde(skip_serializing_if = "Option::is_none")]
879    pub sync_config: Option<SyncConfig>,
880}
881
882#[derive(Debug, Clone, Default, Deserialize, Serialize)]
883pub struct AppSyncRuntime {
884    #[serde(default)]
885    pub name: String,
886    #[serde(rename = "runtimeVersion")]
887    #[serde(default)]
888    pub runtime_version: String,
889}
890
891#[derive(Debug, Clone, Default, Deserialize, Serialize)]
892pub struct SyncConfig {
893    #[serde(rename = "conflictDetection")]
894    #[serde(default)]
895    #[serde(skip_serializing_if = "Option::is_none")]
896    pub conflict_detection: Option<String>,
897    #[serde(rename = "conflictHandler")]
898    #[serde(default)]
899    #[serde(skip_serializing_if = "Option::is_none")]
900    pub conflict_handler: Option<String>,
901    #[serde(rename = "lambdaConflictHandlerConfig")]
902    #[serde(default)]
903    #[serde(skip_serializing_if = "Option::is_none")]
904    pub lambda_conflict_handler_config: Option<LambdaConflictHandlerConfig>,
905}
906
907#[derive(Debug, Clone, Default, Deserialize, Serialize)]
908pub struct LambdaConflictHandlerConfig {
909    #[serde(rename = "lambdaConflictHandlerArn")]
910    #[serde(default)]
911    #[serde(skip_serializing_if = "Option::is_none")]
912    pub lambda_conflict_handler_arn: Option<String>,
913}
914
915#[derive(Debug, Clone, Default, Deserialize, Serialize)]
916pub struct CreateFunctionResponse {
917    #[serde(rename = "functionConfiguration")]
918    #[serde(default)]
919    #[serde(skip_serializing_if = "Option::is_none")]
920    pub function_configuration: Option<FunctionConfiguration>,
921}
922
923#[derive(Debug, Clone, Default, Deserialize, Serialize)]
924pub struct FunctionConfiguration {
925    #[serde(default)]
926    #[serde(skip_serializing_if = "Option::is_none")]
927    pub code: Option<String>,
928    #[serde(rename = "dataSourceName")]
929    #[serde(default)]
930    #[serde(skip_serializing_if = "Option::is_none")]
931    pub data_source_name: Option<String>,
932    #[serde(default)]
933    #[serde(skip_serializing_if = "Option::is_none")]
934    pub description: Option<String>,
935    #[serde(rename = "functionArn")]
936    #[serde(default)]
937    #[serde(skip_serializing_if = "Option::is_none")]
938    pub function_arn: Option<String>,
939    #[serde(rename = "functionId")]
940    #[serde(default)]
941    #[serde(skip_serializing_if = "Option::is_none")]
942    pub function_id: Option<String>,
943    #[serde(rename = "functionVersion")]
944    #[serde(default)]
945    #[serde(skip_serializing_if = "Option::is_none")]
946    pub function_version: Option<String>,
947    #[serde(rename = "maxBatchSize")]
948    #[serde(default)]
949    #[serde(skip_serializing_if = "Option::is_none")]
950    pub max_batch_size: Option<i32>,
951    #[serde(default)]
952    #[serde(skip_serializing_if = "Option::is_none")]
953    pub name: Option<String>,
954    #[serde(rename = "requestMappingTemplate")]
955    #[serde(default)]
956    #[serde(skip_serializing_if = "Option::is_none")]
957    pub request_mapping_template: Option<String>,
958    #[serde(rename = "responseMappingTemplate")]
959    #[serde(default)]
960    #[serde(skip_serializing_if = "Option::is_none")]
961    pub response_mapping_template: Option<String>,
962    #[serde(default)]
963    #[serde(skip_serializing_if = "Option::is_none")]
964    pub runtime: Option<AppSyncRuntime>,
965    #[serde(rename = "syncConfig")]
966    #[serde(default)]
967    #[serde(skip_serializing_if = "Option::is_none")]
968    pub sync_config: Option<SyncConfig>,
969}
970
971#[derive(Debug, Clone, Default, Deserialize, Serialize)]
972pub struct CreateGraphqlApiRequest {
973    #[serde(rename = "additionalAuthenticationProviders")]
974    #[serde(default)]
975    #[serde(skip_serializing_if = "Option::is_none")]
976    pub additional_authentication_providers: Option<Vec<AdditionalAuthenticationProvider>>,
977    #[serde(rename = "apiType")]
978    #[serde(default)]
979    #[serde(skip_serializing_if = "Option::is_none")]
980    pub api_type: Option<String>,
981    #[serde(rename = "authenticationType")]
982    #[serde(default)]
983    pub authentication_type: String,
984    #[serde(rename = "enhancedMetricsConfig")]
985    #[serde(default)]
986    #[serde(skip_serializing_if = "Option::is_none")]
987    pub enhanced_metrics_config: Option<EnhancedMetricsConfig>,
988    #[serde(rename = "introspectionConfig")]
989    #[serde(default)]
990    #[serde(skip_serializing_if = "Option::is_none")]
991    pub introspection_config: Option<String>,
992    #[serde(rename = "lambdaAuthorizerConfig")]
993    #[serde(default)]
994    #[serde(skip_serializing_if = "Option::is_none")]
995    pub lambda_authorizer_config: Option<LambdaAuthorizerConfig>,
996    #[serde(rename = "logConfig")]
997    #[serde(default)]
998    #[serde(skip_serializing_if = "Option::is_none")]
999    pub log_config: Option<LogConfig>,
1000    #[serde(rename = "mergedApiExecutionRoleArn")]
1001    #[serde(default)]
1002    #[serde(skip_serializing_if = "Option::is_none")]
1003    pub merged_api_execution_role_arn: Option<String>,
1004    #[serde(default)]
1005    pub name: String,
1006    #[serde(rename = "openIDConnectConfig")]
1007    #[serde(default)]
1008    #[serde(skip_serializing_if = "Option::is_none")]
1009    pub open_i_d_connect_config: Option<OpenIDConnectConfig>,
1010    #[serde(rename = "ownerContact")]
1011    #[serde(default)]
1012    #[serde(skip_serializing_if = "Option::is_none")]
1013    pub owner_contact: Option<String>,
1014    #[serde(rename = "queryDepthLimit")]
1015    #[serde(default)]
1016    #[serde(skip_serializing_if = "Option::is_none")]
1017    pub query_depth_limit: Option<i32>,
1018    #[serde(rename = "resolverCountLimit")]
1019    #[serde(default)]
1020    #[serde(skip_serializing_if = "Option::is_none")]
1021    pub resolver_count_limit: Option<i32>,
1022    #[serde(default)]
1023    #[serde(skip_serializing_if = "Option::is_none")]
1024    pub tags: Option<std::collections::HashMap<String, String>>,
1025    #[serde(rename = "userPoolConfig")]
1026    #[serde(default)]
1027    #[serde(skip_serializing_if = "Option::is_none")]
1028    pub user_pool_config: Option<UserPoolConfig>,
1029    #[serde(default)]
1030    #[serde(skip_serializing_if = "Option::is_none")]
1031    pub visibility: Option<String>,
1032    #[serde(rename = "xrayEnabled")]
1033    #[serde(default)]
1034    #[serde(skip_serializing_if = "Option::is_none")]
1035    pub xray_enabled: Option<bool>,
1036}
1037
1038#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1039pub struct AdditionalAuthenticationProvider {
1040    #[serde(rename = "authenticationType")]
1041    #[serde(default)]
1042    #[serde(skip_serializing_if = "Option::is_none")]
1043    pub authentication_type: Option<String>,
1044    #[serde(rename = "lambdaAuthorizerConfig")]
1045    #[serde(default)]
1046    #[serde(skip_serializing_if = "Option::is_none")]
1047    pub lambda_authorizer_config: Option<LambdaAuthorizerConfig>,
1048    #[serde(rename = "openIDConnectConfig")]
1049    #[serde(default)]
1050    #[serde(skip_serializing_if = "Option::is_none")]
1051    pub open_i_d_connect_config: Option<OpenIDConnectConfig>,
1052    #[serde(rename = "userPoolConfig")]
1053    #[serde(default)]
1054    #[serde(skip_serializing_if = "Option::is_none")]
1055    pub user_pool_config: Option<CognitoUserPoolConfig>,
1056}
1057
1058#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1059pub struct CognitoUserPoolConfig {
1060    #[serde(rename = "appIdClientRegex")]
1061    #[serde(default)]
1062    #[serde(skip_serializing_if = "Option::is_none")]
1063    pub app_id_client_regex: Option<String>,
1064    #[serde(rename = "awsRegion")]
1065    #[serde(default)]
1066    pub aws_region: String,
1067    #[serde(rename = "userPoolId")]
1068    #[serde(default)]
1069    pub user_pool_id: String,
1070}
1071
1072#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1073pub struct EnhancedMetricsConfig {
1074    #[serde(rename = "dataSourceLevelMetricsBehavior")]
1075    #[serde(default)]
1076    pub data_source_level_metrics_behavior: String,
1077    #[serde(rename = "operationLevelMetricsConfig")]
1078    #[serde(default)]
1079    pub operation_level_metrics_config: String,
1080    #[serde(rename = "resolverLevelMetricsBehavior")]
1081    #[serde(default)]
1082    pub resolver_level_metrics_behavior: String,
1083}
1084
1085#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1086pub struct LogConfig {
1087    #[serde(rename = "cloudWatchLogsRoleArn")]
1088    #[serde(default)]
1089    pub cloud_watch_logs_role_arn: String,
1090    #[serde(rename = "excludeVerboseContent")]
1091    #[serde(default)]
1092    #[serde(skip_serializing_if = "Option::is_none")]
1093    pub exclude_verbose_content: Option<bool>,
1094    #[serde(rename = "fieldLogLevel")]
1095    #[serde(default)]
1096    pub field_log_level: String,
1097}
1098
1099#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1100pub struct UserPoolConfig {
1101    #[serde(rename = "appIdClientRegex")]
1102    #[serde(default)]
1103    #[serde(skip_serializing_if = "Option::is_none")]
1104    pub app_id_client_regex: Option<String>,
1105    #[serde(rename = "awsRegion")]
1106    #[serde(default)]
1107    pub aws_region: String,
1108    #[serde(rename = "defaultAction")]
1109    #[serde(default)]
1110    pub default_action: String,
1111    #[serde(rename = "userPoolId")]
1112    #[serde(default)]
1113    pub user_pool_id: String,
1114}
1115
1116#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1117pub struct CreateGraphqlApiResponse {
1118    #[serde(rename = "graphqlApi")]
1119    #[serde(default)]
1120    #[serde(skip_serializing_if = "Option::is_none")]
1121    pub graphql_api: Option<GraphqlApi>,
1122}
1123
1124#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1125pub struct GraphqlApi {
1126    #[serde(rename = "additionalAuthenticationProviders")]
1127    #[serde(default)]
1128    #[serde(skip_serializing_if = "Option::is_none")]
1129    pub additional_authentication_providers: Option<Vec<AdditionalAuthenticationProvider>>,
1130    #[serde(rename = "apiId")]
1131    #[serde(default)]
1132    #[serde(skip_serializing_if = "Option::is_none")]
1133    pub api_id: Option<String>,
1134    #[serde(rename = "apiType")]
1135    #[serde(default)]
1136    #[serde(skip_serializing_if = "Option::is_none")]
1137    pub api_type: Option<String>,
1138    #[serde(default)]
1139    #[serde(skip_serializing_if = "Option::is_none")]
1140    pub arn: Option<String>,
1141    #[serde(rename = "authenticationType")]
1142    #[serde(default)]
1143    #[serde(skip_serializing_if = "Option::is_none")]
1144    pub authentication_type: Option<String>,
1145    #[serde(default)]
1146    #[serde(skip_serializing_if = "Option::is_none")]
1147    pub dns: Option<std::collections::HashMap<String, String>>,
1148    #[serde(rename = "enhancedMetricsConfig")]
1149    #[serde(default)]
1150    #[serde(skip_serializing_if = "Option::is_none")]
1151    pub enhanced_metrics_config: Option<EnhancedMetricsConfig>,
1152    #[serde(rename = "introspectionConfig")]
1153    #[serde(default)]
1154    #[serde(skip_serializing_if = "Option::is_none")]
1155    pub introspection_config: Option<String>,
1156    #[serde(rename = "lambdaAuthorizerConfig")]
1157    #[serde(default)]
1158    #[serde(skip_serializing_if = "Option::is_none")]
1159    pub lambda_authorizer_config: Option<LambdaAuthorizerConfig>,
1160    #[serde(rename = "logConfig")]
1161    #[serde(default)]
1162    #[serde(skip_serializing_if = "Option::is_none")]
1163    pub log_config: Option<LogConfig>,
1164    #[serde(rename = "mergedApiExecutionRoleArn")]
1165    #[serde(default)]
1166    #[serde(skip_serializing_if = "Option::is_none")]
1167    pub merged_api_execution_role_arn: Option<String>,
1168    #[serde(default)]
1169    #[serde(skip_serializing_if = "Option::is_none")]
1170    pub name: Option<String>,
1171    #[serde(rename = "openIDConnectConfig")]
1172    #[serde(default)]
1173    #[serde(skip_serializing_if = "Option::is_none")]
1174    pub open_i_d_connect_config: Option<OpenIDConnectConfig>,
1175    #[serde(default)]
1176    #[serde(skip_serializing_if = "Option::is_none")]
1177    pub owner: Option<String>,
1178    #[serde(rename = "ownerContact")]
1179    #[serde(default)]
1180    #[serde(skip_serializing_if = "Option::is_none")]
1181    pub owner_contact: Option<String>,
1182    #[serde(rename = "queryDepthLimit")]
1183    #[serde(default)]
1184    #[serde(skip_serializing_if = "Option::is_none")]
1185    pub query_depth_limit: Option<i32>,
1186    #[serde(rename = "resolverCountLimit")]
1187    #[serde(default)]
1188    #[serde(skip_serializing_if = "Option::is_none")]
1189    pub resolver_count_limit: Option<i32>,
1190    #[serde(default)]
1191    #[serde(skip_serializing_if = "Option::is_none")]
1192    pub tags: Option<std::collections::HashMap<String, String>>,
1193    #[serde(default)]
1194    #[serde(skip_serializing_if = "Option::is_none")]
1195    pub uris: Option<std::collections::HashMap<String, String>>,
1196    #[serde(rename = "userPoolConfig")]
1197    #[serde(default)]
1198    #[serde(skip_serializing_if = "Option::is_none")]
1199    pub user_pool_config: Option<UserPoolConfig>,
1200    #[serde(default)]
1201    #[serde(skip_serializing_if = "Option::is_none")]
1202    pub visibility: Option<String>,
1203    #[serde(rename = "wafWebAclArn")]
1204    #[serde(default)]
1205    #[serde(skip_serializing_if = "Option::is_none")]
1206    pub waf_web_acl_arn: Option<String>,
1207    #[serde(rename = "xrayEnabled")]
1208    #[serde(default)]
1209    #[serde(skip_serializing_if = "Option::is_none")]
1210    pub xray_enabled: Option<bool>,
1211}
1212
1213#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1214pub struct CreateResolverRequest {
1215    #[serde(rename = "apiId")]
1216    #[serde(default)]
1217    pub api_id: String,
1218    #[serde(rename = "cachingConfig")]
1219    #[serde(default)]
1220    #[serde(skip_serializing_if = "Option::is_none")]
1221    pub caching_config: Option<CachingConfig>,
1222    #[serde(default)]
1223    #[serde(skip_serializing_if = "Option::is_none")]
1224    pub code: Option<String>,
1225    #[serde(rename = "dataSourceName")]
1226    #[serde(default)]
1227    #[serde(skip_serializing_if = "Option::is_none")]
1228    pub data_source_name: Option<String>,
1229    #[serde(rename = "fieldName")]
1230    #[serde(default)]
1231    pub field_name: String,
1232    #[serde(default)]
1233    #[serde(skip_serializing_if = "Option::is_none")]
1234    pub kind: Option<String>,
1235    #[serde(rename = "maxBatchSize")]
1236    #[serde(default)]
1237    #[serde(skip_serializing_if = "Option::is_none")]
1238    pub max_batch_size: Option<i32>,
1239    #[serde(rename = "metricsConfig")]
1240    #[serde(default)]
1241    #[serde(skip_serializing_if = "Option::is_none")]
1242    pub metrics_config: Option<String>,
1243    #[serde(rename = "pipelineConfig")]
1244    #[serde(default)]
1245    #[serde(skip_serializing_if = "Option::is_none")]
1246    pub pipeline_config: Option<PipelineConfig>,
1247    #[serde(rename = "requestMappingTemplate")]
1248    #[serde(default)]
1249    #[serde(skip_serializing_if = "Option::is_none")]
1250    pub request_mapping_template: Option<String>,
1251    #[serde(rename = "responseMappingTemplate")]
1252    #[serde(default)]
1253    #[serde(skip_serializing_if = "Option::is_none")]
1254    pub response_mapping_template: Option<String>,
1255    #[serde(default)]
1256    #[serde(skip_serializing_if = "Option::is_none")]
1257    pub runtime: Option<AppSyncRuntime>,
1258    #[serde(rename = "syncConfig")]
1259    #[serde(default)]
1260    #[serde(skip_serializing_if = "Option::is_none")]
1261    pub sync_config: Option<SyncConfig>,
1262    #[serde(rename = "typeName")]
1263    #[serde(default)]
1264    pub type_name: String,
1265}
1266
1267#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1268pub struct CachingConfig {
1269    #[serde(rename = "cachingKeys")]
1270    #[serde(default)]
1271    #[serde(skip_serializing_if = "Option::is_none")]
1272    pub caching_keys: Option<Vec<String>>,
1273    #[serde(default)]
1274    pub ttl: i64,
1275}
1276
1277#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1278pub struct PipelineConfig {
1279    #[serde(default)]
1280    #[serde(skip_serializing_if = "Option::is_none")]
1281    pub functions: Option<Vec<String>>,
1282}
1283
1284#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1285pub struct CreateResolverResponse {
1286    #[serde(default)]
1287    #[serde(skip_serializing_if = "Option::is_none")]
1288    pub resolver: Option<Resolver>,
1289}
1290
1291#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1292pub struct Resolver {
1293    #[serde(rename = "cachingConfig")]
1294    #[serde(default)]
1295    #[serde(skip_serializing_if = "Option::is_none")]
1296    pub caching_config: Option<CachingConfig>,
1297    #[serde(default)]
1298    #[serde(skip_serializing_if = "Option::is_none")]
1299    pub code: Option<String>,
1300    #[serde(rename = "dataSourceName")]
1301    #[serde(default)]
1302    #[serde(skip_serializing_if = "Option::is_none")]
1303    pub data_source_name: Option<String>,
1304    #[serde(rename = "fieldName")]
1305    #[serde(default)]
1306    #[serde(skip_serializing_if = "Option::is_none")]
1307    pub field_name: Option<String>,
1308    #[serde(default)]
1309    #[serde(skip_serializing_if = "Option::is_none")]
1310    pub kind: Option<String>,
1311    #[serde(rename = "maxBatchSize")]
1312    #[serde(default)]
1313    #[serde(skip_serializing_if = "Option::is_none")]
1314    pub max_batch_size: Option<i32>,
1315    #[serde(rename = "metricsConfig")]
1316    #[serde(default)]
1317    #[serde(skip_serializing_if = "Option::is_none")]
1318    pub metrics_config: Option<String>,
1319    #[serde(rename = "pipelineConfig")]
1320    #[serde(default)]
1321    #[serde(skip_serializing_if = "Option::is_none")]
1322    pub pipeline_config: Option<PipelineConfig>,
1323    #[serde(rename = "requestMappingTemplate")]
1324    #[serde(default)]
1325    #[serde(skip_serializing_if = "Option::is_none")]
1326    pub request_mapping_template: Option<String>,
1327    #[serde(rename = "resolverArn")]
1328    #[serde(default)]
1329    #[serde(skip_serializing_if = "Option::is_none")]
1330    pub resolver_arn: Option<String>,
1331    #[serde(rename = "responseMappingTemplate")]
1332    #[serde(default)]
1333    #[serde(skip_serializing_if = "Option::is_none")]
1334    pub response_mapping_template: Option<String>,
1335    #[serde(default)]
1336    #[serde(skip_serializing_if = "Option::is_none")]
1337    pub runtime: Option<AppSyncRuntime>,
1338    #[serde(rename = "syncConfig")]
1339    #[serde(default)]
1340    #[serde(skip_serializing_if = "Option::is_none")]
1341    pub sync_config: Option<SyncConfig>,
1342    #[serde(rename = "typeName")]
1343    #[serde(default)]
1344    #[serde(skip_serializing_if = "Option::is_none")]
1345    pub type_name: Option<String>,
1346}
1347
1348#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1349pub struct CreateTypeRequest {
1350    #[serde(rename = "apiId")]
1351    #[serde(default)]
1352    pub api_id: String,
1353    #[serde(default)]
1354    pub definition: String,
1355    #[serde(default)]
1356    pub format: String,
1357}
1358
1359#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1360pub struct CreateTypeResponse {
1361    #[serde(rename = "type")]
1362    #[serde(default)]
1363    #[serde(skip_serializing_if = "Option::is_none")]
1364    pub r#type: Option<Type>,
1365}
1366
1367#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1368pub struct Type {
1369    #[serde(default)]
1370    #[serde(skip_serializing_if = "Option::is_none")]
1371    pub arn: Option<String>,
1372    #[serde(default)]
1373    #[serde(skip_serializing_if = "Option::is_none")]
1374    pub definition: Option<String>,
1375    #[serde(default)]
1376    #[serde(skip_serializing_if = "Option::is_none")]
1377    pub description: Option<String>,
1378    #[serde(default)]
1379    #[serde(skip_serializing_if = "Option::is_none")]
1380    pub format: Option<String>,
1381    #[serde(default)]
1382    #[serde(skip_serializing_if = "Option::is_none")]
1383    pub name: Option<String>,
1384}
1385
1386#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1387pub struct DeleteApiCacheRequest {
1388    #[serde(rename = "apiId")]
1389    #[serde(default)]
1390    pub api_id: String,
1391}
1392
1393#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1394pub struct DeleteApiCacheResponse {}
1395
1396#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1397pub struct DeleteApiKeyRequest {
1398    #[serde(rename = "apiId")]
1399    #[serde(default)]
1400    pub api_id: String,
1401    #[serde(default)]
1402    pub id: String,
1403}
1404
1405#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1406pub struct DeleteApiKeyResponse {}
1407
1408#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1409pub struct DeleteApiRequest {
1410    #[serde(rename = "apiId")]
1411    #[serde(default)]
1412    pub api_id: String,
1413}
1414
1415#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1416pub struct DeleteApiResponse {}
1417
1418#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1419pub struct DeleteChannelNamespaceRequest {
1420    #[serde(rename = "apiId")]
1421    #[serde(default)]
1422    pub api_id: String,
1423    #[serde(default)]
1424    pub name: String,
1425}
1426
1427#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1428pub struct DeleteChannelNamespaceResponse {}
1429
1430#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1431pub struct DeleteDataSourceRequest {
1432    #[serde(rename = "apiId")]
1433    #[serde(default)]
1434    pub api_id: String,
1435    #[serde(default)]
1436    pub name: String,
1437}
1438
1439#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1440pub struct DeleteDataSourceResponse {}
1441
1442#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1443pub struct DeleteDomainNameRequest {
1444    #[serde(rename = "domainName")]
1445    #[serde(default)]
1446    pub domain_name: String,
1447}
1448
1449#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1450pub struct DeleteDomainNameResponse {}
1451
1452#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1453pub struct DeleteFunctionRequest {
1454    #[serde(rename = "apiId")]
1455    #[serde(default)]
1456    pub api_id: String,
1457    #[serde(rename = "functionId")]
1458    #[serde(default)]
1459    pub function_id: String,
1460}
1461
1462#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1463pub struct DeleteFunctionResponse {}
1464
1465#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1466pub struct DeleteGraphqlApiRequest {
1467    #[serde(rename = "apiId")]
1468    #[serde(default)]
1469    pub api_id: String,
1470}
1471
1472#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1473pub struct DeleteGraphqlApiResponse {}
1474
1475#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1476pub struct DeleteResolverRequest {
1477    #[serde(rename = "apiId")]
1478    #[serde(default)]
1479    pub api_id: String,
1480    #[serde(rename = "fieldName")]
1481    #[serde(default)]
1482    pub field_name: String,
1483    #[serde(rename = "typeName")]
1484    #[serde(default)]
1485    pub type_name: String,
1486}
1487
1488#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1489pub struct DeleteResolverResponse {}
1490
1491#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1492pub struct DeleteTypeRequest {
1493    #[serde(rename = "apiId")]
1494    #[serde(default)]
1495    pub api_id: String,
1496    #[serde(rename = "typeName")]
1497    #[serde(default)]
1498    pub type_name: String,
1499}
1500
1501#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1502pub struct DeleteTypeResponse {}
1503
1504#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1505pub struct DisassociateApiRequest {
1506    #[serde(rename = "domainName")]
1507    #[serde(default)]
1508    pub domain_name: String,
1509}
1510
1511#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1512pub struct DisassociateApiResponse {}
1513
1514#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1515pub struct DisassociateMergedGraphqlApiRequest {
1516    #[serde(rename = "associationId")]
1517    #[serde(default)]
1518    pub association_id: String,
1519    #[serde(rename = "sourceApiIdentifier")]
1520    #[serde(default)]
1521    pub source_api_identifier: String,
1522}
1523
1524#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1525pub struct DisassociateMergedGraphqlApiResponse {
1526    #[serde(rename = "sourceApiAssociationStatus")]
1527    #[serde(default)]
1528    #[serde(skip_serializing_if = "Option::is_none")]
1529    pub source_api_association_status: Option<String>,
1530}
1531
1532#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1533pub struct DisassociateSourceGraphqlApiRequest {
1534    #[serde(rename = "associationId")]
1535    #[serde(default)]
1536    pub association_id: String,
1537    #[serde(rename = "mergedApiIdentifier")]
1538    #[serde(default)]
1539    pub merged_api_identifier: String,
1540}
1541
1542#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1543pub struct DisassociateSourceGraphqlApiResponse {
1544    #[serde(rename = "sourceApiAssociationStatus")]
1545    #[serde(default)]
1546    #[serde(skip_serializing_if = "Option::is_none")]
1547    pub source_api_association_status: Option<String>,
1548}
1549
1550#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1551pub struct EvaluateCodeRequest {
1552    #[serde(default)]
1553    pub code: String,
1554    #[serde(default)]
1555    pub context: String,
1556    #[serde(default)]
1557    #[serde(skip_serializing_if = "Option::is_none")]
1558    pub function: Option<String>,
1559    #[serde(default)]
1560    pub runtime: AppSyncRuntime,
1561}
1562
1563#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1564pub struct EvaluateCodeResponse {
1565    #[serde(default)]
1566    #[serde(skip_serializing_if = "Option::is_none")]
1567    pub error: Option<EvaluateCodeErrorDetail>,
1568    #[serde(rename = "evaluationResult")]
1569    #[serde(default)]
1570    #[serde(skip_serializing_if = "Option::is_none")]
1571    pub evaluation_result: Option<String>,
1572    #[serde(default)]
1573    #[serde(skip_serializing_if = "Option::is_none")]
1574    pub logs: Option<Vec<String>>,
1575    #[serde(rename = "outErrors")]
1576    #[serde(default)]
1577    #[serde(skip_serializing_if = "Option::is_none")]
1578    pub out_errors: Option<String>,
1579    #[serde(default)]
1580    #[serde(skip_serializing_if = "Option::is_none")]
1581    pub stash: Option<String>,
1582}
1583
1584#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1585pub struct EvaluateCodeErrorDetail {
1586    #[serde(rename = "codeErrors")]
1587    #[serde(default)]
1588    #[serde(skip_serializing_if = "Option::is_none")]
1589    pub code_errors: Option<Vec<CodeError>>,
1590    #[serde(default)]
1591    #[serde(skip_serializing_if = "Option::is_none")]
1592    pub message: Option<String>,
1593}
1594
1595#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1596pub struct CodeError {
1597    #[serde(rename = "errorType")]
1598    #[serde(default)]
1599    #[serde(skip_serializing_if = "Option::is_none")]
1600    pub error_type: Option<String>,
1601    #[serde(default)]
1602    #[serde(skip_serializing_if = "Option::is_none")]
1603    pub location: Option<CodeErrorLocation>,
1604    #[serde(default)]
1605    #[serde(skip_serializing_if = "Option::is_none")]
1606    pub value: Option<String>,
1607}
1608
1609#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1610pub struct CodeErrorLocation {
1611    #[serde(default)]
1612    #[serde(skip_serializing_if = "Option::is_none")]
1613    pub column: Option<i32>,
1614    #[serde(default)]
1615    #[serde(skip_serializing_if = "Option::is_none")]
1616    pub line: Option<i32>,
1617    #[serde(default)]
1618    #[serde(skip_serializing_if = "Option::is_none")]
1619    pub span: Option<i32>,
1620}
1621
1622#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1623pub struct EvaluateMappingTemplateRequest {
1624    #[serde(default)]
1625    pub context: String,
1626    #[serde(default)]
1627    pub template: String,
1628}
1629
1630#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1631pub struct EvaluateMappingTemplateResponse {
1632    #[serde(default)]
1633    #[serde(skip_serializing_if = "Option::is_none")]
1634    pub error: Option<ErrorDetail>,
1635    #[serde(rename = "evaluationResult")]
1636    #[serde(default)]
1637    #[serde(skip_serializing_if = "Option::is_none")]
1638    pub evaluation_result: Option<String>,
1639    #[serde(default)]
1640    #[serde(skip_serializing_if = "Option::is_none")]
1641    pub logs: Option<Vec<String>>,
1642    #[serde(rename = "outErrors")]
1643    #[serde(default)]
1644    #[serde(skip_serializing_if = "Option::is_none")]
1645    pub out_errors: Option<String>,
1646    #[serde(default)]
1647    #[serde(skip_serializing_if = "Option::is_none")]
1648    pub stash: Option<String>,
1649}
1650
1651#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1652pub struct ErrorDetail {
1653    #[serde(default)]
1654    #[serde(skip_serializing_if = "Option::is_none")]
1655    pub message: Option<String>,
1656}
1657
1658#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1659pub struct FlushApiCacheRequest {
1660    #[serde(rename = "apiId")]
1661    #[serde(default)]
1662    pub api_id: String,
1663}
1664
1665#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1666pub struct FlushApiCacheResponse {}
1667
1668#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1669pub struct GetApiAssociationRequest {
1670    #[serde(rename = "domainName")]
1671    #[serde(default)]
1672    pub domain_name: String,
1673}
1674
1675#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1676pub struct GetApiAssociationResponse {
1677    #[serde(rename = "apiAssociation")]
1678    #[serde(default)]
1679    #[serde(skip_serializing_if = "Option::is_none")]
1680    pub api_association: Option<ApiAssociation>,
1681}
1682
1683#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1684pub struct GetApiCacheRequest {
1685    #[serde(rename = "apiId")]
1686    #[serde(default)]
1687    pub api_id: String,
1688}
1689
1690#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1691pub struct GetApiCacheResponse {
1692    #[serde(rename = "apiCache")]
1693    #[serde(default)]
1694    #[serde(skip_serializing_if = "Option::is_none")]
1695    pub api_cache: Option<ApiCache>,
1696}
1697
1698#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1699pub struct GetApiRequest {
1700    #[serde(rename = "apiId")]
1701    #[serde(default)]
1702    pub api_id: String,
1703}
1704
1705#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1706pub struct GetApiResponse {
1707    #[serde(default)]
1708    #[serde(skip_serializing_if = "Option::is_none")]
1709    pub api: Option<Api>,
1710}
1711
1712#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1713pub struct GetChannelNamespaceRequest {
1714    #[serde(rename = "apiId")]
1715    #[serde(default)]
1716    pub api_id: String,
1717    #[serde(default)]
1718    pub name: String,
1719}
1720
1721#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1722pub struct GetChannelNamespaceResponse {
1723    #[serde(rename = "channelNamespace")]
1724    #[serde(default)]
1725    #[serde(skip_serializing_if = "Option::is_none")]
1726    pub channel_namespace: Option<ChannelNamespace>,
1727}
1728
1729#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1730pub struct GetDataSourceIntrospectionRequest {
1731    #[serde(rename = "includeModelsSDL")]
1732    #[serde(default)]
1733    #[serde(skip_serializing_if = "Option::is_none")]
1734    pub include_models_s_d_l: Option<bool>,
1735    #[serde(rename = "introspectionId")]
1736    #[serde(default)]
1737    pub introspection_id: String,
1738    #[serde(rename = "maxResults")]
1739    #[serde(default)]
1740    #[serde(skip_serializing_if = "Option::is_none")]
1741    pub max_results: Option<i32>,
1742    #[serde(rename = "nextToken")]
1743    #[serde(default)]
1744    #[serde(skip_serializing_if = "Option::is_none")]
1745    pub next_token: Option<String>,
1746}
1747
1748#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1749pub struct GetDataSourceIntrospectionResponse {
1750    #[serde(rename = "introspectionId")]
1751    #[serde(default)]
1752    #[serde(skip_serializing_if = "Option::is_none")]
1753    pub introspection_id: Option<String>,
1754    #[serde(rename = "introspectionResult")]
1755    #[serde(default)]
1756    #[serde(skip_serializing_if = "Option::is_none")]
1757    pub introspection_result: Option<DataSourceIntrospectionResult>,
1758    #[serde(rename = "introspectionStatus")]
1759    #[serde(default)]
1760    #[serde(skip_serializing_if = "Option::is_none")]
1761    pub introspection_status: Option<String>,
1762    #[serde(rename = "introspectionStatusDetail")]
1763    #[serde(default)]
1764    #[serde(skip_serializing_if = "Option::is_none")]
1765    pub introspection_status_detail: Option<String>,
1766}
1767
1768#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1769pub struct DataSourceIntrospectionResult {
1770    #[serde(default)]
1771    #[serde(skip_serializing_if = "Option::is_none")]
1772    pub models: Option<Vec<DataSourceIntrospectionModel>>,
1773    #[serde(rename = "nextToken")]
1774    #[serde(default)]
1775    #[serde(skip_serializing_if = "Option::is_none")]
1776    pub next_token: Option<String>,
1777}
1778
1779#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1780pub struct DataSourceIntrospectionModel {
1781    #[serde(default)]
1782    #[serde(skip_serializing_if = "Option::is_none")]
1783    pub fields: Option<Vec<DataSourceIntrospectionModelField>>,
1784    #[serde(default)]
1785    #[serde(skip_serializing_if = "Option::is_none")]
1786    pub indexes: Option<Vec<DataSourceIntrospectionModelIndex>>,
1787    #[serde(default)]
1788    #[serde(skip_serializing_if = "Option::is_none")]
1789    pub name: Option<String>,
1790    #[serde(rename = "primaryKey")]
1791    #[serde(default)]
1792    #[serde(skip_serializing_if = "Option::is_none")]
1793    pub primary_key: Option<DataSourceIntrospectionModelIndex>,
1794    #[serde(default)]
1795    #[serde(skip_serializing_if = "Option::is_none")]
1796    pub sdl: Option<String>,
1797}
1798
1799#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1800pub struct DataSourceIntrospectionModelField {
1801    #[serde(default)]
1802    #[serde(skip_serializing_if = "Option::is_none")]
1803    pub length: Option<i64>,
1804    #[serde(default)]
1805    #[serde(skip_serializing_if = "Option::is_none")]
1806    pub name: Option<String>,
1807    #[serde(rename = "type")]
1808    #[serde(default)]
1809    #[serde(skip_serializing_if = "Option::is_none")]
1810    pub r#type: Option<DataSourceIntrospectionModelFieldType>,
1811}
1812
1813#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1814pub struct DataSourceIntrospectionModelFieldType {
1815    #[serde(default)]
1816    #[serde(skip_serializing_if = "Option::is_none")]
1817    pub kind: Option<String>,
1818    #[serde(default)]
1819    #[serde(skip_serializing_if = "Option::is_none")]
1820    pub name: Option<String>,
1821    #[serde(rename = "type")]
1822    #[serde(default)]
1823    #[serde(skip_serializing_if = "Option::is_none")]
1824    pub r#type: Option<Box<DataSourceIntrospectionModelFieldType>>,
1825    #[serde(default)]
1826    #[serde(skip_serializing_if = "Option::is_none")]
1827    pub values: Option<Vec<String>>,
1828}
1829
1830#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1831pub struct DataSourceIntrospectionModelIndex {
1832    #[serde(default)]
1833    #[serde(skip_serializing_if = "Option::is_none")]
1834    pub fields: Option<Vec<String>>,
1835    #[serde(default)]
1836    #[serde(skip_serializing_if = "Option::is_none")]
1837    pub name: Option<String>,
1838}
1839
1840#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1841pub struct GetDataSourceRequest {
1842    #[serde(rename = "apiId")]
1843    #[serde(default)]
1844    pub api_id: String,
1845    #[serde(default)]
1846    pub name: String,
1847}
1848
1849#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1850pub struct GetDataSourceResponse {
1851    #[serde(rename = "dataSource")]
1852    #[serde(default)]
1853    #[serde(skip_serializing_if = "Option::is_none")]
1854    pub data_source: Option<DataSource>,
1855}
1856
1857#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1858pub struct GetDomainNameRequest {
1859    #[serde(rename = "domainName")]
1860    #[serde(default)]
1861    pub domain_name: String,
1862}
1863
1864#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1865pub struct GetDomainNameResponse {
1866    #[serde(rename = "domainNameConfig")]
1867    #[serde(default)]
1868    #[serde(skip_serializing_if = "Option::is_none")]
1869    pub domain_name_config: Option<DomainNameConfig>,
1870}
1871
1872#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1873pub struct GetFunctionRequest {
1874    #[serde(rename = "apiId")]
1875    #[serde(default)]
1876    pub api_id: String,
1877    #[serde(rename = "functionId")]
1878    #[serde(default)]
1879    pub function_id: String,
1880}
1881
1882#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1883pub struct GetFunctionResponse {
1884    #[serde(rename = "functionConfiguration")]
1885    #[serde(default)]
1886    #[serde(skip_serializing_if = "Option::is_none")]
1887    pub function_configuration: Option<FunctionConfiguration>,
1888}
1889
1890#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1891pub struct GetGraphqlApiEnvironmentVariablesRequest {
1892    #[serde(rename = "apiId")]
1893    #[serde(default)]
1894    pub api_id: String,
1895}
1896
1897#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1898pub struct GetGraphqlApiEnvironmentVariablesResponse {
1899    #[serde(rename = "environmentVariables")]
1900    #[serde(default)]
1901    #[serde(skip_serializing_if = "Option::is_none")]
1902    pub environment_variables: Option<std::collections::HashMap<String, String>>,
1903}
1904
1905#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1906pub struct GetGraphqlApiRequest {
1907    #[serde(rename = "apiId")]
1908    #[serde(default)]
1909    pub api_id: String,
1910}
1911
1912#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1913pub struct GetGraphqlApiResponse {
1914    #[serde(rename = "graphqlApi")]
1915    #[serde(default)]
1916    #[serde(skip_serializing_if = "Option::is_none")]
1917    pub graphql_api: Option<GraphqlApi>,
1918}
1919
1920#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1921pub struct GetIntrospectionSchemaRequest {
1922    #[serde(rename = "apiId")]
1923    #[serde(default)]
1924    pub api_id: String,
1925    #[serde(default)]
1926    pub format: String,
1927    #[serde(rename = "includeDirectives")]
1928    #[serde(default)]
1929    #[serde(skip_serializing_if = "Option::is_none")]
1930    pub include_directives: Option<bool>,
1931}
1932
1933#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1934pub struct GetIntrospectionSchemaResponse {
1935    #[serde(default)]
1936    #[serde(skip_serializing_if = "Option::is_none")]
1937    pub schema: Option<String>,
1938}
1939
1940#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1941pub struct GetResolverRequest {
1942    #[serde(rename = "apiId")]
1943    #[serde(default)]
1944    pub api_id: String,
1945    #[serde(rename = "fieldName")]
1946    #[serde(default)]
1947    pub field_name: String,
1948    #[serde(rename = "typeName")]
1949    #[serde(default)]
1950    pub type_name: String,
1951}
1952
1953#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1954pub struct GetResolverResponse {
1955    #[serde(default)]
1956    #[serde(skip_serializing_if = "Option::is_none")]
1957    pub resolver: Option<Resolver>,
1958}
1959
1960#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1961pub struct GetSchemaCreationStatusRequest {
1962    #[serde(rename = "apiId")]
1963    #[serde(default)]
1964    pub api_id: String,
1965}
1966
1967#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1968pub struct GetSchemaCreationStatusResponse {
1969    #[serde(default)]
1970    #[serde(skip_serializing_if = "Option::is_none")]
1971    pub details: Option<String>,
1972    #[serde(default)]
1973    #[serde(skip_serializing_if = "Option::is_none")]
1974    pub status: Option<String>,
1975}
1976
1977#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1978pub struct GetSourceApiAssociationRequest {
1979    #[serde(rename = "associationId")]
1980    #[serde(default)]
1981    pub association_id: String,
1982    #[serde(rename = "mergedApiIdentifier")]
1983    #[serde(default)]
1984    pub merged_api_identifier: String,
1985}
1986
1987#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1988pub struct GetSourceApiAssociationResponse {
1989    #[serde(rename = "sourceApiAssociation")]
1990    #[serde(default)]
1991    #[serde(skip_serializing_if = "Option::is_none")]
1992    pub source_api_association: Option<SourceApiAssociation>,
1993}
1994
1995#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1996pub struct GetTypeRequest {
1997    #[serde(rename = "apiId")]
1998    #[serde(default)]
1999    pub api_id: String,
2000    #[serde(default)]
2001    pub format: String,
2002    #[serde(rename = "typeName")]
2003    #[serde(default)]
2004    pub type_name: String,
2005}
2006
2007#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2008pub struct GetTypeResponse {
2009    #[serde(rename = "type")]
2010    #[serde(default)]
2011    #[serde(skip_serializing_if = "Option::is_none")]
2012    pub r#type: Option<Type>,
2013}
2014
2015#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2016pub struct ListApiKeysRequest {
2017    #[serde(rename = "apiId")]
2018    #[serde(default)]
2019    pub api_id: String,
2020    #[serde(rename = "maxResults")]
2021    #[serde(default)]
2022    #[serde(skip_serializing_if = "Option::is_none")]
2023    pub max_results: Option<i32>,
2024    #[serde(rename = "nextToken")]
2025    #[serde(default)]
2026    #[serde(skip_serializing_if = "Option::is_none")]
2027    pub next_token: Option<String>,
2028}
2029
2030#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2031pub struct ListApiKeysResponse {
2032    #[serde(rename = "apiKeys")]
2033    #[serde(default)]
2034    #[serde(skip_serializing_if = "Option::is_none")]
2035    pub api_keys: Option<Vec<ApiKey>>,
2036    #[serde(rename = "nextToken")]
2037    #[serde(default)]
2038    #[serde(skip_serializing_if = "Option::is_none")]
2039    pub next_token: Option<String>,
2040}
2041
2042#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2043pub struct ListApisRequest {
2044    #[serde(rename = "maxResults")]
2045    #[serde(default)]
2046    #[serde(skip_serializing_if = "Option::is_none")]
2047    pub max_results: Option<i32>,
2048    #[serde(rename = "nextToken")]
2049    #[serde(default)]
2050    #[serde(skip_serializing_if = "Option::is_none")]
2051    pub next_token: Option<String>,
2052}
2053
2054#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2055pub struct ListApisResponse {
2056    #[serde(default)]
2057    #[serde(skip_serializing_if = "Option::is_none")]
2058    pub apis: Option<Vec<Api>>,
2059    #[serde(rename = "nextToken")]
2060    #[serde(default)]
2061    #[serde(skip_serializing_if = "Option::is_none")]
2062    pub next_token: Option<String>,
2063}
2064
2065#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2066pub struct ListChannelNamespacesRequest {
2067    #[serde(rename = "apiId")]
2068    #[serde(default)]
2069    pub api_id: String,
2070    #[serde(rename = "maxResults")]
2071    #[serde(default)]
2072    #[serde(skip_serializing_if = "Option::is_none")]
2073    pub max_results: Option<i32>,
2074    #[serde(rename = "nextToken")]
2075    #[serde(default)]
2076    #[serde(skip_serializing_if = "Option::is_none")]
2077    pub next_token: Option<String>,
2078}
2079
2080#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2081pub struct ListChannelNamespacesResponse {
2082    #[serde(rename = "channelNamespaces")]
2083    #[serde(default)]
2084    #[serde(skip_serializing_if = "Option::is_none")]
2085    pub channel_namespaces: Option<Vec<ChannelNamespace>>,
2086    #[serde(rename = "nextToken")]
2087    #[serde(default)]
2088    #[serde(skip_serializing_if = "Option::is_none")]
2089    pub next_token: Option<String>,
2090}
2091
2092#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2093pub struct ListDataSourcesRequest {
2094    #[serde(rename = "apiId")]
2095    #[serde(default)]
2096    pub api_id: String,
2097    #[serde(rename = "maxResults")]
2098    #[serde(default)]
2099    #[serde(skip_serializing_if = "Option::is_none")]
2100    pub max_results: Option<i32>,
2101    #[serde(rename = "nextToken")]
2102    #[serde(default)]
2103    #[serde(skip_serializing_if = "Option::is_none")]
2104    pub next_token: Option<String>,
2105}
2106
2107#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2108pub struct ListDataSourcesResponse {
2109    #[serde(rename = "dataSources")]
2110    #[serde(default)]
2111    #[serde(skip_serializing_if = "Option::is_none")]
2112    pub data_sources: Option<Vec<DataSource>>,
2113    #[serde(rename = "nextToken")]
2114    #[serde(default)]
2115    #[serde(skip_serializing_if = "Option::is_none")]
2116    pub next_token: Option<String>,
2117}
2118
2119#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2120pub struct ListDomainNamesRequest {
2121    #[serde(rename = "maxResults")]
2122    #[serde(default)]
2123    #[serde(skip_serializing_if = "Option::is_none")]
2124    pub max_results: Option<i32>,
2125    #[serde(rename = "nextToken")]
2126    #[serde(default)]
2127    #[serde(skip_serializing_if = "Option::is_none")]
2128    pub next_token: Option<String>,
2129}
2130
2131#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2132pub struct ListDomainNamesResponse {
2133    #[serde(rename = "domainNameConfigs")]
2134    #[serde(default)]
2135    #[serde(skip_serializing_if = "Option::is_none")]
2136    pub domain_name_configs: Option<Vec<DomainNameConfig>>,
2137    #[serde(rename = "nextToken")]
2138    #[serde(default)]
2139    #[serde(skip_serializing_if = "Option::is_none")]
2140    pub next_token: Option<String>,
2141}
2142
2143#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2144pub struct ListFunctionsRequest {
2145    #[serde(rename = "apiId")]
2146    #[serde(default)]
2147    pub api_id: String,
2148    #[serde(rename = "maxResults")]
2149    #[serde(default)]
2150    #[serde(skip_serializing_if = "Option::is_none")]
2151    pub max_results: Option<i32>,
2152    #[serde(rename = "nextToken")]
2153    #[serde(default)]
2154    #[serde(skip_serializing_if = "Option::is_none")]
2155    pub next_token: Option<String>,
2156}
2157
2158#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2159pub struct ListFunctionsResponse {
2160    #[serde(default)]
2161    #[serde(skip_serializing_if = "Option::is_none")]
2162    pub functions: Option<Vec<FunctionConfiguration>>,
2163    #[serde(rename = "nextToken")]
2164    #[serde(default)]
2165    #[serde(skip_serializing_if = "Option::is_none")]
2166    pub next_token: Option<String>,
2167}
2168
2169#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2170pub struct ListGraphqlApisRequest {
2171    #[serde(rename = "apiType")]
2172    #[serde(default)]
2173    #[serde(skip_serializing_if = "Option::is_none")]
2174    pub api_type: Option<String>,
2175    #[serde(rename = "maxResults")]
2176    #[serde(default)]
2177    #[serde(skip_serializing_if = "Option::is_none")]
2178    pub max_results: Option<i32>,
2179    #[serde(rename = "nextToken")]
2180    #[serde(default)]
2181    #[serde(skip_serializing_if = "Option::is_none")]
2182    pub next_token: Option<String>,
2183    #[serde(default)]
2184    #[serde(skip_serializing_if = "Option::is_none")]
2185    pub owner: Option<String>,
2186}
2187
2188#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2189pub struct ListGraphqlApisResponse {
2190    #[serde(rename = "graphqlApis")]
2191    #[serde(default)]
2192    #[serde(skip_serializing_if = "Option::is_none")]
2193    pub graphql_apis: Option<Vec<GraphqlApi>>,
2194    #[serde(rename = "nextToken")]
2195    #[serde(default)]
2196    #[serde(skip_serializing_if = "Option::is_none")]
2197    pub next_token: Option<String>,
2198}
2199
2200#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2201pub struct ListResolversByFunctionRequest {
2202    #[serde(rename = "apiId")]
2203    #[serde(default)]
2204    pub api_id: String,
2205    #[serde(rename = "functionId")]
2206    #[serde(default)]
2207    pub function_id: String,
2208    #[serde(rename = "maxResults")]
2209    #[serde(default)]
2210    #[serde(skip_serializing_if = "Option::is_none")]
2211    pub max_results: Option<i32>,
2212    #[serde(rename = "nextToken")]
2213    #[serde(default)]
2214    #[serde(skip_serializing_if = "Option::is_none")]
2215    pub next_token: Option<String>,
2216}
2217
2218#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2219pub struct ListResolversByFunctionResponse {
2220    #[serde(rename = "nextToken")]
2221    #[serde(default)]
2222    #[serde(skip_serializing_if = "Option::is_none")]
2223    pub next_token: Option<String>,
2224    #[serde(default)]
2225    #[serde(skip_serializing_if = "Option::is_none")]
2226    pub resolvers: Option<Vec<Resolver>>,
2227}
2228
2229#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2230pub struct ListResolversRequest {
2231    #[serde(rename = "apiId")]
2232    #[serde(default)]
2233    pub api_id: String,
2234    #[serde(rename = "maxResults")]
2235    #[serde(default)]
2236    #[serde(skip_serializing_if = "Option::is_none")]
2237    pub max_results: Option<i32>,
2238    #[serde(rename = "nextToken")]
2239    #[serde(default)]
2240    #[serde(skip_serializing_if = "Option::is_none")]
2241    pub next_token: Option<String>,
2242    #[serde(rename = "typeName")]
2243    #[serde(default)]
2244    pub type_name: String,
2245}
2246
2247#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2248pub struct ListResolversResponse {
2249    #[serde(rename = "nextToken")]
2250    #[serde(default)]
2251    #[serde(skip_serializing_if = "Option::is_none")]
2252    pub next_token: Option<String>,
2253    #[serde(default)]
2254    #[serde(skip_serializing_if = "Option::is_none")]
2255    pub resolvers: Option<Vec<Resolver>>,
2256}
2257
2258#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2259pub struct ListSourceApiAssociationsRequest {
2260    #[serde(rename = "apiId")]
2261    #[serde(default)]
2262    pub api_id: String,
2263    #[serde(rename = "maxResults")]
2264    #[serde(default)]
2265    #[serde(skip_serializing_if = "Option::is_none")]
2266    pub max_results: Option<i32>,
2267    #[serde(rename = "nextToken")]
2268    #[serde(default)]
2269    #[serde(skip_serializing_if = "Option::is_none")]
2270    pub next_token: Option<String>,
2271}
2272
2273#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2274pub struct ListSourceApiAssociationsResponse {
2275    #[serde(rename = "nextToken")]
2276    #[serde(default)]
2277    #[serde(skip_serializing_if = "Option::is_none")]
2278    pub next_token: Option<String>,
2279    #[serde(rename = "sourceApiAssociationSummaries")]
2280    #[serde(default)]
2281    #[serde(skip_serializing_if = "Option::is_none")]
2282    pub source_api_association_summaries: Option<Vec<SourceApiAssociationSummary>>,
2283}
2284
2285#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2286pub struct SourceApiAssociationSummary {
2287    #[serde(rename = "associationArn")]
2288    #[serde(default)]
2289    #[serde(skip_serializing_if = "Option::is_none")]
2290    pub association_arn: Option<String>,
2291    #[serde(rename = "associationId")]
2292    #[serde(default)]
2293    #[serde(skip_serializing_if = "Option::is_none")]
2294    pub association_id: Option<String>,
2295    #[serde(default)]
2296    #[serde(skip_serializing_if = "Option::is_none")]
2297    pub description: Option<String>,
2298    #[serde(rename = "mergedApiArn")]
2299    #[serde(default)]
2300    #[serde(skip_serializing_if = "Option::is_none")]
2301    pub merged_api_arn: Option<String>,
2302    #[serde(rename = "mergedApiId")]
2303    #[serde(default)]
2304    #[serde(skip_serializing_if = "Option::is_none")]
2305    pub merged_api_id: Option<String>,
2306    #[serde(rename = "sourceApiArn")]
2307    #[serde(default)]
2308    #[serde(skip_serializing_if = "Option::is_none")]
2309    pub source_api_arn: Option<String>,
2310    #[serde(rename = "sourceApiId")]
2311    #[serde(default)]
2312    #[serde(skip_serializing_if = "Option::is_none")]
2313    pub source_api_id: Option<String>,
2314}
2315
2316#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2317pub struct ListTagsForResourceRequest {
2318    #[serde(rename = "resourceArn")]
2319    #[serde(default)]
2320    pub resource_arn: String,
2321}
2322
2323#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2324pub struct ListTagsForResourceResponse {
2325    #[serde(default)]
2326    #[serde(skip_serializing_if = "Option::is_none")]
2327    pub tags: Option<std::collections::HashMap<String, String>>,
2328}
2329
2330#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2331pub struct ListTypesByAssociationRequest {
2332    #[serde(rename = "associationId")]
2333    #[serde(default)]
2334    pub association_id: String,
2335    #[serde(default)]
2336    pub format: String,
2337    #[serde(rename = "maxResults")]
2338    #[serde(default)]
2339    #[serde(skip_serializing_if = "Option::is_none")]
2340    pub max_results: Option<i32>,
2341    #[serde(rename = "mergedApiIdentifier")]
2342    #[serde(default)]
2343    pub merged_api_identifier: String,
2344    #[serde(rename = "nextToken")]
2345    #[serde(default)]
2346    #[serde(skip_serializing_if = "Option::is_none")]
2347    pub next_token: Option<String>,
2348}
2349
2350#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2351pub struct ListTypesByAssociationResponse {
2352    #[serde(rename = "nextToken")]
2353    #[serde(default)]
2354    #[serde(skip_serializing_if = "Option::is_none")]
2355    pub next_token: Option<String>,
2356    #[serde(default)]
2357    #[serde(skip_serializing_if = "Option::is_none")]
2358    pub types: Option<Vec<Type>>,
2359}
2360
2361#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2362pub struct ListTypesRequest {
2363    #[serde(rename = "apiId")]
2364    #[serde(default)]
2365    pub api_id: String,
2366    #[serde(default)]
2367    pub format: String,
2368    #[serde(rename = "maxResults")]
2369    #[serde(default)]
2370    #[serde(skip_serializing_if = "Option::is_none")]
2371    pub max_results: Option<i32>,
2372    #[serde(rename = "nextToken")]
2373    #[serde(default)]
2374    #[serde(skip_serializing_if = "Option::is_none")]
2375    pub next_token: Option<String>,
2376}
2377
2378#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2379pub struct ListTypesResponse {
2380    #[serde(rename = "nextToken")]
2381    #[serde(default)]
2382    #[serde(skip_serializing_if = "Option::is_none")]
2383    pub next_token: Option<String>,
2384    #[serde(default)]
2385    #[serde(skip_serializing_if = "Option::is_none")]
2386    pub types: Option<Vec<Type>>,
2387}
2388
2389#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2390pub struct PutGraphqlApiEnvironmentVariablesRequest {
2391    #[serde(rename = "apiId")]
2392    #[serde(default)]
2393    pub api_id: String,
2394    #[serde(rename = "environmentVariables")]
2395    #[serde(default)]
2396    pub environment_variables: std::collections::HashMap<String, String>,
2397}
2398
2399#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2400pub struct PutGraphqlApiEnvironmentVariablesResponse {
2401    #[serde(rename = "environmentVariables")]
2402    #[serde(default)]
2403    #[serde(skip_serializing_if = "Option::is_none")]
2404    pub environment_variables: Option<std::collections::HashMap<String, String>>,
2405}
2406
2407#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2408pub struct StartDataSourceIntrospectionRequest {
2409    #[serde(rename = "rdsDataApiConfig")]
2410    #[serde(default)]
2411    #[serde(skip_serializing_if = "Option::is_none")]
2412    pub rds_data_api_config: Option<RdsDataApiConfig>,
2413}
2414
2415#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2416pub struct RdsDataApiConfig {
2417    #[serde(rename = "databaseName")]
2418    #[serde(default)]
2419    pub database_name: String,
2420    #[serde(rename = "resourceArn")]
2421    #[serde(default)]
2422    pub resource_arn: String,
2423    #[serde(rename = "secretArn")]
2424    #[serde(default)]
2425    pub secret_arn: String,
2426}
2427
2428#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2429pub struct StartDataSourceIntrospectionResponse {
2430    #[serde(rename = "introspectionId")]
2431    #[serde(default)]
2432    #[serde(skip_serializing_if = "Option::is_none")]
2433    pub introspection_id: Option<String>,
2434    #[serde(rename = "introspectionStatus")]
2435    #[serde(default)]
2436    #[serde(skip_serializing_if = "Option::is_none")]
2437    pub introspection_status: Option<String>,
2438    #[serde(rename = "introspectionStatusDetail")]
2439    #[serde(default)]
2440    #[serde(skip_serializing_if = "Option::is_none")]
2441    pub introspection_status_detail: Option<String>,
2442}
2443
2444#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2445pub struct StartSchemaCreationRequest {
2446    #[serde(rename = "apiId")]
2447    #[serde(default)]
2448    pub api_id: String,
2449    #[serde(default)]
2450    pub definition: String,
2451}
2452
2453#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2454pub struct StartSchemaCreationResponse {
2455    #[serde(default)]
2456    #[serde(skip_serializing_if = "Option::is_none")]
2457    pub status: Option<String>,
2458}
2459
2460#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2461pub struct StartSchemaMergeRequest {
2462    #[serde(rename = "associationId")]
2463    #[serde(default)]
2464    pub association_id: String,
2465    #[serde(rename = "mergedApiIdentifier")]
2466    #[serde(default)]
2467    pub merged_api_identifier: String,
2468}
2469
2470#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2471pub struct StartSchemaMergeResponse {
2472    #[serde(rename = "sourceApiAssociationStatus")]
2473    #[serde(default)]
2474    #[serde(skip_serializing_if = "Option::is_none")]
2475    pub source_api_association_status: Option<String>,
2476}
2477
2478#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2479pub struct TagResourceRequest {
2480    #[serde(rename = "resourceArn")]
2481    #[serde(default)]
2482    pub resource_arn: String,
2483    #[serde(default)]
2484    pub tags: std::collections::HashMap<String, String>,
2485}
2486
2487#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2488pub struct TagResourceResponse {}
2489
2490#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2491pub struct UntagResourceRequest {
2492    #[serde(rename = "resourceArn")]
2493    #[serde(default)]
2494    pub resource_arn: String,
2495    #[serde(rename = "tagKeys")]
2496    #[serde(default)]
2497    pub tag_keys: Vec<String>,
2498}
2499
2500#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2501pub struct UntagResourceResponse {}
2502
2503#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2504pub struct UpdateApiCacheRequest {
2505    #[serde(rename = "apiCachingBehavior")]
2506    #[serde(default)]
2507    pub api_caching_behavior: String,
2508    #[serde(rename = "apiId")]
2509    #[serde(default)]
2510    pub api_id: String,
2511    #[serde(rename = "healthMetricsConfig")]
2512    #[serde(default)]
2513    #[serde(skip_serializing_if = "Option::is_none")]
2514    pub health_metrics_config: Option<String>,
2515    #[serde(default)]
2516    pub ttl: i64,
2517    #[serde(rename = "type")]
2518    #[serde(default)]
2519    pub r#type: String,
2520}
2521
2522#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2523pub struct UpdateApiCacheResponse {
2524    #[serde(rename = "apiCache")]
2525    #[serde(default)]
2526    #[serde(skip_serializing_if = "Option::is_none")]
2527    pub api_cache: Option<ApiCache>,
2528}
2529
2530#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2531pub struct UpdateApiKeyRequest {
2532    #[serde(rename = "apiId")]
2533    #[serde(default)]
2534    pub api_id: String,
2535    #[serde(default)]
2536    #[serde(skip_serializing_if = "Option::is_none")]
2537    pub description: Option<String>,
2538    #[serde(default)]
2539    #[serde(skip_serializing_if = "Option::is_none")]
2540    pub expires: Option<i64>,
2541    #[serde(default)]
2542    pub id: String,
2543}
2544
2545#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2546pub struct UpdateApiKeyResponse {
2547    #[serde(rename = "apiKey")]
2548    #[serde(default)]
2549    #[serde(skip_serializing_if = "Option::is_none")]
2550    pub api_key: Option<ApiKey>,
2551}
2552
2553#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2554pub struct UpdateApiRequest {
2555    #[serde(rename = "apiId")]
2556    #[serde(default)]
2557    pub api_id: String,
2558    #[serde(rename = "eventConfig")]
2559    #[serde(default)]
2560    pub event_config: EventConfig,
2561    #[serde(default)]
2562    pub name: String,
2563    #[serde(rename = "ownerContact")]
2564    #[serde(default)]
2565    #[serde(skip_serializing_if = "Option::is_none")]
2566    pub owner_contact: Option<String>,
2567}
2568
2569#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2570pub struct UpdateApiResponse {
2571    #[serde(default)]
2572    #[serde(skip_serializing_if = "Option::is_none")]
2573    pub api: Option<Api>,
2574}
2575
2576#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2577pub struct UpdateChannelNamespaceRequest {
2578    #[serde(rename = "apiId")]
2579    #[serde(default)]
2580    pub api_id: String,
2581    #[serde(rename = "codeHandlers")]
2582    #[serde(default)]
2583    #[serde(skip_serializing_if = "Option::is_none")]
2584    pub code_handlers: Option<String>,
2585    #[serde(rename = "handlerConfigs")]
2586    #[serde(default)]
2587    #[serde(skip_serializing_if = "Option::is_none")]
2588    pub handler_configs: Option<HandlerConfigs>,
2589    #[serde(default)]
2590    pub name: String,
2591    #[serde(rename = "publishAuthModes")]
2592    #[serde(default)]
2593    #[serde(skip_serializing_if = "Option::is_none")]
2594    pub publish_auth_modes: Option<Vec<AuthMode>>,
2595    #[serde(rename = "subscribeAuthModes")]
2596    #[serde(default)]
2597    #[serde(skip_serializing_if = "Option::is_none")]
2598    pub subscribe_auth_modes: Option<Vec<AuthMode>>,
2599}
2600
2601#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2602pub struct UpdateChannelNamespaceResponse {
2603    #[serde(rename = "channelNamespace")]
2604    #[serde(default)]
2605    #[serde(skip_serializing_if = "Option::is_none")]
2606    pub channel_namespace: Option<ChannelNamespace>,
2607}
2608
2609#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2610pub struct UpdateDataSourceRequest {
2611    #[serde(rename = "apiId")]
2612    #[serde(default)]
2613    pub api_id: String,
2614    #[serde(default)]
2615    #[serde(skip_serializing_if = "Option::is_none")]
2616    pub description: Option<String>,
2617    #[serde(rename = "dynamodbConfig")]
2618    #[serde(default)]
2619    #[serde(skip_serializing_if = "Option::is_none")]
2620    pub dynamodb_config: Option<DynamodbDataSourceConfig>,
2621    #[serde(rename = "elasticsearchConfig")]
2622    #[serde(default)]
2623    #[serde(skip_serializing_if = "Option::is_none")]
2624    pub elasticsearch_config: Option<ElasticsearchDataSourceConfig>,
2625    #[serde(rename = "eventBridgeConfig")]
2626    #[serde(default)]
2627    #[serde(skip_serializing_if = "Option::is_none")]
2628    pub event_bridge_config: Option<EventBridgeDataSourceConfig>,
2629    #[serde(rename = "httpConfig")]
2630    #[serde(default)]
2631    #[serde(skip_serializing_if = "Option::is_none")]
2632    pub http_config: Option<HttpDataSourceConfig>,
2633    #[serde(rename = "lambdaConfig")]
2634    #[serde(default)]
2635    #[serde(skip_serializing_if = "Option::is_none")]
2636    pub lambda_config: Option<LambdaDataSourceConfig>,
2637    #[serde(rename = "metricsConfig")]
2638    #[serde(default)]
2639    #[serde(skip_serializing_if = "Option::is_none")]
2640    pub metrics_config: Option<String>,
2641    #[serde(default)]
2642    pub name: String,
2643    #[serde(rename = "openSearchServiceConfig")]
2644    #[serde(default)]
2645    #[serde(skip_serializing_if = "Option::is_none")]
2646    pub open_search_service_config: Option<OpenSearchServiceDataSourceConfig>,
2647    #[serde(rename = "relationalDatabaseConfig")]
2648    #[serde(default)]
2649    #[serde(skip_serializing_if = "Option::is_none")]
2650    pub relational_database_config: Option<RelationalDatabaseDataSourceConfig>,
2651    #[serde(rename = "serviceRoleArn")]
2652    #[serde(default)]
2653    #[serde(skip_serializing_if = "Option::is_none")]
2654    pub service_role_arn: Option<String>,
2655    #[serde(rename = "type")]
2656    #[serde(default)]
2657    pub r#type: String,
2658}
2659
2660#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2661pub struct UpdateDataSourceResponse {
2662    #[serde(rename = "dataSource")]
2663    #[serde(default)]
2664    #[serde(skip_serializing_if = "Option::is_none")]
2665    pub data_source: Option<DataSource>,
2666}
2667
2668#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2669pub struct UpdateDomainNameRequest {
2670    #[serde(default)]
2671    #[serde(skip_serializing_if = "Option::is_none")]
2672    pub description: Option<String>,
2673    #[serde(rename = "domainName")]
2674    #[serde(default)]
2675    pub domain_name: String,
2676}
2677
2678#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2679pub struct UpdateDomainNameResponse {
2680    #[serde(rename = "domainNameConfig")]
2681    #[serde(default)]
2682    #[serde(skip_serializing_if = "Option::is_none")]
2683    pub domain_name_config: Option<DomainNameConfig>,
2684}
2685
2686#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2687pub struct UpdateFunctionRequest {
2688    #[serde(rename = "apiId")]
2689    #[serde(default)]
2690    pub api_id: String,
2691    #[serde(default)]
2692    #[serde(skip_serializing_if = "Option::is_none")]
2693    pub code: Option<String>,
2694    #[serde(rename = "dataSourceName")]
2695    #[serde(default)]
2696    pub data_source_name: String,
2697    #[serde(default)]
2698    #[serde(skip_serializing_if = "Option::is_none")]
2699    pub description: Option<String>,
2700    #[serde(rename = "functionId")]
2701    #[serde(default)]
2702    pub function_id: String,
2703    #[serde(rename = "functionVersion")]
2704    #[serde(default)]
2705    #[serde(skip_serializing_if = "Option::is_none")]
2706    pub function_version: Option<String>,
2707    #[serde(rename = "maxBatchSize")]
2708    #[serde(default)]
2709    #[serde(skip_serializing_if = "Option::is_none")]
2710    pub max_batch_size: Option<i32>,
2711    #[serde(default)]
2712    pub name: String,
2713    #[serde(rename = "requestMappingTemplate")]
2714    #[serde(default)]
2715    #[serde(skip_serializing_if = "Option::is_none")]
2716    pub request_mapping_template: Option<String>,
2717    #[serde(rename = "responseMappingTemplate")]
2718    #[serde(default)]
2719    #[serde(skip_serializing_if = "Option::is_none")]
2720    pub response_mapping_template: Option<String>,
2721    #[serde(default)]
2722    #[serde(skip_serializing_if = "Option::is_none")]
2723    pub runtime: Option<AppSyncRuntime>,
2724    #[serde(rename = "syncConfig")]
2725    #[serde(default)]
2726    #[serde(skip_serializing_if = "Option::is_none")]
2727    pub sync_config: Option<SyncConfig>,
2728}
2729
2730#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2731pub struct UpdateFunctionResponse {
2732    #[serde(rename = "functionConfiguration")]
2733    #[serde(default)]
2734    #[serde(skip_serializing_if = "Option::is_none")]
2735    pub function_configuration: Option<FunctionConfiguration>,
2736}
2737
2738#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2739pub struct UpdateGraphqlApiRequest {
2740    #[serde(rename = "additionalAuthenticationProviders")]
2741    #[serde(default)]
2742    #[serde(skip_serializing_if = "Option::is_none")]
2743    pub additional_authentication_providers: Option<Vec<AdditionalAuthenticationProvider>>,
2744    #[serde(rename = "apiId")]
2745    #[serde(default)]
2746    pub api_id: String,
2747    #[serde(rename = "authenticationType")]
2748    #[serde(default)]
2749    pub authentication_type: String,
2750    #[serde(rename = "enhancedMetricsConfig")]
2751    #[serde(default)]
2752    #[serde(skip_serializing_if = "Option::is_none")]
2753    pub enhanced_metrics_config: Option<EnhancedMetricsConfig>,
2754    #[serde(rename = "introspectionConfig")]
2755    #[serde(default)]
2756    #[serde(skip_serializing_if = "Option::is_none")]
2757    pub introspection_config: Option<String>,
2758    #[serde(rename = "lambdaAuthorizerConfig")]
2759    #[serde(default)]
2760    #[serde(skip_serializing_if = "Option::is_none")]
2761    pub lambda_authorizer_config: Option<LambdaAuthorizerConfig>,
2762    #[serde(rename = "logConfig")]
2763    #[serde(default)]
2764    #[serde(skip_serializing_if = "Option::is_none")]
2765    pub log_config: Option<LogConfig>,
2766    #[serde(rename = "mergedApiExecutionRoleArn")]
2767    #[serde(default)]
2768    #[serde(skip_serializing_if = "Option::is_none")]
2769    pub merged_api_execution_role_arn: Option<String>,
2770    #[serde(default)]
2771    pub name: String,
2772    #[serde(rename = "openIDConnectConfig")]
2773    #[serde(default)]
2774    #[serde(skip_serializing_if = "Option::is_none")]
2775    pub open_i_d_connect_config: Option<OpenIDConnectConfig>,
2776    #[serde(rename = "ownerContact")]
2777    #[serde(default)]
2778    #[serde(skip_serializing_if = "Option::is_none")]
2779    pub owner_contact: Option<String>,
2780    #[serde(rename = "queryDepthLimit")]
2781    #[serde(default)]
2782    #[serde(skip_serializing_if = "Option::is_none")]
2783    pub query_depth_limit: Option<i32>,
2784    #[serde(rename = "resolverCountLimit")]
2785    #[serde(default)]
2786    #[serde(skip_serializing_if = "Option::is_none")]
2787    pub resolver_count_limit: Option<i32>,
2788    #[serde(rename = "userPoolConfig")]
2789    #[serde(default)]
2790    #[serde(skip_serializing_if = "Option::is_none")]
2791    pub user_pool_config: Option<UserPoolConfig>,
2792    #[serde(rename = "xrayEnabled")]
2793    #[serde(default)]
2794    #[serde(skip_serializing_if = "Option::is_none")]
2795    pub xray_enabled: Option<bool>,
2796}
2797
2798#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2799pub struct UpdateGraphqlApiResponse {
2800    #[serde(rename = "graphqlApi")]
2801    #[serde(default)]
2802    #[serde(skip_serializing_if = "Option::is_none")]
2803    pub graphql_api: Option<GraphqlApi>,
2804}
2805
2806#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2807pub struct UpdateResolverRequest {
2808    #[serde(rename = "apiId")]
2809    #[serde(default)]
2810    pub api_id: String,
2811    #[serde(rename = "cachingConfig")]
2812    #[serde(default)]
2813    #[serde(skip_serializing_if = "Option::is_none")]
2814    pub caching_config: Option<CachingConfig>,
2815    #[serde(default)]
2816    #[serde(skip_serializing_if = "Option::is_none")]
2817    pub code: Option<String>,
2818    #[serde(rename = "dataSourceName")]
2819    #[serde(default)]
2820    #[serde(skip_serializing_if = "Option::is_none")]
2821    pub data_source_name: Option<String>,
2822    #[serde(rename = "fieldName")]
2823    #[serde(default)]
2824    pub field_name: String,
2825    #[serde(default)]
2826    #[serde(skip_serializing_if = "Option::is_none")]
2827    pub kind: Option<String>,
2828    #[serde(rename = "maxBatchSize")]
2829    #[serde(default)]
2830    #[serde(skip_serializing_if = "Option::is_none")]
2831    pub max_batch_size: Option<i32>,
2832    #[serde(rename = "metricsConfig")]
2833    #[serde(default)]
2834    #[serde(skip_serializing_if = "Option::is_none")]
2835    pub metrics_config: Option<String>,
2836    #[serde(rename = "pipelineConfig")]
2837    #[serde(default)]
2838    #[serde(skip_serializing_if = "Option::is_none")]
2839    pub pipeline_config: Option<PipelineConfig>,
2840    #[serde(rename = "requestMappingTemplate")]
2841    #[serde(default)]
2842    #[serde(skip_serializing_if = "Option::is_none")]
2843    pub request_mapping_template: Option<String>,
2844    #[serde(rename = "responseMappingTemplate")]
2845    #[serde(default)]
2846    #[serde(skip_serializing_if = "Option::is_none")]
2847    pub response_mapping_template: Option<String>,
2848    #[serde(default)]
2849    #[serde(skip_serializing_if = "Option::is_none")]
2850    pub runtime: Option<AppSyncRuntime>,
2851    #[serde(rename = "syncConfig")]
2852    #[serde(default)]
2853    #[serde(skip_serializing_if = "Option::is_none")]
2854    pub sync_config: Option<SyncConfig>,
2855    #[serde(rename = "typeName")]
2856    #[serde(default)]
2857    pub type_name: String,
2858}
2859
2860#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2861pub struct UpdateResolverResponse {
2862    #[serde(default)]
2863    #[serde(skip_serializing_if = "Option::is_none")]
2864    pub resolver: Option<Resolver>,
2865}
2866
2867#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2868pub struct UpdateSourceApiAssociationRequest {
2869    #[serde(rename = "associationId")]
2870    #[serde(default)]
2871    pub association_id: String,
2872    #[serde(default)]
2873    #[serde(skip_serializing_if = "Option::is_none")]
2874    pub description: Option<String>,
2875    #[serde(rename = "mergedApiIdentifier")]
2876    #[serde(default)]
2877    pub merged_api_identifier: String,
2878    #[serde(rename = "sourceApiAssociationConfig")]
2879    #[serde(default)]
2880    #[serde(skip_serializing_if = "Option::is_none")]
2881    pub source_api_association_config: Option<SourceApiAssociationConfig>,
2882}
2883
2884#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2885pub struct UpdateSourceApiAssociationResponse {
2886    #[serde(rename = "sourceApiAssociation")]
2887    #[serde(default)]
2888    #[serde(skip_serializing_if = "Option::is_none")]
2889    pub source_api_association: Option<SourceApiAssociation>,
2890}
2891
2892#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2893pub struct UpdateTypeRequest {
2894    #[serde(rename = "apiId")]
2895    #[serde(default)]
2896    pub api_id: String,
2897    #[serde(default)]
2898    #[serde(skip_serializing_if = "Option::is_none")]
2899    pub definition: Option<String>,
2900    #[serde(default)]
2901    pub format: String,
2902    #[serde(rename = "typeName")]
2903    #[serde(default)]
2904    pub type_name: String,
2905}
2906
2907#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2908pub struct UpdateTypeResponse {
2909    #[serde(rename = "type")]
2910    #[serde(default)]
2911    #[serde(skip_serializing_if = "Option::is_none")]
2912    pub r#type: Option<Type>,
2913}