Skip to main content

aws_sdk_sts/config/
endpoint.rs

1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2pub use ::aws_smithy_runtime_api::client::endpoint::EndpointFuture;
3pub use ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver;
4pub use ::aws_smithy_types::endpoint::Endpoint;
5
6/// Interceptor that tracks endpoint override business metric.
7#[derive(Debug, Default)]
8pub(crate) struct EndpointOverrideFeatureTrackerInterceptor;
9
10#[::aws_smithy_runtime_api::client::interceptors::dyn_dispatch_hint]
11impl ::aws_smithy_runtime_api::client::interceptors::Intercept for EndpointOverrideFeatureTrackerInterceptor {
12    fn name(&self) -> &'static str {
13        "EndpointOverrideFeatureTrackerInterceptor"
14    }
15
16    fn read_before_execution(
17        &self,
18        _context: &::aws_smithy_runtime_api::client::interceptors::context::BeforeSerializationInterceptorContextRef<'_>,
19        cfg: &mut ::aws_smithy_types::config_bag::ConfigBag,
20    ) -> ::std::result::Result<(), ::aws_smithy_runtime_api::box_error::BoxError> {
21        if cfg.load::<::aws_types::endpoint_config::EndpointUrl>().is_some() {
22            cfg.interceptor_state()
23                .store_append(::aws_runtime::sdk_feature::AwsSdkFeature::EndpointOverride);
24        }
25        ::std::result::Result::Ok(())
26    }
27}
28
29#[cfg(test)]
30mod test {
31
32    /// For region af-south-1 with FIPS disabled and DualStack disabled
33    #[test]
34    fn test_1() {
35        let params = crate::config::endpoint::Params::builder()
36            .region("af-south-1".to_string())
37            .use_fips(false)
38            .use_dual_stack(false)
39            .build()
40            .expect("invalid params");
41        let resolver = crate::config::endpoint::DefaultResolver::new();
42        let endpoint = resolver.resolve_endpoint(&params);
43        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.af-south-1.amazonaws.com");
44        assert_eq!(
45            endpoint,
46            ::aws_smithy_types::endpoint::Endpoint::builder()
47                .url("https://sts.af-south-1.amazonaws.com")
48                .build()
49        );
50    }
51
52    /// For region ap-east-1 with FIPS disabled and DualStack disabled
53    #[test]
54    fn test_2() {
55        let params = crate::config::endpoint::Params::builder()
56            .region("ap-east-1".to_string())
57            .use_fips(false)
58            .use_dual_stack(false)
59            .build()
60            .expect("invalid params");
61        let resolver = crate::config::endpoint::DefaultResolver::new();
62        let endpoint = resolver.resolve_endpoint(&params);
63        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-east-1.amazonaws.com");
64        assert_eq!(
65            endpoint,
66            ::aws_smithy_types::endpoint::Endpoint::builder()
67                .url("https://sts.ap-east-1.amazonaws.com")
68                .build()
69        );
70    }
71
72    /// For region ap-northeast-1 with FIPS disabled and DualStack disabled
73    #[test]
74    fn test_3() {
75        let params = crate::config::endpoint::Params::builder()
76            .region("ap-northeast-1".to_string())
77            .use_fips(false)
78            .use_dual_stack(false)
79            .build()
80            .expect("invalid params");
81        let resolver = crate::config::endpoint::DefaultResolver::new();
82        let endpoint = resolver.resolve_endpoint(&params);
83        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-northeast-1.amazonaws.com");
84        assert_eq!(
85            endpoint,
86            ::aws_smithy_types::endpoint::Endpoint::builder()
87                .url("https://sts.ap-northeast-1.amazonaws.com")
88                .build()
89        );
90    }
91
92    /// For region ap-northeast-2 with FIPS disabled and DualStack disabled
93    #[test]
94    fn test_4() {
95        let params = crate::config::endpoint::Params::builder()
96            .region("ap-northeast-2".to_string())
97            .use_fips(false)
98            .use_dual_stack(false)
99            .build()
100            .expect("invalid params");
101        let resolver = crate::config::endpoint::DefaultResolver::new();
102        let endpoint = resolver.resolve_endpoint(&params);
103        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-northeast-2.amazonaws.com");
104        assert_eq!(
105            endpoint,
106            ::aws_smithy_types::endpoint::Endpoint::builder()
107                .url("https://sts.ap-northeast-2.amazonaws.com")
108                .build()
109        );
110    }
111
112    /// For region ap-northeast-3 with FIPS disabled and DualStack disabled
113    #[test]
114    fn test_5() {
115        let params = crate::config::endpoint::Params::builder()
116            .region("ap-northeast-3".to_string())
117            .use_fips(false)
118            .use_dual_stack(false)
119            .build()
120            .expect("invalid params");
121        let resolver = crate::config::endpoint::DefaultResolver::new();
122        let endpoint = resolver.resolve_endpoint(&params);
123        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-northeast-3.amazonaws.com");
124        assert_eq!(
125            endpoint,
126            ::aws_smithy_types::endpoint::Endpoint::builder()
127                .url("https://sts.ap-northeast-3.amazonaws.com")
128                .build()
129        );
130    }
131
132    /// For region ap-south-1 with FIPS disabled and DualStack disabled
133    #[test]
134    fn test_6() {
135        let params = crate::config::endpoint::Params::builder()
136            .region("ap-south-1".to_string())
137            .use_fips(false)
138            .use_dual_stack(false)
139            .build()
140            .expect("invalid params");
141        let resolver = crate::config::endpoint::DefaultResolver::new();
142        let endpoint = resolver.resolve_endpoint(&params);
143        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-south-1.amazonaws.com");
144        assert_eq!(
145            endpoint,
146            ::aws_smithy_types::endpoint::Endpoint::builder()
147                .url("https://sts.ap-south-1.amazonaws.com")
148                .build()
149        );
150    }
151
152    /// For region ap-southeast-1 with FIPS disabled and DualStack disabled
153    #[test]
154    fn test_7() {
155        let params = crate::config::endpoint::Params::builder()
156            .region("ap-southeast-1".to_string())
157            .use_fips(false)
158            .use_dual_stack(false)
159            .build()
160            .expect("invalid params");
161        let resolver = crate::config::endpoint::DefaultResolver::new();
162        let endpoint = resolver.resolve_endpoint(&params);
163        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-southeast-1.amazonaws.com");
164        assert_eq!(
165            endpoint,
166            ::aws_smithy_types::endpoint::Endpoint::builder()
167                .url("https://sts.ap-southeast-1.amazonaws.com")
168                .build()
169        );
170    }
171
172    /// For region ap-southeast-2 with FIPS disabled and DualStack disabled
173    #[test]
174    fn test_8() {
175        let params = crate::config::endpoint::Params::builder()
176            .region("ap-southeast-2".to_string())
177            .use_fips(false)
178            .use_dual_stack(false)
179            .build()
180            .expect("invalid params");
181        let resolver = crate::config::endpoint::DefaultResolver::new();
182        let endpoint = resolver.resolve_endpoint(&params);
183        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-southeast-2.amazonaws.com");
184        assert_eq!(
185            endpoint,
186            ::aws_smithy_types::endpoint::Endpoint::builder()
187                .url("https://sts.ap-southeast-2.amazonaws.com")
188                .build()
189        );
190    }
191
192    /// For region ap-southeast-3 with FIPS disabled and DualStack disabled
193    #[test]
194    fn test_9() {
195        let params = crate::config::endpoint::Params::builder()
196            .region("ap-southeast-3".to_string())
197            .use_fips(false)
198            .use_dual_stack(false)
199            .build()
200            .expect("invalid params");
201        let resolver = crate::config::endpoint::DefaultResolver::new();
202        let endpoint = resolver.resolve_endpoint(&params);
203        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ap-southeast-3.amazonaws.com");
204        assert_eq!(
205            endpoint,
206            ::aws_smithy_types::endpoint::Endpoint::builder()
207                .url("https://sts.ap-southeast-3.amazonaws.com")
208                .build()
209        );
210    }
211
212    /// For region aws-global with FIPS disabled and DualStack disabled
213    #[test]
214    fn test_10() {
215        let params = crate::config::endpoint::Params::builder()
216            .region("aws-global".to_string())
217            .use_fips(false)
218            .use_dual_stack(false)
219            .build()
220            .expect("invalid params");
221        let resolver = crate::config::endpoint::DefaultResolver::new();
222        let endpoint = resolver.resolve_endpoint(&params);
223        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
224        assert_eq!(
225            endpoint,
226            ::aws_smithy_types::endpoint::Endpoint::builder()
227                .url("https://sts.amazonaws.com")
228                .auth_scheme(
229                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
230                        .put("signingName", "sts".to_string())
231                        .put("signingRegion", "us-east-1".to_string())
232                )
233                .build()
234        );
235    }
236
237    /// For region ca-central-1 with FIPS disabled and DualStack disabled
238    #[test]
239    fn test_11() {
240        let params = crate::config::endpoint::Params::builder()
241            .region("ca-central-1".to_string())
242            .use_fips(false)
243            .use_dual_stack(false)
244            .build()
245            .expect("invalid params");
246        let resolver = crate::config::endpoint::DefaultResolver::new();
247        let endpoint = resolver.resolve_endpoint(&params);
248        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.ca-central-1.amazonaws.com");
249        assert_eq!(
250            endpoint,
251            ::aws_smithy_types::endpoint::Endpoint::builder()
252                .url("https://sts.ca-central-1.amazonaws.com")
253                .build()
254        );
255    }
256
257    /// For region eu-central-1 with FIPS disabled and DualStack disabled
258    #[test]
259    fn test_12() {
260        let params = crate::config::endpoint::Params::builder()
261            .region("eu-central-1".to_string())
262            .use_fips(false)
263            .use_dual_stack(false)
264            .build()
265            .expect("invalid params");
266        let resolver = crate::config::endpoint::DefaultResolver::new();
267        let endpoint = resolver.resolve_endpoint(&params);
268        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.eu-central-1.amazonaws.com");
269        assert_eq!(
270            endpoint,
271            ::aws_smithy_types::endpoint::Endpoint::builder()
272                .url("https://sts.eu-central-1.amazonaws.com")
273                .build()
274        );
275    }
276
277    /// For region eu-north-1 with FIPS disabled and DualStack disabled
278    #[test]
279    fn test_13() {
280        let params = crate::config::endpoint::Params::builder()
281            .region("eu-north-1".to_string())
282            .use_fips(false)
283            .use_dual_stack(false)
284            .build()
285            .expect("invalid params");
286        let resolver = crate::config::endpoint::DefaultResolver::new();
287        let endpoint = resolver.resolve_endpoint(&params);
288        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.eu-north-1.amazonaws.com");
289        assert_eq!(
290            endpoint,
291            ::aws_smithy_types::endpoint::Endpoint::builder()
292                .url("https://sts.eu-north-1.amazonaws.com")
293                .build()
294        );
295    }
296
297    /// For region eu-south-1 with FIPS disabled and DualStack disabled
298    #[test]
299    fn test_14() {
300        let params = crate::config::endpoint::Params::builder()
301            .region("eu-south-1".to_string())
302            .use_fips(false)
303            .use_dual_stack(false)
304            .build()
305            .expect("invalid params");
306        let resolver = crate::config::endpoint::DefaultResolver::new();
307        let endpoint = resolver.resolve_endpoint(&params);
308        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.eu-south-1.amazonaws.com");
309        assert_eq!(
310            endpoint,
311            ::aws_smithy_types::endpoint::Endpoint::builder()
312                .url("https://sts.eu-south-1.amazonaws.com")
313                .build()
314        );
315    }
316
317    /// For region eu-west-1 with FIPS disabled and DualStack disabled
318    #[test]
319    fn test_15() {
320        let params = crate::config::endpoint::Params::builder()
321            .region("eu-west-1".to_string())
322            .use_fips(false)
323            .use_dual_stack(false)
324            .build()
325            .expect("invalid params");
326        let resolver = crate::config::endpoint::DefaultResolver::new();
327        let endpoint = resolver.resolve_endpoint(&params);
328        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.eu-west-1.amazonaws.com");
329        assert_eq!(
330            endpoint,
331            ::aws_smithy_types::endpoint::Endpoint::builder()
332                .url("https://sts.eu-west-1.amazonaws.com")
333                .build()
334        );
335    }
336
337    /// For region eu-west-2 with FIPS disabled and DualStack disabled
338    #[test]
339    fn test_16() {
340        let params = crate::config::endpoint::Params::builder()
341            .region("eu-west-2".to_string())
342            .use_fips(false)
343            .use_dual_stack(false)
344            .build()
345            .expect("invalid params");
346        let resolver = crate::config::endpoint::DefaultResolver::new();
347        let endpoint = resolver.resolve_endpoint(&params);
348        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.eu-west-2.amazonaws.com");
349        assert_eq!(
350            endpoint,
351            ::aws_smithy_types::endpoint::Endpoint::builder()
352                .url("https://sts.eu-west-2.amazonaws.com")
353                .build()
354        );
355    }
356
357    /// For region eu-west-3 with FIPS disabled and DualStack disabled
358    #[test]
359    fn test_17() {
360        let params = crate::config::endpoint::Params::builder()
361            .region("eu-west-3".to_string())
362            .use_fips(false)
363            .use_dual_stack(false)
364            .build()
365            .expect("invalid params");
366        let resolver = crate::config::endpoint::DefaultResolver::new();
367        let endpoint = resolver.resolve_endpoint(&params);
368        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.eu-west-3.amazonaws.com");
369        assert_eq!(
370            endpoint,
371            ::aws_smithy_types::endpoint::Endpoint::builder()
372                .url("https://sts.eu-west-3.amazonaws.com")
373                .build()
374        );
375    }
376
377    /// For region me-south-1 with FIPS disabled and DualStack disabled
378    #[test]
379    fn test_18() {
380        let params = crate::config::endpoint::Params::builder()
381            .region("me-south-1".to_string())
382            .use_fips(false)
383            .use_dual_stack(false)
384            .build()
385            .expect("invalid params");
386        let resolver = crate::config::endpoint::DefaultResolver::new();
387        let endpoint = resolver.resolve_endpoint(&params);
388        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.me-south-1.amazonaws.com");
389        assert_eq!(
390            endpoint,
391            ::aws_smithy_types::endpoint::Endpoint::builder()
392                .url("https://sts.me-south-1.amazonaws.com")
393                .build()
394        );
395    }
396
397    /// For region sa-east-1 with FIPS disabled and DualStack disabled
398    #[test]
399    fn test_19() {
400        let params = crate::config::endpoint::Params::builder()
401            .region("sa-east-1".to_string())
402            .use_fips(false)
403            .use_dual_stack(false)
404            .build()
405            .expect("invalid params");
406        let resolver = crate::config::endpoint::DefaultResolver::new();
407        let endpoint = resolver.resolve_endpoint(&params);
408        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.sa-east-1.amazonaws.com");
409        assert_eq!(
410            endpoint,
411            ::aws_smithy_types::endpoint::Endpoint::builder()
412                .url("https://sts.sa-east-1.amazonaws.com")
413                .build()
414        );
415    }
416
417    /// For region us-east-1 with FIPS disabled and DualStack disabled
418    #[test]
419    fn test_20() {
420        let params = crate::config::endpoint::Params::builder()
421            .region("us-east-1".to_string())
422            .use_fips(false)
423            .use_dual_stack(false)
424            .build()
425            .expect("invalid params");
426        let resolver = crate::config::endpoint::DefaultResolver::new();
427        let endpoint = resolver.resolve_endpoint(&params);
428        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-east-1.amazonaws.com");
429        assert_eq!(
430            endpoint,
431            ::aws_smithy_types::endpoint::Endpoint::builder()
432                .url("https://sts.us-east-1.amazonaws.com")
433                .build()
434        );
435    }
436
437    /// For region us-east-1 with FIPS enabled and DualStack disabled
438    #[test]
439    fn test_21() {
440        let params = crate::config::endpoint::Params::builder()
441            .region("us-east-1".to_string())
442            .use_fips(true)
443            .use_dual_stack(false)
444            .build()
445            .expect("invalid params");
446        let resolver = crate::config::endpoint::DefaultResolver::new();
447        let endpoint = resolver.resolve_endpoint(&params);
448        let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-east-1.amazonaws.com");
449        assert_eq!(
450            endpoint,
451            ::aws_smithy_types::endpoint::Endpoint::builder()
452                .url("https://sts-fips.us-east-1.amazonaws.com")
453                .build()
454        );
455    }
456
457    /// For region us-east-2 with FIPS disabled and DualStack disabled
458    #[test]
459    fn test_22() {
460        let params = crate::config::endpoint::Params::builder()
461            .region("us-east-2".to_string())
462            .use_fips(false)
463            .use_dual_stack(false)
464            .build()
465            .expect("invalid params");
466        let resolver = crate::config::endpoint::DefaultResolver::new();
467        let endpoint = resolver.resolve_endpoint(&params);
468        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-east-2.amazonaws.com");
469        assert_eq!(
470            endpoint,
471            ::aws_smithy_types::endpoint::Endpoint::builder()
472                .url("https://sts.us-east-2.amazonaws.com")
473                .build()
474        );
475    }
476
477    /// For region us-east-2 with FIPS enabled and DualStack disabled
478    #[test]
479    fn test_23() {
480        let params = crate::config::endpoint::Params::builder()
481            .region("us-east-2".to_string())
482            .use_fips(true)
483            .use_dual_stack(false)
484            .build()
485            .expect("invalid params");
486        let resolver = crate::config::endpoint::DefaultResolver::new();
487        let endpoint = resolver.resolve_endpoint(&params);
488        let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-east-2.amazonaws.com");
489        assert_eq!(
490            endpoint,
491            ::aws_smithy_types::endpoint::Endpoint::builder()
492                .url("https://sts-fips.us-east-2.amazonaws.com")
493                .build()
494        );
495    }
496
497    /// For region us-west-1 with FIPS disabled and DualStack disabled
498    #[test]
499    fn test_24() {
500        let params = crate::config::endpoint::Params::builder()
501            .region("us-west-1".to_string())
502            .use_fips(false)
503            .use_dual_stack(false)
504            .build()
505            .expect("invalid params");
506        let resolver = crate::config::endpoint::DefaultResolver::new();
507        let endpoint = resolver.resolve_endpoint(&params);
508        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-west-1.amazonaws.com");
509        assert_eq!(
510            endpoint,
511            ::aws_smithy_types::endpoint::Endpoint::builder()
512                .url("https://sts.us-west-1.amazonaws.com")
513                .build()
514        );
515    }
516
517    /// For region us-west-1 with FIPS enabled and DualStack disabled
518    #[test]
519    fn test_25() {
520        let params = crate::config::endpoint::Params::builder()
521            .region("us-west-1".to_string())
522            .use_fips(true)
523            .use_dual_stack(false)
524            .build()
525            .expect("invalid params");
526        let resolver = crate::config::endpoint::DefaultResolver::new();
527        let endpoint = resolver.resolve_endpoint(&params);
528        let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-west-1.amazonaws.com");
529        assert_eq!(
530            endpoint,
531            ::aws_smithy_types::endpoint::Endpoint::builder()
532                .url("https://sts-fips.us-west-1.amazonaws.com")
533                .build()
534        );
535    }
536
537    /// For region us-west-2 with FIPS disabled and DualStack disabled
538    #[test]
539    fn test_26() {
540        let params = crate::config::endpoint::Params::builder()
541            .region("us-west-2".to_string())
542            .use_fips(false)
543            .use_dual_stack(false)
544            .build()
545            .expect("invalid params");
546        let resolver = crate::config::endpoint::DefaultResolver::new();
547        let endpoint = resolver.resolve_endpoint(&params);
548        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-west-2.amazonaws.com");
549        assert_eq!(
550            endpoint,
551            ::aws_smithy_types::endpoint::Endpoint::builder()
552                .url("https://sts.us-west-2.amazonaws.com")
553                .build()
554        );
555    }
556
557    /// For region us-west-2 with FIPS enabled and DualStack disabled
558    #[test]
559    fn test_27() {
560        let params = crate::config::endpoint::Params::builder()
561            .region("us-west-2".to_string())
562            .use_fips(true)
563            .use_dual_stack(false)
564            .build()
565            .expect("invalid params");
566        let resolver = crate::config::endpoint::DefaultResolver::new();
567        let endpoint = resolver.resolve_endpoint(&params);
568        let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-west-2.amazonaws.com");
569        assert_eq!(
570            endpoint,
571            ::aws_smithy_types::endpoint::Endpoint::builder()
572                .url("https://sts-fips.us-west-2.amazonaws.com")
573                .build()
574        );
575    }
576
577    /// For region us-east-1 with FIPS enabled and DualStack enabled
578    #[test]
579    fn test_28() {
580        let params = crate::config::endpoint::Params::builder()
581            .region("us-east-1".to_string())
582            .use_fips(true)
583            .use_dual_stack(true)
584            .build()
585            .expect("invalid params");
586        let resolver = crate::config::endpoint::DefaultResolver::new();
587        let endpoint = resolver.resolve_endpoint(&params);
588        let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-east-1.api.aws");
589        assert_eq!(
590            endpoint,
591            ::aws_smithy_types::endpoint::Endpoint::builder()
592                .url("https://sts-fips.us-east-1.api.aws")
593                .build()
594        );
595    }
596
597    /// For region us-east-1 with FIPS disabled and DualStack enabled
598    #[test]
599    fn test_29() {
600        let params = crate::config::endpoint::Params::builder()
601            .region("us-east-1".to_string())
602            .use_fips(false)
603            .use_dual_stack(true)
604            .build()
605            .expect("invalid params");
606        let resolver = crate::config::endpoint::DefaultResolver::new();
607        let endpoint = resolver.resolve_endpoint(&params);
608        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-east-1.api.aws");
609        assert_eq!(
610            endpoint,
611            ::aws_smithy_types::endpoint::Endpoint::builder()
612                .url("https://sts.us-east-1.api.aws")
613                .build()
614        );
615    }
616
617    /// For region cn-north-1 with FIPS disabled and DualStack disabled
618    #[test]
619    fn test_30() {
620        let params = crate::config::endpoint::Params::builder()
621            .region("cn-north-1".to_string())
622            .use_fips(false)
623            .use_dual_stack(false)
624            .build()
625            .expect("invalid params");
626        let resolver = crate::config::endpoint::DefaultResolver::new();
627        let endpoint = resolver.resolve_endpoint(&params);
628        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.cn-north-1.amazonaws.com.cn");
629        assert_eq!(
630            endpoint,
631            ::aws_smithy_types::endpoint::Endpoint::builder()
632                .url("https://sts.cn-north-1.amazonaws.com.cn")
633                .build()
634        );
635    }
636
637    /// For region cn-northwest-1 with FIPS disabled and DualStack disabled
638    #[test]
639    fn test_31() {
640        let params = crate::config::endpoint::Params::builder()
641            .region("cn-northwest-1".to_string())
642            .use_fips(false)
643            .use_dual_stack(false)
644            .build()
645            .expect("invalid params");
646        let resolver = crate::config::endpoint::DefaultResolver::new();
647        let endpoint = resolver.resolve_endpoint(&params);
648        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.cn-northwest-1.amazonaws.com.cn");
649        assert_eq!(
650            endpoint,
651            ::aws_smithy_types::endpoint::Endpoint::builder()
652                .url("https://sts.cn-northwest-1.amazonaws.com.cn")
653                .build()
654        );
655    }
656
657    /// For region cn-north-1 with FIPS enabled and DualStack enabled
658    #[test]
659    fn test_32() {
660        let params = crate::config::endpoint::Params::builder()
661            .region("cn-north-1".to_string())
662            .use_fips(true)
663            .use_dual_stack(true)
664            .build()
665            .expect("invalid params");
666        let resolver = crate::config::endpoint::DefaultResolver::new();
667        let endpoint = resolver.resolve_endpoint(&params);
668        let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.cn-north-1.api.amazonwebservices.com.cn");
669        assert_eq!(
670            endpoint,
671            ::aws_smithy_types::endpoint::Endpoint::builder()
672                .url("https://sts-fips.cn-north-1.api.amazonwebservices.com.cn")
673                .build()
674        );
675    }
676
677    /// For region cn-north-1 with FIPS enabled and DualStack disabled
678    #[test]
679    fn test_33() {
680        let params = crate::config::endpoint::Params::builder()
681            .region("cn-north-1".to_string())
682            .use_fips(true)
683            .use_dual_stack(false)
684            .build()
685            .expect("invalid params");
686        let resolver = crate::config::endpoint::DefaultResolver::new();
687        let endpoint = resolver.resolve_endpoint(&params);
688        let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.cn-north-1.amazonaws.com.cn");
689        assert_eq!(
690            endpoint,
691            ::aws_smithy_types::endpoint::Endpoint::builder()
692                .url("https://sts-fips.cn-north-1.amazonaws.com.cn")
693                .build()
694        );
695    }
696
697    /// For region cn-north-1 with FIPS disabled and DualStack enabled
698    #[test]
699    fn test_34() {
700        let params = crate::config::endpoint::Params::builder()
701            .region("cn-north-1".to_string())
702            .use_fips(false)
703            .use_dual_stack(true)
704            .build()
705            .expect("invalid params");
706        let resolver = crate::config::endpoint::DefaultResolver::new();
707        let endpoint = resolver.resolve_endpoint(&params);
708        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.cn-north-1.api.amazonwebservices.com.cn");
709        assert_eq!(
710            endpoint,
711            ::aws_smithy_types::endpoint::Endpoint::builder()
712                .url("https://sts.cn-north-1.api.amazonwebservices.com.cn")
713                .build()
714        );
715    }
716
717    /// For region us-gov-east-1 with FIPS disabled and DualStack disabled
718    #[test]
719    fn test_35() {
720        let params = crate::config::endpoint::Params::builder()
721            .region("us-gov-east-1".to_string())
722            .use_fips(false)
723            .use_dual_stack(false)
724            .build()
725            .expect("invalid params");
726        let resolver = crate::config::endpoint::DefaultResolver::new();
727        let endpoint = resolver.resolve_endpoint(&params);
728        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-gov-east-1.amazonaws.com");
729        assert_eq!(
730            endpoint,
731            ::aws_smithy_types::endpoint::Endpoint::builder()
732                .url("https://sts.us-gov-east-1.amazonaws.com")
733                .build()
734        );
735    }
736
737    /// For region us-gov-east-1 with FIPS enabled and DualStack disabled
738    #[test]
739    fn test_36() {
740        let params = crate::config::endpoint::Params::builder()
741            .region("us-gov-east-1".to_string())
742            .use_fips(true)
743            .use_dual_stack(false)
744            .build()
745            .expect("invalid params");
746        let resolver = crate::config::endpoint::DefaultResolver::new();
747        let endpoint = resolver.resolve_endpoint(&params);
748        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-gov-east-1.amazonaws.com");
749        assert_eq!(
750            endpoint,
751            ::aws_smithy_types::endpoint::Endpoint::builder()
752                .url("https://sts.us-gov-east-1.amazonaws.com")
753                .build()
754        );
755    }
756
757    /// For region us-gov-west-1 with FIPS disabled and DualStack disabled
758    #[test]
759    fn test_37() {
760        let params = crate::config::endpoint::Params::builder()
761            .region("us-gov-west-1".to_string())
762            .use_fips(false)
763            .use_dual_stack(false)
764            .build()
765            .expect("invalid params");
766        let resolver = crate::config::endpoint::DefaultResolver::new();
767        let endpoint = resolver.resolve_endpoint(&params);
768        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-gov-west-1.amazonaws.com");
769        assert_eq!(
770            endpoint,
771            ::aws_smithy_types::endpoint::Endpoint::builder()
772                .url("https://sts.us-gov-west-1.amazonaws.com")
773                .build()
774        );
775    }
776
777    /// For region us-gov-west-1 with FIPS enabled and DualStack disabled
778    #[test]
779    fn test_38() {
780        let params = crate::config::endpoint::Params::builder()
781            .region("us-gov-west-1".to_string())
782            .use_fips(true)
783            .use_dual_stack(false)
784            .build()
785            .expect("invalid params");
786        let resolver = crate::config::endpoint::DefaultResolver::new();
787        let endpoint = resolver.resolve_endpoint(&params);
788        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-gov-west-1.amazonaws.com");
789        assert_eq!(
790            endpoint,
791            ::aws_smithy_types::endpoint::Endpoint::builder()
792                .url("https://sts.us-gov-west-1.amazonaws.com")
793                .build()
794        );
795    }
796
797    /// For region us-gov-east-1 with FIPS enabled and DualStack enabled
798    #[test]
799    fn test_39() {
800        let params = crate::config::endpoint::Params::builder()
801            .region("us-gov-east-1".to_string())
802            .use_fips(true)
803            .use_dual_stack(true)
804            .build()
805            .expect("invalid params");
806        let resolver = crate::config::endpoint::DefaultResolver::new();
807        let endpoint = resolver.resolve_endpoint(&params);
808        let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-gov-east-1.api.aws");
809        assert_eq!(
810            endpoint,
811            ::aws_smithy_types::endpoint::Endpoint::builder()
812                .url("https://sts-fips.us-gov-east-1.api.aws")
813                .build()
814        );
815    }
816
817    /// For region us-gov-east-1 with FIPS disabled and DualStack enabled
818    #[test]
819    fn test_40() {
820        let params = crate::config::endpoint::Params::builder()
821            .region("us-gov-east-1".to_string())
822            .use_fips(false)
823            .use_dual_stack(true)
824            .build()
825            .expect("invalid params");
826        let resolver = crate::config::endpoint::DefaultResolver::new();
827        let endpoint = resolver.resolve_endpoint(&params);
828        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-gov-east-1.api.aws");
829        assert_eq!(
830            endpoint,
831            ::aws_smithy_types::endpoint::Endpoint::builder()
832                .url("https://sts.us-gov-east-1.api.aws")
833                .build()
834        );
835    }
836
837    /// For region us-iso-east-1 with FIPS disabled and DualStack disabled
838    #[test]
839    fn test_41() {
840        let params = crate::config::endpoint::Params::builder()
841            .region("us-iso-east-1".to_string())
842            .use_fips(false)
843            .use_dual_stack(false)
844            .build()
845            .expect("invalid params");
846        let resolver = crate::config::endpoint::DefaultResolver::new();
847        let endpoint = resolver.resolve_endpoint(&params);
848        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-iso-east-1.c2s.ic.gov");
849        assert_eq!(
850            endpoint,
851            ::aws_smithy_types::endpoint::Endpoint::builder()
852                .url("https://sts.us-iso-east-1.c2s.ic.gov")
853                .build()
854        );
855    }
856
857    /// For region us-iso-west-1 with FIPS disabled and DualStack disabled
858    #[test]
859    fn test_42() {
860        let params = crate::config::endpoint::Params::builder()
861            .region("us-iso-west-1".to_string())
862            .use_fips(false)
863            .use_dual_stack(false)
864            .build()
865            .expect("invalid params");
866        let resolver = crate::config::endpoint::DefaultResolver::new();
867        let endpoint = resolver.resolve_endpoint(&params);
868        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-iso-west-1.c2s.ic.gov");
869        assert_eq!(
870            endpoint,
871            ::aws_smithy_types::endpoint::Endpoint::builder()
872                .url("https://sts.us-iso-west-1.c2s.ic.gov")
873                .build()
874        );
875    }
876
877    /// For region us-iso-east-1 with FIPS enabled and DualStack disabled
878    #[test]
879    fn test_43() {
880        let params = crate::config::endpoint::Params::builder()
881            .region("us-iso-east-1".to_string())
882            .use_fips(true)
883            .use_dual_stack(false)
884            .build()
885            .expect("invalid params");
886        let resolver = crate::config::endpoint::DefaultResolver::new();
887        let endpoint = resolver.resolve_endpoint(&params);
888        let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-iso-east-1.c2s.ic.gov");
889        assert_eq!(
890            endpoint,
891            ::aws_smithy_types::endpoint::Endpoint::builder()
892                .url("https://sts-fips.us-iso-east-1.c2s.ic.gov")
893                .build()
894        );
895    }
896
897    /// For region us-isob-east-1 with FIPS disabled and DualStack disabled
898    #[test]
899    fn test_44() {
900        let params = crate::config::endpoint::Params::builder()
901            .region("us-isob-east-1".to_string())
902            .use_fips(false)
903            .use_dual_stack(false)
904            .build()
905            .expect("invalid params");
906        let resolver = crate::config::endpoint::DefaultResolver::new();
907        let endpoint = resolver.resolve_endpoint(&params);
908        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-isob-east-1.sc2s.sgov.gov");
909        assert_eq!(
910            endpoint,
911            ::aws_smithy_types::endpoint::Endpoint::builder()
912                .url("https://sts.us-isob-east-1.sc2s.sgov.gov")
913                .build()
914        );
915    }
916
917    /// For region us-isob-east-1 with FIPS enabled and DualStack disabled
918    #[test]
919    fn test_45() {
920        let params = crate::config::endpoint::Params::builder()
921            .region("us-isob-east-1".to_string())
922            .use_fips(true)
923            .use_dual_stack(false)
924            .build()
925            .expect("invalid params");
926        let resolver = crate::config::endpoint::DefaultResolver::new();
927        let endpoint = resolver.resolve_endpoint(&params);
928        let endpoint = endpoint.expect("Expected valid endpoint: https://sts-fips.us-isob-east-1.sc2s.sgov.gov");
929        assert_eq!(
930            endpoint,
931            ::aws_smithy_types::endpoint::Endpoint::builder()
932                .url("https://sts-fips.us-isob-east-1.sc2s.sgov.gov")
933                .build()
934        );
935    }
936
937    /// For custom endpoint with region set and fips disabled and dualstack disabled
938    #[test]
939    fn test_46() {
940        let params = crate::config::endpoint::Params::builder()
941            .region("us-east-1".to_string())
942            .use_fips(false)
943            .use_dual_stack(false)
944            .endpoint("https://example.com".to_string())
945            .build()
946            .expect("invalid params");
947        let resolver = crate::config::endpoint::DefaultResolver::new();
948        let endpoint = resolver.resolve_endpoint(&params);
949        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
950        assert_eq!(
951            endpoint,
952            ::aws_smithy_types::endpoint::Endpoint::builder().url("https://example.com").build()
953        );
954    }
955
956    /// For custom endpoint with region not set and fips disabled and dualstack disabled
957    #[test]
958    fn test_47() {
959        let params = crate::config::endpoint::Params::builder()
960            .use_fips(false)
961            .use_dual_stack(false)
962            .endpoint("https://example.com".to_string())
963            .build()
964            .expect("invalid params");
965        let resolver = crate::config::endpoint::DefaultResolver::new();
966        let endpoint = resolver.resolve_endpoint(&params);
967        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
968        assert_eq!(
969            endpoint,
970            ::aws_smithy_types::endpoint::Endpoint::builder().url("https://example.com").build()
971        );
972    }
973
974    /// For custom endpoint with fips enabled and dualstack disabled
975    #[test]
976    fn test_48() {
977        let params = crate::config::endpoint::Params::builder()
978            .region("us-east-1".to_string())
979            .use_fips(true)
980            .use_dual_stack(false)
981            .endpoint("https://example.com".to_string())
982            .build()
983            .expect("invalid params");
984        let resolver = crate::config::endpoint::DefaultResolver::new();
985        let endpoint = resolver.resolve_endpoint(&params);
986        let error = endpoint.expect_err("expected error: Invalid Configuration: FIPS and custom endpoint are not supported [For custom endpoint with fips enabled and dualstack disabled]");
987        assert_eq!(format!("{}", error), "Invalid Configuration: FIPS and custom endpoint are not supported")
988    }
989
990    /// For custom endpoint with fips disabled and dualstack enabled
991    #[test]
992    fn test_49() {
993        let params = crate::config::endpoint::Params::builder()
994            .region("us-east-1".to_string())
995            .use_fips(false)
996            .use_dual_stack(true)
997            .endpoint("https://example.com".to_string())
998            .build()
999            .expect("invalid params");
1000        let resolver = crate::config::endpoint::DefaultResolver::new();
1001        let endpoint = resolver.resolve_endpoint(&params);
1002        let error = endpoint.expect_err("expected error: Invalid Configuration: Dualstack and custom endpoint are not supported [For custom endpoint with fips disabled and dualstack enabled]");
1003        assert_eq!(
1004            format!("{}", error),
1005            "Invalid Configuration: Dualstack and custom endpoint are not supported"
1006        )
1007    }
1008
1009    /// Missing region
1010    #[test]
1011    fn test_50() {
1012        let params = crate::config::endpoint::Params::builder().build().expect("invalid params");
1013        let resolver = crate::config::endpoint::DefaultResolver::new();
1014        let endpoint = resolver.resolve_endpoint(&params);
1015        let error = endpoint.expect_err("expected error: Invalid Configuration: Missing Region [Missing region]");
1016        assert_eq!(format!("{}", error), "Invalid Configuration: Missing Region")
1017    }
1018
1019    /// UseGlobalEndpoint with legacy region `ap-northeast-1`
1020    #[test]
1021    fn test_51() {
1022        let params = crate::config::endpoint::Params::builder()
1023            .region("ap-northeast-1".to_string())
1024            .use_fips(false)
1025            .use_dual_stack(false)
1026            .use_global_endpoint(true)
1027            .build()
1028            .expect("invalid params");
1029        let resolver = crate::config::endpoint::DefaultResolver::new();
1030        let endpoint = resolver.resolve_endpoint(&params);
1031        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1032        assert_eq!(
1033            endpoint,
1034            ::aws_smithy_types::endpoint::Endpoint::builder()
1035                .url("https://sts.amazonaws.com")
1036                .auth_scheme(
1037                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1038                        .put("signingName", "sts".to_string())
1039                        .put("signingRegion", "us-east-1".to_string())
1040                )
1041                .build()
1042        );
1043    }
1044
1045    /// UseGlobalEndpoint with legacy region `ap-south-1`
1046    #[test]
1047    fn test_52() {
1048        let params = crate::config::endpoint::Params::builder()
1049            .region("ap-south-1".to_string())
1050            .use_fips(false)
1051            .use_dual_stack(false)
1052            .use_global_endpoint(true)
1053            .build()
1054            .expect("invalid params");
1055        let resolver = crate::config::endpoint::DefaultResolver::new();
1056        let endpoint = resolver.resolve_endpoint(&params);
1057        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1058        assert_eq!(
1059            endpoint,
1060            ::aws_smithy_types::endpoint::Endpoint::builder()
1061                .url("https://sts.amazonaws.com")
1062                .auth_scheme(
1063                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1064                        .put("signingName", "sts".to_string())
1065                        .put("signingRegion", "us-east-1".to_string())
1066                )
1067                .build()
1068        );
1069    }
1070
1071    /// UseGlobalEndpoint with legacy region `ap-southeast-1`
1072    #[test]
1073    fn test_53() {
1074        let params = crate::config::endpoint::Params::builder()
1075            .region("ap-southeast-1".to_string())
1076            .use_fips(false)
1077            .use_dual_stack(false)
1078            .use_global_endpoint(true)
1079            .build()
1080            .expect("invalid params");
1081        let resolver = crate::config::endpoint::DefaultResolver::new();
1082        let endpoint = resolver.resolve_endpoint(&params);
1083        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1084        assert_eq!(
1085            endpoint,
1086            ::aws_smithy_types::endpoint::Endpoint::builder()
1087                .url("https://sts.amazonaws.com")
1088                .auth_scheme(
1089                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1090                        .put("signingName", "sts".to_string())
1091                        .put("signingRegion", "us-east-1".to_string())
1092                )
1093                .build()
1094        );
1095    }
1096
1097    /// UseGlobalEndpoint with legacy region `ap-southeast-2`
1098    #[test]
1099    fn test_54() {
1100        let params = crate::config::endpoint::Params::builder()
1101            .region("ap-southeast-2".to_string())
1102            .use_fips(false)
1103            .use_dual_stack(false)
1104            .use_global_endpoint(true)
1105            .build()
1106            .expect("invalid params");
1107        let resolver = crate::config::endpoint::DefaultResolver::new();
1108        let endpoint = resolver.resolve_endpoint(&params);
1109        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1110        assert_eq!(
1111            endpoint,
1112            ::aws_smithy_types::endpoint::Endpoint::builder()
1113                .url("https://sts.amazonaws.com")
1114                .auth_scheme(
1115                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1116                        .put("signingName", "sts".to_string())
1117                        .put("signingRegion", "us-east-1".to_string())
1118                )
1119                .build()
1120        );
1121    }
1122
1123    /// UseGlobalEndpoint with legacy region `aws-global`
1124    #[test]
1125    fn test_55() {
1126        let params = crate::config::endpoint::Params::builder()
1127            .region("aws-global".to_string())
1128            .use_fips(false)
1129            .use_dual_stack(false)
1130            .use_global_endpoint(true)
1131            .build()
1132            .expect("invalid params");
1133        let resolver = crate::config::endpoint::DefaultResolver::new();
1134        let endpoint = resolver.resolve_endpoint(&params);
1135        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1136        assert_eq!(
1137            endpoint,
1138            ::aws_smithy_types::endpoint::Endpoint::builder()
1139                .url("https://sts.amazonaws.com")
1140                .auth_scheme(
1141                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1142                        .put("signingName", "sts".to_string())
1143                        .put("signingRegion", "us-east-1".to_string())
1144                )
1145                .build()
1146        );
1147    }
1148
1149    /// UseGlobalEndpoint with legacy region `ca-central-1`
1150    #[test]
1151    fn test_56() {
1152        let params = crate::config::endpoint::Params::builder()
1153            .region("ca-central-1".to_string())
1154            .use_fips(false)
1155            .use_dual_stack(false)
1156            .use_global_endpoint(true)
1157            .build()
1158            .expect("invalid params");
1159        let resolver = crate::config::endpoint::DefaultResolver::new();
1160        let endpoint = resolver.resolve_endpoint(&params);
1161        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1162        assert_eq!(
1163            endpoint,
1164            ::aws_smithy_types::endpoint::Endpoint::builder()
1165                .url("https://sts.amazonaws.com")
1166                .auth_scheme(
1167                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1168                        .put("signingName", "sts".to_string())
1169                        .put("signingRegion", "us-east-1".to_string())
1170                )
1171                .build()
1172        );
1173    }
1174
1175    /// UseGlobalEndpoint with legacy region `eu-central-1`
1176    #[test]
1177    fn test_57() {
1178        let params = crate::config::endpoint::Params::builder()
1179            .region("eu-central-1".to_string())
1180            .use_fips(false)
1181            .use_dual_stack(false)
1182            .use_global_endpoint(true)
1183            .build()
1184            .expect("invalid params");
1185        let resolver = crate::config::endpoint::DefaultResolver::new();
1186        let endpoint = resolver.resolve_endpoint(&params);
1187        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1188        assert_eq!(
1189            endpoint,
1190            ::aws_smithy_types::endpoint::Endpoint::builder()
1191                .url("https://sts.amazonaws.com")
1192                .auth_scheme(
1193                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1194                        .put("signingName", "sts".to_string())
1195                        .put("signingRegion", "us-east-1".to_string())
1196                )
1197                .build()
1198        );
1199    }
1200
1201    /// UseGlobalEndpoint with legacy region `eu-north-1`
1202    #[test]
1203    fn test_58() {
1204        let params = crate::config::endpoint::Params::builder()
1205            .region("eu-north-1".to_string())
1206            .use_fips(false)
1207            .use_dual_stack(false)
1208            .use_global_endpoint(true)
1209            .build()
1210            .expect("invalid params");
1211        let resolver = crate::config::endpoint::DefaultResolver::new();
1212        let endpoint = resolver.resolve_endpoint(&params);
1213        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1214        assert_eq!(
1215            endpoint,
1216            ::aws_smithy_types::endpoint::Endpoint::builder()
1217                .url("https://sts.amazonaws.com")
1218                .auth_scheme(
1219                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1220                        .put("signingName", "sts".to_string())
1221                        .put("signingRegion", "us-east-1".to_string())
1222                )
1223                .build()
1224        );
1225    }
1226
1227    /// UseGlobalEndpoint with legacy region `eu-west-1`
1228    #[test]
1229    fn test_59() {
1230        let params = crate::config::endpoint::Params::builder()
1231            .region("eu-west-1".to_string())
1232            .use_fips(false)
1233            .use_dual_stack(false)
1234            .use_global_endpoint(true)
1235            .build()
1236            .expect("invalid params");
1237        let resolver = crate::config::endpoint::DefaultResolver::new();
1238        let endpoint = resolver.resolve_endpoint(&params);
1239        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1240        assert_eq!(
1241            endpoint,
1242            ::aws_smithy_types::endpoint::Endpoint::builder()
1243                .url("https://sts.amazonaws.com")
1244                .auth_scheme(
1245                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1246                        .put("signingName", "sts".to_string())
1247                        .put("signingRegion", "us-east-1".to_string())
1248                )
1249                .build()
1250        );
1251    }
1252
1253    /// UseGlobalEndpoint with legacy region `eu-west-2`
1254    #[test]
1255    fn test_60() {
1256        let params = crate::config::endpoint::Params::builder()
1257            .region("eu-west-2".to_string())
1258            .use_fips(false)
1259            .use_dual_stack(false)
1260            .use_global_endpoint(true)
1261            .build()
1262            .expect("invalid params");
1263        let resolver = crate::config::endpoint::DefaultResolver::new();
1264        let endpoint = resolver.resolve_endpoint(&params);
1265        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1266        assert_eq!(
1267            endpoint,
1268            ::aws_smithy_types::endpoint::Endpoint::builder()
1269                .url("https://sts.amazonaws.com")
1270                .auth_scheme(
1271                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1272                        .put("signingName", "sts".to_string())
1273                        .put("signingRegion", "us-east-1".to_string())
1274                )
1275                .build()
1276        );
1277    }
1278
1279    /// UseGlobalEndpoint with legacy region `eu-west-3`
1280    #[test]
1281    fn test_61() {
1282        let params = crate::config::endpoint::Params::builder()
1283            .region("eu-west-3".to_string())
1284            .use_fips(false)
1285            .use_dual_stack(false)
1286            .use_global_endpoint(true)
1287            .build()
1288            .expect("invalid params");
1289        let resolver = crate::config::endpoint::DefaultResolver::new();
1290        let endpoint = resolver.resolve_endpoint(&params);
1291        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1292        assert_eq!(
1293            endpoint,
1294            ::aws_smithy_types::endpoint::Endpoint::builder()
1295                .url("https://sts.amazonaws.com")
1296                .auth_scheme(
1297                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1298                        .put("signingName", "sts".to_string())
1299                        .put("signingRegion", "us-east-1".to_string())
1300                )
1301                .build()
1302        );
1303    }
1304
1305    /// UseGlobalEndpoint with legacy region `sa-east-1`
1306    #[test]
1307    fn test_62() {
1308        let params = crate::config::endpoint::Params::builder()
1309            .region("sa-east-1".to_string())
1310            .use_fips(false)
1311            .use_dual_stack(false)
1312            .use_global_endpoint(true)
1313            .build()
1314            .expect("invalid params");
1315        let resolver = crate::config::endpoint::DefaultResolver::new();
1316        let endpoint = resolver.resolve_endpoint(&params);
1317        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1318        assert_eq!(
1319            endpoint,
1320            ::aws_smithy_types::endpoint::Endpoint::builder()
1321                .url("https://sts.amazonaws.com")
1322                .auth_scheme(
1323                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1324                        .put("signingName", "sts".to_string())
1325                        .put("signingRegion", "us-east-1".to_string())
1326                )
1327                .build()
1328        );
1329    }
1330
1331    /// UseGlobalEndpoint with legacy region `us-east-1`
1332    #[test]
1333    fn test_63() {
1334        let params = crate::config::endpoint::Params::builder()
1335            .region("us-east-1".to_string())
1336            .use_fips(false)
1337            .use_dual_stack(false)
1338            .use_global_endpoint(true)
1339            .build()
1340            .expect("invalid params");
1341        let resolver = crate::config::endpoint::DefaultResolver::new();
1342        let endpoint = resolver.resolve_endpoint(&params);
1343        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1344        assert_eq!(
1345            endpoint,
1346            ::aws_smithy_types::endpoint::Endpoint::builder()
1347                .url("https://sts.amazonaws.com")
1348                .auth_scheme(
1349                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1350                        .put("signingName", "sts".to_string())
1351                        .put("signingRegion", "us-east-1".to_string())
1352                )
1353                .build()
1354        );
1355    }
1356
1357    /// UseGlobalEndpoint with legacy region `us-east-2`
1358    #[test]
1359    fn test_64() {
1360        let params = crate::config::endpoint::Params::builder()
1361            .region("us-east-2".to_string())
1362            .use_fips(false)
1363            .use_dual_stack(false)
1364            .use_global_endpoint(true)
1365            .build()
1366            .expect("invalid params");
1367        let resolver = crate::config::endpoint::DefaultResolver::new();
1368        let endpoint = resolver.resolve_endpoint(&params);
1369        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1370        assert_eq!(
1371            endpoint,
1372            ::aws_smithy_types::endpoint::Endpoint::builder()
1373                .url("https://sts.amazonaws.com")
1374                .auth_scheme(
1375                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1376                        .put("signingName", "sts".to_string())
1377                        .put("signingRegion", "us-east-1".to_string())
1378                )
1379                .build()
1380        );
1381    }
1382
1383    /// UseGlobalEndpoint with legacy region `us-west-1`
1384    #[test]
1385    fn test_65() {
1386        let params = crate::config::endpoint::Params::builder()
1387            .region("us-west-1".to_string())
1388            .use_fips(false)
1389            .use_dual_stack(false)
1390            .use_global_endpoint(true)
1391            .build()
1392            .expect("invalid params");
1393        let resolver = crate::config::endpoint::DefaultResolver::new();
1394        let endpoint = resolver.resolve_endpoint(&params);
1395        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1396        assert_eq!(
1397            endpoint,
1398            ::aws_smithy_types::endpoint::Endpoint::builder()
1399                .url("https://sts.amazonaws.com")
1400                .auth_scheme(
1401                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1402                        .put("signingName", "sts".to_string())
1403                        .put("signingRegion", "us-east-1".to_string())
1404                )
1405                .build()
1406        );
1407    }
1408
1409    /// UseGlobalEndpoint with legacy region `us-west-2`
1410    #[test]
1411    fn test_66() {
1412        let params = crate::config::endpoint::Params::builder()
1413            .region("us-west-2".to_string())
1414            .use_fips(false)
1415            .use_dual_stack(false)
1416            .use_global_endpoint(true)
1417            .build()
1418            .expect("invalid params");
1419        let resolver = crate::config::endpoint::DefaultResolver::new();
1420        let endpoint = resolver.resolve_endpoint(&params);
1421        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.amazonaws.com");
1422        assert_eq!(
1423            endpoint,
1424            ::aws_smithy_types::endpoint::Endpoint::builder()
1425                .url("https://sts.amazonaws.com")
1426                .auth_scheme(
1427                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1428                        .put("signingName", "sts".to_string())
1429                        .put("signingRegion", "us-east-1".to_string())
1430                )
1431                .build()
1432        );
1433    }
1434
1435    /// UseGlobalEndpoint with Non-legacy region `us-east-3`
1436    #[test]
1437    fn test_67() {
1438        let params = crate::config::endpoint::Params::builder()
1439            .region("us-east-3".to_string())
1440            .use_fips(false)
1441            .use_dual_stack(false)
1442            .use_global_endpoint(true)
1443            .build()
1444            .expect("invalid params");
1445        let resolver = crate::config::endpoint::DefaultResolver::new();
1446        let endpoint = resolver.resolve_endpoint(&params);
1447        let endpoint = endpoint.expect("Expected valid endpoint: https://sts.us-east-3.amazonaws.com");
1448        assert_eq!(
1449            endpoint,
1450            ::aws_smithy_types::endpoint::Endpoint::builder()
1451                .url("https://sts.us-east-3.amazonaws.com")
1452                .auth_scheme(
1453                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4", 2)
1454                        .put("signingName", "sts".to_string())
1455                        .put("signingRegion", "us-east-3".to_string())
1456                )
1457                .build()
1458        );
1459    }
1460
1461    /// UseGlobalEndpoint with legacy region and custom endpoint
1462    #[test]
1463    fn test_68() {
1464        let params = crate::config::endpoint::Params::builder()
1465            .region("us-west-1".to_string())
1466            .use_fips(false)
1467            .use_dual_stack(false)
1468            .use_global_endpoint(true)
1469            .endpoint("https://example.com".to_string())
1470            .build()
1471            .expect("invalid params");
1472        let resolver = crate::config::endpoint::DefaultResolver::new();
1473        let endpoint = resolver.resolve_endpoint(&params);
1474        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1475        assert_eq!(
1476            endpoint,
1477            ::aws_smithy_types::endpoint::Endpoint::builder().url("https://example.com").build()
1478        );
1479    }
1480
1481    /// UseGlobalEndpoint with unset region and custom endpoint
1482    #[test]
1483    fn test_69() {
1484        let params = crate::config::endpoint::Params::builder()
1485            .use_fips(false)
1486            .use_dual_stack(false)
1487            .use_global_endpoint(false)
1488            .endpoint("https://example.com".to_string())
1489            .build()
1490            .expect("invalid params");
1491        let resolver = crate::config::endpoint::DefaultResolver::new();
1492        let endpoint = resolver.resolve_endpoint(&params);
1493        let endpoint = endpoint.expect("Expected valid endpoint: https://example.com");
1494        assert_eq!(
1495            endpoint,
1496            ::aws_smithy_types::endpoint::Endpoint::builder().url("https://example.com").build()
1497        );
1498    }
1499}
1500
1501/// Endpoint resolver trait specific to AWS Security Token Service
1502pub trait ResolveEndpoint: ::std::marker::Send + ::std::marker::Sync + ::std::fmt::Debug {
1503    /// Resolve an endpoint with the given parameters
1504    fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a>;
1505
1506    /// Convert this service-specific resolver into a `SharedEndpointResolver`
1507    ///
1508    /// The resulting resolver will downcast `EndpointResolverParams` into `crate::config::endpoint::Params`.
1509    fn into_shared_resolver(self) -> ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver
1510    where
1511        Self: Sized + 'static,
1512    {
1513        ::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver::new(DowncastParams(self))
1514    }
1515}
1516
1517#[derive(Debug)]
1518struct DowncastParams<T>(T);
1519impl<T> ::aws_smithy_runtime_api::client::endpoint::ResolveEndpoint for DowncastParams<T>
1520where
1521    T: ResolveEndpoint,
1522{
1523    fn resolve_endpoint<'a>(
1524        &'a self,
1525        params: &'a ::aws_smithy_runtime_api::client::endpoint::EndpointResolverParams,
1526    ) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
1527        let ep = match params.get::<crate::config::endpoint::Params>() {
1528            Some(params) => self.0.resolve_endpoint(params),
1529            None => ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(Err("params of expected type was not present".into())),
1530        };
1531        ep
1532    }
1533}
1534
1535#[derive(Debug)]
1536/// The default endpoint resolver.
1537pub struct DefaultResolver {
1538    partition_resolver: &'static crate::endpoint_lib::partition::PartitionResolver,
1539    endpoint_cache: ::arc_swap::ArcSwap<::std::option::Option<(Params, ::aws_smithy_types::endpoint::Endpoint)>>,
1540}
1541
1542impl Default for DefaultResolver {
1543    fn default() -> Self {
1544        Self::new()
1545    }
1546}
1547
1548impl DefaultResolver {
1549    /// Create a new DefaultResolver
1550    pub fn new() -> Self {
1551        Self {
1552            partition_resolver: &crate::endpoint_lib::DEFAULT_PARTITION_RESOLVER,
1553            endpoint_cache: ::arc_swap::ArcSwap::from_pointee(None),
1554        }
1555    }
1556
1557    #[allow(
1558        unused_variables,
1559        unused_parens,
1560        clippy::double_parens,
1561        clippy::useless_conversion,
1562        clippy::bool_comparison,
1563        clippy::comparison_to_empty,
1564        clippy::needless_borrow,
1565        clippy::useless_asref,
1566        clippy::redundant_closure_call,
1567        clippy::clone_on_copy,
1568        clippy::single_char_add_str
1569    )]
1570    fn resolve_endpoint<'a>(
1571        &'a self,
1572        params: &'a crate::config::endpoint::Params,
1573    ) -> ::std::result::Result<::aws_smithy_types::endpoint::Endpoint, ::aws_smithy_runtime_api::box_error::BoxError> {
1574        let mut _diagnostic_collector = crate::endpoint_lib::diagnostic::DiagnosticCollector::new();
1575        #[allow(unused_mut)]
1576        let mut context = ConditionContext::default();
1577
1578        // Param bindings
1579        let region = &params.region;
1580        let use_dual_stack = &params.use_dual_stack;
1581        let use_fips = &params.use_fips;
1582        let endpoint = &params.endpoint;
1583        let use_global_endpoint = &params.use_global_endpoint;
1584
1585        let mut current_ref: i32 = 2;
1586        loop {
1587            match current_ref {
1588                ref_val if ref_val >= 100_000_000 => {
1589                    return match (ref_val - 100_000_000) as usize {
1590                        0 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1591                            "No endpoint rule matched",
1592                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
1593                        1 => ::std::result::Result::Ok(
1594                            ::aws_smithy_types::endpoint::Endpoint::builder()
1595                                .url("https://sts.amazonaws.com".to_string())
1596                                .auth_scheme(
1597                                    ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 2)
1598                                        .put("signingName", "sts")
1599                                        .put("signingRegion", "us-east-1"),
1600                                )
1601                                .build(),
1602                        ),
1603                        2 => {
1604                            let region = params.region.as_deref().unwrap_or_default();
1605                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
1606                            ::std::result::Result::Ok(
1607                                ::aws_smithy_types::endpoint::Endpoint::builder()
1608                                    .url({
1609                                        let mut out = String::new();
1610                                        out.push_str("https://sts.");
1611                                        #[allow(clippy::needless_borrow)]
1612                                        out.push_str(&region.as_ref());
1613                                        out.push_str(".");
1614                                        #[allow(clippy::needless_borrow)]
1615                                        out.push_str(&partition_result.dns_suffix());
1616                                        out
1617                                    })
1618                                    .auth_scheme(
1619                                        ::aws_smithy_types::endpoint::EndpointAuthScheme::with_capacity("sigv4".to_string(), 2)
1620                                            .put("signingName", "sts")
1621                                            .put("signingRegion", region.as_ref()),
1622                                    )
1623                                    .build(),
1624                            )
1625                        }
1626                        3 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1627                            "Invalid Configuration: FIPS and custom endpoint are not supported".to_string(),
1628                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
1629                        4 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1630                            "Invalid Configuration: Dualstack and custom endpoint are not supported".to_string(),
1631                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
1632                        5 => {
1633                            let endpoint = params.endpoint.as_deref().unwrap_or_default();
1634                            ::std::result::Result::Ok(::aws_smithy_types::endpoint::Endpoint::builder().url(endpoint.to_owned()).build())
1635                        }
1636                        6 => {
1637                            let region = params.region.as_deref().unwrap_or_default();
1638                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
1639                            ::std::result::Result::Ok(
1640                                ::aws_smithy_types::endpoint::Endpoint::builder()
1641                                    .url({
1642                                        let mut out = String::new();
1643                                        out.push_str("https://sts-fips.");
1644                                        #[allow(clippy::needless_borrow)]
1645                                        out.push_str(&region.as_ref());
1646                                        out.push_str(".");
1647                                        #[allow(clippy::needless_borrow)]
1648                                        out.push_str(&partition_result.dual_stack_dns_suffix());
1649                                        out
1650                                    })
1651                                    .build(),
1652                            )
1653                        }
1654                        7 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1655                            "FIPS and DualStack are enabled, but this partition does not support one or both".to_string(),
1656                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
1657                        8 => {
1658                            let region = params.region.as_deref().unwrap_or_default();
1659                            ::std::result::Result::Ok(
1660                                ::aws_smithy_types::endpoint::Endpoint::builder()
1661                                    .url({
1662                                        let mut out = String::new();
1663                                        out.push_str("https://sts.");
1664                                        #[allow(clippy::needless_borrow)]
1665                                        out.push_str(&region.as_ref());
1666                                        out.push_str(".amazonaws.com");
1667                                        out
1668                                    })
1669                                    .build(),
1670                            )
1671                        }
1672                        9 => {
1673                            let region = params.region.as_deref().unwrap_or_default();
1674                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
1675                            ::std::result::Result::Ok(
1676                                ::aws_smithy_types::endpoint::Endpoint::builder()
1677                                    .url({
1678                                        let mut out = String::new();
1679                                        out.push_str("https://sts-fips.");
1680                                        #[allow(clippy::needless_borrow)]
1681                                        out.push_str(&region.as_ref());
1682                                        out.push_str(".");
1683                                        #[allow(clippy::needless_borrow)]
1684                                        out.push_str(&partition_result.dns_suffix());
1685                                        out
1686                                    })
1687                                    .build(),
1688                            )
1689                        }
1690                        10 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1691                            "FIPS is enabled but this partition does not support FIPS".to_string(),
1692                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
1693                        11 => {
1694                            let region = params.region.as_deref().unwrap_or_default();
1695                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
1696                            ::std::result::Result::Ok(
1697                                ::aws_smithy_types::endpoint::Endpoint::builder()
1698                                    .url({
1699                                        let mut out = String::new();
1700                                        out.push_str("https://sts.");
1701                                        #[allow(clippy::needless_borrow)]
1702                                        out.push_str(&region.as_ref());
1703                                        out.push_str(".");
1704                                        #[allow(clippy::needless_borrow)]
1705                                        out.push_str(&partition_result.dual_stack_dns_suffix());
1706                                        out
1707                                    })
1708                                    .build(),
1709                            )
1710                        }
1711                        12 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1712                            "DualStack is enabled but this partition does not support DualStack".to_string(),
1713                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
1714                        13 => {
1715                            let region = params.region.as_deref().unwrap_or_default();
1716                            let partition_result = context.partition_result.as_ref().expect("Guaranteed to have a value by earlier checks.");
1717                            ::std::result::Result::Ok(
1718                                ::aws_smithy_types::endpoint::Endpoint::builder()
1719                                    .url({
1720                                        let mut out = String::new();
1721                                        out.push_str("https://sts.");
1722                                        #[allow(clippy::needless_borrow)]
1723                                        out.push_str(&region.as_ref());
1724                                        out.push_str(".");
1725                                        #[allow(clippy::needless_borrow)]
1726                                        out.push_str(&partition_result.dns_suffix());
1727                                        out
1728                                    })
1729                                    .build(),
1730                            )
1731                        }
1732                        14 => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1733                            "Invalid Configuration: Missing Region".to_string(),
1734                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
1735                        _ => ::std::result::Result::Err(Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1736                            "No endpoint rule matched",
1737                        )) as ::aws_smithy_runtime_api::box_error::BoxError),
1738                    };
1739                }
1740                1 | -1 => {
1741                    return ::std::result::Result::Err(
1742                        Box::new(::aws_smithy_http::endpoint::ResolveEndpointError::message("No endpoint rule matched"))
1743                            as ::aws_smithy_runtime_api::box_error::BoxError,
1744                    )
1745                }
1746                ref_val => {
1747                    let is_complement = ref_val < 0;
1748                    let node = &NODES[(ref_val.unsigned_abs() as usize) - 1];
1749                    let condition_result = match node.condition_index {
1750                        0 => endpoint.is_some(),
1751                        1 => region.is_some(),
1752                        2 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1753                            let partition_result = &mut context.partition_result;
1754                            let partition_resolver = &self.partition_resolver;
1755                            {
1756                                *partition_result = partition_resolver
1757                                    .resolve_partition(if let Some(param) = region { param } else { return false }, _diagnostic_collector)
1758                                    .map(|inner| inner.into());
1759                                partition_result.is_some()
1760                            }
1761                        })(&mut _diagnostic_collector),
1762                        3 => (use_fips) == (&true),
1763                        4 => (use_dual_stack) == (&true),
1764                        5 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1765                            let partition_resolver = &self.partition_resolver;
1766                            (region) == &mut Some(("aws-global".to_string().into()))
1767                        })(&mut _diagnostic_collector),
1768                        6 => (use_global_endpoint) == (&true),
1769                        7 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1770                            let partition_resolver = &self.partition_resolver;
1771                            (region) == &mut Some(("eu-central-1".to_string().into()))
1772                        })(&mut _diagnostic_collector),
1773                        8 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1774                            let partition_result = &context.partition_result;
1775                            let partition_resolver = &self.partition_resolver;
1776                            (if let Some(inner) = partition_result {
1777                                inner.supports_dual_stack()
1778                            } else {
1779                                return false;
1780                            }) == (true)
1781                        })(&mut _diagnostic_collector),
1782                        9 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1783                            let partition_result = &context.partition_result;
1784                            let partition_resolver = &self.partition_resolver;
1785                            (if let Some(inner) = partition_result {
1786                                inner.supports_fips()
1787                            } else {
1788                                return false;
1789                            }) == (true)
1790                        })(&mut _diagnostic_collector),
1791                        10 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1792                            let partition_resolver = &self.partition_resolver;
1793                            (region) == &mut Some(("ap-south-1".to_string().into()))
1794                        })(&mut _diagnostic_collector),
1795                        11 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1796                            let partition_resolver = &self.partition_resolver;
1797                            (region) == &mut Some(("eu-north-1".to_string().into()))
1798                        })(&mut _diagnostic_collector),
1799                        12 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1800                            let partition_resolver = &self.partition_resolver;
1801                            (region) == &mut Some(("eu-west-1".to_string().into()))
1802                        })(&mut _diagnostic_collector),
1803                        13 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1804                            let partition_resolver = &self.partition_resolver;
1805                            (region) == &mut Some(("eu-west-2".to_string().into()))
1806                        })(&mut _diagnostic_collector),
1807                        14 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1808                            let partition_resolver = &self.partition_resolver;
1809                            (region) == &mut Some(("eu-west-3".to_string().into()))
1810                        })(&mut _diagnostic_collector),
1811                        15 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1812                            let partition_resolver = &self.partition_resolver;
1813                            (region) == &mut Some(("sa-east-1".to_string().into()))
1814                        })(&mut _diagnostic_collector),
1815                        16 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1816                            let partition_resolver = &self.partition_resolver;
1817                            (region) == &mut Some(("us-east-1".to_string().into()))
1818                        })(&mut _diagnostic_collector),
1819                        17 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1820                            let partition_resolver = &self.partition_resolver;
1821                            (region) == &mut Some(("us-east-2".to_string().into()))
1822                        })(&mut _diagnostic_collector),
1823                        18 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1824                            let partition_resolver = &self.partition_resolver;
1825                            (region) == &mut Some(("us-west-2".to_string().into()))
1826                        })(&mut _diagnostic_collector),
1827                        19 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1828                            let partition_resolver = &self.partition_resolver;
1829                            (region) == &mut Some(("us-west-1".to_string().into()))
1830                        })(&mut _diagnostic_collector),
1831                        20 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1832                            let partition_resolver = &self.partition_resolver;
1833                            (region) == &mut Some(("ca-central-1".to_string().into()))
1834                        })(&mut _diagnostic_collector),
1835                        21 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1836                            let partition_resolver = &self.partition_resolver;
1837                            (region) == &mut Some(("ap-southeast-1".to_string().into()))
1838                        })(&mut _diagnostic_collector),
1839                        22 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1840                            let partition_resolver = &self.partition_resolver;
1841                            (region) == &mut Some(("ap-northeast-1".to_string().into()))
1842                        })(&mut _diagnostic_collector),
1843                        23 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1844                            let partition_resolver = &self.partition_resolver;
1845                            (region) == &mut Some(("ap-southeast-2".to_string().into()))
1846                        })(&mut _diagnostic_collector),
1847                        24 => (|_diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector| -> bool {
1848                            let partition_result = &context.partition_result;
1849                            let partition_resolver = &self.partition_resolver;
1850                            (if let Some(inner) = partition_result {
1851                                inner.name()
1852                            } else {
1853                                return false;
1854                            }) == ("aws-us-gov")
1855                        })(&mut _diagnostic_collector),
1856                        _ => unreachable!("Invalid condition index"),
1857                    };
1858                    current_ref = if is_complement ^ condition_result { node.high_ref } else { node.low_ref };
1859                }
1860            }
1861        }
1862    }
1863}
1864
1865impl crate::config::endpoint::ResolveEndpoint for DefaultResolver {
1866    fn resolve_endpoint<'a>(&'a self, params: &'a crate::config::endpoint::Params) -> ::aws_smithy_runtime_api::client::endpoint::EndpointFuture<'a> {
1867        // Check single-entry cache (lock-free read via ArcSwap)
1868        let cached = self.endpoint_cache.load();
1869        if let Some((cached_params, cached_endpoint)) = cached.as_ref() {
1870            if cached_params == params {
1871                return ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(::std::result::Result::Ok(cached_endpoint.clone()));
1872            }
1873        }
1874        drop(cached);
1875        let result = self.resolve_endpoint(params);
1876        if let ::std::result::Result::Ok(ref endpoint) = result {
1877            self.endpoint_cache.store(::std::sync::Arc::new(Some((params.clone(), endpoint.clone()))));
1878        }
1879        ::aws_smithy_runtime_api::client::endpoint::EndpointFuture::ready(result)
1880    }
1881}
1882const NODES: [crate::endpoint_lib::bdd_interpreter::BddNode; 31] = [
1883    crate::endpoint_lib::bdd_interpreter::BddNode {
1884        condition_index: -1,
1885        high_ref: 1,
1886        low_ref: -1,
1887    },
1888    crate::endpoint_lib::bdd_interpreter::BddNode {
1889        condition_index: 0,
1890        high_ref: 30,
1891        low_ref: 3,
1892    },
1893    crate::endpoint_lib::bdd_interpreter::BddNode {
1894        condition_index: 1,
1895        high_ref: 4,
1896        low_ref: 100000014,
1897    },
1898    crate::endpoint_lib::bdd_interpreter::BddNode {
1899        condition_index: 2,
1900        high_ref: 5,
1901        low_ref: 100000014,
1902    },
1903    crate::endpoint_lib::bdd_interpreter::BddNode {
1904        condition_index: 3,
1905        high_ref: 25,
1906        low_ref: 6,
1907    },
1908    crate::endpoint_lib::bdd_interpreter::BddNode {
1909        condition_index: 4,
1910        high_ref: 24,
1911        low_ref: 7,
1912    },
1913    crate::endpoint_lib::bdd_interpreter::BddNode {
1914        condition_index: 5,
1915        high_ref: 100000001,
1916        low_ref: 8,
1917    },
1918    crate::endpoint_lib::bdd_interpreter::BddNode {
1919        condition_index: 6,
1920        high_ref: 9,
1921        low_ref: 100000013,
1922    },
1923    crate::endpoint_lib::bdd_interpreter::BddNode {
1924        condition_index: 7,
1925        high_ref: 100000001,
1926        low_ref: 10,
1927    },
1928    crate::endpoint_lib::bdd_interpreter::BddNode {
1929        condition_index: 10,
1930        high_ref: 100000001,
1931        low_ref: 11,
1932    },
1933    crate::endpoint_lib::bdd_interpreter::BddNode {
1934        condition_index: 11,
1935        high_ref: 100000001,
1936        low_ref: 12,
1937    },
1938    crate::endpoint_lib::bdd_interpreter::BddNode {
1939        condition_index: 12,
1940        high_ref: 100000001,
1941        low_ref: 13,
1942    },
1943    crate::endpoint_lib::bdd_interpreter::BddNode {
1944        condition_index: 13,
1945        high_ref: 100000001,
1946        low_ref: 14,
1947    },
1948    crate::endpoint_lib::bdd_interpreter::BddNode {
1949        condition_index: 14,
1950        high_ref: 100000001,
1951        low_ref: 15,
1952    },
1953    crate::endpoint_lib::bdd_interpreter::BddNode {
1954        condition_index: 15,
1955        high_ref: 100000001,
1956        low_ref: 16,
1957    },
1958    crate::endpoint_lib::bdd_interpreter::BddNode {
1959        condition_index: 16,
1960        high_ref: 100000001,
1961        low_ref: 17,
1962    },
1963    crate::endpoint_lib::bdd_interpreter::BddNode {
1964        condition_index: 17,
1965        high_ref: 100000001,
1966        low_ref: 18,
1967    },
1968    crate::endpoint_lib::bdd_interpreter::BddNode {
1969        condition_index: 18,
1970        high_ref: 100000001,
1971        low_ref: 19,
1972    },
1973    crate::endpoint_lib::bdd_interpreter::BddNode {
1974        condition_index: 19,
1975        high_ref: 100000001,
1976        low_ref: 20,
1977    },
1978    crate::endpoint_lib::bdd_interpreter::BddNode {
1979        condition_index: 20,
1980        high_ref: 100000001,
1981        low_ref: 21,
1982    },
1983    crate::endpoint_lib::bdd_interpreter::BddNode {
1984        condition_index: 21,
1985        high_ref: 100000001,
1986        low_ref: 22,
1987    },
1988    crate::endpoint_lib::bdd_interpreter::BddNode {
1989        condition_index: 22,
1990        high_ref: 100000001,
1991        low_ref: 23,
1992    },
1993    crate::endpoint_lib::bdd_interpreter::BddNode {
1994        condition_index: 23,
1995        high_ref: 100000001,
1996        low_ref: 100000002,
1997    },
1998    crate::endpoint_lib::bdd_interpreter::BddNode {
1999        condition_index: 8,
2000        high_ref: 100000011,
2001        low_ref: 100000012,
2002    },
2003    crate::endpoint_lib::bdd_interpreter::BddNode {
2004        condition_index: 4,
2005        high_ref: 28,
2006        low_ref: 26,
2007    },
2008    crate::endpoint_lib::bdd_interpreter::BddNode {
2009        condition_index: 9,
2010        high_ref: 27,
2011        low_ref: 100000010,
2012    },
2013    crate::endpoint_lib::bdd_interpreter::BddNode {
2014        condition_index: 24,
2015        high_ref: 100000008,
2016        low_ref: 100000009,
2017    },
2018    crate::endpoint_lib::bdd_interpreter::BddNode {
2019        condition_index: 8,
2020        high_ref: 29,
2021        low_ref: 100000007,
2022    },
2023    crate::endpoint_lib::bdd_interpreter::BddNode {
2024        condition_index: 9,
2025        high_ref: 100000006,
2026        low_ref: 100000007,
2027    },
2028    crate::endpoint_lib::bdd_interpreter::BddNode {
2029        condition_index: 3,
2030        high_ref: 100000003,
2031        low_ref: 31,
2032    },
2033    crate::endpoint_lib::bdd_interpreter::BddNode {
2034        condition_index: 4,
2035        high_ref: 100000004,
2036        low_ref: 100000005,
2037    },
2038];
2039// These are all optional since they are set by conditions and will
2040// all be unset when we start evaluation
2041#[derive(Default)]
2042#[allow(unused_lifetimes)]
2043pub(crate) struct ConditionContext<'a> {
2044    pub(crate) partition_result: Option<crate::endpoint_lib::partition::Partition<'a>>,
2045    // Sometimes none of the members reference the lifetime, this makes it still valid
2046    phantom: std::marker::PhantomData<&'a ()>,
2047}
2048
2049#[non_exhaustive]
2050#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
2051/// Configuration parameters for resolving the correct endpoint
2052pub struct Params {
2053    /// The AWS region used to dispatch the request.
2054    pub(crate) region: ::std::option::Option<::std::string::String>,
2055    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
2056    pub(crate) use_dual_stack: bool,
2057    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
2058    pub(crate) use_fips: bool,
2059    /// Override the endpoint used to send this request
2060    pub(crate) endpoint: ::std::option::Option<::std::string::String>,
2061    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
2062    pub(crate) use_global_endpoint: bool,
2063}
2064impl Params {
2065    /// Create a builder for [`Params`]
2066    pub fn builder() -> crate::config::endpoint::ParamsBuilder {
2067        crate::config::endpoint::ParamsBuilder::default()
2068    }
2069    /// The AWS region used to dispatch the request.
2070    pub fn region(&self) -> ::std::option::Option<&str> {
2071        self.region.as_deref()
2072    }
2073    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
2074    pub fn use_dual_stack(&self) -> ::std::option::Option<bool> {
2075        Some(self.use_dual_stack)
2076    }
2077    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
2078    pub fn use_fips(&self) -> ::std::option::Option<bool> {
2079        Some(self.use_fips)
2080    }
2081    /// Override the endpoint used to send this request
2082    pub fn endpoint(&self) -> ::std::option::Option<&str> {
2083        self.endpoint.as_deref()
2084    }
2085    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
2086    pub fn use_global_endpoint(&self) -> ::std::option::Option<bool> {
2087        Some(self.use_global_endpoint)
2088    }
2089}
2090
2091/// Builder for [`Params`]
2092#[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::default::Default, ::std::fmt::Debug)]
2093pub struct ParamsBuilder {
2094    region: ::std::option::Option<::std::string::String>,
2095    use_dual_stack: ::std::option::Option<bool>,
2096    use_fips: ::std::option::Option<bool>,
2097    endpoint: ::std::option::Option<::std::string::String>,
2098    use_global_endpoint: ::std::option::Option<bool>,
2099}
2100impl ParamsBuilder {
2101    /// Consume this builder, creating [`Params`].
2102    pub fn build(self) -> ::std::result::Result<crate::config::endpoint::Params, crate::config::endpoint::InvalidParams> {
2103        if let Some(region) = &self.region {
2104            if !crate::endpoint_lib::host::is_valid_host_label(
2105                region.as_ref() as &str,
2106                true,
2107                &mut crate::endpoint_lib::diagnostic::DiagnosticCollector::new(),
2108            ) {
2109                return Err(crate::config::endpoint::InvalidParams::invalid_value(
2110                    "region",
2111                    "must be a valid host label",
2112                ));
2113            }
2114        };
2115        Ok(
2116            #[allow(clippy::unnecessary_lazy_evaluations)]
2117            crate::config::endpoint::Params {
2118                region: self.region,
2119                use_dual_stack: self
2120                    .use_dual_stack
2121                    .or_else(|| Some(false))
2122                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_dual_stack"))?,
2123                use_fips: self
2124                    .use_fips
2125                    .or_else(|| Some(false))
2126                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_fips"))?,
2127                endpoint: self.endpoint,
2128                use_global_endpoint: self
2129                    .use_global_endpoint
2130                    .or_else(|| Some(false))
2131                    .ok_or_else(|| crate::config::endpoint::InvalidParams::missing("use_global_endpoint"))?,
2132            },
2133        )
2134    }
2135    /// Sets the value for region
2136    ///
2137    /// The AWS region used to dispatch the request.
2138    pub fn region(mut self, value: impl Into<::std::string::String>) -> Self {
2139        self.region = Some(value.into());
2140        self
2141    }
2142
2143    /// Sets the value for region
2144    ///
2145    /// The AWS region used to dispatch the request.
2146    pub fn set_region(mut self, param: Option<::std::string::String>) -> Self {
2147        self.region = param;
2148        self
2149    }
2150    /// Sets the value for use_dual_stack
2151    ///
2152    /// When unset, this parameter has a default value of `false`.
2153    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
2154    pub fn use_dual_stack(mut self, value: impl Into<bool>) -> Self {
2155        self.use_dual_stack = Some(value.into());
2156        self
2157    }
2158
2159    /// Sets the value for use_dual_stack
2160    ///
2161    /// When unset, this parameter has a default value of `false`.
2162    /// When true, use the dual-stack endpoint. If the configured endpoint does not support dual-stack, dispatching the request MAY return an error.
2163    pub fn set_use_dual_stack(mut self, param: Option<bool>) -> Self {
2164        self.use_dual_stack = param;
2165        self
2166    }
2167    /// Sets the value for use_fips
2168    ///
2169    /// When unset, this parameter has a default value of `false`.
2170    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
2171    pub fn use_fips(mut self, value: impl Into<bool>) -> Self {
2172        self.use_fips = Some(value.into());
2173        self
2174    }
2175
2176    /// Sets the value for use_fips
2177    ///
2178    /// When unset, this parameter has a default value of `false`.
2179    /// When true, send this request to the FIPS-compliant regional endpoint. If the configured endpoint does not have a FIPS compliant endpoint, dispatching the request will return an error.
2180    pub fn set_use_fips(mut self, param: Option<bool>) -> Self {
2181        self.use_fips = param;
2182        self
2183    }
2184    /// Sets the value for endpoint
2185    ///
2186    /// Override the endpoint used to send this request
2187    pub fn endpoint(mut self, value: impl Into<::std::string::String>) -> Self {
2188        self.endpoint = Some(value.into());
2189        self
2190    }
2191
2192    /// Sets the value for endpoint
2193    ///
2194    /// Override the endpoint used to send this request
2195    pub fn set_endpoint(mut self, param: Option<::std::string::String>) -> Self {
2196        self.endpoint = param;
2197        self
2198    }
2199    /// Sets the value for use_global_endpoint
2200    ///
2201    /// When unset, this parameter has a default value of `false`.
2202    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
2203    pub fn use_global_endpoint(mut self, value: impl Into<bool>) -> Self {
2204        self.use_global_endpoint = Some(value.into());
2205        self
2206    }
2207
2208    /// Sets the value for use_global_endpoint
2209    ///
2210    /// When unset, this parameter has a default value of `false`.
2211    /// Whether the global endpoint should be used, rather then the regional endpoint for us-east-1.
2212    pub fn set_use_global_endpoint(mut self, param: Option<bool>) -> Self {
2213        self.use_global_endpoint = param;
2214        self
2215    }
2216}
2217
2218/// An error that occurred during endpoint resolution
2219#[derive(Debug)]
2220pub struct InvalidParams {
2221    field: std::borrow::Cow<'static, str>,
2222    kind: InvalidParamsErrorKind,
2223}
2224
2225/// The kind of invalid parameter error
2226#[derive(Debug)]
2227enum InvalidParamsErrorKind {
2228    MissingField,
2229    InvalidValue { message: &'static str },
2230}
2231
2232impl InvalidParams {
2233    #[allow(dead_code)]
2234    fn missing(field: &'static str) -> Self {
2235        Self {
2236            field: field.into(),
2237            kind: InvalidParamsErrorKind::MissingField,
2238        }
2239    }
2240
2241    #[allow(dead_code)]
2242    fn invalid_value(field: &'static str, message: &'static str) -> Self {
2243        Self {
2244            field: field.into(),
2245            kind: InvalidParamsErrorKind::InvalidValue { message },
2246        }
2247    }
2248}
2249
2250impl std::fmt::Display for InvalidParams {
2251    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2252        match self.kind {
2253            InvalidParamsErrorKind::MissingField => write!(f, "a required field was missing: `{}`", self.field),
2254            InvalidParamsErrorKind::InvalidValue { message } => write!(f, "invalid value for field: `{}` - {}", self.field, message),
2255        }
2256    }
2257}
2258
2259impl std::error::Error for InvalidParams {}