aws_sdk_s3/config/endpoint/internals.rs
1// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
2#[allow(
3 clippy::collapsible_if,
4 clippy::bool_comparison,
5 clippy::nonminimal_bool,
6 clippy::comparison_to_empty,
7 clippy::redundant_pattern_matching
8)]
9pub(super) fn resolve_endpoint(
10 _params: &crate::config::endpoint::Params,
11 _diagnostic_collector: &mut crate::endpoint_lib::diagnostic::DiagnosticCollector,
12 partition_resolver: &crate::endpoint_lib::partition::PartitionResolver,
13) -> ::aws_smithy_http::endpoint::Result {
14 #[allow(unused_variables)]
15 let bucket = &_params.bucket;
16 #[allow(unused_variables)]
17 let region = &_params.region;
18 #[allow(unused_variables)]
19 let use_fips = &_params.use_fips;
20 #[allow(unused_variables)]
21 let use_dual_stack = &_params.use_dual_stack;
22 #[allow(unused_variables)]
23 let endpoint = &_params.endpoint;
24 #[allow(unused_variables)]
25 let force_path_style = &_params.force_path_style;
26 #[allow(unused_variables)]
27 let accelerate = &_params.accelerate;
28 #[allow(unused_variables)]
29 let use_global_endpoint = &_params.use_global_endpoint;
30 #[allow(unused_variables)]
31 let use_object_lambda_endpoint = &_params.use_object_lambda_endpoint;
32 #[allow(unused_variables)]
33 let key = &_params.key;
34 #[allow(unused_variables)]
35 let prefix = &_params.prefix;
36 #[allow(unused_variables)]
37 let copy_source = &_params.copy_source;
38 #[allow(unused_variables)]
39 let disable_access_points = &_params.disable_access_points;
40 #[allow(unused_variables)]
41 let disable_multi_region_access_points = &_params.disable_multi_region_access_points;
42 #[allow(unused_variables)]
43 let use_arn_region = &_params.use_arn_region;
44 #[allow(unused_variables)]
45 let use_s3_express_control_endpoint = &_params.use_s3_express_control_endpoint;
46 #[allow(unused_variables)]
47 let disable_s3_express_session_auth = &_params.disable_s3_express_session_auth;
48 #[allow(unused_variables)]
49 if let Some(region) = region {
50 if (*accelerate) == (true) {
51 if (*use_fips) == (true) {
52 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
53 "Accelerate cannot be used with FIPS".to_string(),
54 ));
55 }
56 }
57 if (*use_dual_stack) == (true) {
58 #[allow(unused_variables)]
59 if let Some(endpoint) = endpoint {
60 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
61 "Cannot set dual-stack in combination with a custom endpoint.".to_string(),
62 ));
63 }
64 }
65 #[allow(unused_variables)]
66 if let Some(endpoint) = endpoint {
67 if (*use_fips) == (true) {
68 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
69 "A custom endpoint cannot be combined with FIPS".to_string(),
70 ));
71 }
72 }
73 #[allow(unused_variables)]
74 if let Some(endpoint) = endpoint {
75 if (*accelerate) == (true) {
76 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
77 "A custom endpoint cannot be combined with S3 Accelerate".to_string(),
78 ));
79 }
80 }
81 if (*use_fips) == (true) {
82 #[allow(unused_variables)]
83 if let Some(partition_result) = partition_resolver.resolve_partition(region, _diagnostic_collector) {
84 if (partition_result.name()) == ("aws-cn") {
85 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
86 "Partition does not support FIPS".to_string(),
87 ));
88 }
89 }
90 }
91 #[allow(unused_variables)]
92 if let Some(bucket) = bucket {
93 #[allow(unused_variables)]
94 if let Some(bucket_suffix) = crate::endpoint_lib::substring::substring(bucket, 0, 6, true, _diagnostic_collector) {
95 if (bucket_suffix) == ("--x-s3") {
96 if (*use_dual_stack) == (true) {
97 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
98 "S3Express does not support Dual-stack.".to_string(),
99 ));
100 }
101 if (*accelerate) == (true) {
102 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
103 "S3Express does not support S3 Accelerate.".to_string(),
104 ));
105 }
106 #[allow(unused_variables)]
107 if let Some(endpoint) = endpoint {
108 #[allow(unused_variables)]
109 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
110 #[allow(unused_variables)]
111 if let Some(disable_s3_express_session_auth) = disable_s3_express_session_auth {
112 if (*disable_s3_express_session_auth) == (true) {
113 if (url.is_ip()) == (true) {
114 let uri_encoded_bucket = crate::endpoint_lib::uri_encode::uri_encode(bucket, _diagnostic_collector);
115 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
116 .url({
117 let mut out = String::new();
118 #[allow(clippy::needless_borrow)]
119 out.push_str(&url.scheme());
120 out.push_str("://");
121 #[allow(clippy::needless_borrow)]
122 out.push_str(&url.authority());
123 out.push('/');
124 #[allow(clippy::needless_borrow)]
125 out.push_str(&uri_encoded_bucket);
126 #[allow(clippy::needless_borrow)]
127 out.push_str(&url.path());
128 out
129 })
130 .property("backend", "S3Express".to_string())
131 .property(
132 "authSchemes",
133 vec![::aws_smithy_types::Document::from({
134 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
135 out.insert("disableDoubleEncoding".to_string(), true.into());
136 out.insert("name".to_string(), "sigv4".to_string().into());
137 out.insert("signingName".to_string(), "s3express".to_string().into());
138 out.insert("signingRegion".to_string(), region.to_owned().into());
139 out
140 })],
141 )
142 .build());
143 }
144 if crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(bucket, false, _diagnostic_collector) {
145 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
146 .url({
147 let mut out = String::new();
148 #[allow(clippy::needless_borrow)]
149 out.push_str(&url.scheme());
150 out.push_str("://");
151 #[allow(clippy::needless_borrow)]
152 out.push_str(&bucket);
153 out.push('.');
154 #[allow(clippy::needless_borrow)]
155 out.push_str(&url.authority());
156 #[allow(clippy::needless_borrow)]
157 out.push_str(&url.path());
158 out
159 })
160 .property("backend", "S3Express".to_string())
161 .property(
162 "authSchemes",
163 vec![::aws_smithy_types::Document::from({
164 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
165 out.insert("disableDoubleEncoding".to_string(), true.into());
166 out.insert("name".to_string(), "sigv4".to_string().into());
167 out.insert("signingName".to_string(), "s3express".to_string().into());
168 out.insert("signingRegion".to_string(), region.to_owned().into());
169 out
170 })],
171 )
172 .build());
173 }
174 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
175 "S3Express bucket name is not a valid virtual hostable name.".to_string(),
176 ));
177 }
178 }
179 if (url.is_ip()) == (true) {
180 let uri_encoded_bucket = crate::endpoint_lib::uri_encode::uri_encode(bucket, _diagnostic_collector);
181 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
182 .url({
183 let mut out = String::new();
184 #[allow(clippy::needless_borrow)]
185 out.push_str(&url.scheme());
186 out.push_str("://");
187 #[allow(clippy::needless_borrow)]
188 out.push_str(&url.authority());
189 out.push('/');
190 #[allow(clippy::needless_borrow)]
191 out.push_str(&uri_encoded_bucket);
192 #[allow(clippy::needless_borrow)]
193 out.push_str(&url.path());
194 out
195 })
196 .property("backend", "S3Express".to_string())
197 .property(
198 "authSchemes",
199 vec![::aws_smithy_types::Document::from({
200 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
201 out.insert("disableDoubleEncoding".to_string(), true.into());
202 out.insert("name".to_string(), "sigv4-s3express".to_string().into());
203 out.insert("signingName".to_string(), "s3express".to_string().into());
204 out.insert("signingRegion".to_string(), region.to_owned().into());
205 out
206 })],
207 )
208 .build());
209 }
210 if crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(bucket, false, _diagnostic_collector) {
211 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
212 .url({
213 let mut out = String::new();
214 #[allow(clippy::needless_borrow)]
215 out.push_str(&url.scheme());
216 out.push_str("://");
217 #[allow(clippy::needless_borrow)]
218 out.push_str(&bucket);
219 out.push('.');
220 #[allow(clippy::needless_borrow)]
221 out.push_str(&url.authority());
222 #[allow(clippy::needless_borrow)]
223 out.push_str(&url.path());
224 out
225 })
226 .property("backend", "S3Express".to_string())
227 .property(
228 "authSchemes",
229 vec![::aws_smithy_types::Document::from({
230 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
231 out.insert("disableDoubleEncoding".to_string(), true.into());
232 out.insert("name".to_string(), "sigv4-s3express".to_string().into());
233 out.insert("signingName".to_string(), "s3express".to_string().into());
234 out.insert("signingRegion".to_string(), region.to_owned().into());
235 out
236 })],
237 )
238 .build());
239 }
240 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
241 "S3Express bucket name is not a valid virtual hostable name.".to_string(),
242 ));
243 }
244 }
245 #[allow(unused_variables)]
246 if let Some(use_s3_express_control_endpoint) = use_s3_express_control_endpoint {
247 if (*use_s3_express_control_endpoint) == (true) {
248 let uri_encoded_bucket = crate::endpoint_lib::uri_encode::uri_encode(bucket, _diagnostic_collector);
249 if !(endpoint.is_some()) {
250 if (*use_fips) == (true) {
251 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
252 .url({
253 let mut out = String::new();
254 out.push_str("https://s3express-control-fips.");
255 #[allow(clippy::needless_borrow)]
256 out.push_str(®ion);
257 out.push_str(".amazonaws.com/");
258 #[allow(clippy::needless_borrow)]
259 out.push_str(&uri_encoded_bucket);
260 out
261 })
262 .property("backend", "S3Express".to_string())
263 .property(
264 "authSchemes",
265 vec![::aws_smithy_types::Document::from({
266 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
267 out.insert("disableDoubleEncoding".to_string(), true.into());
268 out.insert("name".to_string(), "sigv4".to_string().into());
269 out.insert("signingName".to_string(), "s3express".to_string().into());
270 out.insert("signingRegion".to_string(), region.to_owned().into());
271 out
272 })],
273 )
274 .build());
275 }
276 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
277 .url({
278 let mut out = String::new();
279 out.push_str("https://s3express-control.");
280 #[allow(clippy::needless_borrow)]
281 out.push_str(®ion);
282 out.push_str(".amazonaws.com/");
283 #[allow(clippy::needless_borrow)]
284 out.push_str(&uri_encoded_bucket);
285 out
286 })
287 .property("backend", "S3Express".to_string())
288 .property(
289 "authSchemes",
290 vec![::aws_smithy_types::Document::from({
291 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
292 out.insert("disableDoubleEncoding".to_string(), true.into());
293 out.insert("name".to_string(), "sigv4".to_string().into());
294 out.insert("signingName".to_string(), "s3express".to_string().into());
295 out.insert("signingRegion".to_string(), region.to_owned().into());
296 out
297 })],
298 )
299 .build());
300 }
301 #[allow(unreachable_code)]
302 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
303 "No rules matched these parameters. This is a bug. {:?}",
304 _params
305 )));
306 }
307 }
308 if crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(bucket, false, _diagnostic_collector) {
309 #[allow(unused_variables)]
310 if let Some(disable_s3_express_session_auth) = disable_s3_express_session_auth {
311 if (*disable_s3_express_session_auth) == (true) {
312 #[allow(unused_variables)]
313 if let Some(s3express_availability_zone_id) =
314 crate::endpoint_lib::substring::substring(bucket, 6, 14, true, _diagnostic_collector)
315 {
316 #[allow(unused_variables)]
317 if let Some(s3express_availability_zone_delim) =
318 crate::endpoint_lib::substring::substring(bucket, 14, 16, true, _diagnostic_collector)
319 {
320 if (s3express_availability_zone_delim) == ("--") {
321 if (*use_fips) == (true) {
322 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
323 .url({
324 let mut out = String::new();
325 out.push_str("https://");
326 #[allow(clippy::needless_borrow)]
327 out.push_str(&bucket);
328 out.push_str(".s3express-fips-");
329 #[allow(clippy::needless_borrow)]
330 out.push_str(&s3express_availability_zone_id);
331 out.push('.');
332 #[allow(clippy::needless_borrow)]
333 out.push_str(®ion);
334 out.push_str(".amazonaws.com");
335 out
336 })
337 .property("backend", "S3Express".to_string())
338 .property(
339 "authSchemes",
340 vec![::aws_smithy_types::Document::from({
341 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
342 out.insert("disableDoubleEncoding".to_string(), true.into());
343 out.insert("name".to_string(), "sigv4".to_string().into());
344 out.insert("signingName".to_string(), "s3express".to_string().into());
345 out.insert("signingRegion".to_string(), region.to_owned().into());
346 out
347 })],
348 )
349 .build());
350 }
351 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
352 .url({
353 let mut out = String::new();
354 out.push_str("https://");
355 #[allow(clippy::needless_borrow)]
356 out.push_str(&bucket);
357 out.push_str(".s3express-");
358 #[allow(clippy::needless_borrow)]
359 out.push_str(&s3express_availability_zone_id);
360 out.push('.');
361 #[allow(clippy::needless_borrow)]
362 out.push_str(®ion);
363 out.push_str(".amazonaws.com");
364 out
365 })
366 .property("backend", "S3Express".to_string())
367 .property(
368 "authSchemes",
369 vec![::aws_smithy_types::Document::from({
370 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
371 out.insert("disableDoubleEncoding".to_string(), true.into());
372 out.insert("name".to_string(), "sigv4".to_string().into());
373 out.insert("signingName".to_string(), "s3express".to_string().into());
374 out.insert("signingRegion".to_string(), region.to_owned().into());
375 out
376 })],
377 )
378 .build());
379 }
380 }
381 }
382 #[allow(unused_variables)]
383 if let Some(s3express_availability_zone_id) =
384 crate::endpoint_lib::substring::substring(bucket, 6, 15, true, _diagnostic_collector)
385 {
386 #[allow(unused_variables)]
387 if let Some(s3express_availability_zone_delim) =
388 crate::endpoint_lib::substring::substring(bucket, 15, 17, true, _diagnostic_collector)
389 {
390 if (s3express_availability_zone_delim) == ("--") {
391 if (*use_fips) == (true) {
392 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
393 .url({
394 let mut out = String::new();
395 out.push_str("https://");
396 #[allow(clippy::needless_borrow)]
397 out.push_str(&bucket);
398 out.push_str(".s3express-fips-");
399 #[allow(clippy::needless_borrow)]
400 out.push_str(&s3express_availability_zone_id);
401 out.push('.');
402 #[allow(clippy::needless_borrow)]
403 out.push_str(®ion);
404 out.push_str(".amazonaws.com");
405 out
406 })
407 .property("backend", "S3Express".to_string())
408 .property(
409 "authSchemes",
410 vec![::aws_smithy_types::Document::from({
411 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
412 out.insert("disableDoubleEncoding".to_string(), true.into());
413 out.insert("name".to_string(), "sigv4".to_string().into());
414 out.insert("signingName".to_string(), "s3express".to_string().into());
415 out.insert("signingRegion".to_string(), region.to_owned().into());
416 out
417 })],
418 )
419 .build());
420 }
421 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
422 .url({
423 let mut out = String::new();
424 out.push_str("https://");
425 #[allow(clippy::needless_borrow)]
426 out.push_str(&bucket);
427 out.push_str(".s3express-");
428 #[allow(clippy::needless_borrow)]
429 out.push_str(&s3express_availability_zone_id);
430 out.push('.');
431 #[allow(clippy::needless_borrow)]
432 out.push_str(®ion);
433 out.push_str(".amazonaws.com");
434 out
435 })
436 .property("backend", "S3Express".to_string())
437 .property(
438 "authSchemes",
439 vec![::aws_smithy_types::Document::from({
440 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
441 out.insert("disableDoubleEncoding".to_string(), true.into());
442 out.insert("name".to_string(), "sigv4".to_string().into());
443 out.insert("signingName".to_string(), "s3express".to_string().into());
444 out.insert("signingRegion".to_string(), region.to_owned().into());
445 out
446 })],
447 )
448 .build());
449 }
450 }
451 }
452 #[allow(unused_variables)]
453 if let Some(s3express_availability_zone_id) =
454 crate::endpoint_lib::substring::substring(bucket, 6, 19, true, _diagnostic_collector)
455 {
456 #[allow(unused_variables)]
457 if let Some(s3express_availability_zone_delim) =
458 crate::endpoint_lib::substring::substring(bucket, 19, 21, true, _diagnostic_collector)
459 {
460 if (s3express_availability_zone_delim) == ("--") {
461 if (*use_fips) == (true) {
462 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
463 .url({
464 let mut out = String::new();
465 out.push_str("https://");
466 #[allow(clippy::needless_borrow)]
467 out.push_str(&bucket);
468 out.push_str(".s3express-fips-");
469 #[allow(clippy::needless_borrow)]
470 out.push_str(&s3express_availability_zone_id);
471 out.push('.');
472 #[allow(clippy::needless_borrow)]
473 out.push_str(®ion);
474 out.push_str(".amazonaws.com");
475 out
476 })
477 .property("backend", "S3Express".to_string())
478 .property(
479 "authSchemes",
480 vec![::aws_smithy_types::Document::from({
481 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
482 out.insert("disableDoubleEncoding".to_string(), true.into());
483 out.insert("name".to_string(), "sigv4".to_string().into());
484 out.insert("signingName".to_string(), "s3express".to_string().into());
485 out.insert("signingRegion".to_string(), region.to_owned().into());
486 out
487 })],
488 )
489 .build());
490 }
491 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
492 .url({
493 let mut out = String::new();
494 out.push_str("https://");
495 #[allow(clippy::needless_borrow)]
496 out.push_str(&bucket);
497 out.push_str(".s3express-");
498 #[allow(clippy::needless_borrow)]
499 out.push_str(&s3express_availability_zone_id);
500 out.push('.');
501 #[allow(clippy::needless_borrow)]
502 out.push_str(®ion);
503 out.push_str(".amazonaws.com");
504 out
505 })
506 .property("backend", "S3Express".to_string())
507 .property(
508 "authSchemes",
509 vec![::aws_smithy_types::Document::from({
510 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
511 out.insert("disableDoubleEncoding".to_string(), true.into());
512 out.insert("name".to_string(), "sigv4".to_string().into());
513 out.insert("signingName".to_string(), "s3express".to_string().into());
514 out.insert("signingRegion".to_string(), region.to_owned().into());
515 out
516 })],
517 )
518 .build());
519 }
520 }
521 }
522 #[allow(unused_variables)]
523 if let Some(s3express_availability_zone_id) =
524 crate::endpoint_lib::substring::substring(bucket, 6, 20, true, _diagnostic_collector)
525 {
526 #[allow(unused_variables)]
527 if let Some(s3express_availability_zone_delim) =
528 crate::endpoint_lib::substring::substring(bucket, 20, 22, true, _diagnostic_collector)
529 {
530 if (s3express_availability_zone_delim) == ("--") {
531 if (*use_fips) == (true) {
532 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
533 .url({
534 let mut out = String::new();
535 out.push_str("https://");
536 #[allow(clippy::needless_borrow)]
537 out.push_str(&bucket);
538 out.push_str(".s3express-fips-");
539 #[allow(clippy::needless_borrow)]
540 out.push_str(&s3express_availability_zone_id);
541 out.push('.');
542 #[allow(clippy::needless_borrow)]
543 out.push_str(®ion);
544 out.push_str(".amazonaws.com");
545 out
546 })
547 .property("backend", "S3Express".to_string())
548 .property(
549 "authSchemes",
550 vec![::aws_smithy_types::Document::from({
551 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
552 out.insert("disableDoubleEncoding".to_string(), true.into());
553 out.insert("name".to_string(), "sigv4".to_string().into());
554 out.insert("signingName".to_string(), "s3express".to_string().into());
555 out.insert("signingRegion".to_string(), region.to_owned().into());
556 out
557 })],
558 )
559 .build());
560 }
561 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
562 .url({
563 let mut out = String::new();
564 out.push_str("https://");
565 #[allow(clippy::needless_borrow)]
566 out.push_str(&bucket);
567 out.push_str(".s3express-");
568 #[allow(clippy::needless_borrow)]
569 out.push_str(&s3express_availability_zone_id);
570 out.push('.');
571 #[allow(clippy::needless_borrow)]
572 out.push_str(®ion);
573 out.push_str(".amazonaws.com");
574 out
575 })
576 .property("backend", "S3Express".to_string())
577 .property(
578 "authSchemes",
579 vec![::aws_smithy_types::Document::from({
580 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
581 out.insert("disableDoubleEncoding".to_string(), true.into());
582 out.insert("name".to_string(), "sigv4".to_string().into());
583 out.insert("signingName".to_string(), "s3express".to_string().into());
584 out.insert("signingRegion".to_string(), region.to_owned().into());
585 out
586 })],
587 )
588 .build());
589 }
590 }
591 }
592 #[allow(unused_variables)]
593 if let Some(s3express_availability_zone_id) =
594 crate::endpoint_lib::substring::substring(bucket, 6, 26, true, _diagnostic_collector)
595 {
596 #[allow(unused_variables)]
597 if let Some(s3express_availability_zone_delim) =
598 crate::endpoint_lib::substring::substring(bucket, 26, 28, true, _diagnostic_collector)
599 {
600 if (s3express_availability_zone_delim) == ("--") {
601 if (*use_fips) == (true) {
602 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
603 .url({
604 let mut out = String::new();
605 out.push_str("https://");
606 #[allow(clippy::needless_borrow)]
607 out.push_str(&bucket);
608 out.push_str(".s3express-fips-");
609 #[allow(clippy::needless_borrow)]
610 out.push_str(&s3express_availability_zone_id);
611 out.push('.');
612 #[allow(clippy::needless_borrow)]
613 out.push_str(®ion);
614 out.push_str(".amazonaws.com");
615 out
616 })
617 .property("backend", "S3Express".to_string())
618 .property(
619 "authSchemes",
620 vec![::aws_smithy_types::Document::from({
621 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
622 out.insert("disableDoubleEncoding".to_string(), true.into());
623 out.insert("name".to_string(), "sigv4".to_string().into());
624 out.insert("signingName".to_string(), "s3express".to_string().into());
625 out.insert("signingRegion".to_string(), region.to_owned().into());
626 out
627 })],
628 )
629 .build());
630 }
631 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
632 .url({
633 let mut out = String::new();
634 out.push_str("https://");
635 #[allow(clippy::needless_borrow)]
636 out.push_str(&bucket);
637 out.push_str(".s3express-");
638 #[allow(clippy::needless_borrow)]
639 out.push_str(&s3express_availability_zone_id);
640 out.push('.');
641 #[allow(clippy::needless_borrow)]
642 out.push_str(®ion);
643 out.push_str(".amazonaws.com");
644 out
645 })
646 .property("backend", "S3Express".to_string())
647 .property(
648 "authSchemes",
649 vec![::aws_smithy_types::Document::from({
650 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
651 out.insert("disableDoubleEncoding".to_string(), true.into());
652 out.insert("name".to_string(), "sigv4".to_string().into());
653 out.insert("signingName".to_string(), "s3express".to_string().into());
654 out.insert("signingRegion".to_string(), region.to_owned().into());
655 out
656 })],
657 )
658 .build());
659 }
660 }
661 }
662 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
663 "Unrecognized S3Express bucket name format.".to_string(),
664 ));
665 }
666 }
667 #[allow(unused_variables)]
668 if let Some(s3express_availability_zone_id) =
669 crate::endpoint_lib::substring::substring(bucket, 6, 14, true, _diagnostic_collector)
670 {
671 #[allow(unused_variables)]
672 if let Some(s3express_availability_zone_delim) =
673 crate::endpoint_lib::substring::substring(bucket, 14, 16, true, _diagnostic_collector)
674 {
675 if (s3express_availability_zone_delim) == ("--") {
676 if (*use_fips) == (true) {
677 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
678 .url({
679 let mut out = String::new();
680 out.push_str("https://");
681 #[allow(clippy::needless_borrow)]
682 out.push_str(&bucket);
683 out.push_str(".s3express-fips-");
684 #[allow(clippy::needless_borrow)]
685 out.push_str(&s3express_availability_zone_id);
686 out.push('.');
687 #[allow(clippy::needless_borrow)]
688 out.push_str(®ion);
689 out.push_str(".amazonaws.com");
690 out
691 })
692 .property("backend", "S3Express".to_string())
693 .property(
694 "authSchemes",
695 vec![::aws_smithy_types::Document::from({
696 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
697 out.insert("disableDoubleEncoding".to_string(), true.into());
698 out.insert("name".to_string(), "sigv4-s3express".to_string().into());
699 out.insert("signingName".to_string(), "s3express".to_string().into());
700 out.insert("signingRegion".to_string(), region.to_owned().into());
701 out
702 })],
703 )
704 .build());
705 }
706 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
707 .url({
708 let mut out = String::new();
709 out.push_str("https://");
710 #[allow(clippy::needless_borrow)]
711 out.push_str(&bucket);
712 out.push_str(".s3express-");
713 #[allow(clippy::needless_borrow)]
714 out.push_str(&s3express_availability_zone_id);
715 out.push('.');
716 #[allow(clippy::needless_borrow)]
717 out.push_str(®ion);
718 out.push_str(".amazonaws.com");
719 out
720 })
721 .property("backend", "S3Express".to_string())
722 .property(
723 "authSchemes",
724 vec![::aws_smithy_types::Document::from({
725 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
726 out.insert("disableDoubleEncoding".to_string(), true.into());
727 out.insert("name".to_string(), "sigv4-s3express".to_string().into());
728 out.insert("signingName".to_string(), "s3express".to_string().into());
729 out.insert("signingRegion".to_string(), region.to_owned().into());
730 out
731 })],
732 )
733 .build());
734 }
735 }
736 }
737 #[allow(unused_variables)]
738 if let Some(s3express_availability_zone_id) =
739 crate::endpoint_lib::substring::substring(bucket, 6, 15, true, _diagnostic_collector)
740 {
741 #[allow(unused_variables)]
742 if let Some(s3express_availability_zone_delim) =
743 crate::endpoint_lib::substring::substring(bucket, 15, 17, true, _diagnostic_collector)
744 {
745 if (s3express_availability_zone_delim) == ("--") {
746 if (*use_fips) == (true) {
747 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
748 .url({
749 let mut out = String::new();
750 out.push_str("https://");
751 #[allow(clippy::needless_borrow)]
752 out.push_str(&bucket);
753 out.push_str(".s3express-fips-");
754 #[allow(clippy::needless_borrow)]
755 out.push_str(&s3express_availability_zone_id);
756 out.push('.');
757 #[allow(clippy::needless_borrow)]
758 out.push_str(®ion);
759 out.push_str(".amazonaws.com");
760 out
761 })
762 .property("backend", "S3Express".to_string())
763 .property(
764 "authSchemes",
765 vec![::aws_smithy_types::Document::from({
766 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
767 out.insert("disableDoubleEncoding".to_string(), true.into());
768 out.insert("name".to_string(), "sigv4-s3express".to_string().into());
769 out.insert("signingName".to_string(), "s3express".to_string().into());
770 out.insert("signingRegion".to_string(), region.to_owned().into());
771 out
772 })],
773 )
774 .build());
775 }
776 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
777 .url({
778 let mut out = String::new();
779 out.push_str("https://");
780 #[allow(clippy::needless_borrow)]
781 out.push_str(&bucket);
782 out.push_str(".s3express-");
783 #[allow(clippy::needless_borrow)]
784 out.push_str(&s3express_availability_zone_id);
785 out.push('.');
786 #[allow(clippy::needless_borrow)]
787 out.push_str(®ion);
788 out.push_str(".amazonaws.com");
789 out
790 })
791 .property("backend", "S3Express".to_string())
792 .property(
793 "authSchemes",
794 vec![::aws_smithy_types::Document::from({
795 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
796 out.insert("disableDoubleEncoding".to_string(), true.into());
797 out.insert("name".to_string(), "sigv4-s3express".to_string().into());
798 out.insert("signingName".to_string(), "s3express".to_string().into());
799 out.insert("signingRegion".to_string(), region.to_owned().into());
800 out
801 })],
802 )
803 .build());
804 }
805 }
806 }
807 #[allow(unused_variables)]
808 if let Some(s3express_availability_zone_id) =
809 crate::endpoint_lib::substring::substring(bucket, 6, 19, true, _diagnostic_collector)
810 {
811 #[allow(unused_variables)]
812 if let Some(s3express_availability_zone_delim) =
813 crate::endpoint_lib::substring::substring(bucket, 19, 21, true, _diagnostic_collector)
814 {
815 if (s3express_availability_zone_delim) == ("--") {
816 if (*use_fips) == (true) {
817 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
818 .url({
819 let mut out = String::new();
820 out.push_str("https://");
821 #[allow(clippy::needless_borrow)]
822 out.push_str(&bucket);
823 out.push_str(".s3express-fips-");
824 #[allow(clippy::needless_borrow)]
825 out.push_str(&s3express_availability_zone_id);
826 out.push('.');
827 #[allow(clippy::needless_borrow)]
828 out.push_str(®ion);
829 out.push_str(".amazonaws.com");
830 out
831 })
832 .property("backend", "S3Express".to_string())
833 .property(
834 "authSchemes",
835 vec![::aws_smithy_types::Document::from({
836 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
837 out.insert("disableDoubleEncoding".to_string(), true.into());
838 out.insert("name".to_string(), "sigv4-s3express".to_string().into());
839 out.insert("signingName".to_string(), "s3express".to_string().into());
840 out.insert("signingRegion".to_string(), region.to_owned().into());
841 out
842 })],
843 )
844 .build());
845 }
846 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
847 .url({
848 let mut out = String::new();
849 out.push_str("https://");
850 #[allow(clippy::needless_borrow)]
851 out.push_str(&bucket);
852 out.push_str(".s3express-");
853 #[allow(clippy::needless_borrow)]
854 out.push_str(&s3express_availability_zone_id);
855 out.push('.');
856 #[allow(clippy::needless_borrow)]
857 out.push_str(®ion);
858 out.push_str(".amazonaws.com");
859 out
860 })
861 .property("backend", "S3Express".to_string())
862 .property(
863 "authSchemes",
864 vec![::aws_smithy_types::Document::from({
865 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
866 out.insert("disableDoubleEncoding".to_string(), true.into());
867 out.insert("name".to_string(), "sigv4-s3express".to_string().into());
868 out.insert("signingName".to_string(), "s3express".to_string().into());
869 out.insert("signingRegion".to_string(), region.to_owned().into());
870 out
871 })],
872 )
873 .build());
874 }
875 }
876 }
877 #[allow(unused_variables)]
878 if let Some(s3express_availability_zone_id) =
879 crate::endpoint_lib::substring::substring(bucket, 6, 20, true, _diagnostic_collector)
880 {
881 #[allow(unused_variables)]
882 if let Some(s3express_availability_zone_delim) =
883 crate::endpoint_lib::substring::substring(bucket, 20, 22, true, _diagnostic_collector)
884 {
885 if (s3express_availability_zone_delim) == ("--") {
886 if (*use_fips) == (true) {
887 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
888 .url({
889 let mut out = String::new();
890 out.push_str("https://");
891 #[allow(clippy::needless_borrow)]
892 out.push_str(&bucket);
893 out.push_str(".s3express-fips-");
894 #[allow(clippy::needless_borrow)]
895 out.push_str(&s3express_availability_zone_id);
896 out.push('.');
897 #[allow(clippy::needless_borrow)]
898 out.push_str(®ion);
899 out.push_str(".amazonaws.com");
900 out
901 })
902 .property("backend", "S3Express".to_string())
903 .property(
904 "authSchemes",
905 vec![::aws_smithy_types::Document::from({
906 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
907 out.insert("disableDoubleEncoding".to_string(), true.into());
908 out.insert("name".to_string(), "sigv4-s3express".to_string().into());
909 out.insert("signingName".to_string(), "s3express".to_string().into());
910 out.insert("signingRegion".to_string(), region.to_owned().into());
911 out
912 })],
913 )
914 .build());
915 }
916 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
917 .url({
918 let mut out = String::new();
919 out.push_str("https://");
920 #[allow(clippy::needless_borrow)]
921 out.push_str(&bucket);
922 out.push_str(".s3express-");
923 #[allow(clippy::needless_borrow)]
924 out.push_str(&s3express_availability_zone_id);
925 out.push('.');
926 #[allow(clippy::needless_borrow)]
927 out.push_str(®ion);
928 out.push_str(".amazonaws.com");
929 out
930 })
931 .property("backend", "S3Express".to_string())
932 .property(
933 "authSchemes",
934 vec![::aws_smithy_types::Document::from({
935 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
936 out.insert("disableDoubleEncoding".to_string(), true.into());
937 out.insert("name".to_string(), "sigv4-s3express".to_string().into());
938 out.insert("signingName".to_string(), "s3express".to_string().into());
939 out.insert("signingRegion".to_string(), region.to_owned().into());
940 out
941 })],
942 )
943 .build());
944 }
945 }
946 }
947 #[allow(unused_variables)]
948 if let Some(s3express_availability_zone_id) =
949 crate::endpoint_lib::substring::substring(bucket, 6, 26, true, _diagnostic_collector)
950 {
951 #[allow(unused_variables)]
952 if let Some(s3express_availability_zone_delim) =
953 crate::endpoint_lib::substring::substring(bucket, 26, 28, true, _diagnostic_collector)
954 {
955 if (s3express_availability_zone_delim) == ("--") {
956 if (*use_fips) == (true) {
957 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
958 .url({
959 let mut out = String::new();
960 out.push_str("https://");
961 #[allow(clippy::needless_borrow)]
962 out.push_str(&bucket);
963 out.push_str(".s3express-fips-");
964 #[allow(clippy::needless_borrow)]
965 out.push_str(&s3express_availability_zone_id);
966 out.push('.');
967 #[allow(clippy::needless_borrow)]
968 out.push_str(®ion);
969 out.push_str(".amazonaws.com");
970 out
971 })
972 .property("backend", "S3Express".to_string())
973 .property(
974 "authSchemes",
975 vec![::aws_smithy_types::Document::from({
976 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
977 out.insert("disableDoubleEncoding".to_string(), true.into());
978 out.insert("name".to_string(), "sigv4-s3express".to_string().into());
979 out.insert("signingName".to_string(), "s3express".to_string().into());
980 out.insert("signingRegion".to_string(), region.to_owned().into());
981 out
982 })],
983 )
984 .build());
985 }
986 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
987 .url({
988 let mut out = String::new();
989 out.push_str("https://");
990 #[allow(clippy::needless_borrow)]
991 out.push_str(&bucket);
992 out.push_str(".s3express-");
993 #[allow(clippy::needless_borrow)]
994 out.push_str(&s3express_availability_zone_id);
995 out.push('.');
996 #[allow(clippy::needless_borrow)]
997 out.push_str(®ion);
998 out.push_str(".amazonaws.com");
999 out
1000 })
1001 .property("backend", "S3Express".to_string())
1002 .property(
1003 "authSchemes",
1004 vec![::aws_smithy_types::Document::from({
1005 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1006 out.insert("disableDoubleEncoding".to_string(), true.into());
1007 out.insert("name".to_string(), "sigv4-s3express".to_string().into());
1008 out.insert("signingName".to_string(), "s3express".to_string().into());
1009 out.insert("signingRegion".to_string(), region.to_owned().into());
1010 out
1011 })],
1012 )
1013 .build());
1014 }
1015 }
1016 }
1017 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1018 "Unrecognized S3Express bucket name format.".to_string(),
1019 ));
1020 }
1021 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1022 "S3Express bucket name is not a valid virtual hostable name.".to_string(),
1023 ));
1024 }
1025 }
1026 }
1027 if !(bucket.is_some()) {
1028 #[allow(unused_variables)]
1029 if let Some(use_s3_express_control_endpoint) = use_s3_express_control_endpoint {
1030 if (*use_s3_express_control_endpoint) == (true) {
1031 #[allow(unused_variables)]
1032 if let Some(endpoint) = endpoint {
1033 #[allow(unused_variables)]
1034 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
1035 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1036 .url({
1037 let mut out = String::new();
1038 #[allow(clippy::needless_borrow)]
1039 out.push_str(&url.scheme());
1040 out.push_str("://");
1041 #[allow(clippy::needless_borrow)]
1042 out.push_str(&url.authority());
1043 #[allow(clippy::needless_borrow)]
1044 out.push_str(&url.path());
1045 out
1046 })
1047 .property("backend", "S3Express".to_string())
1048 .property(
1049 "authSchemes",
1050 vec![::aws_smithy_types::Document::from({
1051 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1052 out.insert("disableDoubleEncoding".to_string(), true.into());
1053 out.insert("name".to_string(), "sigv4".to_string().into());
1054 out.insert("signingName".to_string(), "s3express".to_string().into());
1055 out.insert("signingRegion".to_string(), region.to_owned().into());
1056 out
1057 })],
1058 )
1059 .build());
1060 }
1061 }
1062 if (*use_fips) == (true) {
1063 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1064 .url({
1065 let mut out = String::new();
1066 out.push_str("https://s3express-control-fips.");
1067 #[allow(clippy::needless_borrow)]
1068 out.push_str(®ion);
1069 out.push_str(".amazonaws.com");
1070 out
1071 })
1072 .property("backend", "S3Express".to_string())
1073 .property(
1074 "authSchemes",
1075 vec![::aws_smithy_types::Document::from({
1076 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1077 out.insert("disableDoubleEncoding".to_string(), true.into());
1078 out.insert("name".to_string(), "sigv4".to_string().into());
1079 out.insert("signingName".to_string(), "s3express".to_string().into());
1080 out.insert("signingRegion".to_string(), region.to_owned().into());
1081 out
1082 })],
1083 )
1084 .build());
1085 }
1086 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1087 .url({
1088 let mut out = String::new();
1089 out.push_str("https://s3express-control.");
1090 #[allow(clippy::needless_borrow)]
1091 out.push_str(®ion);
1092 out.push_str(".amazonaws.com");
1093 out
1094 })
1095 .property("backend", "S3Express".to_string())
1096 .property(
1097 "authSchemes",
1098 vec![::aws_smithy_types::Document::from({
1099 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1100 out.insert("disableDoubleEncoding".to_string(), true.into());
1101 out.insert("name".to_string(), "sigv4".to_string().into());
1102 out.insert("signingName".to_string(), "s3express".to_string().into());
1103 out.insert("signingRegion".to_string(), region.to_owned().into());
1104 out
1105 })],
1106 )
1107 .build());
1108 }
1109 }
1110 }
1111 #[allow(unused_variables)]
1112 if let Some(bucket) = bucket {
1113 #[allow(unused_variables)]
1114 if let Some(hardware_type) = crate::endpoint_lib::substring::substring(bucket, 49, 50, true, _diagnostic_collector) {
1115 #[allow(unused_variables)]
1116 if let Some(region_prefix) = crate::endpoint_lib::substring::substring(bucket, 8, 12, true, _diagnostic_collector) {
1117 #[allow(unused_variables)]
1118 if let Some(bucket_alias_suffix) = crate::endpoint_lib::substring::substring(bucket, 0, 7, true, _diagnostic_collector) {
1119 #[allow(unused_variables)]
1120 if let Some(outpost_id) = crate::endpoint_lib::substring::substring(bucket, 32, 49, true, _diagnostic_collector) {
1121 #[allow(unused_variables)]
1122 if let Some(region_partition) = partition_resolver.resolve_partition(region, _diagnostic_collector) {
1123 if (bucket_alias_suffix) == ("--op-s3") {
1124 if crate::endpoint_lib::host::is_valid_host_label(outpost_id, false, _diagnostic_collector) {
1125 if (hardware_type) == ("e") {
1126 if (region_prefix) == ("beta") {
1127 if !(endpoint.is_some()) {
1128 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1129 "Expected a endpoint to be specified but no endpoint was found".to_string(),
1130 ));
1131 }
1132 #[allow(unused_variables)]
1133 if let Some(endpoint) = endpoint {
1134 #[allow(unused_variables)]
1135 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
1136 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1137 .url({
1138 let mut out = String::new();
1139 out.push_str("https://");
1140 #[allow(clippy::needless_borrow)]
1141 out.push_str(&bucket);
1142 out.push_str(".ec2.");
1143 #[allow(clippy::needless_borrow)]
1144 out.push_str(&url.authority());
1145 out
1146 })
1147 .property(
1148 "authSchemes",
1149 vec![
1150 ::aws_smithy_types::Document::from({
1151 let mut out =
1152 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new(
1153 );
1154 out.insert("disableDoubleEncoding".to_string(), true.into());
1155 out.insert("name".to_string(), "sigv4a".to_string().into());
1156 out.insert("signingName".to_string(), "s3-outposts".to_string().into());
1157 out.insert(
1158 "signingRegionSet".to_string(),
1159 vec![::aws_smithy_types::Document::from("*".to_string())].into(),
1160 );
1161 out
1162 }),
1163 ::aws_smithy_types::Document::from({
1164 let mut out =
1165 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new(
1166 );
1167 out.insert("disableDoubleEncoding".to_string(), true.into());
1168 out.insert("name".to_string(), "sigv4".to_string().into());
1169 out.insert("signingName".to_string(), "s3-outposts".to_string().into());
1170 out.insert("signingRegion".to_string(), region.to_owned().into());
1171 out
1172 }),
1173 ],
1174 )
1175 .build());
1176 }
1177 }
1178 #[allow(unreachable_code)]
1179 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
1180 "No rules matched these parameters. This is a bug. {:?}",
1181 _params
1182 )));
1183 }
1184 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1185 .url({
1186 let mut out = String::new();
1187 out.push_str("https://");
1188 #[allow(clippy::needless_borrow)]
1189 out.push_str(&bucket);
1190 out.push_str(".ec2.s3-outposts.");
1191 #[allow(clippy::needless_borrow)]
1192 out.push_str(®ion);
1193 out.push('.');
1194 #[allow(clippy::needless_borrow)]
1195 out.push_str(®ion_partition.dns_suffix());
1196 out
1197 })
1198 .property(
1199 "authSchemes",
1200 vec![
1201 ::aws_smithy_types::Document::from({
1202 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1203 out.insert("disableDoubleEncoding".to_string(), true.into());
1204 out.insert("name".to_string(), "sigv4a".to_string().into());
1205 out.insert("signingName".to_string(), "s3-outposts".to_string().into());
1206 out.insert(
1207 "signingRegionSet".to_string(),
1208 vec![::aws_smithy_types::Document::from("*".to_string())].into(),
1209 );
1210 out
1211 }),
1212 ::aws_smithy_types::Document::from({
1213 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1214 out.insert("disableDoubleEncoding".to_string(), true.into());
1215 out.insert("name".to_string(), "sigv4".to_string().into());
1216 out.insert("signingName".to_string(), "s3-outposts".to_string().into());
1217 out.insert("signingRegion".to_string(), region.to_owned().into());
1218 out
1219 }),
1220 ],
1221 )
1222 .build());
1223 }
1224 if (hardware_type) == ("o") {
1225 if (region_prefix) == ("beta") {
1226 if !(endpoint.is_some()) {
1227 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1228 "Expected a endpoint to be specified but no endpoint was found".to_string(),
1229 ));
1230 }
1231 #[allow(unused_variables)]
1232 if let Some(endpoint) = endpoint {
1233 #[allow(unused_variables)]
1234 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
1235 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1236 .url({
1237 let mut out = String::new();
1238 out.push_str("https://");
1239 #[allow(clippy::needless_borrow)]
1240 out.push_str(&bucket);
1241 out.push_str(".op-");
1242 #[allow(clippy::needless_borrow)]
1243 out.push_str(&outpost_id);
1244 out.push('.');
1245 #[allow(clippy::needless_borrow)]
1246 out.push_str(&url.authority());
1247 out
1248 })
1249 .property(
1250 "authSchemes",
1251 vec![
1252 ::aws_smithy_types::Document::from({
1253 let mut out =
1254 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new(
1255 );
1256 out.insert("disableDoubleEncoding".to_string(), true.into());
1257 out.insert("name".to_string(), "sigv4a".to_string().into());
1258 out.insert("signingName".to_string(), "s3-outposts".to_string().into());
1259 out.insert(
1260 "signingRegionSet".to_string(),
1261 vec![::aws_smithy_types::Document::from("*".to_string())].into(),
1262 );
1263 out
1264 }),
1265 ::aws_smithy_types::Document::from({
1266 let mut out =
1267 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new(
1268 );
1269 out.insert("disableDoubleEncoding".to_string(), true.into());
1270 out.insert("name".to_string(), "sigv4".to_string().into());
1271 out.insert("signingName".to_string(), "s3-outposts".to_string().into());
1272 out.insert("signingRegion".to_string(), region.to_owned().into());
1273 out
1274 }),
1275 ],
1276 )
1277 .build());
1278 }
1279 }
1280 #[allow(unreachable_code)]
1281 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
1282 "No rules matched these parameters. This is a bug. {:?}",
1283 _params
1284 )));
1285 }
1286 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1287 .url({
1288 let mut out = String::new();
1289 out.push_str("https://");
1290 #[allow(clippy::needless_borrow)]
1291 out.push_str(&bucket);
1292 out.push_str(".op-");
1293 #[allow(clippy::needless_borrow)]
1294 out.push_str(&outpost_id);
1295 out.push_str(".s3-outposts.");
1296 #[allow(clippy::needless_borrow)]
1297 out.push_str(®ion);
1298 out.push('.');
1299 #[allow(clippy::needless_borrow)]
1300 out.push_str(®ion_partition.dns_suffix());
1301 out
1302 })
1303 .property(
1304 "authSchemes",
1305 vec![
1306 ::aws_smithy_types::Document::from({
1307 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1308 out.insert("disableDoubleEncoding".to_string(), true.into());
1309 out.insert("name".to_string(), "sigv4a".to_string().into());
1310 out.insert("signingName".to_string(), "s3-outposts".to_string().into());
1311 out.insert(
1312 "signingRegionSet".to_string(),
1313 vec![::aws_smithy_types::Document::from("*".to_string())].into(),
1314 );
1315 out
1316 }),
1317 ::aws_smithy_types::Document::from({
1318 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1319 out.insert("disableDoubleEncoding".to_string(), true.into());
1320 out.insert("name".to_string(), "sigv4".to_string().into());
1321 out.insert("signingName".to_string(), "s3-outposts".to_string().into());
1322 out.insert("signingRegion".to_string(), region.to_owned().into());
1323 out
1324 }),
1325 ],
1326 )
1327 .build());
1328 }
1329 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
1330 let mut out = String::new();
1331 out.push_str("Unrecognized hardware type: \"Expected hardware type o or e but got ");
1332 #[allow(clippy::needless_borrow)]
1333 out.push_str(&hardware_type);
1334 out.push('"');
1335 out
1336 }));
1337 }
1338 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1339 "Invalid ARN: The outpost Id must only contain a-z, A-Z, 0-9 and `-`.".to_string(),
1340 ));
1341 }
1342 }
1343 }
1344 }
1345 }
1346 }
1347 }
1348 #[allow(unused_variables)]
1349 if let Some(bucket) = bucket {
1350 #[allow(unused_variables)]
1351 if let Some(endpoint) = endpoint {
1352 if !(crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector).is_some()) {
1353 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
1354 let mut out = String::new();
1355 out.push_str("Custom endpoint `");
1356 #[allow(clippy::needless_borrow)]
1357 out.push_str(&endpoint);
1358 out.push_str("` was not a valid URI");
1359 out
1360 }));
1361 }
1362 }
1363 if (*force_path_style) == (false) {
1364 if crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(bucket, false, _diagnostic_collector) {
1365 #[allow(unused_variables)]
1366 if let Some(partition_result) = partition_resolver.resolve_partition(region, _diagnostic_collector) {
1367 if crate::endpoint_lib::host::is_valid_host_label(region, false, _diagnostic_collector) {
1368 if (*accelerate) == (true) {
1369 if (partition_result.name()) == ("aws-cn") {
1370 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
1371 "S3 Accelerate cannot be used in this region".to_string(),
1372 ));
1373 }
1374 }
1375 if (*use_dual_stack) == (true) {
1376 if (*use_fips) == (true) {
1377 if (*accelerate) == (false) {
1378 if !(endpoint.is_some()) {
1379 if (region) == ("aws-global") {
1380 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1381 .url({
1382 let mut out = String::new();
1383 out.push_str("https://");
1384 #[allow(clippy::needless_borrow)]
1385 out.push_str(&bucket);
1386 out.push_str(".s3-fips.dualstack.us-east-1.");
1387 #[allow(clippy::needless_borrow)]
1388 out.push_str(&partition_result.dns_suffix());
1389 out
1390 })
1391 .property(
1392 "authSchemes",
1393 vec![::aws_smithy_types::Document::from({
1394 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1395 out.insert("disableDoubleEncoding".to_string(), true.into());
1396 out.insert("name".to_string(), "sigv4".to_string().into());
1397 out.insert("signingName".to_string(), "s3".to_string().into());
1398 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1399 out
1400 })],
1401 )
1402 .build());
1403 }
1404 }
1405 }
1406 }
1407 }
1408 if (*use_dual_stack) == (true) {
1409 if (*use_fips) == (true) {
1410 if (*accelerate) == (false) {
1411 if !(endpoint.is_some()) {
1412 if !((region) == ("aws-global")) {
1413 if (*use_global_endpoint) == (true) {
1414 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1415 .url({
1416 let mut out = String::new();
1417 out.push_str("https://");
1418 #[allow(clippy::needless_borrow)]
1419 out.push_str(&bucket);
1420 out.push_str(".s3-fips.dualstack.");
1421 #[allow(clippy::needless_borrow)]
1422 out.push_str(®ion);
1423 out.push('.');
1424 #[allow(clippy::needless_borrow)]
1425 out.push_str(&partition_result.dns_suffix());
1426 out
1427 })
1428 .property(
1429 "authSchemes",
1430 vec![::aws_smithy_types::Document::from({
1431 let mut out =
1432 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1433 out.insert("disableDoubleEncoding".to_string(), true.into());
1434 out.insert("name".to_string(), "sigv4".to_string().into());
1435 out.insert("signingName".to_string(), "s3".to_string().into());
1436 out.insert("signingRegion".to_string(), region.to_owned().into());
1437 out
1438 })],
1439 )
1440 .build());
1441 }
1442 }
1443 }
1444 }
1445 }
1446 }
1447 if (*use_dual_stack) == (true) {
1448 if (*use_fips) == (true) {
1449 if (*accelerate) == (false) {
1450 if !(endpoint.is_some()) {
1451 if !((region) == ("aws-global")) {
1452 if (*use_global_endpoint) == (false) {
1453 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1454 .url({
1455 let mut out = String::new();
1456 out.push_str("https://");
1457 #[allow(clippy::needless_borrow)]
1458 out.push_str(&bucket);
1459 out.push_str(".s3-fips.dualstack.");
1460 #[allow(clippy::needless_borrow)]
1461 out.push_str(®ion);
1462 out.push('.');
1463 #[allow(clippy::needless_borrow)]
1464 out.push_str(&partition_result.dns_suffix());
1465 out
1466 })
1467 .property(
1468 "authSchemes",
1469 vec![::aws_smithy_types::Document::from({
1470 let mut out =
1471 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1472 out.insert("disableDoubleEncoding".to_string(), true.into());
1473 out.insert("name".to_string(), "sigv4".to_string().into());
1474 out.insert("signingName".to_string(), "s3".to_string().into());
1475 out.insert("signingRegion".to_string(), region.to_owned().into());
1476 out
1477 })],
1478 )
1479 .build());
1480 }
1481 }
1482 }
1483 }
1484 }
1485 }
1486 if (*use_dual_stack) == (false) {
1487 if (*use_fips) == (true) {
1488 if (*accelerate) == (false) {
1489 if !(endpoint.is_some()) {
1490 if (region) == ("aws-global") {
1491 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1492 .url({
1493 let mut out = String::new();
1494 out.push_str("https://");
1495 #[allow(clippy::needless_borrow)]
1496 out.push_str(&bucket);
1497 out.push_str(".s3-fips.us-east-1.");
1498 #[allow(clippy::needless_borrow)]
1499 out.push_str(&partition_result.dns_suffix());
1500 out
1501 })
1502 .property(
1503 "authSchemes",
1504 vec![::aws_smithy_types::Document::from({
1505 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1506 out.insert("disableDoubleEncoding".to_string(), true.into());
1507 out.insert("name".to_string(), "sigv4".to_string().into());
1508 out.insert("signingName".to_string(), "s3".to_string().into());
1509 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1510 out
1511 })],
1512 )
1513 .build());
1514 }
1515 }
1516 }
1517 }
1518 }
1519 if (*use_dual_stack) == (false) {
1520 if (*use_fips) == (true) {
1521 if (*accelerate) == (false) {
1522 if !(endpoint.is_some()) {
1523 if !((region) == ("aws-global")) {
1524 if (*use_global_endpoint) == (true) {
1525 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1526 .url({
1527 let mut out = String::new();
1528 out.push_str("https://");
1529 #[allow(clippy::needless_borrow)]
1530 out.push_str(&bucket);
1531 out.push_str(".s3-fips.");
1532 #[allow(clippy::needless_borrow)]
1533 out.push_str(®ion);
1534 out.push('.');
1535 #[allow(clippy::needless_borrow)]
1536 out.push_str(&partition_result.dns_suffix());
1537 out
1538 })
1539 .property(
1540 "authSchemes",
1541 vec![::aws_smithy_types::Document::from({
1542 let mut out =
1543 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1544 out.insert("disableDoubleEncoding".to_string(), true.into());
1545 out.insert("name".to_string(), "sigv4".to_string().into());
1546 out.insert("signingName".to_string(), "s3".to_string().into());
1547 out.insert("signingRegion".to_string(), region.to_owned().into());
1548 out
1549 })],
1550 )
1551 .build());
1552 }
1553 }
1554 }
1555 }
1556 }
1557 }
1558 if (*use_dual_stack) == (false) {
1559 if (*use_fips) == (true) {
1560 if (*accelerate) == (false) {
1561 if !(endpoint.is_some()) {
1562 if !((region) == ("aws-global")) {
1563 if (*use_global_endpoint) == (false) {
1564 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1565 .url({
1566 let mut out = String::new();
1567 out.push_str("https://");
1568 #[allow(clippy::needless_borrow)]
1569 out.push_str(&bucket);
1570 out.push_str(".s3-fips.");
1571 #[allow(clippy::needless_borrow)]
1572 out.push_str(®ion);
1573 out.push('.');
1574 #[allow(clippy::needless_borrow)]
1575 out.push_str(&partition_result.dns_suffix());
1576 out
1577 })
1578 .property(
1579 "authSchemes",
1580 vec![::aws_smithy_types::Document::from({
1581 let mut out =
1582 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1583 out.insert("disableDoubleEncoding".to_string(), true.into());
1584 out.insert("name".to_string(), "sigv4".to_string().into());
1585 out.insert("signingName".to_string(), "s3".to_string().into());
1586 out.insert("signingRegion".to_string(), region.to_owned().into());
1587 out
1588 })],
1589 )
1590 .build());
1591 }
1592 }
1593 }
1594 }
1595 }
1596 }
1597 if (*use_dual_stack) == (true) {
1598 if (*use_fips) == (false) {
1599 if (*accelerate) == (true) {
1600 if !(endpoint.is_some()) {
1601 if (region) == ("aws-global") {
1602 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1603 .url({
1604 let mut out = String::new();
1605 out.push_str("https://");
1606 #[allow(clippy::needless_borrow)]
1607 out.push_str(&bucket);
1608 out.push_str(".s3-accelerate.dualstack.us-east-1.");
1609 #[allow(clippy::needless_borrow)]
1610 out.push_str(&partition_result.dns_suffix());
1611 out
1612 })
1613 .property(
1614 "authSchemes",
1615 vec![::aws_smithy_types::Document::from({
1616 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1617 out.insert("disableDoubleEncoding".to_string(), true.into());
1618 out.insert("name".to_string(), "sigv4".to_string().into());
1619 out.insert("signingName".to_string(), "s3".to_string().into());
1620 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1621 out
1622 })],
1623 )
1624 .build());
1625 }
1626 }
1627 }
1628 }
1629 }
1630 if (*use_dual_stack) == (true) {
1631 if (*use_fips) == (false) {
1632 if (*accelerate) == (true) {
1633 if !(endpoint.is_some()) {
1634 if !((region) == ("aws-global")) {
1635 if (*use_global_endpoint) == (true) {
1636 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1637 .url({
1638 let mut out = String::new();
1639 out.push_str("https://");
1640 #[allow(clippy::needless_borrow)]
1641 out.push_str(&bucket);
1642 out.push_str(".s3-accelerate.dualstack.");
1643 #[allow(clippy::needless_borrow)]
1644 out.push_str(&partition_result.dns_suffix());
1645 out
1646 })
1647 .property(
1648 "authSchemes",
1649 vec![::aws_smithy_types::Document::from({
1650 let mut out =
1651 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1652 out.insert("disableDoubleEncoding".to_string(), true.into());
1653 out.insert("name".to_string(), "sigv4".to_string().into());
1654 out.insert("signingName".to_string(), "s3".to_string().into());
1655 out.insert("signingRegion".to_string(), region.to_owned().into());
1656 out
1657 })],
1658 )
1659 .build());
1660 }
1661 }
1662 }
1663 }
1664 }
1665 }
1666 if (*use_dual_stack) == (true) {
1667 if (*use_fips) == (false) {
1668 if (*accelerate) == (true) {
1669 if !(endpoint.is_some()) {
1670 if !((region) == ("aws-global")) {
1671 if (*use_global_endpoint) == (false) {
1672 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1673 .url({
1674 let mut out = String::new();
1675 out.push_str("https://");
1676 #[allow(clippy::needless_borrow)]
1677 out.push_str(&bucket);
1678 out.push_str(".s3-accelerate.dualstack.");
1679 #[allow(clippy::needless_borrow)]
1680 out.push_str(&partition_result.dns_suffix());
1681 out
1682 })
1683 .property(
1684 "authSchemes",
1685 vec![::aws_smithy_types::Document::from({
1686 let mut out =
1687 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1688 out.insert("disableDoubleEncoding".to_string(), true.into());
1689 out.insert("name".to_string(), "sigv4".to_string().into());
1690 out.insert("signingName".to_string(), "s3".to_string().into());
1691 out.insert("signingRegion".to_string(), region.to_owned().into());
1692 out
1693 })],
1694 )
1695 .build());
1696 }
1697 }
1698 }
1699 }
1700 }
1701 }
1702 if (*use_dual_stack) == (true) {
1703 if (*use_fips) == (false) {
1704 if (*accelerate) == (false) {
1705 if !(endpoint.is_some()) {
1706 if (region) == ("aws-global") {
1707 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1708 .url({
1709 let mut out = String::new();
1710 out.push_str("https://");
1711 #[allow(clippy::needless_borrow)]
1712 out.push_str(&bucket);
1713 out.push_str(".s3.dualstack.us-east-1.");
1714 #[allow(clippy::needless_borrow)]
1715 out.push_str(&partition_result.dns_suffix());
1716 out
1717 })
1718 .property(
1719 "authSchemes",
1720 vec![::aws_smithy_types::Document::from({
1721 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1722 out.insert("disableDoubleEncoding".to_string(), true.into());
1723 out.insert("name".to_string(), "sigv4".to_string().into());
1724 out.insert("signingName".to_string(), "s3".to_string().into());
1725 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1726 out
1727 })],
1728 )
1729 .build());
1730 }
1731 }
1732 }
1733 }
1734 }
1735 if (*use_dual_stack) == (true) {
1736 if (*use_fips) == (false) {
1737 if (*accelerate) == (false) {
1738 if !(endpoint.is_some()) {
1739 if !((region) == ("aws-global")) {
1740 if (*use_global_endpoint) == (true) {
1741 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1742 .url({
1743 let mut out = String::new();
1744 out.push_str("https://");
1745 #[allow(clippy::needless_borrow)]
1746 out.push_str(&bucket);
1747 out.push_str(".s3.dualstack.");
1748 #[allow(clippy::needless_borrow)]
1749 out.push_str(®ion);
1750 out.push('.');
1751 #[allow(clippy::needless_borrow)]
1752 out.push_str(&partition_result.dns_suffix());
1753 out
1754 })
1755 .property(
1756 "authSchemes",
1757 vec![::aws_smithy_types::Document::from({
1758 let mut out =
1759 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1760 out.insert("disableDoubleEncoding".to_string(), true.into());
1761 out.insert("name".to_string(), "sigv4".to_string().into());
1762 out.insert("signingName".to_string(), "s3".to_string().into());
1763 out.insert("signingRegion".to_string(), region.to_owned().into());
1764 out
1765 })],
1766 )
1767 .build());
1768 }
1769 }
1770 }
1771 }
1772 }
1773 }
1774 if (*use_dual_stack) == (true) {
1775 if (*use_fips) == (false) {
1776 if (*accelerate) == (false) {
1777 if !(endpoint.is_some()) {
1778 if !((region) == ("aws-global")) {
1779 if (*use_global_endpoint) == (false) {
1780 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1781 .url({
1782 let mut out = String::new();
1783 out.push_str("https://");
1784 #[allow(clippy::needless_borrow)]
1785 out.push_str(&bucket);
1786 out.push_str(".s3.dualstack.");
1787 #[allow(clippy::needless_borrow)]
1788 out.push_str(®ion);
1789 out.push('.');
1790 #[allow(clippy::needless_borrow)]
1791 out.push_str(&partition_result.dns_suffix());
1792 out
1793 })
1794 .property(
1795 "authSchemes",
1796 vec![::aws_smithy_types::Document::from({
1797 let mut out =
1798 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1799 out.insert("disableDoubleEncoding".to_string(), true.into());
1800 out.insert("name".to_string(), "sigv4".to_string().into());
1801 out.insert("signingName".to_string(), "s3".to_string().into());
1802 out.insert("signingRegion".to_string(), region.to_owned().into());
1803 out
1804 })],
1805 )
1806 .build());
1807 }
1808 }
1809 }
1810 }
1811 }
1812 }
1813 if (*use_dual_stack) == (false) {
1814 if (*use_fips) == (false) {
1815 if (*accelerate) == (false) {
1816 #[allow(unused_variables)]
1817 if let Some(endpoint) = endpoint {
1818 #[allow(unused_variables)]
1819 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
1820 if (url.is_ip()) == (true) {
1821 if (region) == ("aws-global") {
1822 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1823 .url({
1824 let mut out = String::new();
1825 #[allow(clippy::needless_borrow)]
1826 out.push_str(&url.scheme());
1827 out.push_str("://");
1828 #[allow(clippy::needless_borrow)]
1829 out.push_str(&url.authority());
1830 #[allow(clippy::needless_borrow)]
1831 out.push_str(&url.normalized_path());
1832 #[allow(clippy::needless_borrow)]
1833 out.push_str(&bucket);
1834 out
1835 })
1836 .property(
1837 "authSchemes",
1838 vec![::aws_smithy_types::Document::from({
1839 let mut out =
1840 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1841 out.insert("disableDoubleEncoding".to_string(), true.into());
1842 out.insert("name".to_string(), "sigv4".to_string().into());
1843 out.insert("signingName".to_string(), "s3".to_string().into());
1844 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1845 out
1846 })],
1847 )
1848 .build());
1849 }
1850 }
1851 }
1852 }
1853 }
1854 }
1855 }
1856 if (*use_dual_stack) == (false) {
1857 if (*use_fips) == (false) {
1858 if (*accelerate) == (false) {
1859 #[allow(unused_variables)]
1860 if let Some(endpoint) = endpoint {
1861 #[allow(unused_variables)]
1862 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
1863 if (url.is_ip()) == (false) {
1864 if (region) == ("aws-global") {
1865 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1866 .url({
1867 let mut out = String::new();
1868 #[allow(clippy::needless_borrow)]
1869 out.push_str(&url.scheme());
1870 out.push_str("://");
1871 #[allow(clippy::needless_borrow)]
1872 out.push_str(&bucket);
1873 out.push('.');
1874 #[allow(clippy::needless_borrow)]
1875 out.push_str(&url.authority());
1876 #[allow(clippy::needless_borrow)]
1877 out.push_str(&url.path());
1878 out
1879 })
1880 .property(
1881 "authSchemes",
1882 vec![::aws_smithy_types::Document::from({
1883 let mut out =
1884 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
1885 out.insert("disableDoubleEncoding".to_string(), true.into());
1886 out.insert("name".to_string(), "sigv4".to_string().into());
1887 out.insert("signingName".to_string(), "s3".to_string().into());
1888 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
1889 out
1890 })],
1891 )
1892 .build());
1893 }
1894 }
1895 }
1896 }
1897 }
1898 }
1899 }
1900 if (*use_dual_stack) == (false) {
1901 if (*use_fips) == (false) {
1902 if (*accelerate) == (false) {
1903 #[allow(unused_variables)]
1904 if let Some(endpoint) = endpoint {
1905 #[allow(unused_variables)]
1906 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
1907 if (url.is_ip()) == (true) {
1908 if !((region) == ("aws-global")) {
1909 if (*use_global_endpoint) == (true) {
1910 if (region) == ("us-east-1") {
1911 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1912 .url({
1913 let mut out = String::new();
1914 #[allow(clippy::needless_borrow)]
1915 out.push_str(&url.scheme());
1916 out.push_str("://");
1917 #[allow(clippy::needless_borrow)]
1918 out.push_str(&url.authority());
1919 #[allow(clippy::needless_borrow)]
1920 out.push_str(&url.normalized_path());
1921 #[allow(clippy::needless_borrow)]
1922 out.push_str(&bucket);
1923 out
1924 })
1925 .property(
1926 "authSchemes",
1927 vec![::aws_smithy_types::Document::from({
1928 let mut out = ::std::collections::HashMap::<
1929 String,
1930 ::aws_smithy_types::Document,
1931 >::new(
1932 );
1933 out.insert("disableDoubleEncoding".to_string(), true.into());
1934 out.insert("name".to_string(), "sigv4".to_string().into());
1935 out.insert("signingName".to_string(), "s3".to_string().into());
1936 out.insert("signingRegion".to_string(), region.to_owned().into());
1937 out
1938 })],
1939 )
1940 .build());
1941 }
1942 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1943 .url({
1944 let mut out = String::new();
1945 #[allow(clippy::needless_borrow)]
1946 out.push_str(&url.scheme());
1947 out.push_str("://");
1948 #[allow(clippy::needless_borrow)]
1949 out.push_str(&url.authority());
1950 #[allow(clippy::needless_borrow)]
1951 out.push_str(&url.normalized_path());
1952 #[allow(clippy::needless_borrow)]
1953 out.push_str(&bucket);
1954 out
1955 })
1956 .property(
1957 "authSchemes",
1958 vec![::aws_smithy_types::Document::from({
1959 let mut out =
1960 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new(
1961 );
1962 out.insert("disableDoubleEncoding".to_string(), true.into());
1963 out.insert("name".to_string(), "sigv4".to_string().into());
1964 out.insert("signingName".to_string(), "s3".to_string().into());
1965 out.insert("signingRegion".to_string(), region.to_owned().into());
1966 out
1967 })],
1968 )
1969 .build());
1970 }
1971 }
1972 }
1973 }
1974 }
1975 }
1976 }
1977 }
1978 if (*use_dual_stack) == (false) {
1979 if (*use_fips) == (false) {
1980 if (*accelerate) == (false) {
1981 #[allow(unused_variables)]
1982 if let Some(endpoint) = endpoint {
1983 #[allow(unused_variables)]
1984 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
1985 if (url.is_ip()) == (false) {
1986 if !((region) == ("aws-global")) {
1987 if (*use_global_endpoint) == (true) {
1988 if (region) == ("us-east-1") {
1989 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
1990 .url({
1991 let mut out = String::new();
1992 #[allow(clippy::needless_borrow)]
1993 out.push_str(&url.scheme());
1994 out.push_str("://");
1995 #[allow(clippy::needless_borrow)]
1996 out.push_str(&bucket);
1997 out.push('.');
1998 #[allow(clippy::needless_borrow)]
1999 out.push_str(&url.authority());
2000 #[allow(clippy::needless_borrow)]
2001 out.push_str(&url.path());
2002 out
2003 })
2004 .property(
2005 "authSchemes",
2006 vec![::aws_smithy_types::Document::from({
2007 let mut out = ::std::collections::HashMap::<
2008 String,
2009 ::aws_smithy_types::Document,
2010 >::new(
2011 );
2012 out.insert("disableDoubleEncoding".to_string(), true.into());
2013 out.insert("name".to_string(), "sigv4".to_string().into());
2014 out.insert("signingName".to_string(), "s3".to_string().into());
2015 out.insert("signingRegion".to_string(), region.to_owned().into());
2016 out
2017 })],
2018 )
2019 .build());
2020 }
2021 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2022 .url({
2023 let mut out = String::new();
2024 #[allow(clippy::needless_borrow)]
2025 out.push_str(&url.scheme());
2026 out.push_str("://");
2027 #[allow(clippy::needless_borrow)]
2028 out.push_str(&bucket);
2029 out.push('.');
2030 #[allow(clippy::needless_borrow)]
2031 out.push_str(&url.authority());
2032 #[allow(clippy::needless_borrow)]
2033 out.push_str(&url.path());
2034 out
2035 })
2036 .property(
2037 "authSchemes",
2038 vec![::aws_smithy_types::Document::from({
2039 let mut out =
2040 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new(
2041 );
2042 out.insert("disableDoubleEncoding".to_string(), true.into());
2043 out.insert("name".to_string(), "sigv4".to_string().into());
2044 out.insert("signingName".to_string(), "s3".to_string().into());
2045 out.insert("signingRegion".to_string(), region.to_owned().into());
2046 out
2047 })],
2048 )
2049 .build());
2050 }
2051 }
2052 }
2053 }
2054 }
2055 }
2056 }
2057 }
2058 if (*use_dual_stack) == (false) {
2059 if (*use_fips) == (false) {
2060 if (*accelerate) == (false) {
2061 #[allow(unused_variables)]
2062 if let Some(endpoint) = endpoint {
2063 #[allow(unused_variables)]
2064 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
2065 if (url.is_ip()) == (true) {
2066 if !((region) == ("aws-global")) {
2067 if (*use_global_endpoint) == (false) {
2068 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2069 .url({
2070 let mut out = String::new();
2071 #[allow(clippy::needless_borrow)]
2072 out.push_str(&url.scheme());
2073 out.push_str("://");
2074 #[allow(clippy::needless_borrow)]
2075 out.push_str(&url.authority());
2076 #[allow(clippy::needless_borrow)]
2077 out.push_str(&url.normalized_path());
2078 #[allow(clippy::needless_borrow)]
2079 out.push_str(&bucket);
2080 out
2081 })
2082 .property(
2083 "authSchemes",
2084 vec![::aws_smithy_types::Document::from({
2085 let mut out =
2086 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new(
2087 );
2088 out.insert("disableDoubleEncoding".to_string(), true.into());
2089 out.insert("name".to_string(), "sigv4".to_string().into());
2090 out.insert("signingName".to_string(), "s3".to_string().into());
2091 out.insert("signingRegion".to_string(), region.to_owned().into());
2092 out
2093 })],
2094 )
2095 .build());
2096 }
2097 }
2098 }
2099 }
2100 }
2101 }
2102 }
2103 }
2104 if (*use_dual_stack) == (false) {
2105 if (*use_fips) == (false) {
2106 if (*accelerate) == (false) {
2107 #[allow(unused_variables)]
2108 if let Some(endpoint) = endpoint {
2109 #[allow(unused_variables)]
2110 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
2111 if (url.is_ip()) == (false) {
2112 if !((region) == ("aws-global")) {
2113 if (*use_global_endpoint) == (false) {
2114 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2115 .url({
2116 let mut out = String::new();
2117 #[allow(clippy::needless_borrow)]
2118 out.push_str(&url.scheme());
2119 out.push_str("://");
2120 #[allow(clippy::needless_borrow)]
2121 out.push_str(&bucket);
2122 out.push('.');
2123 #[allow(clippy::needless_borrow)]
2124 out.push_str(&url.authority());
2125 #[allow(clippy::needless_borrow)]
2126 out.push_str(&url.path());
2127 out
2128 })
2129 .property(
2130 "authSchemes",
2131 vec![::aws_smithy_types::Document::from({
2132 let mut out =
2133 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new(
2134 );
2135 out.insert("disableDoubleEncoding".to_string(), true.into());
2136 out.insert("name".to_string(), "sigv4".to_string().into());
2137 out.insert("signingName".to_string(), "s3".to_string().into());
2138 out.insert("signingRegion".to_string(), region.to_owned().into());
2139 out
2140 })],
2141 )
2142 .build());
2143 }
2144 }
2145 }
2146 }
2147 }
2148 }
2149 }
2150 }
2151 if (*use_dual_stack) == (false) {
2152 if (*use_fips) == (false) {
2153 if (*accelerate) == (true) {
2154 if !(endpoint.is_some()) {
2155 if (region) == ("aws-global") {
2156 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2157 .url({
2158 let mut out = String::new();
2159 out.push_str("https://");
2160 #[allow(clippy::needless_borrow)]
2161 out.push_str(&bucket);
2162 out.push_str(".s3-accelerate.");
2163 #[allow(clippy::needless_borrow)]
2164 out.push_str(&partition_result.dns_suffix());
2165 out
2166 })
2167 .property(
2168 "authSchemes",
2169 vec![::aws_smithy_types::Document::from({
2170 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2171 out.insert("disableDoubleEncoding".to_string(), true.into());
2172 out.insert("name".to_string(), "sigv4".to_string().into());
2173 out.insert("signingName".to_string(), "s3".to_string().into());
2174 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2175 out
2176 })],
2177 )
2178 .build());
2179 }
2180 }
2181 }
2182 }
2183 }
2184 if (*use_dual_stack) == (false) {
2185 if (*use_fips) == (false) {
2186 if (*accelerate) == (true) {
2187 if !(endpoint.is_some()) {
2188 if !((region) == ("aws-global")) {
2189 if (*use_global_endpoint) == (true) {
2190 if (region) == ("us-east-1") {
2191 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2192 .url({
2193 let mut out = String::new();
2194 out.push_str("https://");
2195 #[allow(clippy::needless_borrow)]
2196 out.push_str(&bucket);
2197 out.push_str(".s3-accelerate.");
2198 #[allow(clippy::needless_borrow)]
2199 out.push_str(&partition_result.dns_suffix());
2200 out
2201 })
2202 .property(
2203 "authSchemes",
2204 vec![::aws_smithy_types::Document::from({
2205 let mut out =
2206 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2207 out.insert("disableDoubleEncoding".to_string(), true.into());
2208 out.insert("name".to_string(), "sigv4".to_string().into());
2209 out.insert("signingName".to_string(), "s3".to_string().into());
2210 out.insert("signingRegion".to_string(), region.to_owned().into());
2211 out
2212 })],
2213 )
2214 .build());
2215 }
2216 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2217 .url({
2218 let mut out = String::new();
2219 out.push_str("https://");
2220 #[allow(clippy::needless_borrow)]
2221 out.push_str(&bucket);
2222 out.push_str(".s3-accelerate.");
2223 #[allow(clippy::needless_borrow)]
2224 out.push_str(&partition_result.dns_suffix());
2225 out
2226 })
2227 .property(
2228 "authSchemes",
2229 vec![::aws_smithy_types::Document::from({
2230 let mut out =
2231 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2232 out.insert("disableDoubleEncoding".to_string(), true.into());
2233 out.insert("name".to_string(), "sigv4".to_string().into());
2234 out.insert("signingName".to_string(), "s3".to_string().into());
2235 out.insert("signingRegion".to_string(), region.to_owned().into());
2236 out
2237 })],
2238 )
2239 .build());
2240 }
2241 }
2242 }
2243 }
2244 }
2245 }
2246 if (*use_dual_stack) == (false) {
2247 if (*use_fips) == (false) {
2248 if (*accelerate) == (true) {
2249 if !(endpoint.is_some()) {
2250 if !((region) == ("aws-global")) {
2251 if (*use_global_endpoint) == (false) {
2252 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2253 .url({
2254 let mut out = String::new();
2255 out.push_str("https://");
2256 #[allow(clippy::needless_borrow)]
2257 out.push_str(&bucket);
2258 out.push_str(".s3-accelerate.");
2259 #[allow(clippy::needless_borrow)]
2260 out.push_str(&partition_result.dns_suffix());
2261 out
2262 })
2263 .property(
2264 "authSchemes",
2265 vec![::aws_smithy_types::Document::from({
2266 let mut out =
2267 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2268 out.insert("disableDoubleEncoding".to_string(), true.into());
2269 out.insert("name".to_string(), "sigv4".to_string().into());
2270 out.insert("signingName".to_string(), "s3".to_string().into());
2271 out.insert("signingRegion".to_string(), region.to_owned().into());
2272 out
2273 })],
2274 )
2275 .build());
2276 }
2277 }
2278 }
2279 }
2280 }
2281 }
2282 if (*use_dual_stack) == (false) {
2283 if (*use_fips) == (false) {
2284 if (*accelerate) == (false) {
2285 if !(endpoint.is_some()) {
2286 if (region) == ("aws-global") {
2287 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2288 .url({
2289 let mut out = String::new();
2290 out.push_str("https://");
2291 #[allow(clippy::needless_borrow)]
2292 out.push_str(&bucket);
2293 out.push_str(".s3.");
2294 #[allow(clippy::needless_borrow)]
2295 out.push_str(&partition_result.dns_suffix());
2296 out
2297 })
2298 .property(
2299 "authSchemes",
2300 vec![::aws_smithy_types::Document::from({
2301 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2302 out.insert("disableDoubleEncoding".to_string(), true.into());
2303 out.insert("name".to_string(), "sigv4".to_string().into());
2304 out.insert("signingName".to_string(), "s3".to_string().into());
2305 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
2306 out
2307 })],
2308 )
2309 .build());
2310 }
2311 }
2312 }
2313 }
2314 }
2315 if (*use_dual_stack) == (false) {
2316 if (*use_fips) == (false) {
2317 if (*accelerate) == (false) {
2318 if !(endpoint.is_some()) {
2319 if !((region) == ("aws-global")) {
2320 if (*use_global_endpoint) == (true) {
2321 if (region) == ("us-east-1") {
2322 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2323 .url({
2324 let mut out = String::new();
2325 out.push_str("https://");
2326 #[allow(clippy::needless_borrow)]
2327 out.push_str(&bucket);
2328 out.push_str(".s3.");
2329 #[allow(clippy::needless_borrow)]
2330 out.push_str(&partition_result.dns_suffix());
2331 out
2332 })
2333 .property(
2334 "authSchemes",
2335 vec![::aws_smithy_types::Document::from({
2336 let mut out =
2337 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2338 out.insert("disableDoubleEncoding".to_string(), true.into());
2339 out.insert("name".to_string(), "sigv4".to_string().into());
2340 out.insert("signingName".to_string(), "s3".to_string().into());
2341 out.insert("signingRegion".to_string(), region.to_owned().into());
2342 out
2343 })],
2344 )
2345 .build());
2346 }
2347 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2348 .url({
2349 let mut out = String::new();
2350 out.push_str("https://");
2351 #[allow(clippy::needless_borrow)]
2352 out.push_str(&bucket);
2353 out.push_str(".s3.");
2354 #[allow(clippy::needless_borrow)]
2355 out.push_str(®ion);
2356 out.push('.');
2357 #[allow(clippy::needless_borrow)]
2358 out.push_str(&partition_result.dns_suffix());
2359 out
2360 })
2361 .property(
2362 "authSchemes",
2363 vec![::aws_smithy_types::Document::from({
2364 let mut out =
2365 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2366 out.insert("disableDoubleEncoding".to_string(), true.into());
2367 out.insert("name".to_string(), "sigv4".to_string().into());
2368 out.insert("signingName".to_string(), "s3".to_string().into());
2369 out.insert("signingRegion".to_string(), region.to_owned().into());
2370 out
2371 })],
2372 )
2373 .build());
2374 }
2375 }
2376 }
2377 }
2378 }
2379 }
2380 if (*use_dual_stack) == (false) {
2381 if (*use_fips) == (false) {
2382 if (*accelerate) == (false) {
2383 if !(endpoint.is_some()) {
2384 if !((region) == ("aws-global")) {
2385 if (*use_global_endpoint) == (false) {
2386 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2387 .url({
2388 let mut out = String::new();
2389 out.push_str("https://");
2390 #[allow(clippy::needless_borrow)]
2391 out.push_str(&bucket);
2392 out.push_str(".s3.");
2393 #[allow(clippy::needless_borrow)]
2394 out.push_str(®ion);
2395 out.push('.');
2396 #[allow(clippy::needless_borrow)]
2397 out.push_str(&partition_result.dns_suffix());
2398 out
2399 })
2400 .property(
2401 "authSchemes",
2402 vec![::aws_smithy_types::Document::from({
2403 let mut out =
2404 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2405 out.insert("disableDoubleEncoding".to_string(), true.into());
2406 out.insert("name".to_string(), "sigv4".to_string().into());
2407 out.insert("signingName".to_string(), "s3".to_string().into());
2408 out.insert("signingRegion".to_string(), region.to_owned().into());
2409 out
2410 })],
2411 )
2412 .build());
2413 }
2414 }
2415 }
2416 }
2417 }
2418 }
2419 #[allow(unreachable_code)]
2420 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
2421 "No rules matched these parameters. This is a bug. {:?}",
2422 _params
2423 )));
2424 }
2425 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
2426 "Invalid region: region was not a valid DNS name.".to_string(),
2427 ));
2428 }
2429 #[allow(unreachable_code)]
2430 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
2431 "No rules matched these parameters. This is a bug. {:?}",
2432 _params
2433 )));
2434 }
2435 }
2436 #[allow(unused_variables)]
2437 if let Some(endpoint) = endpoint {
2438 #[allow(unused_variables)]
2439 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
2440 if (url.scheme()) == ("http") {
2441 if crate::endpoint_lib::s3::is_virtual_hostable_s3_bucket(bucket, true, _diagnostic_collector) {
2442 if (*force_path_style) == (false) {
2443 if (*use_fips) == (false) {
2444 if (*use_dual_stack) == (false) {
2445 if (*accelerate) == (false) {
2446 #[allow(unused_variables)]
2447 if let Some(partition_result) = partition_resolver.resolve_partition(region, _diagnostic_collector) {
2448 if crate::endpoint_lib::host::is_valid_host_label(region, false, _diagnostic_collector) {
2449 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2450 .url({
2451 let mut out = String::new();
2452 #[allow(clippy::needless_borrow)]
2453 out.push_str(&url.scheme());
2454 out.push_str("://");
2455 #[allow(clippy::needless_borrow)]
2456 out.push_str(&bucket);
2457 out.push('.');
2458 #[allow(clippy::needless_borrow)]
2459 out.push_str(&url.authority());
2460 #[allow(clippy::needless_borrow)]
2461 out.push_str(&url.path());
2462 out
2463 })
2464 .property(
2465 "authSchemes",
2466 vec![::aws_smithy_types::Document::from({
2467 let mut out =
2468 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2469 out.insert("disableDoubleEncoding".to_string(), true.into());
2470 out.insert("name".to_string(), "sigv4".to_string().into());
2471 out.insert("signingName".to_string(), "s3".to_string().into());
2472 out.insert("signingRegion".to_string(), region.to_owned().into());
2473 out
2474 })],
2475 )
2476 .build());
2477 }
2478 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
2479 "Invalid region: region was not a valid DNS name.".to_string(),
2480 ));
2481 }
2482 #[allow(unreachable_code)]
2483 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
2484 "No rules matched these parameters. This is a bug. {:?}",
2485 _params
2486 )));
2487 }
2488 }
2489 }
2490 }
2491 }
2492 }
2493 }
2494 }
2495 if (*force_path_style) == (false) {
2496 #[allow(unused_variables)]
2497 if let Some(bucket_arn) = crate::endpoint_lib::arn::parse_arn(bucket, _diagnostic_collector) {
2498 #[allow(unused_variables)]
2499 if let Some(arn_type) = bucket_arn.resource_id().first().cloned() {
2500 if !((arn_type) == ("")) {
2501 if (bucket_arn.service()) == ("s3-object-lambda") {
2502 if (arn_type) == ("accesspoint") {
2503 #[allow(unused_variables)]
2504 if let Some(access_point_name) = bucket_arn.resource_id().get(1).cloned() {
2505 if !((access_point_name) == ("")) {
2506 if (*use_dual_stack) == (true) {
2507 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
2508 "S3 Object Lambda does not support Dual-stack".to_string(),
2509 ));
2510 }
2511 if (*accelerate) == (true) {
2512 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
2513 "S3 Object Lambda does not support S3 Accelerate".to_string(),
2514 ));
2515 }
2516 if !((bucket_arn.region()) == ("")) {
2517 #[allow(unused_variables)]
2518 if let Some(disable_access_points) = disable_access_points {
2519 if (*disable_access_points) == (true) {
2520 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
2521 "Access points are not supported for this operation".to_string(),
2522 ));
2523 }
2524 }
2525 if !(bucket_arn.resource_id().get(2).cloned().is_some()) {
2526 #[allow(unused_variables)]
2527 if let Some(use_arn_region) = use_arn_region {
2528 if (*use_arn_region) == (false) {
2529 if !((bucket_arn.region()) == (region)) {
2530 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
2531 let mut out = String::new();
2532 out.push_str("Invalid configuration: region from ARN `");
2533 #[allow(clippy::needless_borrow)]
2534 out.push_str(&bucket_arn.region());
2535 out.push_str("` does not match client region `");
2536 #[allow(clippy::needless_borrow)]
2537 out.push_str(®ion);
2538 out.push_str("` and UseArnRegion is `false`");
2539 out
2540 }));
2541 }
2542 }
2543 }
2544 #[allow(unused_variables)]
2545 if let Some(bucket_partition) =
2546 partition_resolver.resolve_partition(bucket_arn.region(), _diagnostic_collector)
2547 {
2548 #[allow(unused_variables)]
2549 if let Some(partition_result) =
2550 partition_resolver.resolve_partition(region, _diagnostic_collector)
2551 {
2552 if (bucket_partition.name()) == (partition_result.name()) {
2553 if crate::endpoint_lib::host::is_valid_host_label(
2554 bucket_arn.region(),
2555 true,
2556 _diagnostic_collector,
2557 ) {
2558 if (bucket_arn.account_id()) == ("") {
2559 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
2560 "Invalid ARN: Missing account id".to_string(),
2561 ));
2562 }
2563 if crate::endpoint_lib::host::is_valid_host_label(
2564 bucket_arn.account_id(),
2565 false,
2566 _diagnostic_collector,
2567 ) {
2568 if crate::endpoint_lib::host::is_valid_host_label(
2569 access_point_name,
2570 false,
2571 _diagnostic_collector,
2572 ) {
2573 #[allow(unused_variables)]
2574 if let Some(endpoint) = endpoint {
2575 #[allow(unused_variables)]
2576 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(
2577 endpoint,
2578 _diagnostic_collector,
2579 ) {
2580 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2581 .url({
2582 let mut out = String::new();
2583 #[allow(clippy::needless_borrow)]
2584 out.push_str(&url.scheme());
2585 out.push_str("://");
2586 #[allow(clippy::needless_borrow)]
2587 out.push_str(&access_point_name);
2588 out.push('-');
2589 #[allow(clippy::needless_borrow)]
2590 out.push_str(&bucket_arn.account_id());
2591 out.push('.');
2592 #[allow(clippy::needless_borrow)]
2593 out.push_str(&url.authority());
2594 #[allow(clippy::needless_borrow)]
2595 out.push_str(&url.path());
2596 out
2597 })
2598 .property(
2599 "authSchemes",
2600 vec![::aws_smithy_types::Document::from({
2601 let mut out = ::std::collections::HashMap::<
2602 String,
2603 ::aws_smithy_types::Document,
2604 >::new(
2605 );
2606 out.insert(
2607 "disableDoubleEncoding".to_string(),
2608 true.into(),
2609 );
2610 out.insert(
2611 "name".to_string(),
2612 "sigv4".to_string().into(),
2613 );
2614 out.insert(
2615 "signingName".to_string(),
2616 "s3-object-lambda".to_string().into(),
2617 );
2618 out.insert(
2619 "signingRegion".to_string(),
2620 bucket_arn.region().to_owned().into(),
2621 );
2622 out
2623 })],
2624 )
2625 .build());
2626 }
2627 }
2628 if (*use_fips) == (true) {
2629 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2630 .url({
2631 let mut out = String::new();
2632 out.push_str("https://");
2633 #[allow(clippy::needless_borrow)]
2634 out.push_str(&access_point_name);
2635 out.push('-');
2636 #[allow(clippy::needless_borrow)]
2637 out.push_str(&bucket_arn.account_id());
2638 out.push_str(".s3-object-lambda-fips.");
2639 #[allow(clippy::needless_borrow)]
2640 out.push_str(&bucket_arn.region());
2641 out.push('.');
2642 #[allow(clippy::needless_borrow)]
2643 out.push_str(&bucket_partition.dns_suffix());
2644 out
2645 })
2646 .property(
2647 "authSchemes",
2648 vec![::aws_smithy_types::Document::from({
2649 let mut out = ::std::collections::HashMap::<
2650 String,
2651 ::aws_smithy_types::Document,
2652 >::new(
2653 );
2654 out.insert(
2655 "disableDoubleEncoding".to_string(),
2656 true.into(),
2657 );
2658 out.insert(
2659 "name".to_string(),
2660 "sigv4".to_string().into(),
2661 );
2662 out.insert(
2663 "signingName".to_string(),
2664 "s3-object-lambda".to_string().into(),
2665 );
2666 out.insert(
2667 "signingRegion".to_string(),
2668 bucket_arn.region().to_owned().into(),
2669 );
2670 out
2671 })],
2672 )
2673 .build());
2674 }
2675 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
2676 .url({
2677 let mut out = String::new();
2678 out.push_str("https://");
2679 #[allow(clippy::needless_borrow)]
2680 out.push_str(&access_point_name);
2681 out.push('-');
2682 #[allow(clippy::needless_borrow)]
2683 out.push_str(&bucket_arn.account_id());
2684 out.push_str(".s3-object-lambda.");
2685 #[allow(clippy::needless_borrow)]
2686 out.push_str(&bucket_arn.region());
2687 out.push('.');
2688 #[allow(clippy::needless_borrow)]
2689 out.push_str(&bucket_partition.dns_suffix());
2690 out
2691 })
2692 .property(
2693 "authSchemes",
2694 vec![::aws_smithy_types::Document::from({
2695 let mut out = ::std::collections::HashMap::<
2696 String,
2697 ::aws_smithy_types::Document,
2698 >::new(
2699 );
2700 out.insert("disableDoubleEncoding".to_string(), true.into());
2701 out.insert("name".to_string(), "sigv4".to_string().into());
2702 out.insert(
2703 "signingName".to_string(),
2704 "s3-object-lambda".to_string().into(),
2705 );
2706 out.insert(
2707 "signingRegion".to_string(),
2708 bucket_arn.region().to_owned().into(),
2709 );
2710 out
2711 })],
2712 )
2713 .build());
2714 }
2715 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
2716 let mut out = String::new();
2717 out.push_str("Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `");
2718 #[allow(clippy::needless_borrow)]
2719 out.push_str(&access_point_name);
2720 out.push('`');
2721 out
2722 }));
2723 }
2724 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
2725 let mut out = String::new();
2726 out.push_str("Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
2727 #[allow(clippy::needless_borrow)]
2728 out.push_str(&bucket_arn.account_id());
2729 out.push('`');
2730 out
2731 }));
2732 }
2733 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
2734 let mut out = String::new();
2735 out.push_str("Invalid region in ARN: `");
2736 #[allow(clippy::needless_borrow)]
2737 out.push_str(&bucket_arn.region());
2738 out.push_str("` (invalid DNS name)");
2739 out
2740 }));
2741 }
2742 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
2743 let mut out = String::new();
2744 out.push_str("Client was configured for partition `");
2745 #[allow(clippy::needless_borrow)]
2746 out.push_str(&partition_result.name());
2747 out.push_str("` but ARN (`");
2748 #[allow(clippy::needless_borrow)]
2749 out.push_str(&bucket);
2750 out.push_str("`) has `");
2751 #[allow(clippy::needless_borrow)]
2752 out.push_str(&bucket_partition.name());
2753 out.push('`');
2754 out
2755 }));
2756 }
2757 #[allow(unreachable_code)]
2758 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
2759 "No rules matched these parameters. This is a bug. {:?}",
2760 _params
2761 )));
2762 }
2763 #[allow(unreachable_code)]
2764 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
2765 "No rules matched these parameters. This is a bug. {:?}",
2766 _params
2767 )));
2768 }
2769 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
2770 "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
2771 .to_string(),
2772 ));
2773 }
2774 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
2775 "Invalid ARN: bucket ARN is missing a region".to_string(),
2776 ));
2777 }
2778 }
2779 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
2780 "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
2781 .to_string(),
2782 ));
2783 }
2784 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
2785 let mut out = String::new();
2786 out.push_str("Invalid ARN: Object Lambda ARNs only support `accesspoint` arn types, but found: `");
2787 #[allow(clippy::needless_borrow)]
2788 out.push_str(&arn_type);
2789 out.push('`');
2790 out
2791 }));
2792 }
2793 if (arn_type) == ("accesspoint") {
2794 #[allow(unused_variables)]
2795 if let Some(access_point_name) = bucket_arn.resource_id().get(1).cloned() {
2796 if !((access_point_name) == ("")) {
2797 if !((bucket_arn.region()) == ("")) {
2798 if (arn_type) == ("accesspoint") {
2799 if !((bucket_arn.region()) == ("")) {
2800 #[allow(unused_variables)]
2801 if let Some(disable_access_points) = disable_access_points {
2802 if (*disable_access_points) == (true) {
2803 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
2804 "Access points are not supported for this operation".to_string(),
2805 ));
2806 }
2807 }
2808 if !(bucket_arn.resource_id().get(2).cloned().is_some()) {
2809 #[allow(unused_variables)]
2810 if let Some(use_arn_region) = use_arn_region {
2811 if (*use_arn_region) == (false) {
2812 if !((bucket_arn.region()) == (region)) {
2813 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
2814 let mut out = String::new();
2815 out.push_str("Invalid configuration: region from ARN `");
2816 #[allow(clippy::needless_borrow)]
2817 out.push_str(&bucket_arn.region());
2818 out.push_str("` does not match client region `");
2819 #[allow(clippy::needless_borrow)]
2820 out.push_str(®ion);
2821 out.push_str("` and UseArnRegion is `false`");
2822 out
2823 }));
2824 }
2825 }
2826 }
2827 #[allow(unused_variables)]
2828 if let Some(bucket_partition) =
2829 partition_resolver.resolve_partition(bucket_arn.region(), _diagnostic_collector)
2830 {
2831 #[allow(unused_variables)]
2832 if let Some(partition_result) =
2833 partition_resolver.resolve_partition(region, _diagnostic_collector)
2834 {
2835 if (bucket_partition.name()) == (partition_result.name()) {
2836 if crate::endpoint_lib::host::is_valid_host_label(
2837 bucket_arn.region(),
2838 true,
2839 _diagnostic_collector,
2840 ) {
2841 if (bucket_arn.service()) == ("s3") {
2842 if crate::endpoint_lib::host::is_valid_host_label(
2843 bucket_arn.account_id(),
2844 false,
2845 _diagnostic_collector,
2846 ) {
2847 if crate::endpoint_lib::host::is_valid_host_label(
2848 access_point_name,
2849 false,
2850 _diagnostic_collector,
2851 ) {
2852 if (*accelerate) == (true) {
2853 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message("Access Points do not support S3 Accelerate"
2854.to_string()));
2855 }
2856 if (*use_fips) == (true) {
2857 if (*use_dual_stack) == (true) {
2858 return Ok(::aws_smithy_types::endpoint::Endpoint::builder().url({ let mut out = String::new();
2859out.push_str("https://");
2860#[allow(clippy::needless_borrow)]
2861out.push_str(&access_point_name);
2862out.push('-');
2863#[allow(clippy::needless_borrow)]
2864out.push_str(&bucket_arn.account_id());
2865out.push_str(".s3-accesspoint-fips.dualstack.");
2866#[allow(clippy::needless_borrow)]
2867out.push_str(&bucket_arn.region());
2868out.push('.');
2869#[allow(clippy::needless_borrow)]
2870out.push_str(&bucket_partition.dns_suffix());
2871out })
2872.property("authSchemes", vec![::aws_smithy_types::Document::from( {
2873 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2874 out.insert("disableDoubleEncoding".to_string(), true.into());
2875 out.insert("name".to_string(), "sigv4"
2876 .to_string().into());
2877 out.insert("signingName".to_string(), "s3"
2878 .to_string().into());
2879 out.insert("signingRegion".to_string(), bucket_arn.region()
2880 .to_owned().into());
2881 out
2882}),])
2883.build());
2884 }
2885 }
2886 if (*use_fips) == (true) {
2887 if (*use_dual_stack) == (false) {
2888 return Ok(::aws_smithy_types::endpoint::Endpoint::builder().url({ let mut out = String::new();
2889out.push_str("https://");
2890#[allow(clippy::needless_borrow)]
2891out.push_str(&access_point_name);
2892out.push('-');
2893#[allow(clippy::needless_borrow)]
2894out.push_str(&bucket_arn.account_id());
2895out.push_str(".s3-accesspoint-fips.");
2896#[allow(clippy::needless_borrow)]
2897out.push_str(&bucket_arn.region());
2898out.push('.');
2899#[allow(clippy::needless_borrow)]
2900out.push_str(&bucket_partition.dns_suffix());
2901out })
2902.property("authSchemes", vec![::aws_smithy_types::Document::from( {
2903 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2904 out.insert("disableDoubleEncoding".to_string(), true.into());
2905 out.insert("name".to_string(), "sigv4"
2906 .to_string().into());
2907 out.insert("signingName".to_string(), "s3"
2908 .to_string().into());
2909 out.insert("signingRegion".to_string(), bucket_arn.region()
2910 .to_owned().into());
2911 out
2912}),])
2913.build());
2914 }
2915 }
2916 if (*use_fips) == (false) {
2917 if (*use_dual_stack) == (true) {
2918 return Ok(::aws_smithy_types::endpoint::Endpoint::builder().url({ let mut out = String::new();
2919out.push_str("https://");
2920#[allow(clippy::needless_borrow)]
2921out.push_str(&access_point_name);
2922out.push('-');
2923#[allow(clippy::needless_borrow)]
2924out.push_str(&bucket_arn.account_id());
2925out.push_str(".s3-accesspoint.dualstack.");
2926#[allow(clippy::needless_borrow)]
2927out.push_str(&bucket_arn.region());
2928out.push('.');
2929#[allow(clippy::needless_borrow)]
2930out.push_str(&bucket_partition.dns_suffix());
2931out })
2932.property("authSchemes", vec![::aws_smithy_types::Document::from( {
2933 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2934 out.insert("disableDoubleEncoding".to_string(), true.into());
2935 out.insert("name".to_string(), "sigv4"
2936 .to_string().into());
2937 out.insert("signingName".to_string(), "s3"
2938 .to_string().into());
2939 out.insert("signingRegion".to_string(), bucket_arn.region()
2940 .to_owned().into());
2941 out
2942}),])
2943.build());
2944 }
2945 }
2946 if (*use_fips) == (false) {
2947 if (*use_dual_stack) == (false) {
2948 #[allow(unused_variables)]
2949 if let Some(endpoint) = endpoint {
2950 #[allow(unused_variables)]
2951 if let Some(url) =
2952 crate::endpoint_lib::parse_url::parse_url(
2953 endpoint,
2954 _diagnostic_collector,
2955 )
2956 {
2957 return Ok(::aws_smithy_types::endpoint::Endpoint::builder().url({ let mut out = String::new();
2958#[allow(clippy::needless_borrow)]
2959out.push_str(&url.scheme());
2960out.push_str("://");
2961#[allow(clippy::needless_borrow)]
2962out.push_str(&access_point_name);
2963out.push('-');
2964#[allow(clippy::needless_borrow)]
2965out.push_str(&bucket_arn.account_id());
2966out.push('.');
2967#[allow(clippy::needless_borrow)]
2968out.push_str(&url.authority());
2969#[allow(clippy::needless_borrow)]
2970out.push_str(&url.path());
2971out })
2972.property("authSchemes", vec![::aws_smithy_types::Document::from( {
2973 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
2974 out.insert("disableDoubleEncoding".to_string(), true.into());
2975 out.insert("name".to_string(), "sigv4"
2976 .to_string().into());
2977 out.insert("signingName".to_string(), "s3"
2978 .to_string().into());
2979 out.insert("signingRegion".to_string(), bucket_arn.region()
2980 .to_owned().into());
2981 out
2982}),])
2983.build());
2984 }
2985 }
2986 }
2987 }
2988 if (*use_fips) == (false) {
2989 if (*use_dual_stack) == (false) {
2990 return Ok(::aws_smithy_types::endpoint::Endpoint::builder().url({ let mut out = String::new();
2991out.push_str("https://");
2992#[allow(clippy::needless_borrow)]
2993out.push_str(&access_point_name);
2994out.push('-');
2995#[allow(clippy::needless_borrow)]
2996out.push_str(&bucket_arn.account_id());
2997out.push_str(".s3-accesspoint.");
2998#[allow(clippy::needless_borrow)]
2999out.push_str(&bucket_arn.region());
3000out.push('.');
3001#[allow(clippy::needless_borrow)]
3002out.push_str(&bucket_partition.dns_suffix());
3003out })
3004.property("authSchemes", vec![::aws_smithy_types::Document::from( {
3005 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3006 out.insert("disableDoubleEncoding".to_string(), true.into());
3007 out.insert("name".to_string(), "sigv4"
3008 .to_string().into());
3009 out.insert("signingName".to_string(), "s3"
3010 .to_string().into());
3011 out.insert("signingRegion".to_string(), bucket_arn.region()
3012 .to_owned().into());
3013 out
3014}),])
3015.build());
3016 }
3017 }
3018 #[allow(unreachable_code)]
3019return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!("No rules matched these parameters. This is a bug. {:?}", _params)));
3020 }
3021 return Err(
3022 ::aws_smithy_http::endpoint::ResolveEndpointError::message({
3023 let mut out = String::new();
3024 out.push_str("Invalid ARN: The access point name may only contain a-z, A-Z, 0-9 and `-`. Found: `");
3025 #[allow(clippy::needless_borrow)]
3026 out.push_str(&access_point_name);
3027 out.push('`');
3028 out
3029 }),
3030 );
3031 }
3032 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3033 {
3034 let mut out = String::new();
3035 out.push_str("Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
3036 #[allow(clippy::needless_borrow)]
3037 out.push_str(&bucket_arn.account_id());
3038 out.push('`');
3039 out
3040 },
3041 ));
3042 }
3043 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
3044 let mut out = String::new();
3045 out.push_str("Invalid ARN: The ARN was not for the S3 service, found: ");
3046 #[allow(clippy::needless_borrow)]
3047 out.push_str(&bucket_arn.service());
3048 out
3049 }));
3050 }
3051 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
3052 let mut out = String::new();
3053 out.push_str("Invalid region in ARN: `");
3054 #[allow(clippy::needless_borrow)]
3055 out.push_str(&bucket_arn.region());
3056 out.push_str("` (invalid DNS name)");
3057 out
3058 }));
3059 }
3060 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
3061 let mut out = String::new();
3062 out.push_str("Client was configured for partition `");
3063 #[allow(clippy::needless_borrow)]
3064 out.push_str(&partition_result.name());
3065 out.push_str("` but ARN (`");
3066 #[allow(clippy::needless_borrow)]
3067 out.push_str(&bucket);
3068 out.push_str("`) has `");
3069 #[allow(clippy::needless_borrow)]
3070 out.push_str(&bucket_partition.name());
3071 out.push('`');
3072 out
3073 }));
3074 }
3075 #[allow(unreachable_code)]
3076 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
3077 "No rules matched these parameters. This is a bug. {:?}",
3078 _params
3079 )));
3080 }
3081 #[allow(unreachable_code)]
3082 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
3083 "No rules matched these parameters. This is a bug. {:?}",
3084 _params
3085 )));
3086 }
3087 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3088 "Invalid ARN: The ARN may only contain a single resource component after `accesspoint`."
3089 .to_string(),
3090 ));
3091 }
3092 #[allow(unreachable_code)]
3093 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
3094 "No rules matched these parameters. This is a bug. {:?}",
3095 _params
3096 )));
3097 }
3098 #[allow(unreachable_code)]
3099 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
3100 "No rules matched these parameters. This is a bug. {:?}",
3101 _params
3102 )));
3103 }
3104 if crate::endpoint_lib::host::is_valid_host_label(access_point_name, true, _diagnostic_collector) {
3105 if (*use_dual_stack) == (true) {
3106 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3107 "S3 MRAP does not support dual-stack".to_string(),
3108 ));
3109 }
3110 if (*use_fips) == (true) {
3111 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3112 "S3 MRAP does not support FIPS".to_string(),
3113 ));
3114 }
3115 if (*accelerate) == (true) {
3116 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3117 "S3 MRAP does not support S3 Accelerate".to_string(),
3118 ));
3119 }
3120 if (*disable_multi_region_access_points) == (true) {
3121 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3122 "Invalid configuration: Multi-Region Access Point ARNs are disabled.".to_string(),
3123 ));
3124 }
3125 #[allow(unused_variables)]
3126 if let Some(mrap_partition) = partition_resolver.resolve_partition(region, _diagnostic_collector) {
3127 if (mrap_partition.name()) == (bucket_arn.partition()) {
3128 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3129 .url({
3130 let mut out = String::new();
3131 out.push_str("https://");
3132 #[allow(clippy::needless_borrow)]
3133 out.push_str(&access_point_name);
3134 out.push_str(".accesspoint.s3-global.");
3135 #[allow(clippy::needless_borrow)]
3136 out.push_str(&mrap_partition.dns_suffix());
3137 out
3138 })
3139 .property(
3140 "authSchemes",
3141 vec![::aws_smithy_types::Document::from({
3142 let mut out =
3143 ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3144 out.insert("disableDoubleEncoding".to_string(), true.into());
3145 out.insert("name".to_string(), "sigv4a".to_string().into());
3146 out.insert("signingName".to_string(), "s3".to_string().into());
3147 out.insert(
3148 "signingRegionSet".to_string(),
3149 vec![::aws_smithy_types::Document::from("*".to_string())].into(),
3150 );
3151 out
3152 })],
3153 )
3154 .build());
3155 }
3156 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
3157 let mut out = String::new();
3158 out.push_str("Client was configured for partition `");
3159 #[allow(clippy::needless_borrow)]
3160 out.push_str(&mrap_partition.name());
3161 out.push_str("` but bucket referred to partition `");
3162 #[allow(clippy::needless_borrow)]
3163 out.push_str(&bucket_arn.partition());
3164 out.push('`');
3165 out
3166 }));
3167 }
3168 #[allow(unreachable_code)]
3169 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
3170 "No rules matched these parameters. This is a bug. {:?}",
3171 _params
3172 )));
3173 }
3174 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3175 "Invalid Access Point Name".to_string(),
3176 ));
3177 }
3178 }
3179 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3180 "Invalid ARN: Expected a resource of the format `accesspoint:<accesspoint name>` but no name was provided"
3181 .to_string(),
3182 ));
3183 }
3184 if (bucket_arn.service()) == ("s3-outposts") {
3185 if (*use_dual_stack) == (true) {
3186 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3187 "S3 Outposts does not support Dual-stack".to_string(),
3188 ));
3189 }
3190 if (*use_fips) == (true) {
3191 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3192 "S3 Outposts does not support FIPS".to_string(),
3193 ));
3194 }
3195 if (*accelerate) == (true) {
3196 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3197 "S3 Outposts does not support S3 Accelerate".to_string(),
3198 ));
3199 }
3200 #[allow(unused_variables)]
3201 if let Some(_) = bucket_arn.resource_id().get(4).cloned() {
3202 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3203 "Invalid Arn: Outpost Access Point ARN contains sub resources".to_string(),
3204 ));
3205 }
3206 #[allow(unused_variables)]
3207 if let Some(outpost_id) = bucket_arn.resource_id().get(1).cloned() {
3208 if crate::endpoint_lib::host::is_valid_host_label(outpost_id, false, _diagnostic_collector) {
3209 #[allow(unused_variables)]
3210 if let Some(use_arn_region) = use_arn_region {
3211 if (*use_arn_region) == (false) {
3212 if !((bucket_arn.region()) == (region)) {
3213 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
3214 let mut out = String::new();
3215 out.push_str("Invalid configuration: region from ARN `");
3216 #[allow(clippy::needless_borrow)]
3217 out.push_str(&bucket_arn.region());
3218 out.push_str("` does not match client region `");
3219 #[allow(clippy::needless_borrow)]
3220 out.push_str(®ion);
3221 out.push_str("` and UseArnRegion is `false`");
3222 out
3223 }));
3224 }
3225 }
3226 }
3227 #[allow(unused_variables)]
3228 if let Some(bucket_partition) =
3229 partition_resolver.resolve_partition(bucket_arn.region(), _diagnostic_collector)
3230 {
3231 #[allow(unused_variables)]
3232 if let Some(partition_result) = partition_resolver.resolve_partition(region, _diagnostic_collector) {
3233 if (bucket_partition.name()) == (partition_result.name()) {
3234 if crate::endpoint_lib::host::is_valid_host_label(
3235 bucket_arn.region(),
3236 true,
3237 _diagnostic_collector,
3238 ) {
3239 if crate::endpoint_lib::host::is_valid_host_label(
3240 bucket_arn.account_id(),
3241 false,
3242 _diagnostic_collector,
3243 ) {
3244 #[allow(unused_variables)]
3245 if let Some(outpost_type) = bucket_arn.resource_id().get(2).cloned() {
3246 #[allow(unused_variables)]
3247 if let Some(access_point_name) = bucket_arn.resource_id().get(3).cloned() {
3248 if (outpost_type) == ("accesspoint") {
3249 #[allow(unused_variables)]
3250 if let Some(endpoint) = endpoint {
3251 #[allow(unused_variables)]
3252 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(
3253 endpoint,
3254 _diagnostic_collector,
3255 ) {
3256 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3257 .url({
3258 let mut out = String::new();
3259 out.push_str("https://");
3260 #[allow(clippy::needless_borrow)]
3261 out.push_str(&access_point_name);
3262 out.push('-');
3263 #[allow(clippy::needless_borrow)]
3264 out.push_str(&bucket_arn.account_id());
3265 out.push('.');
3266 #[allow(clippy::needless_borrow)]
3267 out.push_str(&outpost_id);
3268 out.push('.');
3269 #[allow(clippy::needless_borrow)]
3270 out.push_str(&url.authority());
3271 out
3272 })
3273 .property(
3274 "authSchemes",
3275 vec![
3276 ::aws_smithy_types::Document::from({
3277 let mut out = ::std::collections::HashMap::<
3278 String,
3279 ::aws_smithy_types::Document,
3280 >::new(
3281 );
3282 out.insert(
3283 "disableDoubleEncoding".to_string(),
3284 true.into(),
3285 );
3286 out.insert(
3287 "name".to_string(),
3288 "sigv4a".to_string().into(),
3289 );
3290 out.insert(
3291 "signingName".to_string(),
3292 "s3-outposts".to_string().into(),
3293 );
3294 out.insert(
3295 "signingRegionSet".to_string(),
3296 vec![::aws_smithy_types::Document::from(
3297 "*".to_string(),
3298 )]
3299 .into(),
3300 );
3301 out
3302 }),
3303 ::aws_smithy_types::Document::from({
3304 let mut out = ::std::collections::HashMap::<
3305 String,
3306 ::aws_smithy_types::Document,
3307 >::new(
3308 );
3309 out.insert(
3310 "disableDoubleEncoding".to_string(),
3311 true.into(),
3312 );
3313 out.insert(
3314 "name".to_string(),
3315 "sigv4".to_string().into(),
3316 );
3317 out.insert(
3318 "signingName".to_string(),
3319 "s3-outposts".to_string().into(),
3320 );
3321 out.insert(
3322 "signingRegion".to_string(),
3323 bucket_arn.region().to_owned().into(),
3324 );
3325 out
3326 }),
3327 ],
3328 )
3329 .build());
3330 }
3331 }
3332 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3333 .url({
3334 let mut out = String::new();
3335 out.push_str("https://");
3336 #[allow(clippy::needless_borrow)]
3337 out.push_str(&access_point_name);
3338 out.push('-');
3339 #[allow(clippy::needless_borrow)]
3340 out.push_str(&bucket_arn.account_id());
3341 out.push('.');
3342 #[allow(clippy::needless_borrow)]
3343 out.push_str(&outpost_id);
3344 out.push_str(".s3-outposts.");
3345 #[allow(clippy::needless_borrow)]
3346 out.push_str(&bucket_arn.region());
3347 out.push('.');
3348 #[allow(clippy::needless_borrow)]
3349 out.push_str(&bucket_partition.dns_suffix());
3350 out
3351 })
3352 .property(
3353 "authSchemes",
3354 vec![
3355 ::aws_smithy_types::Document::from({
3356 let mut out = ::std::collections::HashMap::<
3357 String,
3358 ::aws_smithy_types::Document,
3359 >::new(
3360 );
3361 out.insert("disableDoubleEncoding".to_string(), true.into());
3362 out.insert("name".to_string(), "sigv4a".to_string().into());
3363 out.insert(
3364 "signingName".to_string(),
3365 "s3-outposts".to_string().into(),
3366 );
3367 out.insert(
3368 "signingRegionSet".to_string(),
3369 vec![::aws_smithy_types::Document::from("*".to_string())]
3370 .into(),
3371 );
3372 out
3373 }),
3374 ::aws_smithy_types::Document::from({
3375 let mut out = ::std::collections::HashMap::<
3376 String,
3377 ::aws_smithy_types::Document,
3378 >::new(
3379 );
3380 out.insert("disableDoubleEncoding".to_string(), true.into());
3381 out.insert("name".to_string(), "sigv4".to_string().into());
3382 out.insert(
3383 "signingName".to_string(),
3384 "s3-outposts".to_string().into(),
3385 );
3386 out.insert(
3387 "signingRegion".to_string(),
3388 bucket_arn.region().to_owned().into(),
3389 );
3390 out
3391 }),
3392 ],
3393 )
3394 .build());
3395 }
3396 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
3397 let mut out = String::new();
3398 out.push_str("Expected an outpost type `accesspoint`, found ");
3399 #[allow(clippy::needless_borrow)]
3400 out.push_str(&outpost_type);
3401 out
3402 }));
3403 }
3404 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3405 "Invalid ARN: expected an access point name".to_string(),
3406 ));
3407 }
3408 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3409 "Invalid ARN: Expected a 4-component resource".to_string(),
3410 ));
3411 }
3412 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
3413 let mut out = String::new();
3414 out.push_str(
3415 "Invalid ARN: The account id may only contain a-z, A-Z, 0-9 and `-`. Found: `",
3416 );
3417 #[allow(clippy::needless_borrow)]
3418 out.push_str(&bucket_arn.account_id());
3419 out.push('`');
3420 out
3421 }));
3422 }
3423 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
3424 let mut out = String::new();
3425 out.push_str("Invalid region in ARN: `");
3426 #[allow(clippy::needless_borrow)]
3427 out.push_str(&bucket_arn.region());
3428 out.push_str("` (invalid DNS name)");
3429 out
3430 }));
3431 }
3432 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
3433 let mut out = String::new();
3434 out.push_str("Client was configured for partition `");
3435 #[allow(clippy::needless_borrow)]
3436 out.push_str(&partition_result.name());
3437 out.push_str("` but ARN (`");
3438 #[allow(clippy::needless_borrow)]
3439 out.push_str(&bucket);
3440 out.push_str("`) has `");
3441 #[allow(clippy::needless_borrow)]
3442 out.push_str(&bucket_partition.name());
3443 out.push('`');
3444 out
3445 }));
3446 }
3447 #[allow(unreachable_code)]
3448 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
3449 "No rules matched these parameters. This is a bug. {:?}",
3450 _params
3451 )));
3452 }
3453 #[allow(unreachable_code)]
3454 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
3455 "No rules matched these parameters. This is a bug. {:?}",
3456 _params
3457 )));
3458 }
3459 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
3460 let mut out = String::new();
3461 out.push_str("Invalid ARN: The outpost Id may only contain a-z, A-Z, 0-9 and `-`. Found: `");
3462 #[allow(clippy::needless_borrow)]
3463 out.push_str(&outpost_id);
3464 out.push('`');
3465 out
3466 }));
3467 }
3468 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3469 "Invalid ARN: The Outpost Id was not set".to_string(),
3470 ));
3471 }
3472 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
3473 let mut out = String::new();
3474 out.push_str("Invalid ARN: Unrecognized format: ");
3475 #[allow(clippy::needless_borrow)]
3476 out.push_str(&bucket);
3477 out.push_str(" (type: ");
3478 #[allow(clippy::needless_borrow)]
3479 out.push_str(&arn_type);
3480 out.push(')');
3481 out
3482 }));
3483 }
3484 }
3485 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3486 "Invalid ARN: No ARN type specified".to_string(),
3487 ));
3488 }
3489 }
3490 #[allow(unused_variables)]
3491 if let Some(arn_prefix) = crate::endpoint_lib::substring::substring(bucket, 0, 4, false, _diagnostic_collector) {
3492 if (arn_prefix) == ("arn:") {
3493 if !(crate::endpoint_lib::arn::parse_arn(bucket, _diagnostic_collector).is_some()) {
3494 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message({
3495 let mut out = String::new();
3496 out.push_str("Invalid ARN: `");
3497 #[allow(clippy::needless_borrow)]
3498 out.push_str(&bucket);
3499 out.push_str("` was not a valid ARN");
3500 out
3501 }));
3502 }
3503 }
3504 }
3505 if (*force_path_style) == (true) {
3506 #[allow(unused_variables)]
3507 if let Some(_) = crate::endpoint_lib::arn::parse_arn(bucket, _diagnostic_collector) {
3508 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
3509 "Path-style addressing cannot be used with ARN buckets".to_string(),
3510 ));
3511 }
3512 }
3513 let uri_encoded_bucket = crate::endpoint_lib::uri_encode::uri_encode(bucket, _diagnostic_collector);
3514 #[allow(unused_variables)]
3515 if let Some(partition_result) = partition_resolver.resolve_partition(region, _diagnostic_collector) {
3516 if (*accelerate) == (false) {
3517 if (*use_dual_stack) == (true) {
3518 if !(endpoint.is_some()) {
3519 if (*use_fips) == (true) {
3520 if (region) == ("aws-global") {
3521 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3522 .url({
3523 let mut out = String::new();
3524 out.push_str("https://s3-fips.dualstack.us-east-1.");
3525 #[allow(clippy::needless_borrow)]
3526 out.push_str(&partition_result.dns_suffix());
3527 out.push('/');
3528 #[allow(clippy::needless_borrow)]
3529 out.push_str(&uri_encoded_bucket);
3530 out
3531 })
3532 .property(
3533 "authSchemes",
3534 vec![::aws_smithy_types::Document::from({
3535 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3536 out.insert("disableDoubleEncoding".to_string(), true.into());
3537 out.insert("name".to_string(), "sigv4".to_string().into());
3538 out.insert("signingName".to_string(), "s3".to_string().into());
3539 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3540 out
3541 })],
3542 )
3543 .build());
3544 }
3545 }
3546 }
3547 }
3548 if (*use_dual_stack) == (true) {
3549 if !(endpoint.is_some()) {
3550 if (*use_fips) == (true) {
3551 if !((region) == ("aws-global")) {
3552 if (*use_global_endpoint) == (true) {
3553 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3554 .url({
3555 let mut out = String::new();
3556 out.push_str("https://s3-fips.dualstack.");
3557 #[allow(clippy::needless_borrow)]
3558 out.push_str(®ion);
3559 out.push('.');
3560 #[allow(clippy::needless_borrow)]
3561 out.push_str(&partition_result.dns_suffix());
3562 out.push('/');
3563 #[allow(clippy::needless_borrow)]
3564 out.push_str(&uri_encoded_bucket);
3565 out
3566 })
3567 .property(
3568 "authSchemes",
3569 vec![::aws_smithy_types::Document::from({
3570 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3571 out.insert("disableDoubleEncoding".to_string(), true.into());
3572 out.insert("name".to_string(), "sigv4".to_string().into());
3573 out.insert("signingName".to_string(), "s3".to_string().into());
3574 out.insert("signingRegion".to_string(), region.to_owned().into());
3575 out
3576 })],
3577 )
3578 .build());
3579 }
3580 }
3581 }
3582 }
3583 }
3584 if (*use_dual_stack) == (true) {
3585 if !(endpoint.is_some()) {
3586 if (*use_fips) == (true) {
3587 if !((region) == ("aws-global")) {
3588 if (*use_global_endpoint) == (false) {
3589 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3590 .url({
3591 let mut out = String::new();
3592 out.push_str("https://s3-fips.dualstack.");
3593 #[allow(clippy::needless_borrow)]
3594 out.push_str(®ion);
3595 out.push('.');
3596 #[allow(clippy::needless_borrow)]
3597 out.push_str(&partition_result.dns_suffix());
3598 out.push('/');
3599 #[allow(clippy::needless_borrow)]
3600 out.push_str(&uri_encoded_bucket);
3601 out
3602 })
3603 .property(
3604 "authSchemes",
3605 vec![::aws_smithy_types::Document::from({
3606 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3607 out.insert("disableDoubleEncoding".to_string(), true.into());
3608 out.insert("name".to_string(), "sigv4".to_string().into());
3609 out.insert("signingName".to_string(), "s3".to_string().into());
3610 out.insert("signingRegion".to_string(), region.to_owned().into());
3611 out
3612 })],
3613 )
3614 .build());
3615 }
3616 }
3617 }
3618 }
3619 }
3620 if (*use_dual_stack) == (false) {
3621 if !(endpoint.is_some()) {
3622 if (*use_fips) == (true) {
3623 if (region) == ("aws-global") {
3624 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3625 .url({
3626 let mut out = String::new();
3627 out.push_str("https://s3-fips.us-east-1.");
3628 #[allow(clippy::needless_borrow)]
3629 out.push_str(&partition_result.dns_suffix());
3630 out.push('/');
3631 #[allow(clippy::needless_borrow)]
3632 out.push_str(&uri_encoded_bucket);
3633 out
3634 })
3635 .property(
3636 "authSchemes",
3637 vec![::aws_smithy_types::Document::from({
3638 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3639 out.insert("disableDoubleEncoding".to_string(), true.into());
3640 out.insert("name".to_string(), "sigv4".to_string().into());
3641 out.insert("signingName".to_string(), "s3".to_string().into());
3642 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3643 out
3644 })],
3645 )
3646 .build());
3647 }
3648 }
3649 }
3650 }
3651 if (*use_dual_stack) == (false) {
3652 if !(endpoint.is_some()) {
3653 if (*use_fips) == (true) {
3654 if !((region) == ("aws-global")) {
3655 if (*use_global_endpoint) == (true) {
3656 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3657 .url({
3658 let mut out = String::new();
3659 out.push_str("https://s3-fips.");
3660 #[allow(clippy::needless_borrow)]
3661 out.push_str(®ion);
3662 out.push('.');
3663 #[allow(clippy::needless_borrow)]
3664 out.push_str(&partition_result.dns_suffix());
3665 out.push('/');
3666 #[allow(clippy::needless_borrow)]
3667 out.push_str(&uri_encoded_bucket);
3668 out
3669 })
3670 .property(
3671 "authSchemes",
3672 vec![::aws_smithy_types::Document::from({
3673 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3674 out.insert("disableDoubleEncoding".to_string(), true.into());
3675 out.insert("name".to_string(), "sigv4".to_string().into());
3676 out.insert("signingName".to_string(), "s3".to_string().into());
3677 out.insert("signingRegion".to_string(), region.to_owned().into());
3678 out
3679 })],
3680 )
3681 .build());
3682 }
3683 }
3684 }
3685 }
3686 }
3687 if (*use_dual_stack) == (false) {
3688 if !(endpoint.is_some()) {
3689 if (*use_fips) == (true) {
3690 if !((region) == ("aws-global")) {
3691 if (*use_global_endpoint) == (false) {
3692 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3693 .url({
3694 let mut out = String::new();
3695 out.push_str("https://s3-fips.");
3696 #[allow(clippy::needless_borrow)]
3697 out.push_str(®ion);
3698 out.push('.');
3699 #[allow(clippy::needless_borrow)]
3700 out.push_str(&partition_result.dns_suffix());
3701 out.push('/');
3702 #[allow(clippy::needless_borrow)]
3703 out.push_str(&uri_encoded_bucket);
3704 out
3705 })
3706 .property(
3707 "authSchemes",
3708 vec![::aws_smithy_types::Document::from({
3709 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3710 out.insert("disableDoubleEncoding".to_string(), true.into());
3711 out.insert("name".to_string(), "sigv4".to_string().into());
3712 out.insert("signingName".to_string(), "s3".to_string().into());
3713 out.insert("signingRegion".to_string(), region.to_owned().into());
3714 out
3715 })],
3716 )
3717 .build());
3718 }
3719 }
3720 }
3721 }
3722 }
3723 if (*use_dual_stack) == (true) {
3724 if !(endpoint.is_some()) {
3725 if (*use_fips) == (false) {
3726 if (region) == ("aws-global") {
3727 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3728 .url({
3729 let mut out = String::new();
3730 out.push_str("https://s3.dualstack.us-east-1.");
3731 #[allow(clippy::needless_borrow)]
3732 out.push_str(&partition_result.dns_suffix());
3733 out.push('/');
3734 #[allow(clippy::needless_borrow)]
3735 out.push_str(&uri_encoded_bucket);
3736 out
3737 })
3738 .property(
3739 "authSchemes",
3740 vec![::aws_smithy_types::Document::from({
3741 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3742 out.insert("disableDoubleEncoding".to_string(), true.into());
3743 out.insert("name".to_string(), "sigv4".to_string().into());
3744 out.insert("signingName".to_string(), "s3".to_string().into());
3745 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3746 out
3747 })],
3748 )
3749 .build());
3750 }
3751 }
3752 }
3753 }
3754 if (*use_dual_stack) == (true) {
3755 if !(endpoint.is_some()) {
3756 if (*use_fips) == (false) {
3757 if !((region) == ("aws-global")) {
3758 if (*use_global_endpoint) == (true) {
3759 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3760 .url({
3761 let mut out = String::new();
3762 out.push_str("https://s3.dualstack.");
3763 #[allow(clippy::needless_borrow)]
3764 out.push_str(®ion);
3765 out.push('.');
3766 #[allow(clippy::needless_borrow)]
3767 out.push_str(&partition_result.dns_suffix());
3768 out.push('/');
3769 #[allow(clippy::needless_borrow)]
3770 out.push_str(&uri_encoded_bucket);
3771 out
3772 })
3773 .property(
3774 "authSchemes",
3775 vec![::aws_smithy_types::Document::from({
3776 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3777 out.insert("disableDoubleEncoding".to_string(), true.into());
3778 out.insert("name".to_string(), "sigv4".to_string().into());
3779 out.insert("signingName".to_string(), "s3".to_string().into());
3780 out.insert("signingRegion".to_string(), region.to_owned().into());
3781 out
3782 })],
3783 )
3784 .build());
3785 }
3786 }
3787 }
3788 }
3789 }
3790 if (*use_dual_stack) == (true) {
3791 if !(endpoint.is_some()) {
3792 if (*use_fips) == (false) {
3793 if !((region) == ("aws-global")) {
3794 if (*use_global_endpoint) == (false) {
3795 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3796 .url({
3797 let mut out = String::new();
3798 out.push_str("https://s3.dualstack.");
3799 #[allow(clippy::needless_borrow)]
3800 out.push_str(®ion);
3801 out.push('.');
3802 #[allow(clippy::needless_borrow)]
3803 out.push_str(&partition_result.dns_suffix());
3804 out.push('/');
3805 #[allow(clippy::needless_borrow)]
3806 out.push_str(&uri_encoded_bucket);
3807 out
3808 })
3809 .property(
3810 "authSchemes",
3811 vec![::aws_smithy_types::Document::from({
3812 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3813 out.insert("disableDoubleEncoding".to_string(), true.into());
3814 out.insert("name".to_string(), "sigv4".to_string().into());
3815 out.insert("signingName".to_string(), "s3".to_string().into());
3816 out.insert("signingRegion".to_string(), region.to_owned().into());
3817 out
3818 })],
3819 )
3820 .build());
3821 }
3822 }
3823 }
3824 }
3825 }
3826 if (*use_dual_stack) == (false) {
3827 #[allow(unused_variables)]
3828 if let Some(endpoint) = endpoint {
3829 #[allow(unused_variables)]
3830 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
3831 if (*use_fips) == (false) {
3832 if (region) == ("aws-global") {
3833 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3834 .url({
3835 let mut out = String::new();
3836 #[allow(clippy::needless_borrow)]
3837 out.push_str(&url.scheme());
3838 out.push_str("://");
3839 #[allow(clippy::needless_borrow)]
3840 out.push_str(&url.authority());
3841 #[allow(clippy::needless_borrow)]
3842 out.push_str(&url.normalized_path());
3843 #[allow(clippy::needless_borrow)]
3844 out.push_str(&uri_encoded_bucket);
3845 out
3846 })
3847 .property(
3848 "authSchemes",
3849 vec![::aws_smithy_types::Document::from({
3850 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3851 out.insert("disableDoubleEncoding".to_string(), true.into());
3852 out.insert("name".to_string(), "sigv4".to_string().into());
3853 out.insert("signingName".to_string(), "s3".to_string().into());
3854 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3855 out
3856 })],
3857 )
3858 .build());
3859 }
3860 }
3861 }
3862 }
3863 }
3864 if (*use_dual_stack) == (false) {
3865 #[allow(unused_variables)]
3866 if let Some(endpoint) = endpoint {
3867 #[allow(unused_variables)]
3868 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
3869 if (*use_fips) == (false) {
3870 if !((region) == ("aws-global")) {
3871 if (*use_global_endpoint) == (true) {
3872 if (region) == ("us-east-1") {
3873 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3874 .url({
3875 let mut out = String::new();
3876 #[allow(clippy::needless_borrow)]
3877 out.push_str(&url.scheme());
3878 out.push_str("://");
3879 #[allow(clippy::needless_borrow)]
3880 out.push_str(&url.authority());
3881 #[allow(clippy::needless_borrow)]
3882 out.push_str(&url.normalized_path());
3883 #[allow(clippy::needless_borrow)]
3884 out.push_str(&uri_encoded_bucket);
3885 out
3886 })
3887 .property(
3888 "authSchemes",
3889 vec![::aws_smithy_types::Document::from({
3890 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3891 out.insert("disableDoubleEncoding".to_string(), true.into());
3892 out.insert("name".to_string(), "sigv4".to_string().into());
3893 out.insert("signingName".to_string(), "s3".to_string().into());
3894 out.insert("signingRegion".to_string(), region.to_owned().into());
3895 out
3896 })],
3897 )
3898 .build());
3899 }
3900 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3901 .url({
3902 let mut out = String::new();
3903 #[allow(clippy::needless_borrow)]
3904 out.push_str(&url.scheme());
3905 out.push_str("://");
3906 #[allow(clippy::needless_borrow)]
3907 out.push_str(&url.authority());
3908 #[allow(clippy::needless_borrow)]
3909 out.push_str(&url.normalized_path());
3910 #[allow(clippy::needless_borrow)]
3911 out.push_str(&uri_encoded_bucket);
3912 out
3913 })
3914 .property(
3915 "authSchemes",
3916 vec![::aws_smithy_types::Document::from({
3917 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3918 out.insert("disableDoubleEncoding".to_string(), true.into());
3919 out.insert("name".to_string(), "sigv4".to_string().into());
3920 out.insert("signingName".to_string(), "s3".to_string().into());
3921 out.insert("signingRegion".to_string(), region.to_owned().into());
3922 out
3923 })],
3924 )
3925 .build());
3926 }
3927 }
3928 }
3929 }
3930 }
3931 }
3932 if (*use_dual_stack) == (false) {
3933 #[allow(unused_variables)]
3934 if let Some(endpoint) = endpoint {
3935 #[allow(unused_variables)]
3936 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
3937 if (*use_fips) == (false) {
3938 if !((region) == ("aws-global")) {
3939 if (*use_global_endpoint) == (false) {
3940 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3941 .url({
3942 let mut out = String::new();
3943 #[allow(clippy::needless_borrow)]
3944 out.push_str(&url.scheme());
3945 out.push_str("://");
3946 #[allow(clippy::needless_borrow)]
3947 out.push_str(&url.authority());
3948 #[allow(clippy::needless_borrow)]
3949 out.push_str(&url.normalized_path());
3950 #[allow(clippy::needless_borrow)]
3951 out.push_str(&uri_encoded_bucket);
3952 out
3953 })
3954 .property(
3955 "authSchemes",
3956 vec![::aws_smithy_types::Document::from({
3957 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3958 out.insert("disableDoubleEncoding".to_string(), true.into());
3959 out.insert("name".to_string(), "sigv4".to_string().into());
3960 out.insert("signingName".to_string(), "s3".to_string().into());
3961 out.insert("signingRegion".to_string(), region.to_owned().into());
3962 out
3963 })],
3964 )
3965 .build());
3966 }
3967 }
3968 }
3969 }
3970 }
3971 }
3972 if (*use_dual_stack) == (false) {
3973 if !(endpoint.is_some()) {
3974 if (*use_fips) == (false) {
3975 if (region) == ("aws-global") {
3976 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
3977 .url({
3978 let mut out = String::new();
3979 out.push_str("https://s3.");
3980 #[allow(clippy::needless_borrow)]
3981 out.push_str(&partition_result.dns_suffix());
3982 out.push('/');
3983 #[allow(clippy::needless_borrow)]
3984 out.push_str(&uri_encoded_bucket);
3985 out
3986 })
3987 .property(
3988 "authSchemes",
3989 vec![::aws_smithy_types::Document::from({
3990 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
3991 out.insert("disableDoubleEncoding".to_string(), true.into());
3992 out.insert("name".to_string(), "sigv4".to_string().into());
3993 out.insert("signingName".to_string(), "s3".to_string().into());
3994 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
3995 out
3996 })],
3997 )
3998 .build());
3999 }
4000 }
4001 }
4002 }
4003 if (*use_dual_stack) == (false) {
4004 if !(endpoint.is_some()) {
4005 if (*use_fips) == (false) {
4006 if !((region) == ("aws-global")) {
4007 if (*use_global_endpoint) == (true) {
4008 if (region) == ("us-east-1") {
4009 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4010 .url({
4011 let mut out = String::new();
4012 out.push_str("https://s3.");
4013 #[allow(clippy::needless_borrow)]
4014 out.push_str(&partition_result.dns_suffix());
4015 out.push('/');
4016 #[allow(clippy::needless_borrow)]
4017 out.push_str(&uri_encoded_bucket);
4018 out
4019 })
4020 .property(
4021 "authSchemes",
4022 vec![::aws_smithy_types::Document::from({
4023 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4024 out.insert("disableDoubleEncoding".to_string(), true.into());
4025 out.insert("name".to_string(), "sigv4".to_string().into());
4026 out.insert("signingName".to_string(), "s3".to_string().into());
4027 out.insert("signingRegion".to_string(), region.to_owned().into());
4028 out
4029 })],
4030 )
4031 .build());
4032 }
4033 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4034 .url({
4035 let mut out = String::new();
4036 out.push_str("https://s3.");
4037 #[allow(clippy::needless_borrow)]
4038 out.push_str(®ion);
4039 out.push('.');
4040 #[allow(clippy::needless_borrow)]
4041 out.push_str(&partition_result.dns_suffix());
4042 out.push('/');
4043 #[allow(clippy::needless_borrow)]
4044 out.push_str(&uri_encoded_bucket);
4045 out
4046 })
4047 .property(
4048 "authSchemes",
4049 vec![::aws_smithy_types::Document::from({
4050 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4051 out.insert("disableDoubleEncoding".to_string(), true.into());
4052 out.insert("name".to_string(), "sigv4".to_string().into());
4053 out.insert("signingName".to_string(), "s3".to_string().into());
4054 out.insert("signingRegion".to_string(), region.to_owned().into());
4055 out
4056 })],
4057 )
4058 .build());
4059 }
4060 }
4061 }
4062 }
4063 }
4064 if (*use_dual_stack) == (false) {
4065 if !(endpoint.is_some()) {
4066 if (*use_fips) == (false) {
4067 if !((region) == ("aws-global")) {
4068 if (*use_global_endpoint) == (false) {
4069 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4070 .url({
4071 let mut out = String::new();
4072 out.push_str("https://s3.");
4073 #[allow(clippy::needless_borrow)]
4074 out.push_str(®ion);
4075 out.push('.');
4076 #[allow(clippy::needless_borrow)]
4077 out.push_str(&partition_result.dns_suffix());
4078 out.push('/');
4079 #[allow(clippy::needless_borrow)]
4080 out.push_str(&uri_encoded_bucket);
4081 out
4082 })
4083 .property(
4084 "authSchemes",
4085 vec![::aws_smithy_types::Document::from({
4086 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4087 out.insert("disableDoubleEncoding".to_string(), true.into());
4088 out.insert("name".to_string(), "sigv4".to_string().into());
4089 out.insert("signingName".to_string(), "s3".to_string().into());
4090 out.insert("signingRegion".to_string(), region.to_owned().into());
4091 out
4092 })],
4093 )
4094 .build());
4095 }
4096 }
4097 }
4098 }
4099 }
4100 #[allow(unreachable_code)]
4101 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
4102 "No rules matched these parameters. This is a bug. {:?}",
4103 _params
4104 )));
4105 }
4106 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
4107 "Path-style addressing cannot be used with S3 Accelerate".to_string(),
4108 ));
4109 }
4110 #[allow(unreachable_code)]
4111 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
4112 "No rules matched these parameters. This is a bug. {:?}",
4113 _params
4114 )));
4115 }
4116 #[allow(unused_variables)]
4117 if let Some(use_object_lambda_endpoint) = use_object_lambda_endpoint {
4118 if (*use_object_lambda_endpoint) == (true) {
4119 #[allow(unused_variables)]
4120 if let Some(partition_result) = partition_resolver.resolve_partition(region, _diagnostic_collector) {
4121 if crate::endpoint_lib::host::is_valid_host_label(region, true, _diagnostic_collector) {
4122 if (*use_dual_stack) == (true) {
4123 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
4124 "S3 Object Lambda does not support Dual-stack".to_string(),
4125 ));
4126 }
4127 if (*accelerate) == (true) {
4128 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
4129 "S3 Object Lambda does not support S3 Accelerate".to_string(),
4130 ));
4131 }
4132 #[allow(unused_variables)]
4133 if let Some(endpoint) = endpoint {
4134 #[allow(unused_variables)]
4135 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
4136 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4137 .url({
4138 let mut out = String::new();
4139 #[allow(clippy::needless_borrow)]
4140 out.push_str(&url.scheme());
4141 out.push_str("://");
4142 #[allow(clippy::needless_borrow)]
4143 out.push_str(&url.authority());
4144 #[allow(clippy::needless_borrow)]
4145 out.push_str(&url.path());
4146 out
4147 })
4148 .property(
4149 "authSchemes",
4150 vec![::aws_smithy_types::Document::from({
4151 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4152 out.insert("disableDoubleEncoding".to_string(), true.into());
4153 out.insert("name".to_string(), "sigv4".to_string().into());
4154 out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
4155 out.insert("signingRegion".to_string(), region.to_owned().into());
4156 out
4157 })],
4158 )
4159 .build());
4160 }
4161 }
4162 if (*use_fips) == (true) {
4163 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4164 .url({
4165 let mut out = String::new();
4166 out.push_str("https://s3-object-lambda-fips.");
4167 #[allow(clippy::needless_borrow)]
4168 out.push_str(®ion);
4169 out.push('.');
4170 #[allow(clippy::needless_borrow)]
4171 out.push_str(&partition_result.dns_suffix());
4172 out
4173 })
4174 .property(
4175 "authSchemes",
4176 vec![::aws_smithy_types::Document::from({
4177 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4178 out.insert("disableDoubleEncoding".to_string(), true.into());
4179 out.insert("name".to_string(), "sigv4".to_string().into());
4180 out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
4181 out.insert("signingRegion".to_string(), region.to_owned().into());
4182 out
4183 })],
4184 )
4185 .build());
4186 }
4187 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4188 .url({
4189 let mut out = String::new();
4190 out.push_str("https://s3-object-lambda.");
4191 #[allow(clippy::needless_borrow)]
4192 out.push_str(®ion);
4193 out.push('.');
4194 #[allow(clippy::needless_borrow)]
4195 out.push_str(&partition_result.dns_suffix());
4196 out
4197 })
4198 .property(
4199 "authSchemes",
4200 vec![::aws_smithy_types::Document::from({
4201 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4202 out.insert("disableDoubleEncoding".to_string(), true.into());
4203 out.insert("name".to_string(), "sigv4".to_string().into());
4204 out.insert("signingName".to_string(), "s3-object-lambda".to_string().into());
4205 out.insert("signingRegion".to_string(), region.to_owned().into());
4206 out
4207 })],
4208 )
4209 .build());
4210 }
4211 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
4212 "Invalid region: region was not a valid DNS name.".to_string(),
4213 ));
4214 }
4215 #[allow(unreachable_code)]
4216 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
4217 "No rules matched these parameters. This is a bug. {:?}",
4218 _params
4219 )));
4220 }
4221 }
4222 if !(bucket.is_some()) {
4223 #[allow(unused_variables)]
4224 if let Some(partition_result) = partition_resolver.resolve_partition(region, _diagnostic_collector) {
4225 if crate::endpoint_lib::host::is_valid_host_label(region, true, _diagnostic_collector) {
4226 if (*use_fips) == (true) {
4227 if (*use_dual_stack) == (true) {
4228 if !(endpoint.is_some()) {
4229 if (region) == ("aws-global") {
4230 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4231 .url({
4232 let mut out = String::new();
4233 out.push_str("https://s3-fips.dualstack.us-east-1.");
4234 #[allow(clippy::needless_borrow)]
4235 out.push_str(&partition_result.dns_suffix());
4236 out
4237 })
4238 .property(
4239 "authSchemes",
4240 vec![::aws_smithy_types::Document::from({
4241 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4242 out.insert("disableDoubleEncoding".to_string(), true.into());
4243 out.insert("name".to_string(), "sigv4".to_string().into());
4244 out.insert("signingName".to_string(), "s3".to_string().into());
4245 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
4246 out
4247 })],
4248 )
4249 .build());
4250 }
4251 }
4252 }
4253 }
4254 if (*use_fips) == (true) {
4255 if (*use_dual_stack) == (true) {
4256 if !(endpoint.is_some()) {
4257 if !((region) == ("aws-global")) {
4258 if (*use_global_endpoint) == (true) {
4259 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4260 .url({
4261 let mut out = String::new();
4262 out.push_str("https://s3-fips.dualstack.");
4263 #[allow(clippy::needless_borrow)]
4264 out.push_str(®ion);
4265 out.push('.');
4266 #[allow(clippy::needless_borrow)]
4267 out.push_str(&partition_result.dns_suffix());
4268 out
4269 })
4270 .property(
4271 "authSchemes",
4272 vec![::aws_smithy_types::Document::from({
4273 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4274 out.insert("disableDoubleEncoding".to_string(), true.into());
4275 out.insert("name".to_string(), "sigv4".to_string().into());
4276 out.insert("signingName".to_string(), "s3".to_string().into());
4277 out.insert("signingRegion".to_string(), region.to_owned().into());
4278 out
4279 })],
4280 )
4281 .build());
4282 }
4283 }
4284 }
4285 }
4286 }
4287 if (*use_fips) == (true) {
4288 if (*use_dual_stack) == (true) {
4289 if !(endpoint.is_some()) {
4290 if !((region) == ("aws-global")) {
4291 if (*use_global_endpoint) == (false) {
4292 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4293 .url({
4294 let mut out = String::new();
4295 out.push_str("https://s3-fips.dualstack.");
4296 #[allow(clippy::needless_borrow)]
4297 out.push_str(®ion);
4298 out.push('.');
4299 #[allow(clippy::needless_borrow)]
4300 out.push_str(&partition_result.dns_suffix());
4301 out
4302 })
4303 .property(
4304 "authSchemes",
4305 vec![::aws_smithy_types::Document::from({
4306 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4307 out.insert("disableDoubleEncoding".to_string(), true.into());
4308 out.insert("name".to_string(), "sigv4".to_string().into());
4309 out.insert("signingName".to_string(), "s3".to_string().into());
4310 out.insert("signingRegion".to_string(), region.to_owned().into());
4311 out
4312 })],
4313 )
4314 .build());
4315 }
4316 }
4317 }
4318 }
4319 }
4320 if (*use_fips) == (true) {
4321 if (*use_dual_stack) == (false) {
4322 if !(endpoint.is_some()) {
4323 if (region) == ("aws-global") {
4324 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4325 .url({
4326 let mut out = String::new();
4327 out.push_str("https://s3-fips.us-east-1.");
4328 #[allow(clippy::needless_borrow)]
4329 out.push_str(&partition_result.dns_suffix());
4330 out
4331 })
4332 .property(
4333 "authSchemes",
4334 vec![::aws_smithy_types::Document::from({
4335 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4336 out.insert("disableDoubleEncoding".to_string(), true.into());
4337 out.insert("name".to_string(), "sigv4".to_string().into());
4338 out.insert("signingName".to_string(), "s3".to_string().into());
4339 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
4340 out
4341 })],
4342 )
4343 .build());
4344 }
4345 }
4346 }
4347 }
4348 if (*use_fips) == (true) {
4349 if (*use_dual_stack) == (false) {
4350 if !(endpoint.is_some()) {
4351 if !((region) == ("aws-global")) {
4352 if (*use_global_endpoint) == (true) {
4353 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4354 .url({
4355 let mut out = String::new();
4356 out.push_str("https://s3-fips.");
4357 #[allow(clippy::needless_borrow)]
4358 out.push_str(®ion);
4359 out.push('.');
4360 #[allow(clippy::needless_borrow)]
4361 out.push_str(&partition_result.dns_suffix());
4362 out
4363 })
4364 .property(
4365 "authSchemes",
4366 vec![::aws_smithy_types::Document::from({
4367 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4368 out.insert("disableDoubleEncoding".to_string(), true.into());
4369 out.insert("name".to_string(), "sigv4".to_string().into());
4370 out.insert("signingName".to_string(), "s3".to_string().into());
4371 out.insert("signingRegion".to_string(), region.to_owned().into());
4372 out
4373 })],
4374 )
4375 .build());
4376 }
4377 }
4378 }
4379 }
4380 }
4381 if (*use_fips) == (true) {
4382 if (*use_dual_stack) == (false) {
4383 if !(endpoint.is_some()) {
4384 if !((region) == ("aws-global")) {
4385 if (*use_global_endpoint) == (false) {
4386 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4387 .url({
4388 let mut out = String::new();
4389 out.push_str("https://s3-fips.");
4390 #[allow(clippy::needless_borrow)]
4391 out.push_str(®ion);
4392 out.push('.');
4393 #[allow(clippy::needless_borrow)]
4394 out.push_str(&partition_result.dns_suffix());
4395 out
4396 })
4397 .property(
4398 "authSchemes",
4399 vec![::aws_smithy_types::Document::from({
4400 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4401 out.insert("disableDoubleEncoding".to_string(), true.into());
4402 out.insert("name".to_string(), "sigv4".to_string().into());
4403 out.insert("signingName".to_string(), "s3".to_string().into());
4404 out.insert("signingRegion".to_string(), region.to_owned().into());
4405 out
4406 })],
4407 )
4408 .build());
4409 }
4410 }
4411 }
4412 }
4413 }
4414 if (*use_fips) == (false) {
4415 if (*use_dual_stack) == (true) {
4416 if !(endpoint.is_some()) {
4417 if (region) == ("aws-global") {
4418 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4419 .url({
4420 let mut out = String::new();
4421 out.push_str("https://s3.dualstack.us-east-1.");
4422 #[allow(clippy::needless_borrow)]
4423 out.push_str(&partition_result.dns_suffix());
4424 out
4425 })
4426 .property(
4427 "authSchemes",
4428 vec![::aws_smithy_types::Document::from({
4429 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4430 out.insert("disableDoubleEncoding".to_string(), true.into());
4431 out.insert("name".to_string(), "sigv4".to_string().into());
4432 out.insert("signingName".to_string(), "s3".to_string().into());
4433 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
4434 out
4435 })],
4436 )
4437 .build());
4438 }
4439 }
4440 }
4441 }
4442 if (*use_fips) == (false) {
4443 if (*use_dual_stack) == (true) {
4444 if !(endpoint.is_some()) {
4445 if !((region) == ("aws-global")) {
4446 if (*use_global_endpoint) == (true) {
4447 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4448 .url({
4449 let mut out = String::new();
4450 out.push_str("https://s3.dualstack.");
4451 #[allow(clippy::needless_borrow)]
4452 out.push_str(®ion);
4453 out.push('.');
4454 #[allow(clippy::needless_borrow)]
4455 out.push_str(&partition_result.dns_suffix());
4456 out
4457 })
4458 .property(
4459 "authSchemes",
4460 vec![::aws_smithy_types::Document::from({
4461 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4462 out.insert("disableDoubleEncoding".to_string(), true.into());
4463 out.insert("name".to_string(), "sigv4".to_string().into());
4464 out.insert("signingName".to_string(), "s3".to_string().into());
4465 out.insert("signingRegion".to_string(), region.to_owned().into());
4466 out
4467 })],
4468 )
4469 .build());
4470 }
4471 }
4472 }
4473 }
4474 }
4475 if (*use_fips) == (false) {
4476 if (*use_dual_stack) == (true) {
4477 if !(endpoint.is_some()) {
4478 if !((region) == ("aws-global")) {
4479 if (*use_global_endpoint) == (false) {
4480 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4481 .url({
4482 let mut out = String::new();
4483 out.push_str("https://s3.dualstack.");
4484 #[allow(clippy::needless_borrow)]
4485 out.push_str(®ion);
4486 out.push('.');
4487 #[allow(clippy::needless_borrow)]
4488 out.push_str(&partition_result.dns_suffix());
4489 out
4490 })
4491 .property(
4492 "authSchemes",
4493 vec![::aws_smithy_types::Document::from({
4494 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4495 out.insert("disableDoubleEncoding".to_string(), true.into());
4496 out.insert("name".to_string(), "sigv4".to_string().into());
4497 out.insert("signingName".to_string(), "s3".to_string().into());
4498 out.insert("signingRegion".to_string(), region.to_owned().into());
4499 out
4500 })],
4501 )
4502 .build());
4503 }
4504 }
4505 }
4506 }
4507 }
4508 if (*use_fips) == (false) {
4509 if (*use_dual_stack) == (false) {
4510 #[allow(unused_variables)]
4511 if let Some(endpoint) = endpoint {
4512 #[allow(unused_variables)]
4513 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
4514 if (region) == ("aws-global") {
4515 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4516 .url({
4517 let mut out = String::new();
4518 #[allow(clippy::needless_borrow)]
4519 out.push_str(&url.scheme());
4520 out.push_str("://");
4521 #[allow(clippy::needless_borrow)]
4522 out.push_str(&url.authority());
4523 #[allow(clippy::needless_borrow)]
4524 out.push_str(&url.path());
4525 out
4526 })
4527 .property(
4528 "authSchemes",
4529 vec![::aws_smithy_types::Document::from({
4530 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4531 out.insert("disableDoubleEncoding".to_string(), true.into());
4532 out.insert("name".to_string(), "sigv4".to_string().into());
4533 out.insert("signingName".to_string(), "s3".to_string().into());
4534 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
4535 out
4536 })],
4537 )
4538 .build());
4539 }
4540 }
4541 }
4542 }
4543 }
4544 if (*use_fips) == (false) {
4545 if (*use_dual_stack) == (false) {
4546 #[allow(unused_variables)]
4547 if let Some(endpoint) = endpoint {
4548 #[allow(unused_variables)]
4549 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
4550 if !((region) == ("aws-global")) {
4551 if (*use_global_endpoint) == (true) {
4552 if (region) == ("us-east-1") {
4553 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4554 .url({
4555 let mut out = String::new();
4556 #[allow(clippy::needless_borrow)]
4557 out.push_str(&url.scheme());
4558 out.push_str("://");
4559 #[allow(clippy::needless_borrow)]
4560 out.push_str(&url.authority());
4561 #[allow(clippy::needless_borrow)]
4562 out.push_str(&url.path());
4563 out
4564 })
4565 .property(
4566 "authSchemes",
4567 vec![::aws_smithy_types::Document::from({
4568 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4569 out.insert("disableDoubleEncoding".to_string(), true.into());
4570 out.insert("name".to_string(), "sigv4".to_string().into());
4571 out.insert("signingName".to_string(), "s3".to_string().into());
4572 out.insert("signingRegion".to_string(), region.to_owned().into());
4573 out
4574 })],
4575 )
4576 .build());
4577 }
4578 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4579 .url({
4580 let mut out = String::new();
4581 #[allow(clippy::needless_borrow)]
4582 out.push_str(&url.scheme());
4583 out.push_str("://");
4584 #[allow(clippy::needless_borrow)]
4585 out.push_str(&url.authority());
4586 #[allow(clippy::needless_borrow)]
4587 out.push_str(&url.path());
4588 out
4589 })
4590 .property(
4591 "authSchemes",
4592 vec![::aws_smithy_types::Document::from({
4593 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4594 out.insert("disableDoubleEncoding".to_string(), true.into());
4595 out.insert("name".to_string(), "sigv4".to_string().into());
4596 out.insert("signingName".to_string(), "s3".to_string().into());
4597 out.insert("signingRegion".to_string(), region.to_owned().into());
4598 out
4599 })],
4600 )
4601 .build());
4602 }
4603 }
4604 }
4605 }
4606 }
4607 }
4608 if (*use_fips) == (false) {
4609 if (*use_dual_stack) == (false) {
4610 #[allow(unused_variables)]
4611 if let Some(endpoint) = endpoint {
4612 #[allow(unused_variables)]
4613 if let Some(url) = crate::endpoint_lib::parse_url::parse_url(endpoint, _diagnostic_collector) {
4614 if !((region) == ("aws-global")) {
4615 if (*use_global_endpoint) == (false) {
4616 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4617 .url({
4618 let mut out = String::new();
4619 #[allow(clippy::needless_borrow)]
4620 out.push_str(&url.scheme());
4621 out.push_str("://");
4622 #[allow(clippy::needless_borrow)]
4623 out.push_str(&url.authority());
4624 #[allow(clippy::needless_borrow)]
4625 out.push_str(&url.path());
4626 out
4627 })
4628 .property(
4629 "authSchemes",
4630 vec![::aws_smithy_types::Document::from({
4631 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4632 out.insert("disableDoubleEncoding".to_string(), true.into());
4633 out.insert("name".to_string(), "sigv4".to_string().into());
4634 out.insert("signingName".to_string(), "s3".to_string().into());
4635 out.insert("signingRegion".to_string(), region.to_owned().into());
4636 out
4637 })],
4638 )
4639 .build());
4640 }
4641 }
4642 }
4643 }
4644 }
4645 }
4646 if (*use_fips) == (false) {
4647 if (*use_dual_stack) == (false) {
4648 if !(endpoint.is_some()) {
4649 if (region) == ("aws-global") {
4650 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4651 .url({
4652 let mut out = String::new();
4653 out.push_str("https://s3.");
4654 #[allow(clippy::needless_borrow)]
4655 out.push_str(&partition_result.dns_suffix());
4656 out
4657 })
4658 .property(
4659 "authSchemes",
4660 vec![::aws_smithy_types::Document::from({
4661 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4662 out.insert("disableDoubleEncoding".to_string(), true.into());
4663 out.insert("name".to_string(), "sigv4".to_string().into());
4664 out.insert("signingName".to_string(), "s3".to_string().into());
4665 out.insert("signingRegion".to_string(), "us-east-1".to_string().into());
4666 out
4667 })],
4668 )
4669 .build());
4670 }
4671 }
4672 }
4673 }
4674 if (*use_fips) == (false) {
4675 if (*use_dual_stack) == (false) {
4676 if !(endpoint.is_some()) {
4677 if !((region) == ("aws-global")) {
4678 if (*use_global_endpoint) == (true) {
4679 if (region) == ("us-east-1") {
4680 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4681 .url({
4682 let mut out = String::new();
4683 out.push_str("https://s3.");
4684 #[allow(clippy::needless_borrow)]
4685 out.push_str(&partition_result.dns_suffix());
4686 out
4687 })
4688 .property(
4689 "authSchemes",
4690 vec![::aws_smithy_types::Document::from({
4691 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4692 out.insert("disableDoubleEncoding".to_string(), true.into());
4693 out.insert("name".to_string(), "sigv4".to_string().into());
4694 out.insert("signingName".to_string(), "s3".to_string().into());
4695 out.insert("signingRegion".to_string(), region.to_owned().into());
4696 out
4697 })],
4698 )
4699 .build());
4700 }
4701 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4702 .url({
4703 let mut out = String::new();
4704 out.push_str("https://s3.");
4705 #[allow(clippy::needless_borrow)]
4706 out.push_str(®ion);
4707 out.push('.');
4708 #[allow(clippy::needless_borrow)]
4709 out.push_str(&partition_result.dns_suffix());
4710 out
4711 })
4712 .property(
4713 "authSchemes",
4714 vec![::aws_smithy_types::Document::from({
4715 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4716 out.insert("disableDoubleEncoding".to_string(), true.into());
4717 out.insert("name".to_string(), "sigv4".to_string().into());
4718 out.insert("signingName".to_string(), "s3".to_string().into());
4719 out.insert("signingRegion".to_string(), region.to_owned().into());
4720 out
4721 })],
4722 )
4723 .build());
4724 }
4725 }
4726 }
4727 }
4728 }
4729 if (*use_fips) == (false) {
4730 if (*use_dual_stack) == (false) {
4731 if !(endpoint.is_some()) {
4732 if !((region) == ("aws-global")) {
4733 if (*use_global_endpoint) == (false) {
4734 return Ok(::aws_smithy_types::endpoint::Endpoint::builder()
4735 .url({
4736 let mut out = String::new();
4737 out.push_str("https://s3.");
4738 #[allow(clippy::needless_borrow)]
4739 out.push_str(®ion);
4740 out.push('.');
4741 #[allow(clippy::needless_borrow)]
4742 out.push_str(&partition_result.dns_suffix());
4743 out
4744 })
4745 .property(
4746 "authSchemes",
4747 vec![::aws_smithy_types::Document::from({
4748 let mut out = ::std::collections::HashMap::<String, ::aws_smithy_types::Document>::new();
4749 out.insert("disableDoubleEncoding".to_string(), true.into());
4750 out.insert("name".to_string(), "sigv4".to_string().into());
4751 out.insert("signingName".to_string(), "s3".to_string().into());
4752 out.insert("signingRegion".to_string(), region.to_owned().into());
4753 out
4754 })],
4755 )
4756 .build());
4757 }
4758 }
4759 }
4760 }
4761 }
4762 #[allow(unreachable_code)]
4763 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
4764 "No rules matched these parameters. This is a bug. {:?}",
4765 _params
4766 )));
4767 }
4768 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
4769 "Invalid region: region was not a valid DNS name.".to_string(),
4770 ));
4771 }
4772 #[allow(unreachable_code)]
4773 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
4774 "No rules matched these parameters. This is a bug. {:?}",
4775 _params
4776 )));
4777 }
4778 #[allow(unreachable_code)]
4779 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(format!(
4780 "No rules matched these parameters. This is a bug. {:?}",
4781 _params
4782 )));
4783 }
4784 return Err(::aws_smithy_http::endpoint::ResolveEndpointError::message(
4785 "A region must be set when sending requests to S3.".to_string(),
4786 ));
4787}