• aidl-parser 0.12.3/src/traverse.rs
    85
    		 
    #[allow(clippy::needless_borrow)] // because of false-positives when invoking macros...
    86
    		 
    fn walk_symbols_with_control_flow<'a, V, F>(
  • arti-client 0.8.0/src/address.rs
    516
    		 
            // This tests impl DangerouslyIntoTorAddr for &T
    517
    		 
            #[allow(clippy::needless_borrow)]
    518
    		 
            check(&(ip, 443), "203.0.133.6:443");
  • askama_shared 0.12.2/src/filters/mod.rs
    610
    		 
        #[allow(clippy::needless_borrow)]
    611
    		 
        #[test]
  • aws-sdk-accessanalyzer 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://access-analyzer-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://access-analyzer.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://access-analyzer-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-accessanalyzer 0.24.0/src/input.rs
    63
    		 
        #[allow(clippy::let_and_return)]
    64
    		 
        #[allow(clippy::needless_borrow)]
    65
    		 
        pub async fn make_operation(
    225
    		 
        #[allow(clippy::let_and_return)]
    226
    		 
        #[allow(clippy::needless_borrow)]
    227
    		 
        pub async fn make_operation(
    431
    		 
        #[allow(clippy::let_and_return)]
    432
    		 
        #[allow(clippy::needless_borrow)]
    433
    		 
        pub async fn make_operation(
    669
    		 
        #[allow(clippy::let_and_return)]
    670
    		 
        #[allow(clippy::needless_borrow)]
    671
    		 
        pub async fn make_operation(
    887
    		 
        #[allow(clippy::let_and_return)]
    888
    		 
        #[allow(clippy::needless_borrow)]
    889
    		 
        pub async fn make_operation(
  • aws-sdk-account 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://account-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    69
    		 
                                out.push_str("https://account-fips.");
    70
    		 
                                #[allow(clippy::needless_borrow)]
    71
    		 
                                out.push_str(&region);
    86
    		 
                                out.push_str("https://account.");
    87
    		 
                                #[allow(clippy::needless_borrow)]
    88
    		 
                                out.push_str(&region);
    122
    		 
                                        out.push_str("https://account-fips.");
    123
    		 
                                        #[allow(clippy::needless_borrow)]
    124
    		 
                                        out.push_str(&region);
    140
    		 
                                out.push_str("https://account-fips.");
    141
    		 
                                #[allow(clippy::needless_borrow)]
    142
    		 
                                out.push_str(&region);
  • aws-sdk-account 0.24.0/src/input.rs
    64
    		 
        #[allow(clippy::let_and_return)]
    65
    		 
        #[allow(clippy::needless_borrow)]
    66
    		 
        pub async fn make_operation(
    250
    		 
        #[allow(clippy::let_and_return)]
    251
    		 
        #[allow(clippy::needless_borrow)]
    252
    		 
        pub async fn make_operation(
    415
    		 
        #[allow(clippy::let_and_return)]
    416
    		 
        #[allow(clippy::needless_borrow)]
    417
    		 
        pub async fn make_operation(
    664
    		 
        #[allow(clippy::let_and_return)]
    665
    		 
        #[allow(clippy::needless_borrow)]
    666
    		 
        pub async fn make_operation(
    844
    		 
        #[allow(clippy::let_and_return)]
    845
    		 
        #[allow(clippy::needless_borrow)]
    846
    		 
        pub async fn make_operation(
  • aws-sdk-acm 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://acm-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://acm.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://acm-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-acm 0.24.0/src/input.rs
    67
    		 
        #[allow(clippy::let_and_return)]
    68
    		 
        #[allow(clippy::needless_borrow)]
    69
    		 
        pub async fn make_operation(
    240
    		 
        #[allow(clippy::let_and_return)]
    241
    		 
        #[allow(clippy::needless_borrow)]
    242
    		 
        pub async fn make_operation(
    411
    		 
        #[allow(clippy::let_and_return)]
    412
    		 
        #[allow(clippy::needless_borrow)]
    413
    		 
        pub async fn make_operation(
    611
    		 
        #[allow(clippy::let_and_return)]
    612
    		 
        #[allow(clippy::needless_borrow)]
    613
    		 
        pub async fn make_operation(
    761
    		 
        #[allow(clippy::let_and_return)]
    762
    		 
        #[allow(clippy::needless_borrow)]
    763
    		 
        pub async fn make_operation(
  • aws-sdk-acmpca 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://acm-pca-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://acm-pca.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://acm-pca-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-acmpca 0.24.0/src/input.rs
    188
    		 
        #[allow(clippy::let_and_return)]
    189
    		 
        #[allow(clippy::needless_borrow)]
    190
    		 
        pub async fn make_operation(
    393
    		 
        #[allow(clippy::let_and_return)]
    394
    		 
        #[allow(clippy::needless_borrow)]
    395
    		 
        pub async fn make_operation(
    610
    		 
        #[allow(clippy::let_and_return)]
    611
    		 
        #[allow(clippy::needless_borrow)]
    612
    		 
        pub async fn make_operation(
    794
    		 
        #[allow(clippy::let_and_return)]
    795
    		 
        #[allow(clippy::needless_borrow)]
    796
    		 
        pub async fn make_operation(
    992
    		 
        #[allow(clippy::let_and_return)]
    993
    		 
        #[allow(clippy::needless_borrow)]
    994
    		 
        pub async fn make_operation(
  • aws-sdk-alexaforbusiness 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://a4b-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://a4b-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://a4b.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-alexaforbusiness 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    216
    		 
        #[allow(clippy::let_and_return)]
    217
    		 
        #[allow(clippy::needless_borrow)]
    218
    		 
        pub async fn make_operation(
    395
    		 
        #[allow(clippy::let_and_return)]
    396
    		 
        #[allow(clippy::needless_borrow)]
    397
    		 
        pub async fn make_operation(
    571
    		 
        #[allow(clippy::let_and_return)]
    572
    		 
        #[allow(clippy::needless_borrow)]
    573
    		 
        pub async fn make_operation(
    752
    		 
        #[allow(clippy::let_and_return)]
    753
    		 
        #[allow(clippy::needless_borrow)]
    754
    		 
        pub async fn make_operation(
  • aws-sdk-amp 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://aps-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://aps-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://aps.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-amp 0.24.0/src/input.rs
    63
    		 
        #[allow(clippy::let_and_return)]
    64
    		 
        #[allow(clippy::needless_borrow)]
    65
    		 
        pub async fn make_operation(
    276
    		 
        #[allow(clippy::let_and_return)]
    277
    		 
        #[allow(clippy::needless_borrow)]
    278
    		 
        pub async fn make_operation(
    529
    		 
        #[allow(clippy::let_and_return)]
    530
    		 
        #[allow(clippy::needless_borrow)]
    531
    		 
        pub async fn make_operation(
    756
    		 
        #[allow(clippy::let_and_return)]
    757
    		 
        #[allow(clippy::needless_borrow)]
    758
    		 
        pub async fn make_operation(
    930
    		 
        #[allow(clippy::let_and_return)]
    931
    		 
        #[allow(clippy::needless_borrow)]
    932
    		 
        pub async fn make_operation(
  • aws-sdk-amplify 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://amplify-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://amplify-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://amplify.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-amplify 0.24.0/src/input.rs
    374
    		 
        #[allow(clippy::let_and_return)]
    375
    		 
        #[allow(clippy::needless_borrow)]
    376
    		 
        pub async fn make_operation(
    573
    		 
        #[allow(clippy::let_and_return)]
    574
    		 
        #[allow(clippy::needless_borrow)]
    575
    		 
        pub async fn make_operation(
    1034
    		 
        #[allow(clippy::let_and_return)]
    1035
    		 
        #[allow(clippy::needless_borrow)]
    1036
    		 
        pub async fn make_operation(
    1254
    		 
        #[allow(clippy::let_and_return)]
    1255
    		 
        #[allow(clippy::needless_borrow)]
    1256
    		 
        pub async fn make_operation(
    1543
    		 
        #[allow(clippy::let_and_return)]
    1544
    		 
        #[allow(clippy::needless_borrow)]
    1545
    		 
        pub async fn make_operation(
  • aws-sdk-amplifybackend 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://amplifybackend-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://amplifybackend-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://amplifybackend.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-amplifybackend 0.24.0/src/input.rs
    67
    		 
        #[allow(clippy::let_and_return)]
    68
    		 
        #[allow(clippy::needless_borrow)]
    69
    		 
        pub async fn make_operation(
    325
    		 
        #[allow(clippy::let_and_return)]
    326
    		 
        #[allow(clippy::needless_borrow)]
    327
    		 
        pub async fn make_operation(
    529
    		 
        #[allow(clippy::let_and_return)]
    530
    		 
        #[allow(clippy::needless_borrow)]
    531
    		 
        pub async fn make_operation(
    757
    		 
        #[allow(clippy::let_and_return)]
    758
    		 
        #[allow(clippy::needless_borrow)]
    759
    		 
        pub async fn make_operation(
    951
    		 
        #[allow(clippy::let_and_return)]
    952
    		 
        #[allow(clippy::needless_borrow)]
    953
    		 
        pub async fn make_operation(
  • aws-sdk-amplifyuibuilder 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://amplifyuibuilder-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://amplifyuibuilder-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://amplifyuibuilder.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-amplifyuibuilder 0.24.0/src/input.rs
    79
    		 
        #[allow(clippy::let_and_return)]
    80
    		 
        #[allow(clippy::needless_borrow)]
    81
    		 
        pub async fn make_operation(
    340
    		 
        #[allow(clippy::let_and_return)]
    341
    		 
        #[allow(clippy::needless_borrow)]
    342
    		 
        pub async fn make_operation(
    599
    		 
        #[allow(clippy::let_and_return)]
    600
    		 
        #[allow(clippy::needless_borrow)]
    601
    		 
        pub async fn make_operation(
    843
    		 
        #[allow(clippy::let_and_return)]
    844
    		 
        #[allow(clippy::needless_borrow)]
    845
    		 
        pub async fn make_operation(
    1077
    		 
        #[allow(clippy::let_and_return)]
    1078
    		 
        #[allow(clippy::needless_borrow)]
    1079
    		 
        pub async fn make_operation(
  • aws-sdk-apigateway 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://apigateway-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://apigateway-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://apigateway.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-apigateway 0.24.0/src/input.rs
    147
    		 
        #[allow(clippy::let_and_return)]
    148
    		 
        #[allow(clippy::needless_borrow)]
    149
    		 
        pub async fn make_operation(
    448
    		 
        #[allow(clippy::let_and_return)]
    449
    		 
        #[allow(clippy::needless_borrow)]
    450
    		 
        pub async fn make_operation(
    671
    		 
        #[allow(clippy::let_and_return)]
    672
    		 
        #[allow(clippy::needless_borrow)]
    673
    		 
        pub async fn make_operation(
    982
    		 
        #[allow(clippy::let_and_return)]
    983
    		 
        #[allow(clippy::needless_borrow)]
    984
    		 
        pub async fn make_operation(
    1196
    		 
        #[allow(clippy::let_and_return)]
    1197
    		 
        #[allow(clippy::needless_borrow)]
    1198
    		 
        pub async fn make_operation(
  • aws-sdk-apigatewaymanagement 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://execute-api-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://execute-api-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://execute-api.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-apigatewaymanagement 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    212
    		 
        #[allow(clippy::let_and_return)]
    213
    		 
        #[allow(clippy::needless_borrow)]
    214
    		 
        pub async fn make_operation(
    396
    		 
        #[allow(clippy::let_and_return)]
    397
    		 
        #[allow(clippy::needless_borrow)]
    398
    		 
        pub async fn make_operation(
  • aws-sdk-apigatewayv2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://apigateway-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://apigateway-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://apigateway.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-apigatewayv2 0.24.0/src/input.rs
    219
    		 
        #[allow(clippy::let_and_return)]
    220
    		 
        #[allow(clippy::needless_borrow)]
    221
    		 
        pub async fn make_operation(
    415
    		 
        #[allow(clippy::let_and_return)]
    416
    		 
        #[allow(clippy::needless_borrow)]
    417
    		 
        pub async fn make_operation(
    776
    		 
        #[allow(clippy::let_and_return)]
    777
    		 
        #[allow(clippy::needless_borrow)]
    778
    		 
        pub async fn make_operation(
    979
    		 
        #[allow(clippy::let_and_return)]
    980
    		 
        #[allow(clippy::needless_borrow)]
    981
    		 
        pub async fn make_operation(
    1231
    		 
        #[allow(clippy::let_and_return)]
    1232
    		 
        #[allow(clippy::needless_borrow)]
    1233
    		 
        pub async fn make_operation(
  • aws-sdk-appconfig 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://appconfig-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    80
    		 
                            out.push_str("https://appconfig-fips.");
    81
    		 
                            #[allow(clippy::needless_borrow)]
    82
    		 
                            out.push_str(&region);
    83
    		 
                            out.push('.');
    84
    		 
                            #[allow(clippy::needless_borrow)]
    85
    		 
                            out.push_str(&partition_result.dns_suffix());
    99
    		 
                            out.push_str("https://appconfig.");
    100
    		 
                            #[allow(clippy::needless_borrow)]
    101
    		 
                            out.push_str(&region);
  • aws-sdk-appconfig 0.24.0/src/input.rs
    80
    		 
        #[allow(clippy::let_and_return)]
    81
    		 
        #[allow(clippy::needless_borrow)]
    82
    		 
        pub async fn make_operation(
    377
    		 
        #[allow(clippy::let_and_return)]
    378
    		 
        #[allow(clippy::needless_borrow)]
    379
    		 
        pub async fn make_operation(
    684
    		 
        #[allow(clippy::let_and_return)]
    685
    		 
        #[allow(clippy::needless_borrow)]
    686
    		 
        pub async fn make_operation(
    922
    		 
        #[allow(clippy::let_and_return)]
    923
    		 
        #[allow(clippy::needless_borrow)]
    924
    		 
        pub async fn make_operation(
    1220
    		 
        #[allow(clippy::let_and_return)]
    1221
    		 
        #[allow(clippy::needless_borrow)]
    1222
    		 
        pub async fn make_operation(
  • aws-sdk-appconfigdata 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://appconfigdata-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://appconfigdata-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://appconfigdata.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-appconfigdata 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    266
    		 
        #[allow(clippy::let_and_return)]
    267
    		 
        #[allow(clippy::needless_borrow)]
    268
    		 
        pub async fn make_operation(
  • aws-sdk-appflow 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://appflow-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://appflow-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://appflow.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-appflow 0.24.0/src/input.rs
    118
    		 
        #[allow(clippy::let_and_return)]
    119
    		 
        #[allow(clippy::needless_borrow)]
    120
    		 
        pub async fn make_operation(
    425
    		 
        #[allow(clippy::let_and_return)]
    426
    		 
        #[allow(clippy::needless_borrow)]
    427
    		 
        pub async fn make_operation(
    599
    		 
        #[allow(clippy::let_and_return)]
    600
    		 
        #[allow(clippy::needless_borrow)]
    601
    		 
        pub async fn make_operation(
    770
    		 
        #[allow(clippy::let_and_return)]
    771
    		 
        #[allow(clippy::needless_borrow)]
    772
    		 
        pub async fn make_operation(
    947
    		 
        #[allow(clippy::let_and_return)]
    948
    		 
        #[allow(clippy::needless_borrow)]
    949
    		 
        pub async fn make_operation(
  • aws-sdk-appintegrations 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://app-integrations-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://app-integrations-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://app-integrations.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-appintegrations 0.24.0/src/input.rs
    131
    		 
        #[allow(clippy::let_and_return)]
    132
    		 
        #[allow(clippy::needless_borrow)]
    133
    		 
        pub async fn make_operation(
    378
    		 
        #[allow(clippy::let_and_return)]
    379
    		 
        #[allow(clippy::needless_borrow)]
    380
    		 
        pub async fn make_operation(
    548
    		 
        #[allow(clippy::let_and_return)]
    549
    		 
        #[allow(clippy::needless_borrow)]
    550
    		 
        pub async fn make_operation(
    715
    		 
        #[allow(clippy::let_and_return)]
    716
    		 
        #[allow(clippy::needless_borrow)]
    717
    		 
        pub async fn make_operation(
    880
    		 
        #[allow(clippy::let_and_return)]
    881
    		 
        #[allow(clippy::needless_borrow)]
    882
    		 
        pub async fn make_operation(
  • aws-sdk-applicationautoscaling 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://application-autoscaling-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://application-autoscaling.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://application-autoscaling-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-applicationautoscaling 0.24.0/src/input.rs
    161
    		 
        #[allow(clippy::let_and_return)]
    162
    		 
        #[allow(clippy::needless_borrow)]
    163
    		 
        pub async fn make_operation(
    450
    		 
        #[allow(clippy::let_and_return)]
    451
    		 
        #[allow(clippy::needless_borrow)]
    452
    		 
        pub async fn make_operation(
    726
    		 
        #[allow(clippy::let_and_return)]
    727
    		 
        #[allow(clippy::needless_borrow)]
    728
    		 
        pub async fn make_operation(
    1037
    		 
        #[allow(clippy::let_and_return)]
    1038
    		 
        #[allow(clippy::needless_borrow)]
    1039
    		 
        pub async fn make_operation(
    1354
    		 
        #[allow(clippy::let_and_return)]
    1355
    		 
        #[allow(clippy::needless_borrow)]
    1356
    		 
        pub async fn make_operation(
  • aws-sdk-applicationcostprofiler 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://application-cost-profiler-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://application-cost-profiler-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://application-cost-profiler.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-applicationcostprofiler 0.24.0/src/input.rs
    39
    		 
        #[allow(clippy::let_and_return)]
    40
    		 
        #[allow(clippy::needless_borrow)]
    41
    		 
        pub async fn make_operation(
    204
    		 
        #[allow(clippy::let_and_return)]
    205
    		 
        #[allow(clippy::needless_borrow)]
    206
    		 
        pub async fn make_operation(
    372
    		 
        #[allow(clippy::let_and_return)]
    373
    		 
        #[allow(clippy::needless_borrow)]
    374
    		 
        pub async fn make_operation(
    545
    		 
        #[allow(clippy::let_and_return)]
    546
    		 
        #[allow(clippy::needless_borrow)]
    547
    		 
        pub async fn make_operation(
    768
    		 
        #[allow(clippy::let_and_return)]
    769
    		 
        #[allow(clippy::needless_borrow)]
    770
    		 
        pub async fn make_operation(
  • aws-sdk-applicationdiscovery 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://discovery-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://discovery-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://discovery.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-applicationdiscovery 0.24.0/src/input.rs
    68
    		 
        #[allow(clippy::let_and_return)]
    69
    		 
        #[allow(clippy::needless_borrow)]
    70
    		 
        pub async fn make_operation(
    241
    		 
        #[allow(clippy::let_and_return)]
    242
    		 
        #[allow(clippy::needless_borrow)]
    243
    		 
        pub async fn make_operation(
    419
    		 
        #[allow(clippy::let_and_return)]
    420
    		 
        #[allow(clippy::needless_borrow)]
    421
    		 
        pub async fn make_operation(
    613
    		 
        #[allow(clippy::let_and_return)]
    614
    		 
        #[allow(clippy::needless_borrow)]
    615
    		 
        pub async fn make_operation(
    786
    		 
        #[allow(clippy::let_and_return)]
    787
    		 
        #[allow(clippy::needless_borrow)]
    788
    		 
        pub async fn make_operation(
  • aws-sdk-applicationinsights 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://applicationinsights-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://applicationinsights-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://applicationinsights.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-applicationinsights 0.24.0/src/input.rs
    141
    		 
        #[allow(clippy::let_and_return)]
    142
    		 
        #[allow(clippy::needless_borrow)]
    143
    		 
        pub async fn make_operation(
    342
    		 
        #[allow(clippy::let_and_return)]
    343
    		 
        #[allow(clippy::needless_borrow)]
    344
    		 
        pub async fn make_operation(
    560
    		 
        #[allow(clippy::let_and_return)]
    561
    		 
        #[allow(clippy::needless_borrow)]
    562
    		 
        pub async fn make_operation(
    727
    		 
        #[allow(clippy::let_and_return)]
    728
    		 
        #[allow(clippy::needless_borrow)]
    729
    		 
        pub async fn make_operation(
    907
    		 
        #[allow(clippy::let_and_return)]
    908
    		 
        #[allow(clippy::needless_borrow)]
    909
    		 
        pub async fn make_operation(
  • aws-sdk-appmesh 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://appmesh-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://appmesh-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://appmesh.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-appmesh 0.24.0/src/input.rs
    129
    		 
        #[allow(clippy::let_and_return)]
    130
    		 
        #[allow(clippy::needless_borrow)]
    131
    		 
        pub async fn make_operation(
    385
    		 
        #[allow(clippy::let_and_return)]
    386
    		 
        #[allow(clippy::needless_borrow)]
    387
    		 
        pub async fn make_operation(
    629
    		 
        #[allow(clippy::let_and_return)]
    630
    		 
        #[allow(clippy::needless_borrow)]
    631
    		 
        pub async fn make_operation(
    923
    		 
        #[allow(clippy::let_and_return)]
    924
    		 
        #[allow(clippy::needless_borrow)]
    925
    		 
        pub async fn make_operation(
    1199
    		 
        #[allow(clippy::let_and_return)]
    1200
    		 
        #[allow(clippy::needless_borrow)]
    1201
    		 
        pub async fn make_operation(
  • aws-sdk-apprunner 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://apprunner-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://apprunner-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://apprunner.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-apprunner 0.24.0/src/input.rs
    65
    		 
        #[allow(clippy::let_and_return)]
    66
    		 
        #[allow(clippy::needless_borrow)]
    67
    		 
        pub async fn make_operation(
    308
    		 
        #[allow(clippy::let_and_return)]
    309
    		 
        #[allow(clippy::needless_borrow)]
    310
    		 
        pub async fn make_operation(
    511
    		 
        #[allow(clippy::let_and_return)]
    512
    		 
        #[allow(clippy::needless_borrow)]
    513
    		 
        pub async fn make_operation(
    723
    		 
        #[allow(clippy::let_and_return)]
    724
    		 
        #[allow(clippy::needless_borrow)]
    725
    		 
        pub async fn make_operation(
    1033
    		 
        #[allow(clippy::let_and_return)]
    1034
    		 
        #[allow(clippy::needless_borrow)]
    1035
    		 
        pub async fn make_operation(
  • aws-sdk-appstream 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://appstream2-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://appstream2-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://appstream2.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-appstream 0.24.0/src/input.rs
    54
    		 
        #[allow(clippy::let_and_return)]
    55
    		 
        #[allow(clippy::needless_borrow)]
    56
    		 
        pub async fn make_operation(
    250
    		 
        #[allow(clippy::let_and_return)]
    251
    		 
        #[allow(clippy::needless_borrow)]
    252
    		 
        pub async fn make_operation(
    424
    		 
        #[allow(clippy::let_and_return)]
    425
    		 
        #[allow(clippy::needless_borrow)]
    426
    		 
        pub async fn make_operation(
    601
    		 
        #[allow(clippy::let_and_return)]
    602
    		 
        #[allow(clippy::needless_borrow)]
    603
    		 
        pub async fn make_operation(
    780
    		 
        #[allow(clippy::let_and_return)]
    781
    		 
        #[allow(clippy::needless_borrow)]
    782
    		 
        pub async fn make_operation(
  • aws-sdk-appsync 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://appsync-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://appsync-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://appsync.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-appsync 0.24.0/src/input.rs
    49
    		 
        #[allow(clippy::let_and_return)]
    50
    		 
        #[allow(clippy::needless_borrow)]
    51
    		 
        pub async fn make_operation(
    345
    		 
        #[allow(clippy::let_and_return)]
    346
    		 
        #[allow(clippy::needless_borrow)]
    347
    		 
        pub async fn make_operation(
    546
    		 
        #[allow(clippy::let_and_return)]
    547
    		 
        #[allow(clippy::needless_borrow)]
    548
    		 
        pub async fn make_operation(
    883
    		 
        #[allow(clippy::let_and_return)]
    884
    		 
        #[allow(clippy::needless_borrow)]
    885
    		 
        pub async fn make_operation(
    1089
    		 
        #[allow(clippy::let_and_return)]
    1090
    		 
        #[allow(clippy::needless_borrow)]
    1091
    		 
        pub async fn make_operation(
  • aws-sdk-arczonalshift 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://arc-zonal-shift-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://arc-zonal-shift-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://arc-zonal-shift.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-arczonalshift 0.2.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    216
    		 
        #[allow(clippy::let_and_return)]
    217
    		 
        #[allow(clippy::needless_borrow)]
    218
    		 
        pub async fn make_operation(
    397
    		 
        #[allow(clippy::let_and_return)]
    398
    		 
        #[allow(clippy::needless_borrow)]
    399
    		 
        pub async fn make_operation(
    600
    		 
        #[allow(clippy::let_and_return)]
    601
    		 
        #[allow(clippy::needless_borrow)]
    602
    		 
        pub async fn make_operation(
    824
    		 
        #[allow(clippy::let_and_return)]
    825
    		 
        #[allow(clippy::needless_borrow)]
    826
    		 
        pub async fn make_operation(
  • aws-sdk-athena 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://athena-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://athena-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://athena.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-athena 0.24.0/src/input.rs
    48
    		 
        #[allow(clippy::let_and_return)]
    49
    		 
        #[allow(clippy::needless_borrow)]
    50
    		 
        pub async fn make_operation(
    234
    		 
        #[allow(clippy::let_and_return)]
    235
    		 
        #[allow(clippy::needless_borrow)]
    236
    		 
        pub async fn make_operation(
    409
    		 
        #[allow(clippy::let_and_return)]
    410
    		 
        #[allow(clippy::needless_borrow)]
    411
    		 
        pub async fn make_operation(
    680
    		 
        #[allow(clippy::let_and_return)]
    681
    		 
        #[allow(clippy::needless_borrow)]
    682
    		 
        pub async fn make_operation(
    911
    		 
        #[allow(clippy::let_and_return)]
    912
    		 
        #[allow(clippy::needless_borrow)]
    913
    		 
        pub async fn make_operation(
  • aws-sdk-auditmanager 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://auditmanager-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://auditmanager-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://auditmanager.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-auditmanager 0.24.0/src/input.rs
    57
    		 
        #[allow(clippy::let_and_return)]
    58
    		 
        #[allow(clippy::needless_borrow)]
    59
    		 
        pub async fn make_operation(
    279
    		 
        #[allow(clippy::let_and_return)]
    280
    		 
        #[allow(clippy::needless_borrow)]
    281
    		 
        pub async fn make_operation(
    490
    		 
        #[allow(clippy::let_and_return)]
    491
    		 
        #[allow(clippy::needless_borrow)]
    492
    		 
        pub async fn make_operation(
    697
    		 
        #[allow(clippy::let_and_return)]
    698
    		 
        #[allow(clippy::needless_borrow)]
    699
    		 
        pub async fn make_operation(
    921
    		 
        #[allow(clippy::let_and_return)]
    922
    		 
        #[allow(clippy::needless_borrow)]
    923
    		 
        pub async fn make_operation(
  • aws-sdk-autoscaling 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://autoscaling-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://autoscaling.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://autoscaling-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-autoscaling 0.24.0/src/input.rs
    61
    		 
        #[allow(clippy::let_and_return)]
    62
    		 
        #[allow(clippy::needless_borrow)]
    63
    		 
        pub async fn make_operation(
    244
    		 
        #[allow(clippy::let_and_return)]
    245
    		 
        #[allow(clippy::needless_borrow)]
    246
    		 
        pub async fn make_operation(
    427
    		 
        #[allow(clippy::let_and_return)]
    428
    		 
        #[allow(clippy::needless_borrow)]
    429
    		 
        pub async fn make_operation(
    613
    		 
        #[allow(clippy::let_and_return)]
    614
    		 
        #[allow(clippy::needless_borrow)]
    615
    		 
        pub async fn make_operation(
    798
    		 
        #[allow(clippy::let_and_return)]
    799
    		 
        #[allow(clippy::needless_borrow)]
    800
    		 
        pub async fn make_operation(
  • aws-sdk-autoscalingplans 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://autoscaling-plans-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://autoscaling-plans-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://autoscaling-plans.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-autoscalingplans 0.24.0/src/input.rs
    83
    		 
        #[allow(clippy::let_and_return)]
    84
    		 
        #[allow(clippy::needless_borrow)]
    85
    		 
        pub async fn make_operation(
    262
    		 
        #[allow(clippy::let_and_return)]
    263
    		 
        #[allow(clippy::needless_borrow)]
    264
    		 
        pub async fn make_operation(
    465
    		 
        #[allow(clippy::let_and_return)]
    466
    		 
        #[allow(clippy::needless_borrow)]
    467
    		 
        pub async fn make_operation(
    700
    		 
        #[allow(clippy::let_and_return)]
    701
    		 
        #[allow(clippy::needless_borrow)]
    702
    		 
        pub async fn make_operation(
    982
    		 
        #[allow(clippy::let_and_return)]
    983
    		 
        #[allow(clippy::needless_borrow)]
    984
    		 
        pub async fn make_operation(
  • aws-sdk-backup 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://backup-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://backup-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://backup.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-backup 0.24.0/src/input.rs
    67
    		 
        #[allow(clippy::let_and_return)]
    68
    		 
        #[allow(clippy::needless_borrow)]
    69
    		 
        pub async fn make_operation(
    329
    		 
        #[allow(clippy::let_and_return)]
    330
    		 
        #[allow(clippy::needless_borrow)]
    331
    		 
        pub async fn make_operation(
    523
    		 
        #[allow(clippy::let_and_return)]
    524
    		 
        #[allow(clippy::needless_borrow)]
    525
    		 
        pub async fn make_operation(
    782
    		 
        #[allow(clippy::let_and_return)]
    783
    		 
        #[allow(clippy::needless_borrow)]
    784
    		 
        pub async fn make_operation(
    1047
    		 
        #[allow(clippy::let_and_return)]
    1048
    		 
        #[allow(clippy::needless_borrow)]
    1049
    		 
        pub async fn make_operation(
  • aws-sdk-backupgateway 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://backup-gateway-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://backup-gateway-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://backup-gateway.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-backupgateway 0.24.0/src/input.rs
    51
    		 
        #[allow(clippy::let_and_return)]
    52
    		 
        #[allow(clippy::needless_borrow)]
    53
    		 
        pub async fn make_operation(
    269
    		 
        #[allow(clippy::let_and_return)]
    270
    		 
        #[allow(clippy::needless_borrow)]
    271
    		 
        pub async fn make_operation(
    431
    		 
        #[allow(clippy::let_and_return)]
    432
    		 
        #[allow(clippy::needless_borrow)]
    433
    		 
        pub async fn make_operation(
    598
    		 
        #[allow(clippy::let_and_return)]
    599
    		 
        #[allow(clippy::needless_borrow)]
    600
    		 
        pub async fn make_operation(
    762
    		 
        #[allow(clippy::let_and_return)]
    763
    		 
        #[allow(clippy::needless_borrow)]
    764
    		 
        pub async fn make_operation(
  • aws-sdk-backupstorage 0.7.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://backupstorage-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://backupstorage-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://backupstorage.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-backupstorage 0.7.0/src/input.rs
    52
    		 
        #[allow(clippy::let_and_return)]
    53
    		 
        #[allow(clippy::needless_borrow)]
    54
    		 
        pub async fn make_operation(
    254
    		 
        #[allow(clippy::let_and_return)]
    255
    		 
        #[allow(clippy::needless_borrow)]
    256
    		 
        pub async fn make_operation(
    456
    		 
        #[allow(clippy::let_and_return)]
    457
    		 
        #[allow(clippy::needless_borrow)]
    458
    		 
        pub async fn make_operation(
    682
    		 
        #[allow(clippy::let_and_return)]
    683
    		 
        #[allow(clippy::needless_borrow)]
    684
    		 
        pub async fn make_operation(
    975
    		 
        #[allow(clippy::let_and_return)]
    976
    		 
        #[allow(clippy::needless_borrow)]
    977
    		 
        pub async fn make_operation(
  • aws-sdk-batch 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://batch-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://fips.batch.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    83
    		 
                                out.push_str("https://batch.");
    84
    		 
                                #[allow(clippy::needless_borrow)]
    85
    		 
                                out.push_str(&region);
    94
    		 
                            out.push_str("https://batch-fips.");
    95
    		 
                            #[allow(clippy::needless_borrow)]
    96
    		 
                            out.push_str(&region);
  • aws-sdk-batch 0.24.0/src/input.rs
    49
    		 
        #[allow(clippy::let_and_return)]
    50
    		 
        #[allow(clippy::needless_borrow)]
    51
    		 
        pub async fn make_operation(
    336
    		 
        #[allow(clippy::let_and_return)]
    337
    		 
        #[allow(clippy::needless_borrow)]
    338
    		 
        pub async fn make_operation(
    595
    		 
        #[allow(clippy::let_and_return)]
    596
    		 
        #[allow(clippy::needless_borrow)]
    597
    		 
        pub async fn make_operation(
    800
    		 
        #[allow(clippy::let_and_return)]
    801
    		 
        #[allow(clippy::needless_borrow)]
    802
    		 
        pub async fn make_operation(
    964
    		 
        #[allow(clippy::let_and_return)]
    965
    		 
        #[allow(clippy::needless_borrow)]
    966
    		 
        pub async fn make_operation(
  • aws-sdk-billingconductor 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://billingconductor-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    69
    		 
                                out.push_str("https://billingconductor-fips.");
    70
    		 
                                #[allow(clippy::needless_borrow)]
    71
    		 
                                out.push_str(&region);
    86
    		 
                                out.push_str("https://billingconductor.");
    87
    		 
                                #[allow(clippy::needless_borrow)]
    88
    		 
                                out.push_str(&region);
    124
    		 
                                    out.push_str("https://billingconductor-fips.");
    125
    		 
                                    #[allow(clippy::needless_borrow)]
    126
    		 
                                    out.push_str(&region);
    127
    		 
                                    out.push('.');
    128
    		 
                                    #[allow(clippy::needless_borrow)]
    129
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
  • aws-sdk-billingconductor 0.24.0/src/input.rs
    60
    		 
        #[allow(clippy::let_and_return)]
    61
    		 
        #[allow(clippy::needless_borrow)]
    62
    		 
        pub async fn make_operation(
    240
    		 
        #[allow(clippy::let_and_return)]
    241
    		 
        #[allow(clippy::needless_borrow)]
    242
    		 
        pub async fn make_operation(
    441
    		 
        #[allow(clippy::let_and_return)]
    442
    		 
        #[allow(clippy::needless_borrow)]
    443
    		 
        pub async fn make_operation(
    643
    		 
        #[allow(clippy::let_and_return)]
    644
    		 
        #[allow(clippy::needless_borrow)]
    645
    		 
        pub async fn make_operation(
    921
    		 
        #[allow(clippy::let_and_return)]
    922
    		 
        #[allow(clippy::needless_borrow)]
    923
    		 
        pub async fn make_operation(
  • aws-sdk-braket 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://braket-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://braket-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://braket.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-braket 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    215
    		 
        #[allow(clippy::let_and_return)]
    216
    		 
        #[allow(clippy::needless_borrow)]
    217
    		 
        pub async fn make_operation(
    597
    		 
        #[allow(clippy::let_and_return)]
    598
    		 
        #[allow(clippy::needless_borrow)]
    599
    		 
        pub async fn make_operation(
    879
    		 
        #[allow(clippy::let_and_return)]
    880
    		 
        #[allow(clippy::needless_borrow)]
    881
    		 
        pub async fn make_operation(
    1039
    		 
        #[allow(clippy::let_and_return)]
    1040
    		 
        #[allow(clippy::needless_borrow)]
    1041
    		 
        pub async fn make_operation(
  • aws-sdk-budgets 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://budgets-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    69
    		 
                                out.push_str("https://budgets-fips.");
    70
    		 
                                #[allow(clippy::needless_borrow)]
    71
    		 
                                out.push_str(&region);
    86
    		 
                                out.push_str("https://budgets.");
    87
    		 
                                #[allow(clippy::needless_borrow)]
    88
    		 
                                out.push_str(&region);
    122
    		 
                                        out.push_str("https://budgets-fips.");
    123
    		 
                                        #[allow(clippy::needless_borrow)]
    124
    		 
                                        out.push_str(&region);
    140
    		 
                                out.push_str("https://budgets-fips.");
    141
    		 
                                #[allow(clippy::needless_borrow)]
    142
    		 
                                out.push_str(&region);
  • aws-sdk-budgets 0.24.0/src/input.rs
    74
    		 
        #[allow(clippy::let_and_return)]
    75
    		 
        #[allow(clippy::needless_borrow)]
    76
    		 
        pub async fn make_operation(
    361
    		 
        #[allow(clippy::let_and_return)]
    362
    		 
        #[allow(clippy::needless_borrow)]
    363
    		 
        pub async fn make_operation(
    573
    		 
        #[allow(clippy::let_and_return)]
    574
    		 
        #[allow(clippy::needless_borrow)]
    575
    		 
        pub async fn make_operation(
    779
    		 
        #[allow(clippy::let_and_return)]
    780
    		 
        #[allow(clippy::needless_borrow)]
    781
    		 
        pub async fn make_operation(
    953
    		 
        #[allow(clippy::let_and_return)]
    954
    		 
        #[allow(clippy::needless_borrow)]
    955
    		 
        pub async fn make_operation(
  • aws-sdk-chime 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://chime-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    69
    		 
                                out.push_str("https://chime-fips.");
    70
    		 
                                #[allow(clippy::needless_borrow)]
    71
    		 
                                out.push_str(&region);
    86
    		 
                                out.push_str("https://chime.");
    87
    		 
                                #[allow(clippy::needless_borrow)]
    88
    		 
                                out.push_str(&region);
    121
    		 
                                    out.push_str("https://chime-fips.");
    122
    		 
                                    #[allow(clippy::needless_borrow)]
    123
    		 
                                    out.push_str(&region);
    124
    		 
                                    out.push('.');
    125
    		 
                                    #[allow(clippy::needless_borrow)]
    126
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
  • aws-sdk-chime 0.24.0/src/input.rs
    75
    		 
        #[allow(clippy::let_and_return)]
    76
    		 
        #[allow(clippy::needless_borrow)]
    77
    		 
        pub async fn make_operation(
    305
    		 
        #[allow(clippy::let_and_return)]
    306
    		 
        #[allow(clippy::needless_borrow)]
    307
    		 
        pub async fn make_operation(
    534
    		 
        #[allow(clippy::let_and_return)]
    535
    		 
        #[allow(clippy::needless_borrow)]
    536
    		 
        pub async fn make_operation(
    770
    		 
        #[allow(clippy::let_and_return)]
    771
    		 
        #[allow(clippy::needless_borrow)]
    772
    		 
        pub async fn make_operation(
    980
    		 
        #[allow(clippy::let_and_return)]
    981
    		 
        #[allow(clippy::needless_borrow)]
    982
    		 
        pub async fn make_operation(
  • aws-sdk-chimesdkidentity 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://identity-chime-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://identity-chime-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://identity-chime.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-chimesdkidentity 0.24.0/src/input.rs
    97
    		 
        #[allow(clippy::let_and_return)]
    98
    		 
        #[allow(clippy::needless_borrow)]
    99
    		 
        pub async fn make_operation(
    277
    		 
        #[allow(clippy::let_and_return)]
    278
    		 
        #[allow(clippy::needless_borrow)]
    279
    		 
        pub async fn make_operation(
    552
    		 
        #[allow(clippy::let_and_return)]
    553
    		 
        #[allow(clippy::needless_borrow)]
    554
    		 
        pub async fn make_operation(
    719
    		 
        #[allow(clippy::let_and_return)]
    720
    		 
        #[allow(clippy::needless_borrow)]
    721
    		 
        pub async fn make_operation(
    906
    		 
        #[allow(clippy::let_and_return)]
    907
    		 
        #[allow(clippy::needless_borrow)]
    908
    		 
        pub async fn make_operation(
  • aws-sdk-chimesdkmediapipelines 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://media-pipelines-chime-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://media-pipelines-chime-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://media-pipelines-chime.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-chimesdkmediapipelines 0.24.0/src/input.rs
    152
    		 
        #[allow(clippy::let_and_return)]
    153
    		 
        #[allow(clippy::needless_borrow)]
    154
    		 
        pub async fn make_operation(
    390
    		 
        #[allow(clippy::let_and_return)]
    391
    		 
        #[allow(clippy::needless_borrow)]
    392
    		 
        pub async fn make_operation(
    633
    		 
        #[allow(clippy::let_and_return)]
    634
    		 
        #[allow(clippy::needless_borrow)]
    635
    		 
        pub async fn make_operation(
    799
    		 
        #[allow(clippy::let_and_return)]
    800
    		 
        #[allow(clippy::needless_borrow)]
    801
    		 
        pub async fn make_operation(
    971
    		 
        #[allow(clippy::let_and_return)]
    972
    		 
        #[allow(clippy::needless_borrow)]
    973
    		 
        pub async fn make_operation(
  • aws-sdk-chimesdkmeetings 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://meetings-chime-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://meetings-chime-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://meetings-chime.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-chimesdkmeetings 0.24.0/src/input.rs
    61
    		 
        #[allow(clippy::let_and_return)]
    62
    		 
        #[allow(clippy::needless_borrow)]
    63
    		 
        pub async fn make_operation(
    290
    		 
        #[allow(clippy::let_and_return)]
    291
    		 
        #[allow(clippy::needless_borrow)]
    292
    		 
        pub async fn make_operation(
    535
    		 
        #[allow(clippy::let_and_return)]
    536
    		 
        #[allow(clippy::needless_borrow)]
    537
    		 
        pub async fn make_operation(
    906
    		 
        #[allow(clippy::let_and_return)]
    907
    		 
        #[allow(clippy::needless_borrow)]
    908
    		 
        pub async fn make_operation(
    1253
    		 
        #[allow(clippy::let_and_return)]
    1254
    		 
        #[allow(clippy::needless_borrow)]
    1255
    		 
        pub async fn make_operation(
  • aws-sdk-chimesdkmessaging 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://messaging-chime-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://messaging-chime-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://messaging-chime.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-chimesdkmessaging 0.24.0/src/input.rs
    66
    		 
        #[allow(clippy::let_and_return)]
    67
    		 
        #[allow(clippy::needless_borrow)]
    68
    		 
        pub async fn make_operation(
    320
    		 
        #[allow(clippy::let_and_return)]
    321
    		 
        #[allow(clippy::needless_borrow)]
    322
    		 
        pub async fn make_operation(
    553
    		 
        #[allow(clippy::let_and_return)]
    554
    		 
        #[allow(clippy::needless_borrow)]
    555
    		 
        pub async fn make_operation(
    938
    		 
        #[allow(clippy::let_and_return)]
    939
    		 
        #[allow(clippy::needless_borrow)]
    940
    		 
        pub async fn make_operation(
    1125
    		 
        #[allow(clippy::let_and_return)]
    1126
    		 
        #[allow(clippy::needless_borrow)]
    1127
    		 
        pub async fn make_operation(
  • aws-sdk-chimesdkvoice 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://voice-chime-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://voice-chime-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://voice-chime.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-chimesdkvoice 0.2.0/src/input.rs
    74
    		 
        #[allow(clippy::let_and_return)]
    75
    		 
        #[allow(clippy::needless_borrow)]
    76
    		 
        pub async fn make_operation(
    303
    		 
        #[allow(clippy::let_and_return)]
    304
    		 
        #[allow(clippy::needless_borrow)]
    305
    		 
        pub async fn make_operation(
    504
    		 
        #[allow(clippy::let_and_return)]
    505
    		 
        #[allow(clippy::needless_borrow)]
    506
    		 
        pub async fn make_operation(
    686
    		 
        #[allow(clippy::let_and_return)]
    687
    		 
        #[allow(clippy::needless_borrow)]
    688
    		 
        pub async fn make_operation(
    879
    		 
        #[allow(clippy::let_and_return)]
    880
    		 
        #[allow(clippy::needless_borrow)]
    881
    		 
        pub async fn make_operation(
  • aws-sdk-cleanrooms 0.1.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cleanrooms-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://cleanrooms-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://cleanrooms.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-cleanrooms 0.1.0/src/input.rs
    61
    		 
        #[allow(clippy::let_and_return)]
    62
    		 
        #[allow(clippy::needless_borrow)]
    63
    		 
        pub async fn make_operation(
    351
    		 
        #[allow(clippy::let_and_return)]
    352
    		 
        #[allow(clippy::needless_borrow)]
    353
    		 
        pub async fn make_operation(
    573
    		 
        #[allow(clippy::let_and_return)]
    574
    		 
        #[allow(clippy::needless_borrow)]
    575
    		 
        pub async fn make_operation(
    778
    		 
        #[allow(clippy::let_and_return)]
    779
    		 
        #[allow(clippy::needless_borrow)]
    780
    		 
        pub async fn make_operation(
    1018
    		 
        #[allow(clippy::let_and_return)]
    1019
    		 
        #[allow(clippy::needless_borrow)]
    1020
    		 
        pub async fn make_operation(
  • aws-sdk-cloud9 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cloud9-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://cloud9-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://cloud9.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-cloud9 0.24.0/src/input.rs
    231
    		 
        #[allow(clippy::let_and_return)]
    232
    		 
        #[allow(clippy::needless_borrow)]
    233
    		 
        pub async fn make_operation(
    435
    		 
        #[allow(clippy::let_and_return)]
    436
    		 
        #[allow(clippy::needless_borrow)]
    437
    		 
        pub async fn make_operation(
    602
    		 
        #[allow(clippy::let_and_return)]
    603
    		 
        #[allow(clippy::needless_borrow)]
    604
    		 
        pub async fn make_operation(
    781
    		 
        #[allow(clippy::let_and_return)]
    782
    		 
        #[allow(clippy::needless_borrow)]
    783
    		 
        pub async fn make_operation(
    1017
    		 
        #[allow(clippy::let_and_return)]
    1018
    		 
        #[allow(clippy::needless_borrow)]
    1019
    		 
        pub async fn make_operation(
  • aws-sdk-cloudcontrol 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cloudcontrolapi-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://cloudcontrolapi-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://cloudcontrolapi.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-cloudcontrol 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    299
    		 
        #[allow(clippy::let_and_return)]
    300
    		 
        #[allow(clippy::needless_borrow)]
    301
    		 
        pub async fn make_operation(
    531
    		 
        #[allow(clippy::let_and_return)]
    532
    		 
        #[allow(clippy::needless_borrow)]
    533
    		 
        pub async fn make_operation(
    745
    		 
        #[allow(clippy::let_and_return)]
    746
    		 
        #[allow(clippy::needless_borrow)]
    747
    		 
        pub async fn make_operation(
    914
    		 
        #[allow(clippy::let_and_return)]
    915
    		 
        #[allow(clippy::needless_borrow)]
    916
    		 
        pub async fn make_operation(
  • aws-sdk-clouddirectory 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://clouddirectory-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://clouddirectory.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://clouddirectory-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-clouddirectory 0.24.0/src/input.rs
    94
    		 
        #[allow(clippy::let_and_return)]
    95
    		 
        #[allow(clippy::needless_borrow)]
    96
    		 
        pub async fn make_operation(
    271
    		 
        #[allow(clippy::let_and_return)]
    272
    		 
        #[allow(clippy::needless_borrow)]
    273
    		 
        pub async fn make_operation(
    475
    		 
        #[allow(clippy::let_and_return)]
    476
    		 
        #[allow(clippy::needless_borrow)]
    477
    		 
        pub async fn make_operation(
    667
    		 
        #[allow(clippy::let_and_return)]
    668
    		 
        #[allow(clippy::needless_borrow)]
    669
    		 
        pub async fn make_operation(
    859
    		 
        #[allow(clippy::let_and_return)]
    860
    		 
        #[allow(clippy::needless_borrow)]
    861
    		 
        pub async fn make_operation(
  • aws-sdk-cloudformation 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cloudformation-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://cloudformation.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://cloudformation-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-cloudformation 0.24.0/src/input.rs
    185
    		 
        #[allow(clippy::let_and_return)]
    186
    		 
        #[allow(clippy::needless_borrow)]
    187
    		 
        pub async fn make_operation(
    357
    		 
        #[allow(clippy::let_and_return)]
    358
    		 
        #[allow(clippy::needless_borrow)]
    359
    		 
        pub async fn make_operation(
    531
    		 
        #[allow(clippy::let_and_return)]
    532
    		 
        #[allow(clippy::needless_borrow)]
    533
    		 
        pub async fn make_operation(
    756
    		 
        #[allow(clippy::let_and_return)]
    757
    		 
        #[allow(clippy::needless_borrow)]
    758
    		 
        pub async fn make_operation(
    1233
    		 
        #[allow(clippy::let_and_return)]
    1234
    		 
        #[allow(clippy::needless_borrow)]
    1235
    		 
        pub async fn make_operation(
  • aws-sdk-cloudfront 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://cloudfront-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    98
    		 
                                out.push_str("https://cloudfront.");
    99
    		 
                                #[allow(clippy::needless_borrow)]
    100
    		 
                                out.push_str(&region);
    134
    		 
                                        out.push_str("https://cloudfront-fips.");
    135
    		 
                                        #[allow(clippy::needless_borrow)]
    136
    		 
                                        out.push_str(&region);
    152
    		 
                                out.push_str("https://cloudfront-fips.");
    153
    		 
                                #[allow(clippy::needless_borrow)]
    154
    		 
                                out.push_str(&region);
    169
    		 
                                out.push_str("https://cloudfront.");
    170
    		 
                                #[allow(clippy::needless_borrow)]
    171
    		 
                                out.push_str(&region);
  • aws-sdk-cloudfront 0.24.0/src/input.rs
    52
    		 
        #[allow(clippy::let_and_return)]
    53
    		 
        #[allow(clippy::needless_borrow)]
    54
    		 
        pub async fn make_operation(
    287
    		 
        #[allow(clippy::let_and_return)]
    288
    		 
        #[allow(clippy::needless_borrow)]
    289
    		 
        pub async fn make_operation(
    474
    		 
        #[allow(clippy::let_and_return)]
    475
    		 
        #[allow(clippy::needless_borrow)]
    476
    		 
        pub async fn make_operation(
    643
    		 
        #[allow(clippy::let_and_return)]
    644
    		 
        #[allow(clippy::needless_borrow)]
    645
    		 
        pub async fn make_operation(
    810
    		 
        #[allow(clippy::let_and_return)]
    811
    		 
        #[allow(clippy::needless_borrow)]
    812
    		 
        pub async fn make_operation(
  • aws-sdk-cloudhsm 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cloudhsm-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://cloudhsm-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://cloudhsm.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-cloudhsm 0.24.0/src/input.rs
    60
    		 
        #[allow(clippy::let_and_return)]
    61
    		 
        #[allow(clippy::needless_borrow)]
    62
    		 
        pub async fn make_operation(
    220
    		 
        #[allow(clippy::let_and_return)]
    221
    		 
        #[allow(clippy::needless_borrow)]
    222
    		 
        pub async fn make_operation(
    479
    		 
        #[allow(clippy::let_and_return)]
    480
    		 
        #[allow(clippy::needless_borrow)]
    481
    		 
        pub async fn make_operation(
    653
    		 
        #[allow(clippy::let_and_return)]
    654
    		 
        #[allow(clippy::needless_borrow)]
    655
    		 
        pub async fn make_operation(
    815
    		 
        #[allow(clippy::let_and_return)]
    816
    		 
        #[allow(clippy::needless_borrow)]
    817
    		 
        pub async fn make_operation(
  • aws-sdk-cloudhsmv2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cloudhsmv2-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://cloudhsmv2-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://cloudhsmv2.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-cloudhsmv2 0.24.0/src/input.rs
    75
    		 
        #[allow(clippy::let_and_return)]
    76
    		 
        #[allow(clippy::needless_borrow)]
    77
    		 
        pub async fn make_operation(
    321
    		 
        #[allow(clippy::let_and_return)]
    322
    		 
        #[allow(clippy::needless_borrow)]
    323
    		 
        pub async fn make_operation(
    510
    		 
        #[allow(clippy::let_and_return)]
    511
    		 
        #[allow(clippy::needless_borrow)]
    512
    		 
        pub async fn make_operation(
    670
    		 
        #[allow(clippy::let_and_return)]
    671
    		 
        #[allow(clippy::needless_borrow)]
    672
    		 
        pub async fn make_operation(
    832
    		 
        #[allow(clippy::let_and_return)]
    833
    		 
        #[allow(clippy::needless_borrow)]
    834
    		 
        pub async fn make_operation(
  • aws-sdk-cloudsearch 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cloudsearch-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://cloudsearch-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://cloudsearch.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-cloudsearch 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    194
    		 
        #[allow(clippy::let_and_return)]
    195
    		 
        #[allow(clippy::needless_borrow)]
    196
    		 
        pub async fn make_operation(
    368
    		 
        #[allow(clippy::let_and_return)]
    369
    		 
        #[allow(clippy::needless_borrow)]
    370
    		 
        pub async fn make_operation(
    544
    		 
        #[allow(clippy::let_and_return)]
    545
    		 
        #[allow(clippy::needless_borrow)]
    546
    		 
        pub async fn make_operation(
    718
    		 
        #[allow(clippy::let_and_return)]
    719
    		 
        #[allow(clippy::needless_borrow)]
    720
    		 
        pub async fn make_operation(
  • aws-sdk-cloudsearchdomain 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cloudsearchdomain-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://cloudsearchdomain-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://cloudsearchdomain.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-cloudsearchdomain 0.24.0/src/input.rs
    299
    		 
        #[allow(clippy::let_and_return)]
    300
    		 
        #[allow(clippy::needless_borrow)]
    301
    		 
        pub async fn make_operation(
    558
    		 
        #[allow(clippy::let_and_return)]
    559
    		 
        #[allow(clippy::needless_borrow)]
    560
    		 
        pub async fn make_operation(
    773
    		 
        #[allow(clippy::let_and_return)]
    774
    		 
        #[allow(clippy::needless_borrow)]
    775
    		 
        pub async fn make_operation(
  • aws-sdk-cloudtrail 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cloudtrail-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    80
    		 
                            out.push_str("https://cloudtrail-fips.");
    81
    		 
                            #[allow(clippy::needless_borrow)]
    82
    		 
                            out.push_str(&region);
    83
    		 
                            out.push('.');
    84
    		 
                            #[allow(clippy::needless_borrow)]
    85
    		 
                            out.push_str(&partition_result.dns_suffix());
    99
    		 
                            out.push_str("https://cloudtrail.");
    100
    		 
                            #[allow(clippy::needless_borrow)]
    101
    		 
                            out.push_str(&region);
  • aws-sdk-cloudtrail 0.24.0/src/input.rs
    60
    		 
        #[allow(clippy::let_and_return)]
    61
    		 
        #[allow(clippy::needless_borrow)]
    62
    		 
        pub async fn make_operation(
    237
    		 
        #[allow(clippy::let_and_return)]
    238
    		 
        #[allow(clippy::needless_borrow)]
    239
    		 
        pub async fn make_operation(
    530
    		 
        #[allow(clippy::let_and_return)]
    531
    		 
        #[allow(clippy::needless_borrow)]
    532
    		 
        pub async fn make_operation(
    890
    		 
        #[allow(clippy::let_and_return)]
    891
    		 
        #[allow(clippy::needless_borrow)]
    892
    		 
        pub async fn make_operation(
    1057
    		 
        #[allow(clippy::let_and_return)]
    1058
    		 
        #[allow(clippy::needless_borrow)]
    1059
    		 
        pub async fn make_operation(
  • aws-sdk-cloudwatch 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://monitoring-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://monitoring.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://monitoring-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-cloudwatch 0.24.0/src/input.rs
    46
    		 
        #[allow(clippy::let_and_return)]
    47
    		 
        #[allow(clippy::needless_borrow)]
    48
    		 
        pub async fn make_operation(
    332
    		 
        #[allow(clippy::let_and_return)]
    333
    		 
        #[allow(clippy::needless_borrow)]
    334
    		 
        pub async fn make_operation(
    502
    		 
        #[allow(clippy::let_and_return)]
    503
    		 
        #[allow(clippy::needless_borrow)]
    504
    		 
        pub async fn make_operation(
    670
    		 
        #[allow(clippy::let_and_return)]
    671
    		 
        #[allow(clippy::needless_borrow)]
    672
    		 
        pub async fn make_operation(
    827
    		 
        #[allow(clippy::let_and_return)]
    828
    		 
        #[allow(clippy::needless_borrow)]
    829
    		 
        pub async fn make_operation(
  • aws-sdk-cloudwatchevents 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://events-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    80
    		 
                            out.push_str("https://events-fips.");
    81
    		 
                            #[allow(clippy::needless_borrow)]
    82
    		 
                            out.push_str(&region);
    83
    		 
                            out.push('.');
    84
    		 
                            #[allow(clippy::needless_borrow)]
    85
    		 
                            out.push_str(&partition_result.dns_suffix());
    99
    		 
                            out.push_str("https://events.");
    100
    		 
                            #[allow(clippy::needless_borrow)]
    101
    		 
                            out.push_str(&region);
  • aws-sdk-cloudwatchevents 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    199
    		 
        #[allow(clippy::let_and_return)]
    200
    		 
        #[allow(clippy::needless_borrow)]
    201
    		 
        pub async fn make_operation(
    435
    		 
        #[allow(clippy::let_and_return)]
    436
    		 
        #[allow(clippy::needless_borrow)]
    437
    		 
        pub async fn make_operation(
    653
    		 
        #[allow(clippy::let_and_return)]
    654
    		 
        #[allow(clippy::needless_borrow)]
    655
    		 
        pub async fn make_operation(
    867
    		 
        #[allow(clippy::let_and_return)]
    868
    		 
        #[allow(clippy::needless_borrow)]
    869
    		 
        pub async fn make_operation(
  • aws-sdk-cloudwatchlogs 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://logs-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    80
    		 
                            out.push_str("https://logs-fips.");
    81
    		 
                            #[allow(clippy::needless_borrow)]
    82
    		 
                            out.push_str(&region);
    83
    		 
                            out.push('.');
    84
    		 
                            #[allow(clippy::needless_borrow)]
    85
    		 
                            out.push_str(&partition_result.dns_suffix());
    99
    		 
                            out.push_str("https://logs.");
    100
    		 
                            #[allow(clippy::needless_borrow)]
    101
    		 
                            out.push_str(&region);
  • aws-sdk-cloudwatchlogs 0.24.0/src/input.rs
    52
    		 
        #[allow(clippy::let_and_return)]
    53
    		 
        #[allow(clippy::needless_borrow)]
    54
    		 
        pub async fn make_operation(
    216
    		 
        #[allow(clippy::let_and_return)]
    217
    		 
        #[allow(clippy::needless_borrow)]
    218
    		 
        pub async fn make_operation(
    463
    		 
        #[allow(clippy::let_and_return)]
    464
    		 
        #[allow(clippy::needless_borrow)]
    465
    		 
        pub async fn make_operation(
    671
    		 
        #[allow(clippy::let_and_return)]
    672
    		 
        #[allow(clippy::needless_borrow)]
    673
    		 
        pub async fn make_operation(
    851
    		 
        #[allow(clippy::let_and_return)]
    852
    		 
        #[allow(clippy::needless_borrow)]
    853
    		 
        pub async fn make_operation(
  • aws-sdk-codeartifact 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://codeartifact-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://codeartifact-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://codeartifact.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-codeartifact 0.24.0/src/input.rs
    96
    		 
        #[allow(clippy::let_and_return)]
    97
    		 
        #[allow(clippy::needless_borrow)]
    98
    		 
        pub async fn make_operation(
    482
    		 
        #[allow(clippy::let_and_return)]
    483
    		 
        #[allow(clippy::needless_borrow)]
    484
    		 
        pub async fn make_operation(
    778
    		 
        #[allow(clippy::let_and_return)]
    779
    		 
        #[allow(clippy::needless_borrow)]
    780
    		 
        pub async fn make_operation(
    1039
    		 
        #[allow(clippy::let_and_return)]
    1040
    		 
        #[allow(clippy::needless_borrow)]
    1041
    		 
        pub async fn make_operation(
    1256
    		 
        #[allow(clippy::let_and_return)]
    1257
    		 
        #[allow(clippy::needless_borrow)]
    1258
    		 
        pub async fn make_operation(
  • aws-sdk-codebuild 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://codebuild-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://codebuild-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://codebuild.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-codebuild 0.24.0/src/input.rs
    46
    		 
        #[allow(clippy::let_and_return)]
    47
    		 
        #[allow(clippy::needless_borrow)]
    48
    		 
        pub async fn make_operation(
    217
    		 
        #[allow(clippy::let_and_return)]
    218
    		 
        #[allow(clippy::needless_borrow)]
    219
    		 
        pub async fn make_operation(
    388
    		 
        #[allow(clippy::let_and_return)]
    389
    		 
        #[allow(clippy::needless_borrow)]
    390
    		 
        pub async fn make_operation(
    559
    		 
        #[allow(clippy::let_and_return)]
    560
    		 
        #[allow(clippy::needless_borrow)]
    561
    		 
        pub async fn make_operation(
    732
    		 
        #[allow(clippy::let_and_return)]
    733
    		 
        #[allow(clippy::needless_borrow)]
    734
    		 
        pub async fn make_operation(
  • aws-sdk-codecatalyst 0.2.0/src/endpoint/internals.rs
    40
    		 
                            out.push_str("https://codecatalyst-fips.global.");
    41
    		 
                            #[allow(clippy::needless_borrow)]
    42
    		 
                            out.push_str(&partition_result.dual_stack_dns_suffix());
    50
    		 
                        out.push_str("https://codecatalyst.global.");
    51
    		 
                        #[allow(clippy::needless_borrow)]
    52
    		 
                        out.push_str(&partition_result.dual_stack_dns_suffix());
    73
    		 
                            out.push_str("https://codecatalyst-fips.global.");
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dual_stack_dns_suffix());
    83
    		 
                        out.push_str("https://codecatalyst.global.");
    84
    		 
                        #[allow(clippy::needless_borrow)]
    85
    		 
                        out.push_str(&partition_result.dual_stack_dns_suffix());
  • aws-sdk-codecatalyst 0.2.0/src/input.rs
    54
    		 
        #[allow(clippy::let_and_return)]
    55
    		 
        #[allow(clippy::needless_borrow)]
    56
    		 
        pub async fn make_operation(
    332
    		 
        #[allow(clippy::let_and_return)]
    333
    		 
        #[allow(clippy::needless_borrow)]
    334
    		 
        pub async fn make_operation(
    546
    		 
        #[allow(clippy::let_and_return)]
    547
    		 
        #[allow(clippy::needless_borrow)]
    548
    		 
        pub async fn make_operation(
    770
    		 
        #[allow(clippy::let_and_return)]
    771
    		 
        #[allow(clippy::needless_borrow)]
    772
    		 
        pub async fn make_operation(
    990
    		 
        #[allow(clippy::let_and_return)]
    991
    		 
        #[allow(clippy::needless_borrow)]
    992
    		 
        pub async fn make_operation(
  • aws-sdk-codecommit 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://codecommit-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://codecommit-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://codecommit.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-codecommit 0.24.0/src/input.rs
    62
    		 
        #[allow(clippy::let_and_return)]
    63
    		 
        #[allow(clippy::needless_borrow)]
    64
    		 
        pub async fn make_operation(
    260
    		 
        #[allow(clippy::let_and_return)]
    261
    		 
        #[allow(clippy::needless_borrow)]
    262
    		 
        pub async fn make_operation(
    571
    		 
        #[allow(clippy::let_and_return)]
    572
    		 
        #[allow(clippy::needless_borrow)]
    573
    		 
        pub async fn make_operation(
    768
    		 
        #[allow(clippy::let_and_return)]
    769
    		 
        #[allow(clippy::needless_borrow)]
    770
    		 
        pub async fn make_operation(
    960
    		 
        #[allow(clippy::let_and_return)]
    961
    		 
        #[allow(clippy::needless_borrow)]
    962
    		 
        pub async fn make_operation(
  • aws-sdk-codedeploy 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://codedeploy-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://codedeploy-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://codedeploy.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-codedeploy 0.24.0/src/input.rs
    71
    		 
        #[allow(clippy::let_and_return)]
    72
    		 
        #[allow(clippy::needless_borrow)]
    73
    		 
        pub async fn make_operation(
    259
    		 
        #[allow(clippy::let_and_return)]
    260
    		 
        #[allow(clippy::needless_borrow)]
    261
    		 
        pub async fn make_operation(
    432
    		 
        #[allow(clippy::let_and_return)]
    433
    		 
        #[allow(clippy::needless_borrow)]
    434
    		 
        pub async fn make_operation(
    622
    		 
        #[allow(clippy::let_and_return)]
    623
    		 
        #[allow(clippy::needless_borrow)]
    624
    		 
        pub async fn make_operation(
    812
    		 
        #[allow(clippy::let_and_return)]
    813
    		 
        #[allow(clippy::needless_borrow)]
    814
    		 
        pub async fn make_operation(
  • aws-sdk-codeguruprofiler 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://codeguru-profiler-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://codeguru-profiler-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://codeguru-profiler.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-codeguruprofiler 0.24.0/src/input.rs
    63
    		 
        #[allow(clippy::let_and_return)]
    64
    		 
        #[allow(clippy::needless_borrow)]
    65
    		 
        pub async fn make_operation(
    339
    		 
        #[allow(clippy::let_and_return)]
    340
    		 
        #[allow(clippy::needless_borrow)]
    341
    		 
        pub async fn make_operation(
    634
    		 
        #[allow(clippy::let_and_return)]
    635
    		 
        #[allow(clippy::needless_borrow)]
    636
    		 
        pub async fn make_operation(
    895
    		 
        #[allow(clippy::let_and_return)]
    896
    		 
        #[allow(clippy::needless_borrow)]
    897
    		 
        pub async fn make_operation(
    1086
    		 
        #[allow(clippy::let_and_return)]
    1087
    		 
        #[allow(clippy::needless_borrow)]
    1088
    		 
        pub async fn make_operation(
  • aws-sdk-codegurureviewer 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://codeguru-reviewer-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://codeguru-reviewer-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://codeguru-reviewer.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-codegurureviewer 0.24.0/src/input.rs
    117
    		 
        #[allow(clippy::let_and_return)]
    118
    		 
        #[allow(clippy::needless_borrow)]
    119
    		 
        pub async fn make_operation(
    326
    		 
        #[allow(clippy::let_and_return)]
    327
    		 
        #[allow(clippy::needless_borrow)]
    328
    		 
        pub async fn make_operation(
    491
    		 
        #[allow(clippy::let_and_return)]
    492
    		 
        #[allow(clippy::needless_borrow)]
    493
    		 
        pub async fn make_operation(
    692
    		 
        #[allow(clippy::let_and_return)]
    693
    		 
        #[allow(clippy::needless_borrow)]
    694
    		 
        pub async fn make_operation(
    896
    		 
        #[allow(clippy::let_and_return)]
    897
    		 
        #[allow(clippy::needless_borrow)]
    898
    		 
        pub async fn make_operation(
  • aws-sdk-codepipeline 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://codepipeline-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://codepipeline-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://codepipeline.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-codepipeline 0.24.0/src/input.rs
    49
    		 
        #[allow(clippy::let_and_return)]
    50
    		 
        #[allow(clippy::needless_borrow)]
    51
    		 
        pub async fn make_operation(
    237
    		 
        #[allow(clippy::let_and_return)]
    238
    		 
        #[allow(clippy::needless_borrow)]
    239
    		 
        pub async fn make_operation(
    525
    		 
        #[allow(clippy::let_and_return)]
    526
    		 
        #[allow(clippy::needless_borrow)]
    527
    		 
        pub async fn make_operation(
    713
    		 
        #[allow(clippy::let_and_return)]
    714
    		 
        #[allow(clippy::needless_borrow)]
    715
    		 
        pub async fn make_operation(
    904
    		 
        #[allow(clippy::let_and_return)]
    905
    		 
        #[allow(clippy::needless_borrow)]
    906
    		 
        pub async fn make_operation(
  • aws-sdk-codestar 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://codestar-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://codestar-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://codestar.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-codestar 0.24.0/src/input.rs
    90
    		 
        #[allow(clippy::let_and_return)]
    91
    		 
        #[allow(clippy::needless_borrow)]
    92
    		 
        pub async fn make_operation(
    369
    		 
        #[allow(clippy::let_and_return)]
    370
    		 
        #[allow(clippy::needless_borrow)]
    371
    		 
        pub async fn make_operation(
    585
    		 
        #[allow(clippy::let_and_return)]
    586
    		 
        #[allow(clippy::needless_borrow)]
    587
    		 
        pub async fn make_operation(
    774
    		 
        #[allow(clippy::let_and_return)]
    775
    		 
        #[allow(clippy::needless_borrow)]
    776
    		 
        pub async fn make_operation(
    938
    		 
        #[allow(clippy::let_and_return)]
    939
    		 
        #[allow(clippy::needless_borrow)]
    940
    		 
        pub async fn make_operation(
  • aws-sdk-codestarconnections 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://codestar-connections-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://codestar-connections-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://codestar-connections.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-codestarconnections 0.24.0/src/input.rs
    90
    		 
        #[allow(clippy::let_and_return)]
    91
    		 
        #[allow(clippy::needless_borrow)]
    92
    		 
        pub async fn make_operation(
    317
    		 
        #[allow(clippy::let_and_return)]
    318
    		 
        #[allow(clippy::needless_borrow)]
    319
    		 
        pub async fn make_operation(
    488
    		 
        #[allow(clippy::let_and_return)]
    489
    		 
        #[allow(clippy::needless_borrow)]
    490
    		 
        pub async fn make_operation(
    650
    		 
        #[allow(clippy::let_and_return)]
    651
    		 
        #[allow(clippy::needless_borrow)]
    652
    		 
        pub async fn make_operation(
    815
    		 
        #[allow(clippy::let_and_return)]
    816
    		 
        #[allow(clippy::needless_borrow)]
    817
    		 
        pub async fn make_operation(
  • aws-sdk-codestarnotifications 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://codestar-notifications-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://codestar-notifications-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://codestar-notifications.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-codestarnotifications 0.24.0/src/input.rs
    185
    		 
        #[allow(clippy::let_and_return)]
    186
    		 
        #[allow(clippy::needless_borrow)]
    187
    		 
        pub async fn make_operation(
    347
    		 
        #[allow(clippy::let_and_return)]
    348
    		 
        #[allow(clippy::needless_borrow)]
    349
    		 
        pub async fn make_operation(
    529
    		 
        #[allow(clippy::let_and_return)]
    530
    		 
        #[allow(clippy::needless_borrow)]
    531
    		 
        pub async fn make_operation(
    686
    		 
        #[allow(clippy::let_and_return)]
    687
    		 
        #[allow(clippy::needless_borrow)]
    688
    		 
        pub async fn make_operation(
    878
    		 
        #[allow(clippy::let_and_return)]
    879
    		 
        #[allow(clippy::needless_borrow)]
    880
    		 
        pub async fn make_operation(
  • aws-sdk-cognitoidentity 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cognito-identity-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://cognito-identity-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://cognito-identity.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-cognitoidentity 0.24.0/src/input.rs
    217
    		 
        #[allow(clippy::let_and_return)]
    218
    		 
        #[allow(clippy::needless_borrow)]
    219
    		 
        pub async fn make_operation(
    390
    		 
        #[allow(clippy::let_and_return)]
    391
    		 
        #[allow(clippy::needless_borrow)]
    392
    		 
        pub async fn make_operation(
    557
    		 
        #[allow(clippy::let_and_return)]
    558
    		 
        #[allow(clippy::needless_borrow)]
    559
    		 
        pub async fn make_operation(
    721
    		 
        #[allow(clippy::let_and_return)]
    722
    		 
        #[allow(clippy::needless_borrow)]
    723
    		 
        pub async fn make_operation(
    888
    		 
        #[allow(clippy::let_and_return)]
    889
    		 
        #[allow(clippy::needless_borrow)]
    890
    		 
        pub async fn make_operation(
  • aws-sdk-cognitoidentityprovider 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cognito-idp-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://cognito-idp-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://cognito-idp.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-cognitoidentityprovider 0.24.0/src/input.rs
    61
    		 
        #[allow(clippy::let_and_return)]
    62
    		 
        #[allow(clippy::needless_borrow)]
    63
    		 
        pub async fn make_operation(
    258
    		 
        #[allow(clippy::let_and_return)]
    259
    		 
        #[allow(clippy::needless_borrow)]
    260
    		 
        pub async fn make_operation(
    492
    		 
        #[allow(clippy::let_and_return)]
    493
    		 
        #[allow(clippy::needless_borrow)]
    494
    		 
        pub async fn make_operation(
    862
    		 
        #[allow(clippy::let_and_return)]
    863
    		 
        #[allow(clippy::needless_borrow)]
    864
    		 
        pub async fn make_operation(
    1044
    		 
        #[allow(clippy::let_and_return)]
    1045
    		 
        #[allow(clippy::needless_borrow)]
    1046
    		 
        pub async fn make_operation(
  • aws-sdk-cognitosync 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cognito-sync-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://cognito-sync-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://cognito-sync.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-cognitosync 0.24.0/src/input.rs
    40
    		 
        #[allow(clippy::let_and_return)]
    41
    		 
        #[allow(clippy::needless_borrow)]
    42
    		 
        pub async fn make_operation(
    234
    		 
        #[allow(clippy::let_and_return)]
    235
    		 
        #[allow(clippy::needless_borrow)]
    236
    		 
        pub async fn make_operation(
    461
    		 
        #[allow(clippy::let_and_return)]
    462
    		 
        #[allow(clippy::needless_borrow)]
    463
    		 
        pub async fn make_operation(
    666
    		 
        #[allow(clippy::let_and_return)]
    667
    		 
        #[allow(clippy::needless_borrow)]
    668
    		 
        pub async fn make_operation(
    850
    		 
        #[allow(clippy::let_and_return)]
    851
    		 
        #[allow(clippy::needless_borrow)]
    852
    		 
        pub async fn make_operation(
  • aws-sdk-comprehend 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://comprehend-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://comprehend-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://comprehend.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-comprehend 0.24.0/src/input.rs
    55
    		 
        #[allow(clippy::let_and_return)]
    56
    		 
        #[allow(clippy::needless_borrow)]
    57
    		 
        pub async fn make_operation(
    251
    		 
        #[allow(clippy::let_and_return)]
    252
    		 
        #[allow(clippy::needless_borrow)]
    253
    		 
        pub async fn make_operation(
    447
    		 
        #[allow(clippy::let_and_return)]
    448
    		 
        #[allow(clippy::needless_borrow)]
    449
    		 
        pub async fn make_operation(
    649
    		 
        #[allow(clippy::let_and_return)]
    650
    		 
        #[allow(clippy::needless_borrow)]
    651
    		 
        pub async fn make_operation(
    847
    		 
        #[allow(clippy::let_and_return)]
    848
    		 
        #[allow(clippy::needless_borrow)]
    849
    		 
        pub async fn make_operation(
  • aws-sdk-comprehendmedical 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://comprehendmedical-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://comprehendmedical-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://comprehendmedical.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-comprehendmedical 0.24.0/src/input.rs
    39
    		 
        #[allow(clippy::let_and_return)]
    40
    		 
        #[allow(clippy::needless_borrow)]
    41
    		 
        pub async fn make_operation(
    203
    		 
        #[allow(clippy::let_and_return)]
    204
    		 
        #[allow(clippy::needless_borrow)]
    205
    		 
        pub async fn make_operation(
    367
    		 
        #[allow(clippy::let_and_return)]
    368
    		 
        #[allow(clippy::needless_borrow)]
    369
    		 
        pub async fn make_operation(
    533
    		 
        #[allow(clippy::let_and_return)]
    534
    		 
        #[allow(clippy::needless_borrow)]
    535
    		 
        pub async fn make_operation(
    697
    		 
        #[allow(clippy::let_and_return)]
    698
    		 
        #[allow(clippy::needless_borrow)]
    699
    		 
        pub async fn make_operation(
  • aws-sdk-computeoptimizer 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://compute-optimizer-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://compute-optimizer-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://compute-optimizer.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-computeoptimizer 0.24.0/src/input.rs
    87
    		 
        #[allow(clippy::let_and_return)]
    88
    		 
        #[allow(clippy::needless_borrow)]
    89
    		 
        pub async fn make_operation(
    311
    		 
        #[allow(clippy::let_and_return)]
    312
    		 
        #[allow(clippy::needless_borrow)]
    313
    		 
        pub async fn make_operation(
    613
    		 
        #[allow(clippy::let_and_return)]
    614
    		 
        #[allow(clippy::needless_borrow)]
    615
    		 
        pub async fn make_operation(
    891
    		 
        #[allow(clippy::let_and_return)]
    892
    		 
        #[allow(clippy::needless_borrow)]
    893
    		 
        pub async fn make_operation(
    1186
    		 
        #[allow(clippy::let_and_return)]
    1187
    		 
        #[allow(clippy::needless_borrow)]
    1188
    		 
        pub async fn make_operation(
  • aws-sdk-config 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://config-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://config.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://config-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-config 0.24.0/src/input.rs
    70
    		 
        #[allow(clippy::let_and_return)]
    71
    		 
        #[allow(clippy::needless_borrow)]
    72
    		 
        pub async fn make_operation(
    243
    		 
        #[allow(clippy::let_and_return)]
    244
    		 
        #[allow(clippy::needless_borrow)]
    245
    		 
        pub async fn make_operation(
    427
    		 
        #[allow(clippy::let_and_return)]
    428
    		 
        #[allow(clippy::needless_borrow)]
    429
    		 
        pub async fn make_operation(
    594
    		 
        #[allow(clippy::let_and_return)]
    595
    		 
        #[allow(clippy::needless_borrow)]
    596
    		 
        pub async fn make_operation(
    764
    		 
        #[allow(clippy::let_and_return)]
    765
    		 
        #[allow(clippy::needless_borrow)]
    766
    		 
        pub async fn make_operation(
  • aws-sdk-connect 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://connect-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://connect.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://connect-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-connect 0.24.0/src/input.rs
    51
    		 
        #[allow(clippy::let_and_return)]
    52
    		 
        #[allow(clippy::needless_borrow)]
    53
    		 
        pub async fn make_operation(
    261
    		 
        #[allow(clippy::let_and_return)]
    262
    		 
        #[allow(clippy::needless_borrow)]
    263
    		 
        pub async fn make_operation(
    474
    		 
        #[allow(clippy::let_and_return)]
    475
    		 
        #[allow(clippy::needless_borrow)]
    476
    		 
        pub async fn make_operation(
    709
    		 
        #[allow(clippy::let_and_return)]
    710
    		 
        #[allow(clippy::needless_borrow)]
    711
    		 
        pub async fn make_operation(
    904
    		 
        #[allow(clippy::let_and_return)]
    905
    		 
        #[allow(clippy::needless_borrow)]
    906
    		 
        pub async fn make_operation(
  • aws-sdk-connectcampaigns 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://connect-campaigns-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://connect-campaigns-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://connect-campaigns.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-connectcampaigns 0.24.0/src/input.rs
    111
    		 
        #[allow(clippy::let_and_return)]
    112
    		 
        #[allow(clippy::needless_borrow)]
    113
    		 
        pub async fn make_operation(
    266
    		 
        #[allow(clippy::let_and_return)]
    267
    		 
        #[allow(clippy::needless_borrow)]
    268
    		 
        pub async fn make_operation(
    433
    		 
        #[allow(clippy::let_and_return)]
    434
    		 
        #[allow(clippy::needless_borrow)]
    435
    		 
        pub async fn make_operation(
    605
    		 
        #[allow(clippy::let_and_return)]
    606
    		 
        #[allow(clippy::needless_borrow)]
    607
    		 
        pub async fn make_operation(
    772
    		 
        #[allow(clippy::let_and_return)]
    773
    		 
        #[allow(clippy::needless_borrow)]
    774
    		 
        pub async fn make_operation(
  • aws-sdk-connectcases 0.5.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cases-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://cases-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://cases.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-connectcases 0.5.0/src/input.rs
    58
    		 
        #[allow(clippy::let_and_return)]
    59
    		 
        #[allow(clippy::needless_borrow)]
    60
    		 
        pub async fn make_operation(
    274
    		 
        #[allow(clippy::let_and_return)]
    275
    		 
        #[allow(clippy::needless_borrow)]
    276
    		 
        pub async fn make_operation(
    522
    		 
        #[allow(clippy::let_and_return)]
    523
    		 
        #[allow(clippy::needless_borrow)]
    524
    		 
        pub async fn make_operation(
    700
    		 
        #[allow(clippy::let_and_return)]
    701
    		 
        #[allow(clippy::needless_borrow)]
    702
    		 
        pub async fn make_operation(
    893
    		 
        #[allow(clippy::let_and_return)]
    894
    		 
        #[allow(clippy::needless_borrow)]
    895
    		 
        pub async fn make_operation(
  • aws-sdk-connectcontactlens 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://contact-lens-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://contact-lens-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://contact-lens.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-connectcontactlens 0.24.0/src/input.rs
    75
    		 
        #[allow(clippy::let_and_return)]
    76
    		 
        #[allow(clippy::needless_borrow)]
    77
    		 
        pub async fn make_operation(
  • aws-sdk-connectparticipant 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://participant.connect-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://participant.connect.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://participant.connect-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-connectparticipant 0.24.0/src/input.rs
    75
    		 
        #[allow(clippy::let_and_return)]
    76
    		 
        #[allow(clippy::needless_borrow)]
    77
    		 
        pub async fn make_operation(
    280
    		 
        #[allow(clippy::let_and_return)]
    281
    		 
        #[allow(clippy::needless_borrow)]
    282
    		 
        pub async fn make_operation(
    456
    		 
        #[allow(clippy::let_and_return)]
    457
    		 
        #[allow(clippy::needless_borrow)]
    458
    		 
        pub async fn make_operation(
    638
    		 
        #[allow(clippy::let_and_return)]
    639
    		 
        #[allow(clippy::needless_borrow)]
    640
    		 
        pub async fn make_operation(
    877
    		 
        #[allow(clippy::let_and_return)]
    878
    		 
        #[allow(clippy::needless_borrow)]
    879
    		 
        pub async fn make_operation(
  • aws-sdk-controltower 0.5.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://controltower-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://controltower-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://controltower.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-controltower 0.5.0/src/input.rs
    55
    		 
        #[allow(clippy::let_and_return)]
    56
    		 
        #[allow(clippy::needless_borrow)]
    57
    		 
        pub async fn make_operation(
    230
    		 
        #[allow(clippy::let_and_return)]
    231
    		 
        #[allow(clippy::needless_borrow)]
    232
    		 
        pub async fn make_operation(
    392
    		 
        #[allow(clippy::let_and_return)]
    393
    		 
        #[allow(clippy::needless_borrow)]
    394
    		 
        pub async fn make_operation(
    578
    		 
        #[allow(clippy::let_and_return)]
    579
    		 
        #[allow(clippy::needless_borrow)]
    580
    		 
        pub async fn make_operation(
  • aws-sdk-costandusagereport 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cur-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://cur-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://cur.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-costandusagereport 0.24.0/src/input.rs
    39
    		 
        #[allow(clippy::let_and_return)]
    40
    		 
        #[allow(clippy::needless_borrow)]
    41
    		 
        pub async fn make_operation(
    217
    		 
        #[allow(clippy::let_and_return)]
    218
    		 
        #[allow(clippy::needless_borrow)]
    219
    		 
        pub async fn make_operation(
    398
    		 
        #[allow(clippy::let_and_return)]
    399
    		 
        #[allow(clippy::needless_borrow)]
    400
    		 
        pub async fn make_operation(
    567
    		 
        #[allow(clippy::let_and_return)]
    568
    		 
        #[allow(clippy::needless_borrow)]
    569
    		 
        pub async fn make_operation(
  • aws-sdk-costexplorer 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://ce-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    69
    		 
                                out.push_str("https://ce-fips.");
    70
    		 
                                #[allow(clippy::needless_borrow)]
    71
    		 
                                out.push_str(&region);
    86
    		 
                                out.push_str("https://ce.");
    87
    		 
                                #[allow(clippy::needless_borrow)]
    88
    		 
                                out.push_str(&region);
    122
    		 
                                        out.push_str("https://ce-fips.");
    123
    		 
                                        #[allow(clippy::needless_borrow)]
    124
    		 
                                        out.push_str(&region);
    140
    		 
                                out.push_str("https://ce-fips.");
    141
    		 
                                #[allow(clippy::needless_borrow)]
    142
    		 
                                out.push_str(&region);
  • aws-sdk-costexplorer 0.24.0/src/input.rs
    83
    		 
        #[allow(clippy::let_and_return)]
    84
    		 
        #[allow(clippy::needless_borrow)]
    85
    		 
        pub async fn make_operation(
    293
    		 
        #[allow(clippy::let_and_return)]
    294
    		 
        #[allow(clippy::needless_borrow)]
    295
    		 
        pub async fn make_operation(
    591
    		 
        #[allow(clippy::let_and_return)]
    592
    		 
        #[allow(clippy::needless_borrow)]
    593
    		 
        pub async fn make_operation(
    755
    		 
        #[allow(clippy::let_and_return)]
    756
    		 
        #[allow(clippy::needless_borrow)]
    757
    		 
        pub async fn make_operation(
    924
    		 
        #[allow(clippy::let_and_return)]
    925
    		 
        #[allow(clippy::needless_borrow)]
    926
    		 
        pub async fn make_operation(
  • aws-sdk-customerprofiles 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://profile-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://profile-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://profile.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-customerprofiles 0.24.0/src/input.rs
    82
    		 
        #[allow(clippy::let_and_return)]
    83
    		 
        #[allow(clippy::needless_borrow)]
    84
    		 
        pub async fn make_operation(
    351
    		 
        #[allow(clippy::let_and_return)]
    352
    		 
        #[allow(clippy::needless_borrow)]
    353
    		 
        pub async fn make_operation(
    616
    		 
        #[allow(clippy::let_and_return)]
    617
    		 
        #[allow(clippy::needless_borrow)]
    618
    		 
        pub async fn make_operation(
    1137
    		 
        #[allow(clippy::let_and_return)]
    1138
    		 
        #[allow(clippy::needless_borrow)]
    1139
    		 
        pub async fn make_operation(
    1318
    		 
        #[allow(clippy::let_and_return)]
    1319
    		 
        #[allow(clippy::needless_borrow)]
    1320
    		 
        pub async fn make_operation(
  • aws-sdk-databasemigration 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://dms-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://dms.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    83
    		 
                                out.push_str("https://dms.");
    84
    		 
                                #[allow(clippy::needless_borrow)]
    85
    		 
                                out.push_str(&region);
    95
    		 
                                out.push_str("https://dms.");
    96
    		 
                                #[allow(clippy::needless_borrow)]
    97
    		 
                                out.push_str(&region);
  • aws-sdk-databasemigration 0.24.0/src/input.rs
    62
    		 
        #[allow(clippy::let_and_return)]
    63
    		 
        #[allow(clippy::needless_borrow)]
    64
    		 
        pub async fn make_operation(
    267
    		 
        #[allow(clippy::let_and_return)]
    268
    		 
        #[allow(clippy::needless_borrow)]
    269
    		 
        pub async fn make_operation(
    437
    		 
        #[allow(clippy::let_and_return)]
    438
    		 
        #[allow(clippy::needless_borrow)]
    439
    		 
        pub async fn make_operation(
    1159
    		 
        #[allow(clippy::let_and_return)]
    1160
    		 
        #[allow(clippy::needless_borrow)]
    1161
    		 
        pub async fn make_operation(
    1434
    		 
        #[allow(clippy::let_and_return)]
    1435
    		 
        #[allow(clippy::needless_borrow)]
    1436
    		 
        pub async fn make_operation(
  • aws-sdk-databrew 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://databrew-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    75
    		 
                            out.push_str("https://databrew-fips.");
    76
    		 
                            #[allow(clippy::needless_borrow)]
    77
    		 
                            out.push_str(&region);
    78
    		 
                            out.push('.');
    79
    		 
                            #[allow(clippy::needless_borrow)]
    80
    		 
                            out.push_str(&partition_result.dns_suffix());
    94
    		 
                            out.push_str("https://databrew.");
    95
    		 
                            #[allow(clippy::needless_borrow)]
    96
    		 
                            out.push_str(&region);
  • aws-sdk-databrew 0.24.0/src/input.rs
    60
    		 
        #[allow(clippy::let_and_return)]
    61
    		 
        #[allow(clippy::needless_borrow)]
    62
    		 
        pub async fn make_operation(
    326
    		 
        #[allow(clippy::let_and_return)]
    327
    		 
        #[allow(clippy::needless_borrow)]
    328
    		 
        pub async fn make_operation(
    697
    		 
        #[allow(clippy::let_and_return)]
    698
    		 
        #[allow(clippy::needless_borrow)]
    699
    		 
        pub async fn make_operation(
    931
    		 
        #[allow(clippy::let_and_return)]
    932
    		 
        #[allow(clippy::needless_borrow)]
    933
    		 
        pub async fn make_operation(
    1150
    		 
        #[allow(clippy::let_and_return)]
    1151
    		 
        #[allow(clippy::needless_borrow)]
    1152
    		 
        pub async fn make_operation(
  • aws-sdk-dataexchange 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://dataexchange-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://dataexchange-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://dataexchange.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-dataexchange 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    254
    		 
        #[allow(clippy::let_and_return)]
    255
    		 
        #[allow(clippy::needless_borrow)]
    256
    		 
        pub async fn make_operation(
    425
    		 
        #[allow(clippy::let_and_return)]
    426
    		 
        #[allow(clippy::needless_borrow)]
    427
    		 
        pub async fn make_operation(
    597
    		 
        #[allow(clippy::let_and_return)]
    598
    		 
        #[allow(clippy::needless_borrow)]
    599
    		 
        pub async fn make_operation(
    793
    		 
        #[allow(clippy::let_and_return)]
    794
    		 
        #[allow(clippy::needless_borrow)]
    795
    		 
        pub async fn make_operation(
  • aws-sdk-datapipeline 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://datapipeline-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://datapipeline-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://datapipeline.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-datapipeline 0.24.0/src/input.rs
    76
    		 
        #[allow(clippy::let_and_return)]
    77
    		 
        #[allow(clippy::needless_borrow)]
    78
    		 
        pub async fn make_operation(
    259
    		 
        #[allow(clippy::let_and_return)]
    260
    		 
        #[allow(clippy::needless_borrow)]
    261
    		 
        pub async fn make_operation(
    464
    		 
        #[allow(clippy::let_and_return)]
    465
    		 
        #[allow(clippy::needless_borrow)]
    466
    		 
        pub async fn make_operation(
    640
    		 
        #[allow(clippy::let_and_return)]
    641
    		 
        #[allow(clippy::needless_borrow)]
    642
    		 
        pub async fn make_operation(
    802
    		 
        #[allow(clippy::let_and_return)]
    803
    		 
        #[allow(clippy::needless_borrow)]
    804
    		 
        pub async fn make_operation(
  • aws-sdk-datasync 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://datasync-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://datasync-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://datasync.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-datasync 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    307
    		 
        #[allow(clippy::let_and_return)]
    308
    		 
        #[allow(clippy::needless_borrow)]
    309
    		 
        pub async fn make_operation(
    579
    		 
        #[allow(clippy::let_and_return)]
    580
    		 
        #[allow(clippy::needless_borrow)]
    581
    		 
        pub async fn make_operation(
    800
    		 
        #[allow(clippy::let_and_return)]
    801
    		 
        #[allow(clippy::needless_borrow)]
    802
    		 
        pub async fn make_operation(
    1057
    		 
        #[allow(clippy::let_and_return)]
    1058
    		 
        #[allow(clippy::needless_borrow)]
    1059
    		 
        pub async fn make_operation(
  • aws-sdk-dax 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://dax-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://dax-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://dax.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-dax 0.24.0/src/input.rs
    303
    		 
        #[allow(clippy::let_and_return)]
    304
    		 
        #[allow(clippy::needless_borrow)]
    305
    		 
        pub async fn make_operation(
    482
    		 
        #[allow(clippy::let_and_return)]
    483
    		 
        #[allow(clippy::needless_borrow)]
    484
    		 
        pub async fn make_operation(
    684
    		 
        #[allow(clippy::let_and_return)]
    685
    		 
        #[allow(clippy::needless_borrow)]
    686
    		 
        pub async fn make_operation(
    902
    		 
        #[allow(clippy::let_and_return)]
    903
    		 
        #[allow(clippy::needless_borrow)]
    904
    		 
        pub async fn make_operation(
    1066
    		 
        #[allow(clippy::let_and_return)]
    1067
    		 
        #[allow(clippy::needless_borrow)]
    1068
    		 
        pub async fn make_operation(
  • aws-sdk-detective 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://api.detective-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://api.detective-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://api.detective.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-detective 0.24.0/src/input.rs
    41
    		 
        #[allow(clippy::let_and_return)]
    42
    		 
        #[allow(clippy::needless_borrow)]
    43
    		 
        pub async fn make_operation(
    221
    		 
        #[allow(clippy::let_and_return)]
    222
    		 
        #[allow(clippy::needless_borrow)]
    223
    		 
        pub async fn make_operation(
    389
    		 
        #[allow(clippy::let_and_return)]
    390
    		 
        #[allow(clippy::needless_borrow)]
    391
    		 
        pub async fn make_operation(
    561
    		 
        #[allow(clippy::let_and_return)]
    562
    		 
        #[allow(clippy::needless_borrow)]
    563
    		 
        pub async fn make_operation(
    765
    		 
        #[allow(clippy::let_and_return)]
    766
    		 
        #[allow(clippy::needless_borrow)]
    767
    		 
        pub async fn make_operation(
  • aws-sdk-devicefarm 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://devicefarm-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://devicefarm-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://devicefarm.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-devicefarm 0.24.0/src/input.rs
    98
    		 
        #[allow(clippy::let_and_return)]
    99
    		 
        #[allow(clippy::needless_borrow)]
    100
    		 
        pub async fn make_operation(
    325
    		 
        #[allow(clippy::let_and_return)]
    326
    		 
        #[allow(clippy::needless_borrow)]
    327
    		 
        pub async fn make_operation(
    626
    		 
        #[allow(clippy::let_and_return)]
    627
    		 
        #[allow(clippy::needless_borrow)]
    628
    		 
        pub async fn make_operation(
    817
    		 
        #[allow(clippy::let_and_return)]
    818
    		 
        #[allow(clippy::needless_borrow)]
    819
    		 
        pub async fn make_operation(
    1147
    		 
        #[allow(clippy::let_and_return)]
    1148
    		 
        #[allow(clippy::needless_borrow)]
    1149
    		 
        pub async fn make_operation(
  • aws-sdk-devopsguru 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://devops-guru-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://devops-guru-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://devops-guru.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-devopsguru 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    199
    		 
        #[allow(clippy::let_and_return)]
    200
    		 
        #[allow(clippy::needless_borrow)]
    201
    		 
        pub async fn make_operation(
    349
    		 
        #[allow(clippy::let_and_return)]
    350
    		 
        #[allow(clippy::needless_borrow)]
    351
    		 
        pub async fn make_operation(
    512
    		 
        #[allow(clippy::let_and_return)]
    513
    		 
        #[allow(clippy::needless_borrow)]
    514
    		 
        pub async fn make_operation(
    683
    		 
        #[allow(clippy::let_and_return)]
    684
    		 
        #[allow(clippy::needless_borrow)]
    685
    		 
        pub async fn make_operation(
  • aws-sdk-directconnect 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://directconnect-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://directconnect-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://directconnect.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-directconnect 0.24.0/src/input.rs
    104
    		 
        #[allow(clippy::let_and_return)]
    105
    		 
        #[allow(clippy::needless_borrow)]
    106
    		 
        pub async fn make_operation(
    326
    		 
        #[allow(clippy::let_and_return)]
    327
    		 
        #[allow(clippy::needless_borrow)]
    328
    		 
        pub async fn make_operation(
    568
    		 
        #[allow(clippy::let_and_return)]
    569
    		 
        #[allow(clippy::needless_borrow)]
    570
    		 
        pub async fn make_operation(
    772
    		 
        #[allow(clippy::let_and_return)]
    773
    		 
        #[allow(clippy::needless_borrow)]
    774
    		 
        pub async fn make_operation(
    974
    		 
        #[allow(clippy::let_and_return)]
    975
    		 
        #[allow(clippy::needless_borrow)]
    976
    		 
        pub async fn make_operation(
  • aws-sdk-directory 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://ds-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://ds-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://ds.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-directory 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    296
    		 
        #[allow(clippy::let_and_return)]
    297
    		 
        #[allow(clippy::needless_borrow)]
    298
    		 
        pub async fn make_operation(
    485
    		 
        #[allow(clippy::let_and_return)]
    486
    		 
        #[allow(clippy::needless_borrow)]
    487
    		 
        pub async fn make_operation(
    668
    		 
        #[allow(clippy::let_and_return)]
    669
    		 
        #[allow(clippy::needless_borrow)]
    670
    		 
        pub async fn make_operation(
    847
    		 
        #[allow(clippy::let_and_return)]
    848
    		 
        #[allow(clippy::needless_borrow)]
    849
    		 
        pub async fn make_operation(
  • aws-sdk-dlm 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://dlm-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://dlm.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://dlm-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-dlm 0.24.0/src/input.rs
    113
    		 
        #[allow(clippy::let_and_return)]
    114
    		 
        #[allow(clippy::needless_borrow)]
    115
    		 
        pub async fn make_operation(
    274
    		 
        #[allow(clippy::let_and_return)]
    275
    		 
        #[allow(clippy::needless_borrow)]
    276
    		 
        pub async fn make_operation(
    533
    		 
        #[allow(clippy::let_and_return)]
    534
    		 
        #[allow(clippy::needless_borrow)]
    535
    		 
        pub async fn make_operation(
    731
    		 
        #[allow(clippy::let_and_return)]
    732
    		 
        #[allow(clippy::needless_borrow)]
    733
    		 
        pub async fn make_operation(
    896
    		 
        #[allow(clippy::let_and_return)]
    897
    		 
        #[allow(clippy::needless_borrow)]
    898
    		 
        pub async fn make_operation(
  • aws-sdk-docdb 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://rds-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://rds.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://rds-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-docdb 0.24.0/src/input.rs
    69
    		 
        #[allow(clippy::let_and_return)]
    70
    		 
        #[allow(clippy::needless_borrow)]
    71
    		 
        pub async fn make_operation(
    252
    		 
        #[allow(clippy::let_and_return)]
    253
    		 
        #[allow(clippy::needless_borrow)]
    254
    		 
        pub async fn make_operation(
    452
    		 
        #[allow(clippy::let_and_return)]
    453
    		 
        #[allow(clippy::needless_borrow)]
    454
    		 
        pub async fn make_operation(
    708
    		 
        #[allow(clippy::let_and_return)]
    709
    		 
        #[allow(clippy::needless_borrow)]
    710
    		 
        pub async fn make_operation(
    1001
    		 
        #[allow(clippy::let_and_return)]
    1002
    		 
        #[allow(clippy::needless_borrow)]
    1003
    		 
        pub async fn make_operation(
  • aws-sdk-docdbelastic 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://docdb-elastic-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://docdb-elastic-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://docdb-elastic.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-docdbelastic 0.2.0/src/input.rs
    285
    		 
        #[allow(clippy::let_and_return)]
    286
    		 
        #[allow(clippy::needless_borrow)]
    287
    		 
        pub async fn make_operation(
    491
    		 
        #[allow(clippy::let_and_return)]
    492
    		 
        #[allow(clippy::needless_borrow)]
    493
    		 
        pub async fn make_operation(
    650
    		 
        #[allow(clippy::let_and_return)]
    651
    		 
        #[allow(clippy::needless_borrow)]
    652
    		 
        pub async fn make_operation(
    815
    		 
        #[allow(clippy::let_and_return)]
    816
    		 
        #[allow(clippy::needless_borrow)]
    817
    		 
        pub async fn make_operation(
    982
    		 
        #[allow(clippy::let_and_return)]
    983
    		 
        #[allow(clippy::needless_borrow)]
    984
    		 
        pub async fn make_operation(
  • aws-sdk-drs 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://drs-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://drs-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://drs.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-drs 0.24.0/src/input.rs
    79
    		 
        #[allow(clippy::let_and_return)]
    80
    		 
        #[allow(clippy::needless_borrow)]
    81
    		 
        pub async fn make_operation(
    529
    		 
        #[allow(clippy::let_and_return)]
    530
    		 
        #[allow(clippy::needless_borrow)]
    531
    		 
        pub async fn make_operation(
    687
    		 
        #[allow(clippy::let_and_return)]
    688
    		 
        #[allow(clippy::needless_borrow)]
    689
    		 
        pub async fn make_operation(
    847
    		 
        #[allow(clippy::let_and_return)]
    848
    		 
        #[allow(clippy::needless_borrow)]
    849
    		 
        pub async fn make_operation(
    1014
    		 
        #[allow(clippy::let_and_return)]
    1015
    		 
        #[allow(clippy::needless_borrow)]
    1016
    		 
        pub async fn make_operation(
  • aws-sdk-dynamodb 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://dynamodb-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://dynamodb.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://dynamodb-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-dynamodb 0.24.0/src/input.rs
    78
    		 
        #[allow(clippy::let_and_return)]
    79
    		 
        #[allow(clippy::needless_borrow)]
    80
    		 
        pub async fn make_operation(
    336
    		 
        #[allow(clippy::let_and_return)]
    337
    		 
        #[allow(clippy::needless_borrow)]
    338
    		 
        pub async fn make_operation(
    589
    		 
        #[allow(clippy::let_and_return)]
    590
    		 
        #[allow(clippy::needless_borrow)]
    591
    		 
        pub async fn make_operation(
    763
    		 
        #[allow(clippy::let_and_return)]
    764
    		 
        #[allow(clippy::needless_borrow)]
    765
    		 
        pub async fn make_operation(
    951
    		 
        #[allow(clippy::let_and_return)]
    952
    		 
        #[allow(clippy::needless_borrow)]
    953
    		 
        pub async fn make_operation(
  • aws-sdk-dynamodbstreams 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://streams.dynamodb-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://streams.dynamodb.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://streams.dynamodb-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-dynamodbstreams 0.24.0/src/input.rs
    64
    		 
        #[allow(clippy::let_and_return)]
    65
    		 
        #[allow(clippy::needless_borrow)]
    66
    		 
        pub async fn make_operation(
    241
    		 
        #[allow(clippy::let_and_return)]
    242
    		 
        #[allow(clippy::needless_borrow)]
    243
    		 
        pub async fn make_operation(
    459
    		 
        #[allow(clippy::let_and_return)]
    460
    		 
        #[allow(clippy::needless_borrow)]
    461
    		 
        pub async fn make_operation(
    648
    		 
        #[allow(clippy::let_and_return)]
    649
    		 
        #[allow(clippy::needless_borrow)]
    650
    		 
        pub async fn make_operation(
  • aws-sdk-ebs 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://ebs-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://ebs-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://ebs.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-ebs 0.24.0/src/input.rs
    99
    		 
        #[allow(clippy::let_and_return)]
    100
    		 
        #[allow(clippy::needless_borrow)]
    101
    		 
        pub async fn make_operation(
    297
    		 
        #[allow(clippy::let_and_return)]
    298
    		 
        #[allow(clippy::needless_borrow)]
    299
    		 
        pub async fn make_operation(
    580
    		 
        #[allow(clippy::let_and_return)]
    581
    		 
        #[allow(clippy::needless_borrow)]
    582
    		 
        pub async fn make_operation(
    830
    		 
        #[allow(clippy::let_and_return)]
    831
    		 
        #[allow(clippy::needless_borrow)]
    832
    		 
        pub async fn make_operation(
    1127
    		 
        #[allow(clippy::let_and_return)]
    1128
    		 
        #[allow(clippy::needless_borrow)]
    1129
    		 
        pub async fn make_operation(
  • aws-sdk-ec2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://ec2-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://ec2.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    74
    		 
                                out.push('.');
    75
    		 
                                #[allow(clippy::needless_borrow)]
    76
    		 
                                out.push_str(&partition_result.dns_suffix());
    84
    		 
                            out.push_str("https://ec2-fips.");
    85
    		 
                            #[allow(clippy::needless_borrow)]
    86
    		 
                            out.push_str(&region);
  • aws-sdk-ec2 0.24.0/src/input.rs
    85
    		 
        #[allow(clippy::let_and_return)]
    86
    		 
        #[allow(clippy::needless_borrow)]
    87
    		 
        pub async fn make_operation(
    292
    		 
        #[allow(clippy::let_and_return)]
    293
    		 
        #[allow(clippy::needless_borrow)]
    294
    		 
        pub async fn make_operation(
    510
    		 
        #[allow(clippy::let_and_return)]
    511
    		 
        #[allow(clippy::needless_borrow)]
    512
    		 
        pub async fn make_operation(
    688
    		 
        #[allow(clippy::let_and_return)]
    689
    		 
        #[allow(clippy::needless_borrow)]
    690
    		 
        pub async fn make_operation(
    865
    		 
        #[allow(clippy::let_and_return)]
    866
    		 
        #[allow(clippy::needless_borrow)]
    867
    		 
        pub async fn make_operation(
  • aws-sdk-ec2instanceconnect 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://ec2-instance-connect-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://ec2-instance-connect-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://ec2-instance-connect.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-ec2instanceconnect 0.24.0/src/input.rs
    68
    		 
        #[allow(clippy::let_and_return)]
    69
    		 
        #[allow(clippy::needless_borrow)]
    70
    		 
        pub async fn make_operation(
    277
    		 
        #[allow(clippy::let_and_return)]
    278
    		 
        #[allow(clippy::needless_borrow)]
    279
    		 
        pub async fn make_operation(
  • aws-sdk-ecr 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://api.ecr-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://ecr-fips.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    83
    		 
                                out.push_str("https://ecr-fips.");
    84
    		 
                                #[allow(clippy::needless_borrow)]
    85
    		 
                                out.push_str(&region);
    94
    		 
                            out.push_str("https://api.ecr-fips.");
    95
    		 
                            #[allow(clippy::needless_borrow)]
    96
    		 
                            out.push_str(&region);
  • aws-sdk-ecr 0.24.0/src/input.rs
    75
    		 
        #[allow(clippy::let_and_return)]
    76
    		 
        #[allow(clippy::needless_borrow)]
    77
    		 
        pub async fn make_operation(
    275
    		 
        #[allow(clippy::let_and_return)]
    276
    		 
        #[allow(clippy::needless_borrow)]
    277
    		 
        pub async fn make_operation(
    496
    		 
        #[allow(clippy::let_and_return)]
    497
    		 
        #[allow(clippy::needless_borrow)]
    498
    		 
        pub async fn make_operation(
    669
    		 
        #[allow(clippy::let_and_return)]
    670
    		 
        #[allow(clippy::needless_borrow)]
    671
    		 
        pub async fn make_operation(
    881
    		 
        #[allow(clippy::let_and_return)]
    882
    		 
        #[allow(clippy::needless_borrow)]
    883
    		 
        pub async fn make_operation(
  • aws-sdk-ecrpublic 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://api.ecr-public-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://api.ecr-public-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://api.ecr-public.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-ecrpublic 0.24.0/src/input.rs
    75
    		 
        #[allow(clippy::let_and_return)]
    76
    		 
        #[allow(clippy::needless_borrow)]
    77
    		 
        pub async fn make_operation(
    275
    		 
        #[allow(clippy::let_and_return)]
    276
    		 
        #[allow(clippy::needless_borrow)]
    277
    		 
        pub async fn make_operation(
    487
    		 
        #[allow(clippy::let_and_return)]
    488
    		 
        #[allow(clippy::needless_borrow)]
    489
    		 
        pub async fn make_operation(
    690
    		 
        #[allow(clippy::let_and_return)]
    691
    		 
        #[allow(clippy::needless_borrow)]
    692
    		 
        pub async fn make_operation(
    881
    		 
        #[allow(clippy::let_and_return)]
    882
    		 
        #[allow(clippy::needless_borrow)]
    883
    		 
        pub async fn make_operation(
  • aws-sdk-ecs 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://ecs-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://ecs-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://ecs.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-ecs 0.24.0/src/input.rs
    99
    		 
        #[allow(clippy::let_and_return)]
    100
    		 
        #[allow(clippy::needless_borrow)]
    101
    		 
        pub async fn make_operation(
    415
    		 
        #[allow(clippy::let_and_return)]
    416
    		 
        #[allow(clippy::needless_borrow)]
    417
    		 
        pub async fn make_operation(
    1022
    		 
        #[allow(clippy::let_and_return)]
    1023
    		 
        #[allow(clippy::needless_borrow)]
    1024
    		 
        pub async fn make_operation(
    1413
    		 
        #[allow(clippy::let_and_return)]
    1414
    		 
        #[allow(clippy::needless_borrow)]
    1415
    		 
        pub async fn make_operation(
    1592
    		 
        #[allow(clippy::let_and_return)]
    1593
    		 
        #[allow(clippy::needless_borrow)]
    1594
    		 
        pub async fn make_operation(
  • aws-sdk-efs 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://elasticfilesystem-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://elasticfilesystem-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://elasticfilesystem.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-efs 0.24.0/src/input.rs
    107
    		 
        #[allow(clippy::let_and_return)]
    108
    		 
        #[allow(clippy::needless_borrow)]
    109
    		 
        pub async fn make_operation(
    423
    		 
        #[allow(clippy::let_and_return)]
    424
    		 
        #[allow(clippy::needless_borrow)]
    425
    		 
        pub async fn make_operation(
    633
    		 
        #[allow(clippy::let_and_return)]
    634
    		 
        #[allow(clippy::needless_borrow)]
    635
    		 
        pub async fn make_operation(
    817
    		 
        #[allow(clippy::let_and_return)]
    818
    		 
        #[allow(clippy::needless_borrow)]
    819
    		 
        pub async fn make_operation(
    1022
    		 
        #[allow(clippy::let_and_return)]
    1023
    		 
        #[allow(clippy::needless_borrow)]
    1024
    		 
        pub async fn make_operation(
  • aws-sdk-eks 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://eks-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://fips.eks.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    83
    		 
                                out.push_str("https://eks.");
    84
    		 
                                #[allow(clippy::needless_borrow)]
    85
    		 
                                out.push_str(&region);
    94
    		 
                            out.push_str("https://eks-fips.");
    95
    		 
                            #[allow(clippy::needless_borrow)]
    96
    		 
                            out.push_str(&region);
  • aws-sdk-eks 0.24.0/src/input.rs
    76
    		 
        #[allow(clippy::let_and_return)]
    77
    		 
        #[allow(clippy::needless_borrow)]
    78
    		 
        pub async fn make_operation(
    323
    		 
        #[allow(clippy::let_and_return)]
    324
    		 
        #[allow(clippy::needless_borrow)]
    325
    		 
        pub async fn make_operation(
    639
    		 
        #[allow(clippy::let_and_return)]
    640
    		 
        #[allow(clippy::needless_borrow)]
    641
    		 
        pub async fn make_operation(
    982
    		 
        #[allow(clippy::let_and_return)]
    983
    		 
        #[allow(clippy::needless_borrow)]
    984
    		 
        pub async fn make_operation(
    1261
    		 
        #[allow(clippy::let_and_return)]
    1262
    		 
        #[allow(clippy::needless_borrow)]
    1263
    		 
        pub async fn make_operation(
  • aws-sdk-elasticache 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://elasticache-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://elasticache.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://elasticache-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-elasticache 0.24.0/src/input.rs
    65
    		 
        #[allow(clippy::let_and_return)]
    66
    		 
        #[allow(clippy::needless_borrow)]
    67
    		 
        pub async fn make_operation(
    260
    		 
        #[allow(clippy::let_and_return)]
    261
    		 
        #[allow(clippy::needless_borrow)]
    262
    		 
        pub async fn make_operation(
    464
    		 
        #[allow(clippy::let_and_return)]
    465
    		 
        #[allow(clippy::needless_borrow)]
    466
    		 
        pub async fn make_operation(
    670
    		 
        #[allow(clippy::let_and_return)]
    671
    		 
        #[allow(clippy::needless_borrow)]
    672
    		 
        pub async fn make_operation(
    846
    		 
        #[allow(clippy::let_and_return)]
    847
    		 
        #[allow(clippy::needless_borrow)]
    848
    		 
        pub async fn make_operation(
  • aws-sdk-elasticbeanstalk 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://elasticbeanstalk-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://elasticbeanstalk.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://elasticbeanstalk-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-elasticbeanstalk 0.24.0/src/input.rs
    57
    		 
        #[allow(clippy::let_and_return)]
    58
    		 
        #[allow(clippy::needless_borrow)]
    59
    		 
        pub async fn make_operation(
    248
    		 
        #[allow(clippy::let_and_return)]
    249
    		 
        #[allow(clippy::needless_borrow)]
    250
    		 
        pub async fn make_operation(
    425
    		 
        #[allow(clippy::let_and_return)]
    426
    		 
        #[allow(clippy::needless_borrow)]
    427
    		 
        pub async fn make_operation(
    584
    		 
        #[allow(clippy::let_and_return)]
    585
    		 
        #[allow(clippy::needless_borrow)]
    586
    		 
        pub async fn make_operation(
    781
    		 
        #[allow(clippy::let_and_return)]
    782
    		 
        #[allow(clippy::needless_borrow)]
    783
    		 
        pub async fn make_operation(
  • aws-sdk-elasticinference 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://api.elastic-inference-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://api.elastic-inference-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://api.elastic-inference.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-elasticinference 0.24.0/src/input.rs
    63
    		 
        #[allow(clippy::let_and_return)]
    64
    		 
        #[allow(clippy::needless_borrow)]
    65
    		 
        pub async fn make_operation(
    277
    		 
        #[allow(clippy::let_and_return)]
    278
    		 
        #[allow(clippy::needless_borrow)]
    279
    		 
        pub async fn make_operation(
    422
    		 
        #[allow(clippy::let_and_return)]
    423
    		 
        #[allow(clippy::needless_borrow)]
    424
    		 
        pub async fn make_operation(
    567
    		 
        #[allow(clippy::let_and_return)]
    568
    		 
        #[allow(clippy::needless_borrow)]
    569
    		 
        pub async fn make_operation(
    759
    		 
        #[allow(clippy::let_and_return)]
    760
    		 
        #[allow(clippy::needless_borrow)]
    761
    		 
        pub async fn make_operation(
  • aws-sdk-elasticloadbalancing 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://elasticloadbalancing-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://elasticloadbalancing.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://elasticloadbalancing-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-elasticloadbalancing 0.24.0/src/input.rs
    67
    		 
        #[allow(clippy::let_and_return)]
    68
    		 
        #[allow(clippy::needless_borrow)]
    69
    		 
        pub async fn make_operation(
    248
    		 
        #[allow(clippy::let_and_return)]
    249
    		 
        #[allow(clippy::needless_borrow)]
    250
    		 
        pub async fn make_operation(
    431
    		 
        #[allow(clippy::let_and_return)]
    432
    		 
        #[allow(clippy::needless_borrow)]
    433
    		 
        pub async fn make_operation(
    608
    		 
        #[allow(clippy::let_and_return)]
    609
    		 
        #[allow(clippy::needless_borrow)]
    610
    		 
        pub async fn make_operation(
    796
    		 
        #[allow(clippy::let_and_return)]
    797
    		 
        #[allow(clippy::needless_borrow)]
    798
    		 
        pub async fn make_operation(
  • aws-sdk-elasticloadbalancingv2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://elasticloadbalancing-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://elasticloadbalancing.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://elasticloadbalancing-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-elasticloadbalancingv2 0.24.0/src/input.rs
    60
    		 
        #[allow(clippy::let_and_return)]
    61
    		 
        #[allow(clippy::needless_borrow)]
    62
    		 
        pub async fn make_operation(
    249
    		 
        #[allow(clippy::let_and_return)]
    250
    		 
        #[allow(clippy::needless_borrow)]
    251
    		 
        pub async fn make_operation(
    548
    		 
        #[allow(clippy::let_and_return)]
    549
    		 
        #[allow(clippy::needless_borrow)]
    550
    		 
        pub async fn make_operation(
    879
    		 
        #[allow(clippy::let_and_return)]
    880
    		 
        #[allow(clippy::needless_borrow)]
    881
    		 
        pub async fn make_operation(
    1111
    		 
        #[allow(clippy::let_and_return)]
    1112
    		 
        #[allow(clippy::needless_borrow)]
    1113
    		 
        pub async fn make_operation(
  • aws-sdk-elasticsearch 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://es-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://es-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://es.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-elasticsearch 0.24.0/src/input.rs
    47
    		 
        #[allow(clippy::let_and_return)]
    48
    		 
        #[allow(clippy::needless_borrow)]
    49
    		 
        pub async fn make_operation(
    236
    		 
        #[allow(clippy::let_and_return)]
    237
    		 
        #[allow(clippy::needless_borrow)]
    238
    		 
        pub async fn make_operation(
    405
    		 
        #[allow(clippy::let_and_return)]
    406
    		 
        #[allow(clippy::needless_borrow)]
    407
    		 
        pub async fn make_operation(
    606
    		 
        #[allow(clippy::let_and_return)]
    607
    		 
        #[allow(clippy::needless_borrow)]
    608
    		 
        pub async fn make_operation(
    791
    		 
        #[allow(clippy::let_and_return)]
    792
    		 
        #[allow(clippy::needless_borrow)]
    793
    		 
        pub async fn make_operation(
  • aws-sdk-elastictranscoder 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://elastictranscoder-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://elastictranscoder-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://elastictranscoder.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-elastictranscoder 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    334
    		 
        #[allow(clippy::let_and_return)]
    335
    		 
        #[allow(clippy::needless_borrow)]
    336
    		 
        pub async fn make_operation(
    720
    		 
        #[allow(clippy::let_and_return)]
    721
    		 
        #[allow(clippy::needless_borrow)]
    722
    		 
        pub async fn make_operation(
    946
    		 
        #[allow(clippy::let_and_return)]
    947
    		 
        #[allow(clippy::needless_borrow)]
    948
    		 
        pub async fn make_operation(
    1101
    		 
        #[allow(clippy::let_and_return)]
    1102
    		 
        #[allow(clippy::needless_borrow)]
    1103
    		 
        pub async fn make_operation(
  • aws-sdk-emr 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://elasticmapreduce-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://elasticmapreduce.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://elasticmapreduce-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-emr 0.24.0/src/input.rs
    54
    		 
        #[allow(clippy::let_and_return)]
    55
    		 
        #[allow(clippy::needless_borrow)]
    56
    		 
        pub async fn make_operation(
    240
    		 
        #[allow(clippy::let_and_return)]
    241
    		 
        #[allow(clippy::needless_borrow)]
    242
    		 
        pub async fn make_operation(
    440
    		 
        #[allow(clippy::let_and_return)]
    441
    		 
        #[allow(clippy::needless_borrow)]
    442
    		 
        pub async fn make_operation(
    623
    		 
        #[allow(clippy::let_and_return)]
    624
    		 
        #[allow(clippy::needless_borrow)]
    625
    		 
        pub async fn make_operation(
    820
    		 
        #[allow(clippy::let_and_return)]
    821
    		 
        #[allow(clippy::needless_borrow)]
    822
    		 
        pub async fn make_operation(
  • aws-sdk-emrcontainers 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://emr-containers-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://emr-containers-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://emr-containers.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-emrcontainers 0.24.0/src/input.rs
    52
    		 
        #[allow(clippy::let_and_return)]
    53
    		 
        #[allow(clippy::needless_borrow)]
    54
    		 
        pub async fn make_operation(
    309
    		 
        #[allow(clippy::let_and_return)]
    310
    		 
        #[allow(clippy::needless_borrow)]
    311
    		 
        pub async fn make_operation(
    609
    		 
        #[allow(clippy::let_and_return)]
    610
    		 
        #[allow(clippy::needless_borrow)]
    611
    		 
        pub async fn make_operation(
    853
    		 
        #[allow(clippy::let_and_return)]
    854
    		 
        #[allow(clippy::needless_borrow)]
    855
    		 
        pub async fn make_operation(
    1015
    		 
        #[allow(clippy::let_and_return)]
    1016
    		 
        #[allow(clippy::needless_borrow)]
    1017
    		 
        pub async fn make_operation(
  • aws-sdk-emrserverless 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://emr-serverless-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://emr-serverless-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://emr-serverless.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-emrserverless 0.24.0/src/input.rs
    52
    		 
        #[allow(clippy::let_and_return)]
    53
    		 
        #[allow(clippy::needless_borrow)]
    54
    		 
        pub async fn make_operation(
    463
    		 
        #[allow(clippy::let_and_return)]
    464
    		 
        #[allow(clippy::needless_borrow)]
    465
    		 
        pub async fn make_operation(
    628
    		 
        #[allow(clippy::let_and_return)]
    629
    		 
        #[allow(clippy::needless_borrow)]
    630
    		 
        pub async fn make_operation(
    798
    		 
        #[allow(clippy::let_and_return)]
    799
    		 
        #[allow(clippy::needless_borrow)]
    800
    		 
        pub async fn make_operation(
    982
    		 
        #[allow(clippy::let_and_return)]
    983
    		 
        #[allow(clippy::needless_borrow)]
    984
    		 
        pub async fn make_operation(
  • aws-sdk-eventbridge 0.24.0/src/endpoint/internals.rs
    67
    		 
                                        out.push_str("https://");
    68
    		 
                                        #[allow(clippy::needless_borrow)]
    69
    		 
                                        out.push_str(&endpoint_id);
    70
    		 
                                        out.push_str(".endpoint.events.");
    71
    		 
                                        #[allow(clippy::needless_borrow)]
    72
    		 
                                        out.push_str(&partition_result.dual_stack_dns_suffix());
    106
    		 
                                out.push_str("https://");
    107
    		 
                                #[allow(clippy::needless_borrow)]
    108
    		 
                                out.push_str(&endpoint_id);
    109
    		 
                                out.push_str(".endpoint.events.");
    110
    		 
                                #[allow(clippy::needless_borrow)]
    111
    		 
                                out.push_str(&partition_result.dns_suffix());
    163
    		 
                                    out.push_str("https://events-fips.");
    164
    		 
                                    #[allow(clippy::needless_borrow)]
    165
    		 
                                    out.push_str(&region);
  • aws-sdk-eventbridge 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    199
    		 
        #[allow(clippy::let_and_return)]
    200
    		 
        #[allow(clippy::needless_borrow)]
    201
    		 
        pub async fn make_operation(
    435
    		 
        #[allow(clippy::let_and_return)]
    436
    		 
        #[allow(clippy::needless_borrow)]
    437
    		 
        pub async fn make_operation(
    653
    		 
        #[allow(clippy::let_and_return)]
    654
    		 
        #[allow(clippy::needless_borrow)]
    655
    		 
        pub async fn make_operation(
    867
    		 
        #[allow(clippy::let_and_return)]
    868
    		 
        #[allow(clippy::needless_borrow)]
    869
    		 
        pub async fn make_operation(
  • aws-sdk-evidently 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://evidently-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://evidently-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://evidently.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-evidently 0.24.0/src/input.rs
    60
    		 
        #[allow(clippy::let_and_return)]
    61
    		 
        #[allow(clippy::needless_borrow)]
    62
    		 
        pub async fn make_operation(
    402
    		 
        #[allow(clippy::let_and_return)]
    403
    		 
        #[allow(clippy::needless_borrow)]
    404
    		 
        pub async fn make_operation(
    728
    		 
        #[allow(clippy::let_and_return)]
    729
    		 
        #[allow(clippy::needless_borrow)]
    730
    		 
        pub async fn make_operation(
    1043
    		 
        #[allow(clippy::let_and_return)]
    1044
    		 
        #[allow(clippy::needless_borrow)]
    1045
    		 
        pub async fn make_operation(
    1307
    		 
        #[allow(clippy::let_and_return)]
    1308
    		 
        #[allow(clippy::needless_borrow)]
    1309
    		 
        pub async fn make_operation(
  • aws-sdk-finspace 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://finspace-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://finspace-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://finspace.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-finspace 0.24.0/src/input.rs
    174
    		 
        #[allow(clippy::let_and_return)]
    175
    		 
        #[allow(clippy::needless_borrow)]
    176
    		 
        pub async fn make_operation(
    336
    		 
        #[allow(clippy::let_and_return)]
    337
    		 
        #[allow(clippy::needless_borrow)]
    338
    		 
        pub async fn make_operation(
    506
    		 
        #[allow(clippy::let_and_return)]
    507
    		 
        #[allow(clippy::needless_borrow)]
    508
    		 
        pub async fn make_operation(
    687
    		 
        #[allow(clippy::let_and_return)]
    688
    		 
        #[allow(clippy::needless_borrow)]
    689
    		 
        pub async fn make_operation(
    851
    		 
        #[allow(clippy::let_and_return)]
    852
    		 
        #[allow(clippy::needless_borrow)]
    853
    		 
        pub async fn make_operation(
  • aws-sdk-finspacedata 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://finspace-api-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://finspace-api-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://finspace-api.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-finspacedata 0.24.0/src/input.rs
    66
    		 
        #[allow(clippy::let_and_return)]
    67
    		 
        #[allow(clippy::needless_borrow)]
    68
    		 
        pub async fn make_operation(
    397
    		 
        #[allow(clippy::let_and_return)]
    398
    		 
        #[allow(clippy::needless_borrow)]
    399
    		 
        pub async fn make_operation(
    692
    		 
        #[allow(clippy::let_and_return)]
    693
    		 
        #[allow(clippy::needless_borrow)]
    694
    		 
        pub async fn make_operation(
    949
    		 
        #[allow(clippy::let_and_return)]
    950
    		 
        #[allow(clippy::needless_borrow)]
    951
    		 
        pub async fn make_operation(
    1216
    		 
        #[allow(clippy::let_and_return)]
    1217
    		 
        #[allow(clippy::needless_borrow)]
    1218
    		 
        pub async fn make_operation(
  • aws-sdk-firehose 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://firehose-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://firehose-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://firehose.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-firehose 0.24.0/src/input.rs
    289
    		 
        #[allow(clippy::let_and_return)]
    290
    		 
        #[allow(clippy::needless_borrow)]
    291
    		 
        pub async fn make_operation(
    472
    		 
        #[allow(clippy::let_and_return)]
    473
    		 
        #[allow(clippy::needless_borrow)]
    474
    		 
        pub async fn make_operation(
    671
    		 
        #[allow(clippy::let_and_return)]
    672
    		 
        #[allow(clippy::needless_borrow)]
    673
    		 
        pub async fn make_operation(
    880
    		 
        #[allow(clippy::let_and_return)]
    881
    		 
        #[allow(clippy::needless_borrow)]
    882
    		 
        pub async fn make_operation(
    1074
    		 
        #[allow(clippy::let_and_return)]
    1075
    		 
        #[allow(clippy::needless_borrow)]
    1076
    		 
        pub async fn make_operation(
  • aws-sdk-fis 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://fis-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://fis.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://fis-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-fis 0.24.0/src/input.rs
    209
    		 
        #[allow(clippy::let_and_return)]
    210
    		 
        #[allow(clippy::needless_borrow)]
    211
    		 
        pub async fn make_operation(
    371
    		 
        #[allow(clippy::let_and_return)]
    372
    		 
        #[allow(clippy::needless_borrow)]
    373
    		 
        pub async fn make_operation(
    532
    		 
        #[allow(clippy::let_and_return)]
    533
    		 
        #[allow(clippy::needless_borrow)]
    534
    		 
        pub async fn make_operation(
    690
    		 
        #[allow(clippy::let_and_return)]
    691
    		 
        #[allow(clippy::needless_borrow)]
    692
    		 
        pub async fn make_operation(
    852
    		 
        #[allow(clippy::let_and_return)]
    853
    		 
        #[allow(clippy::needless_borrow)]
    854
    		 
        pub async fn make_operation(
  • aws-sdk-fms 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://fms-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://fms-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://fms.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-fms 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    211
    		 
        #[allow(clippy::let_and_return)]
    212
    		 
        #[allow(clippy::needless_borrow)]
    213
    		 
        pub async fn make_operation(
    399
    		 
        #[allow(clippy::let_and_return)]
    400
    		 
        #[allow(clippy::needless_borrow)]
    401
    		 
        pub async fn make_operation(
    589
    		 
        #[allow(clippy::let_and_return)]
    590
    		 
        #[allow(clippy::needless_borrow)]
    591
    		 
        pub async fn make_operation(
    753
    		 
        #[allow(clippy::let_and_return)]
    754
    		 
        #[allow(clippy::needless_borrow)]
    755
    		 
        pub async fn make_operation(
  • aws-sdk-forecast 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://forecast-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://forecast-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://forecast.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-forecast 0.24.0/src/input.rs
    272
    		 
        #[allow(clippy::let_and_return)]
    273
    		 
        #[allow(clippy::needless_borrow)]
    274
    		 
        pub async fn make_operation(
    548
    		 
        #[allow(clippy::let_and_return)]
    549
    		 
        #[allow(clippy::needless_borrow)]
    550
    		 
        pub async fn make_operation(
    791
    		 
        #[allow(clippy::let_and_return)]
    792
    		 
        #[allow(clippy::needless_borrow)]
    793
    		 
        pub async fn make_operation(
    1119
    		 
        #[allow(clippy::let_and_return)]
    1120
    		 
        #[allow(clippy::needless_borrow)]
    1121
    		 
        pub async fn make_operation(
    1427
    		 
        #[allow(clippy::let_and_return)]
    1428
    		 
        #[allow(clippy::needless_borrow)]
    1429
    		 
        pub async fn make_operation(
  • aws-sdk-forecastquery 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://forecastquery-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://forecastquery-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://forecastquery.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-forecastquery 0.24.0/src/input.rs
    106
    		 
        #[allow(clippy::let_and_return)]
    107
    		 
        #[allow(clippy::needless_borrow)]
    108
    		 
        pub async fn make_operation(
    342
    		 
        #[allow(clippy::let_and_return)]
    343
    		 
        #[allow(clippy::needless_borrow)]
    344
    		 
        pub async fn make_operation(
  • aws-sdk-frauddetector 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://frauddetector-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://frauddetector-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://frauddetector.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-frauddetector 0.24.0/src/input.rs
    70
    		 
        #[allow(clippy::let_and_return)]
    71
    		 
        #[allow(clippy::needless_borrow)]
    72
    		 
        pub async fn make_operation(
    241
    		 
        #[allow(clippy::let_and_return)]
    242
    		 
        #[allow(clippy::needless_borrow)]
    243
    		 
        pub async fn make_operation(
    407
    		 
        #[allow(clippy::let_and_return)]
    408
    		 
        #[allow(clippy::needless_borrow)]
    409
    		 
        pub async fn make_operation(
    573
    		 
        #[allow(clippy::let_and_return)]
    574
    		 
        #[allow(clippy::needless_borrow)]
    575
    		 
        pub async fn make_operation(
    813
    		 
        #[allow(clippy::let_and_return)]
    814
    		 
        #[allow(clippy::needless_borrow)]
    815
    		 
        pub async fn make_operation(
  • aws-sdk-fsx 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://fsx-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://fsx-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://fsx.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-fsx 0.24.0/src/input.rs
    92
    		 
        #[allow(clippy::let_and_return)]
    93
    		 
        #[allow(clippy::needless_borrow)]
    94
    		 
        pub async fn make_operation(
    259
    		 
        #[allow(clippy::let_and_return)]
    260
    		 
        #[allow(clippy::needless_borrow)]
    261
    		 
        pub async fn make_operation(
    517
    		 
        #[allow(clippy::let_and_return)]
    518
    		 
        #[allow(clippy::needless_borrow)]
    519
    		 
        pub async fn make_operation(
    733
    		 
        #[allow(clippy::let_and_return)]
    734
    		 
        #[allow(clippy::needless_borrow)]
    735
    		 
        pub async fn make_operation(
    1019
    		 
        #[allow(clippy::let_and_return)]
    1020
    		 
        #[allow(clippy::needless_borrow)]
    1021
    		 
        pub async fn make_operation(
  • aws-sdk-gamelift 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://gamelift-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://gamelift-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://gamelift.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-gamelift 0.24.0/src/input.rs
    73
    		 
        #[allow(clippy::let_and_return)]
    74
    		 
        #[allow(clippy::needless_borrow)]
    75
    		 
        pub async fn make_operation(
    268
    		 
        #[allow(clippy::let_and_return)]
    269
    		 
        #[allow(clippy::needless_borrow)]
    270
    		 
        pub async fn make_operation(
    478
    		 
        #[allow(clippy::let_and_return)]
    479
    		 
        #[allow(clippy::needless_borrow)]
    480
    		 
        pub async fn make_operation(
    720
    		 
        #[allow(clippy::let_and_return)]
    721
    		 
        #[allow(clippy::needless_borrow)]
    722
    		 
        pub async fn make_operation(
    1250
    		 
        #[allow(clippy::let_and_return)]
    1251
    		 
        #[allow(clippy::needless_borrow)]
    1252
    		 
        pub async fn make_operation(
  • aws-sdk-gamesparks 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://gamesparks-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://gamesparks-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://gamesparks.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-gamesparks 0.24.0/src/input.rs
    90
    		 
        #[allow(clippy::let_and_return)]
    91
    		 
        #[allow(clippy::needless_borrow)]
    92
    		 
        pub async fn make_operation(
    259
    		 
        #[allow(clippy::let_and_return)]
    260
    		 
        #[allow(clippy::needless_borrow)]
    261
    		 
        pub async fn make_operation(
    513
    		 
        #[allow(clippy::let_and_return)]
    514
    		 
        #[allow(clippy::needless_borrow)]
    515
    		 
        pub async fn make_operation(
    690
    		 
        #[allow(clippy::let_and_return)]
    691
    		 
        #[allow(clippy::needless_borrow)]
    692
    		 
        pub async fn make_operation(
    865
    		 
        #[allow(clippy::let_and_return)]
    866
    		 
        #[allow(clippy::needless_borrow)]
    867
    		 
        pub async fn make_operation(
  • aws-sdk-glacier 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://glacier-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://glacier.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://glacier-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-glacier 0.24.0/src/input.rs
    63
    		 
        #[allow(clippy::let_and_return)]
    64
    		 
        #[allow(clippy::needless_borrow)]
    65
    		 
        pub async fn make_operation(
    289
    		 
        #[allow(clippy::let_and_return)]
    290
    		 
        #[allow(clippy::needless_borrow)]
    291
    		 
        pub async fn make_operation(
    524
    		 
        #[allow(clippy::let_and_return)]
    525
    		 
        #[allow(clippy::needless_borrow)]
    526
    		 
        pub async fn make_operation(
    791
    		 
        #[allow(clippy::let_and_return)]
    792
    		 
        #[allow(clippy::needless_borrow)]
    793
    		 
        pub async fn make_operation(
    1033
    		 
        #[allow(clippy::let_and_return)]
    1034
    		 
        #[allow(clippy::needless_borrow)]
    1035
    		 
        pub async fn make_operation(
  • aws-sdk-globalaccelerator 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://globalaccelerator-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://globalaccelerator-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://globalaccelerator.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-globalaccelerator 0.24.0/src/input.rs
    69
    		 
        #[allow(clippy::let_and_return)]
    70
    		 
        #[allow(clippy::needless_borrow)]
    71
    		 
        pub async fn make_operation(
    261
    		 
        #[allow(clippy::let_and_return)]
    262
    		 
        #[allow(clippy::needless_borrow)]
    263
    		 
        pub async fn make_operation(
    423
    		 
        #[allow(clippy::let_and_return)]
    424
    		 
        #[allow(clippy::needless_borrow)]
    425
    		 
        pub async fn make_operation(
    667
    		 
        #[allow(clippy::let_and_return)]
    668
    		 
        #[allow(clippy::needless_borrow)]
    669
    		 
        pub async fn make_operation(
    929
    		 
        #[allow(clippy::let_and_return)]
    930
    		 
        #[allow(clippy::needless_borrow)]
    931
    		 
        pub async fn make_operation(
  • aws-sdk-glue 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://glue-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://glue-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://glue.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-glue 0.24.0/src/input.rs
    88
    		 
        #[allow(clippy::let_and_return)]
    89
    		 
        #[allow(clippy::needless_borrow)]
    90
    		 
        pub async fn make_operation(
    275
    		 
        #[allow(clippy::let_and_return)]
    276
    		 
        #[allow(clippy::needless_borrow)]
    277
    		 
        pub async fn make_operation(
    490
    		 
        #[allow(clippy::let_and_return)]
    491
    		 
        #[allow(clippy::needless_borrow)]
    492
    		 
        pub async fn make_operation(
    707
    		 
        #[allow(clippy::let_and_return)]
    708
    		 
        #[allow(clippy::needless_borrow)]
    709
    		 
        pub async fn make_operation(
    919
    		 
        #[allow(clippy::let_and_return)]
    920
    		 
        #[allow(clippy::needless_borrow)]
    921
    		 
        pub async fn make_operation(
  • aws-sdk-grafana 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://grafana-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://grafana-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://grafana.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-grafana 0.24.0/src/input.rs
    54
    		 
        #[allow(clippy::let_and_return)]
    55
    		 
        #[allow(clippy::needless_borrow)]
    56
    		 
        pub async fn make_operation(
    537
    		 
        #[allow(clippy::let_and_return)]
    538
    		 
        #[allow(clippy::needless_borrow)]
    539
    		 
        pub async fn make_operation(
    737
    		 
        #[allow(clippy::let_and_return)]
    738
    		 
        #[allow(clippy::needless_borrow)]
    739
    		 
        pub async fn make_operation(
    920
    		 
        #[allow(clippy::let_and_return)]
    921
    		 
        #[allow(clippy::needless_borrow)]
    922
    		 
        pub async fn make_operation(
    1101
    		 
        #[allow(clippy::let_and_return)]
    1102
    		 
        #[allow(clippy::needless_borrow)]
    1103
    		 
        pub async fn make_operation(
  • aws-sdk-greengrass 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://greengrass-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    80
    		 
                            out.push_str("https://greengrass-fips.");
    81
    		 
                            #[allow(clippy::needless_borrow)]
    82
    		 
                            out.push_str(&region);
    83
    		 
                            out.push('.');
    84
    		 
                            #[allow(clippy::needless_borrow)]
    85
    		 
                            out.push_str(&partition_result.dns_suffix());
    99
    		 
                            out.push_str("https://greengrass.");
    100
    		 
                            #[allow(clippy::needless_borrow)]
    101
    		 
                            out.push_str(&region);
  • aws-sdk-greengrass 0.24.0/src/input.rs
    51
    		 
        #[allow(clippy::let_and_return)]
    52
    		 
        #[allow(clippy::needless_borrow)]
    53
    		 
        pub async fn make_operation(
    236
    		 
        #[allow(clippy::let_and_return)]
    237
    		 
        #[allow(clippy::needless_borrow)]
    238
    		 
        pub async fn make_operation(
    454
    		 
        #[allow(clippy::let_and_return)]
    455
    		 
        #[allow(clippy::needless_borrow)]
    456
    		 
        pub async fn make_operation(
    657
    		 
        #[allow(clippy::let_and_return)]
    658
    		 
        #[allow(clippy::needless_borrow)]
    659
    		 
        pub async fn make_operation(
    902
    		 
        #[allow(clippy::let_and_return)]
    903
    		 
        #[allow(clippy::needless_borrow)]
    904
    		 
        pub async fn make_operation(
  • aws-sdk-greengrassv2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://greengrass-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    80
    		 
                            out.push_str("https://greengrass-fips.");
    81
    		 
                            #[allow(clippy::needless_borrow)]
    82
    		 
                            out.push_str(&region);
    83
    		 
                            out.push('.');
    84
    		 
                            #[allow(clippy::needless_borrow)]
    85
    		 
                            out.push_str(&partition_result.dns_suffix());
    99
    		 
                            out.push_str("https://greengrass.");
    100
    		 
                            #[allow(clippy::needless_borrow)]
    101
    		 
                            out.push_str(&region);
  • aws-sdk-greengrassv2 0.24.0/src/input.rs
    39
    		 
        #[allow(clippy::let_and_return)]
    40
    		 
        #[allow(clippy::needless_borrow)]
    41
    		 
        pub async fn make_operation(
    231
    		 
        #[allow(clippy::let_and_return)]
    232
    		 
        #[allow(clippy::needless_borrow)]
    233
    		 
        pub async fn make_operation(
    448
    		 
        #[allow(clippy::let_and_return)]
    449
    		 
        #[allow(clippy::needless_borrow)]
    450
    		 
        pub async fn make_operation(
    635
    		 
        #[allow(clippy::let_and_return)]
    636
    		 
        #[allow(clippy::needless_borrow)]
    637
    		 
        pub async fn make_operation(
    867
    		 
        #[allow(clippy::let_and_return)]
    868
    		 
        #[allow(clippy::needless_borrow)]
    869
    		 
        pub async fn make_operation(
  • aws-sdk-groundstation 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://groundstation-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://groundstation-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://groundstation.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-groundstation 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    244
    		 
        #[allow(clippy::let_and_return)]
    245
    		 
        #[allow(clippy::needless_borrow)]
    246
    		 
        pub async fn make_operation(
    472
    		 
        #[allow(clippy::let_and_return)]
    473
    		 
        #[allow(clippy::needless_borrow)]
    474
    		 
        pub async fn make_operation(
    742
    		 
        #[allow(clippy::let_and_return)]
    743
    		 
        #[allow(clippy::needless_borrow)]
    744
    		 
        pub async fn make_operation(
    1013
    		 
        #[allow(clippy::let_and_return)]
    1014
    		 
        #[allow(clippy::needless_borrow)]
    1015
    		 
        pub async fn make_operation(
  • aws-sdk-guardduty 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://guardduty-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://guardduty.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://guardduty-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-guardduty 0.24.0/src/input.rs
    69
    		 
        #[allow(clippy::let_and_return)]
    70
    		 
        #[allow(clippy::needless_borrow)]
    71
    		 
        pub async fn make_operation(
    279
    		 
        #[allow(clippy::let_and_return)]
    280
    		 
        #[allow(clippy::needless_borrow)]
    281
    		 
        pub async fn make_operation(
    481
    		 
        #[allow(clippy::let_and_return)]
    482
    		 
        #[allow(clippy::needless_borrow)]
    483
    		 
        pub async fn make_operation(
    737
    		 
        #[allow(clippy::let_and_return)]
    738
    		 
        #[allow(clippy::needless_borrow)]
    739
    		 
        pub async fn make_operation(
    1124
    		 
        #[allow(clippy::let_and_return)]
    1125
    		 
        #[allow(clippy::needless_borrow)]
    1126
    		 
        pub async fn make_operation(
  • aws-sdk-health 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://health-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    69
    		 
                                out.push_str("https://health-fips.");
    70
    		 
                                #[allow(clippy::needless_borrow)]
    71
    		 
                                out.push_str(&region);
    86
    		 
                                out.push_str("https://health.");
    87
    		 
                                #[allow(clippy::needless_borrow)]
    88
    		 
                                out.push_str(&region);
    122
    		 
                                        out.push_str("https://health-fips.");
    123
    		 
                                        #[allow(clippy::needless_borrow)]
    124
    		 
                                        out.push_str(&region);
    140
    		 
                                out.push_str("https://health-fips.");
    141
    		 
                                #[allow(clippy::needless_borrow)]
    142
    		 
                                out.push_str(&region);
  • aws-sdk-health 0.24.0/src/input.rs
    67
    		 
        #[allow(clippy::let_and_return)]
    68
    		 
        #[allow(clippy::needless_borrow)]
    69
    		 
        pub async fn make_operation(
    270
    		 
        #[allow(clippy::let_and_return)]
    271
    		 
        #[allow(clippy::needless_borrow)]
    272
    		 
        pub async fn make_operation(
    485
    		 
        #[allow(clippy::let_and_return)]
    486
    		 
        #[allow(clippy::needless_borrow)]
    487
    		 
        pub async fn make_operation(
    658
    		 
        #[allow(clippy::let_and_return)]
    659
    		 
        #[allow(clippy::needless_borrow)]
    660
    		 
        pub async fn make_operation(
    863
    		 
        #[allow(clippy::let_and_return)]
    864
    		 
        #[allow(clippy::needless_borrow)]
    865
    		 
        pub async fn make_operation(
  • aws-sdk-healthlake 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://healthlake-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://healthlake-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://healthlake.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-healthlake 0.24.0/src/input.rs
    120
    		 
        #[allow(clippy::let_and_return)]
    121
    		 
        #[allow(clippy::needless_borrow)]
    122
    		 
        pub async fn make_operation(
    287
    		 
        #[allow(clippy::let_and_return)]
    288
    		 
        #[allow(clippy::needless_borrow)]
    289
    		 
        pub async fn make_operation(
    451
    		 
        #[allow(clippy::let_and_return)]
    452
    		 
        #[allow(clippy::needless_borrow)]
    453
    		 
        pub async fn make_operation(
    629
    		 
        #[allow(clippy::let_and_return)]
    630
    		 
        #[allow(clippy::needless_borrow)]
    631
    		 
        pub async fn make_operation(
    807
    		 
        #[allow(clippy::let_and_return)]
    808
    		 
        #[allow(clippy::needless_borrow)]
    809
    		 
        pub async fn make_operation(
  • aws-sdk-honeycode 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://honeycode-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://honeycode-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://honeycode.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-honeycode 0.24.0/src/input.rs
    95
    		 
        #[allow(clippy::let_and_return)]
    96
    		 
        #[allow(clippy::needless_borrow)]
    97
    		 
        pub async fn make_operation(
    356
    		 
        #[allow(clippy::let_and_return)]
    357
    		 
        #[allow(clippy::needless_borrow)]
    358
    		 
        pub async fn make_operation(
    617
    		 
        #[allow(clippy::let_and_return)]
    618
    		 
        #[allow(clippy::needless_borrow)]
    619
    		 
        pub async fn make_operation(
    878
    		 
        #[allow(clippy::let_and_return)]
    879
    		 
        #[allow(clippy::needless_borrow)]
    880
    		 
        pub async fn make_operation(
    1113
    		 
        #[allow(clippy::let_and_return)]
    1114
    		 
        #[allow(clippy::needless_borrow)]
    1115
    		 
        pub async fn make_operation(
  • aws-sdk-iam 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://iam-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    95
    		 
                                out.push_str("https://iam.");
    96
    		 
                                #[allow(clippy::needless_borrow)]
    97
    		 
                                out.push_str(&region);
    131
    		 
                                        out.push_str("https://iam-fips.");
    132
    		 
                                        #[allow(clippy::needless_borrow)]
    133
    		 
                                        out.push_str(&region);
    149
    		 
                                out.push_str("https://iam-fips.");
    150
    		 
                                #[allow(clippy::needless_borrow)]
    151
    		 
                                out.push_str(&region);
    166
    		 
                                out.push_str("https://iam.");
    167
    		 
                                #[allow(clippy::needless_borrow)]
    168
    		 
                                out.push_str(&region);
  • aws-sdk-iam 0.24.0/src/input.rs
    57
    		 
        #[allow(clippy::let_and_return)]
    58
    		 
        #[allow(clippy::needless_borrow)]
    59
    		 
        pub async fn make_operation(
    235
    		 
        #[allow(clippy::let_and_return)]
    236
    		 
        #[allow(clippy::needless_borrow)]
    237
    		 
        pub async fn make_operation(
    410
    		 
        #[allow(clippy::let_and_return)]
    411
    		 
        #[allow(clippy::needless_borrow)]
    412
    		 
        pub async fn make_operation(
    585
    		 
        #[allow(clippy::let_and_return)]
    586
    		 
        #[allow(clippy::needless_borrow)]
    587
    		 
        pub async fn make_operation(
    760
    		 
        #[allow(clippy::let_and_return)]
    761
    		 
        #[allow(clippy::needless_borrow)]
    762
    		 
        pub async fn make_operation(
  • aws-sdk-identitystore 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://identitystore-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://identitystore.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://identitystore-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-identitystore 0.24.0/src/input.rs
    73
    		 
        #[allow(clippy::let_and_return)]
    74
    		 
        #[allow(clippy::needless_borrow)]
    75
    		 
        pub async fn make_operation(
    264
    		 
        #[allow(clippy::let_and_return)]
    265
    		 
        #[allow(clippy::needless_borrow)]
    266
    		 
        pub async fn make_operation(
    637
    		 
        #[allow(clippy::let_and_return)]
    638
    		 
        #[allow(clippy::needless_borrow)]
    639
    		 
        pub async fn make_operation(
    814
    		 
        #[allow(clippy::let_and_return)]
    815
    		 
        #[allow(clippy::needless_borrow)]
    816
    		 
        pub async fn make_operation(
    996
    		 
        #[allow(clippy::let_and_return)]
    997
    		 
        #[allow(clippy::needless_borrow)]
    998
    		 
        pub async fn make_operation(
  • aws-sdk-imagebuilder 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://imagebuilder-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://imagebuilder.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://imagebuilder-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-imagebuilder 0.24.0/src/input.rs
    54
    		 
        #[allow(clippy::let_and_return)]
    55
    		 
        #[allow(clippy::needless_borrow)]
    56
    		 
        pub async fn make_operation(
    398
    		 
        #[allow(clippy::let_and_return)]
    399
    		 
        #[allow(clippy::needless_borrow)]
    400
    		 
        pub async fn make_operation(
    827
    		 
        #[allow(clippy::let_and_return)]
    828
    		 
        #[allow(clippy::needless_borrow)]
    829
    		 
        pub async fn make_operation(
    1065
    		 
        #[allow(clippy::let_and_return)]
    1066
    		 
        #[allow(clippy::needless_borrow)]
    1067
    		 
        pub async fn make_operation(
    1355
    		 
        #[allow(clippy::let_and_return)]
    1356
    		 
        #[allow(clippy::needless_borrow)]
    1357
    		 
        pub async fn make_operation(
  • aws-sdk-inspector 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://inspector-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://inspector-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://inspector.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-inspector 0.24.0/src/input.rs
    69
    		 
        #[allow(clippy::let_and_return)]
    70
    		 
        #[allow(clippy::needless_borrow)]
    71
    		 
        pub async fn make_operation(
    253
    		 
        #[allow(clippy::let_and_return)]
    254
    		 
        #[allow(clippy::needless_borrow)]
    255
    		 
        pub async fn make_operation(
    492
    		 
        #[allow(clippy::let_and_return)]
    493
    		 
        #[allow(clippy::needless_borrow)]
    494
    		 
        pub async fn make_operation(
    661
    		 
        #[allow(clippy::let_and_return)]
    662
    		 
        #[allow(clippy::needless_borrow)]
    663
    		 
        pub async fn make_operation(
    839
    		 
        #[allow(clippy::let_and_return)]
    840
    		 
        #[allow(clippy::needless_borrow)]
    841
    		 
        pub async fn make_operation(
  • aws-sdk-inspector2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://inspector2-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://inspector2-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://inspector2.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-inspector2 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    205
    		 
        #[allow(clippy::let_and_return)]
    206
    		 
        #[allow(clippy::needless_borrow)]
    207
    		 
        pub async fn make_operation(
    375
    		 
        #[allow(clippy::let_and_return)]
    376
    		 
        #[allow(clippy::needless_borrow)]
    377
    		 
        pub async fn make_operation(
    536
    		 
        #[allow(clippy::let_and_return)]
    537
    		 
        #[allow(clippy::needless_borrow)]
    538
    		 
        pub async fn make_operation(
    778
    		 
        #[allow(clippy::let_and_return)]
    779
    		 
        #[allow(clippy::needless_borrow)]
    780
    		 
        pub async fn make_operation(
  • aws-sdk-iot 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://iot-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://iot-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://iot.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iot 0.24.0/src/input.rs
    54
    		 
        #[allow(clippy::let_and_return)]
    55
    		 
        #[allow(clippy::needless_borrow)]
    56
    		 
        pub async fn make_operation(
    283
    		 
        #[allow(clippy::let_and_return)]
    284
    		 
        #[allow(clippy::needless_borrow)]
    285
    		 
        pub async fn make_operation(
    499
    		 
        #[allow(clippy::let_and_return)]
    500
    		 
        #[allow(clippy::needless_borrow)]
    501
    		 
        pub async fn make_operation(
    714
    		 
        #[allow(clippy::let_and_return)]
    715
    		 
        #[allow(clippy::needless_borrow)]
    716
    		 
        pub async fn make_operation(
    918
    		 
        #[allow(clippy::let_and_return)]
    919
    		 
        #[allow(clippy::needless_borrow)]
    920
    		 
        pub async fn make_operation(
  • aws-sdk-iot1clickdevices 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://devices.iot1click-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://devices.iot1click-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://devices.iot1click.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iot1clickdevices 0.24.0/src/input.rs
    39
    		 
        #[allow(clippy::let_and_return)]
    40
    		 
        #[allow(clippy::needless_borrow)]
    41
    		 
        pub async fn make_operation(
    202
    		 
        #[allow(clippy::let_and_return)]
    203
    		 
        #[allow(clippy::needless_borrow)]
    204
    		 
        pub async fn make_operation(
    398
    		 
        #[allow(clippy::let_and_return)]
    399
    		 
        #[allow(clippy::needless_borrow)]
    400
    		 
        pub async fn make_operation(
    581
    		 
        #[allow(clippy::let_and_return)]
    582
    		 
        #[allow(clippy::needless_borrow)]
    583
    		 
        pub async fn make_operation(
    746
    		 
        #[allow(clippy::let_and_return)]
    747
    		 
        #[allow(clippy::needless_borrow)]
    748
    		 
        pub async fn make_operation(
  • aws-sdk-iot1clickprojects 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://projects.iot1click-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://projects.iot1click-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://projects.iot1click.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iot1clickprojects 0.24.0/src/input.rs
    81
    		 
        #[allow(clippy::let_and_return)]
    82
    		 
        #[allow(clippy::needless_borrow)]
    83
    		 
        pub async fn make_operation(
    339
    		 
        #[allow(clippy::let_and_return)]
    340
    		 
        #[allow(clippy::needless_borrow)]
    341
    		 
        pub async fn make_operation(
    576
    		 
        #[allow(clippy::let_and_return)]
    577
    		 
        #[allow(clippy::needless_borrow)]
    578
    		 
        pub async fn make_operation(
    748
    		 
        #[allow(clippy::let_and_return)]
    749
    		 
        #[allow(clippy::needless_borrow)]
    750
    		 
        pub async fn make_operation(
    935
    		 
        #[allow(clippy::let_and_return)]
    936
    		 
        #[allow(clippy::needless_borrow)]
    937
    		 
        pub async fn make_operation(
  • aws-sdk-iotanalytics 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://iotanalytics-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://iotanalytics-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://iotanalytics.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iotanalytics 0.24.0/src/input.rs
    78
    		 
        #[allow(clippy::let_and_return)]
    79
    		 
        #[allow(clippy::needless_borrow)]
    80
    		 
        pub async fn make_operation(
    255
    		 
        #[allow(clippy::let_and_return)]
    256
    		 
        #[allow(clippy::needless_borrow)]
    257
    		 
        pub async fn make_operation(
    493
    		 
        #[allow(clippy::let_and_return)]
    494
    		 
        #[allow(clippy::needless_borrow)]
    495
    		 
        pub async fn make_operation(
    793
    		 
        #[allow(clippy::let_and_return)]
    794
    		 
        #[allow(clippy::needless_borrow)]
    795
    		 
        pub async fn make_operation(
    964
    		 
        #[allow(clippy::let_and_return)]
    965
    		 
        #[allow(clippy::needless_borrow)]
    966
    		 
        pub async fn make_operation(
  • aws-sdk-iotdataplane 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://data-ats.iot-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    105
    		 
                            out.push_str("https://data-ats.iot-fips.");
    106
    		 
                            #[allow(clippy::needless_borrow)]
    107
    		 
                            out.push_str(&region);
    108
    		 
                            out.push('.');
    109
    		 
                            #[allow(clippy::needless_borrow)]
    110
    		 
                            out.push_str(&partition_result.dns_suffix());
    124
    		 
                            out.push_str("https://data-ats.iot.");
    125
    		 
                            #[allow(clippy::needless_borrow)]
    126
    		 
                            out.push_str(&region);
  • aws-sdk-iotdataplane 0.24.0/src/input.rs
    51
    		 
        #[allow(clippy::let_and_return)]
    52
    		 
        #[allow(clippy::needless_borrow)]
    53
    		 
        pub async fn make_operation(
    227
    		 
        #[allow(clippy::let_and_return)]
    228
    		 
        #[allow(clippy::needless_borrow)]
    229
    		 
        pub async fn make_operation(
    402
    		 
        #[allow(clippy::let_and_return)]
    403
    		 
        #[allow(clippy::needless_borrow)]
    404
    		 
        pub async fn make_operation(
    604
    		 
        #[allow(clippy::let_and_return)]
    605
    		 
        #[allow(clippy::needless_borrow)]
    606
    		 
        pub async fn make_operation(
    806
    		 
        #[allow(clippy::let_and_return)]
    807
    		 
        #[allow(clippy::needless_borrow)]
    808
    		 
        pub async fn make_operation(
  • aws-sdk-iotdeviceadvisor 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://api.iotdeviceadvisor-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://api.iotdeviceadvisor-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://api.iotdeviceadvisor.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iotdeviceadvisor 0.24.0/src/input.rs
    75
    		 
        #[allow(clippy::let_and_return)]
    76
    		 
        #[allow(clippy::needless_borrow)]
    77
    		 
        pub async fn make_operation(
    239
    		 
        #[allow(clippy::let_and_return)]
    240
    		 
        #[allow(clippy::needless_borrow)]
    241
    		 
        pub async fn make_operation(
    421
    		 
        #[allow(clippy::let_and_return)]
    422
    		 
        #[allow(clippy::needless_borrow)]
    423
    		 
        pub async fn make_operation(
    605
    		 
        #[allow(clippy::let_and_return)]
    606
    		 
        #[allow(clippy::needless_borrow)]
    607
    		 
        pub async fn make_operation(
    803
    		 
        #[allow(clippy::let_and_return)]
    804
    		 
        #[allow(clippy::needless_borrow)]
    805
    		 
        pub async fn make_operation(
  • aws-sdk-iotevents 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://iotevents-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://iotevents-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://iotevents.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iotevents 0.24.0/src/input.rs
    176
    		 
        #[allow(clippy::let_and_return)]
    177
    		 
        #[allow(clippy::needless_borrow)]
    178
    		 
        pub async fn make_operation(
    432
    		 
        #[allow(clippy::let_and_return)]
    433
    		 
        #[allow(clippy::needless_borrow)]
    434
    		 
        pub async fn make_operation(
    640
    		 
        #[allow(clippy::let_and_return)]
    641
    		 
        #[allow(clippy::needless_borrow)]
    642
    		 
        pub async fn make_operation(
    802
    		 
        #[allow(clippy::let_and_return)]
    803
    		 
        #[allow(clippy::needless_borrow)]
    804
    		 
        pub async fn make_operation(
    974
    		 
        #[allow(clippy::let_and_return)]
    975
    		 
        #[allow(clippy::needless_borrow)]
    976
    		 
        pub async fn make_operation(
  • aws-sdk-ioteventsdata 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://data.iotevents-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://data.iotevents-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://data.iotevents.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-ioteventsdata 0.24.0/src/input.rs
    52
    		 
        #[allow(clippy::let_and_return)]
    53
    		 
        #[allow(clippy::needless_borrow)]
    54
    		 
        pub async fn make_operation(
    223
    		 
        #[allow(clippy::let_and_return)]
    224
    		 
        #[allow(clippy::needless_borrow)]
    225
    		 
        pub async fn make_operation(
    395
    		 
        #[allow(clippy::let_and_return)]
    396
    		 
        #[allow(clippy::needless_borrow)]
    397
    		 
        pub async fn make_operation(
    567
    		 
        #[allow(clippy::let_and_return)]
    568
    		 
        #[allow(clippy::needless_borrow)]
    569
    		 
        pub async fn make_operation(
    733
    		 
        #[allow(clippy::let_and_return)]
    734
    		 
        #[allow(clippy::needless_borrow)]
    735
    		 
        pub async fn make_operation(
  • aws-sdk-iotfleethub 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://api.fleethub.iot-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://api.fleethub.iot-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://api.fleethub.iot.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iotfleethub 0.24.0/src/input.rs
    114
    		 
        #[allow(clippy::let_and_return)]
    115
    		 
        #[allow(clippy::needless_borrow)]
    116
    		 
        pub async fn make_operation(
    291
    		 
        #[allow(clippy::let_and_return)]
    292
    		 
        #[allow(clippy::needless_borrow)]
    293
    		 
        pub async fn make_operation(
    479
    		 
        #[allow(clippy::let_and_return)]
    480
    		 
        #[allow(clippy::needless_borrow)]
    481
    		 
        pub async fn make_operation(
    648
    		 
        #[allow(clippy::let_and_return)]
    649
    		 
        #[allow(clippy::needless_borrow)]
    650
    		 
        pub async fn make_operation(
    806
    		 
        #[allow(clippy::let_and_return)]
    807
    		 
        #[allow(clippy::needless_borrow)]
    808
    		 
        pub async fn make_operation(
  • aws-sdk-iotfleetwise 0.5.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://iotfleetwise-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://iotfleetwise-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://iotfleetwise.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iotfleetwise 0.5.0/src/input.rs
    51
    		 
        #[allow(clippy::let_and_return)]
    52
    		 
        #[allow(clippy::needless_borrow)]
    53
    		 
        pub async fn make_operation(
    227
    		 
        #[allow(clippy::let_and_return)]
    228
    		 
        #[allow(clippy::needless_borrow)]
    229
    		 
        pub async fn make_operation(
    401
    		 
        #[allow(clippy::let_and_return)]
    402
    		 
        #[allow(clippy::needless_borrow)]
    403
    		 
        pub async fn make_operation(
    801
    		 
        #[allow(clippy::let_and_return)]
    802
    		 
        #[allow(clippy::needless_borrow)]
    803
    		 
        pub async fn make_operation(
    1056
    		 
        #[allow(clippy::let_and_return)]
    1057
    		 
        #[allow(clippy::needless_borrow)]
    1058
    		 
        pub async fn make_operation(
  • aws-sdk-iotjobsdataplane 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://data.jobs.iot-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://data.jobs.iot-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://data.jobs.iot.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iotjobsdataplane 0.24.0/src/input.rs
    75
    		 
        #[allow(clippy::let_and_return)]
    76
    		 
        #[allow(clippy::needless_borrow)]
    77
    		 
        pub async fn make_operation(
    288
    		 
        #[allow(clippy::let_and_return)]
    289
    		 
        #[allow(clippy::needless_borrow)]
    290
    		 
        pub async fn make_operation(
    494
    		 
        #[allow(clippy::let_and_return)]
    495
    		 
        #[allow(clippy::needless_borrow)]
    496
    		 
        pub async fn make_operation(
    793
    		 
        #[allow(clippy::let_and_return)]
    794
    		 
        #[allow(clippy::needless_borrow)]
    795
    		 
        pub async fn make_operation(
  • aws-sdk-iotroborunner 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://iotroborunner-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://iotroborunner-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://iotroborunner.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iotroborunner 0.2.0/src/input.rs
    96
    		 
        #[allow(clippy::let_and_return)]
    97
    		 
        #[allow(clippy::needless_borrow)]
    98
    		 
        pub async fn make_operation(
    292
    		 
        #[allow(clippy::let_and_return)]
    293
    		 
        #[allow(clippy::needless_borrow)]
    294
    		 
        pub async fn make_operation(
    557
    		 
        #[allow(clippy::let_and_return)]
    558
    		 
        #[allow(clippy::needless_borrow)]
    559
    		 
        pub async fn make_operation(
    761
    		 
        #[allow(clippy::let_and_return)]
    762
    		 
        #[allow(clippy::needless_borrow)]
    763
    		 
        pub async fn make_operation(
    921
    		 
        #[allow(clippy::let_and_return)]
    922
    		 
        #[allow(clippy::needless_borrow)]
    923
    		 
        pub async fn make_operation(
  • aws-sdk-iotsecuretunneling 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://api.tunneling.iot-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://api.tunneling.iot-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://api.tunneling.iot.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iotsecuretunneling 0.24.0/src/input.rs
    49
    		 
        #[allow(clippy::let_and_return)]
    50
    		 
        #[allow(clippy::needless_borrow)]
    51
    		 
        pub async fn make_operation(
    227
    		 
        #[allow(clippy::let_and_return)]
    228
    		 
        #[allow(clippy::needless_borrow)]
    229
    		 
        pub async fn make_operation(
    391
    		 
        #[allow(clippy::let_and_return)]
    392
    		 
        #[allow(clippy::needless_borrow)]
    393
    		 
        pub async fn make_operation(
    603
    		 
        #[allow(clippy::let_and_return)]
    604
    		 
        #[allow(clippy::needless_borrow)]
    605
    		 
        pub async fn make_operation(
    842
    		 
        #[allow(clippy::let_and_return)]
    843
    		 
        #[allow(clippy::needless_borrow)]
    844
    		 
        pub async fn make_operation(
  • aws-sdk-iotsitewise 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://iotsitewise-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://iotsitewise-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://iotsitewise.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iotsitewise 0.24.0/src/input.rs
    76
    		 
        #[allow(clippy::let_and_return)]
    77
    		 
        #[allow(clippy::needless_borrow)]
    78
    		 
        pub async fn make_operation(
    296
    		 
        #[allow(clippy::let_and_return)]
    297
    		 
        #[allow(clippy::needless_borrow)]
    298
    		 
        pub async fn make_operation(
    549
    		 
        #[allow(clippy::let_and_return)]
    550
    		 
        #[allow(clippy::needless_borrow)]
    551
    		 
        pub async fn make_operation(
    770
    		 
        #[allow(clippy::let_and_return)]
    771
    		 
        #[allow(clippy::needless_borrow)]
    772
    		 
        pub async fn make_operation(
    1005
    		 
        #[allow(clippy::let_and_return)]
    1006
    		 
        #[allow(clippy::needless_borrow)]
    1007
    		 
        pub async fn make_operation(
  • aws-sdk-iotthingsgraph 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://iotthingsgraph-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://iotthingsgraph-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://iotthingsgraph.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iotthingsgraph 0.24.0/src/input.rs
    67
    		 
        #[allow(clippy::let_and_return)]
    68
    		 
        #[allow(clippy::needless_borrow)]
    69
    		 
        pub async fn make_operation(
    250
    		 
        #[allow(clippy::let_and_return)]
    251
    		 
        #[allow(clippy::needless_borrow)]
    252
    		 
        pub async fn make_operation(
    513
    		 
        #[allow(clippy::let_and_return)]
    514
    		 
        #[allow(clippy::needless_borrow)]
    515
    		 
        pub async fn make_operation(
    696
    		 
        #[allow(clippy::let_and_return)]
    697
    		 
        #[allow(clippy::needless_borrow)]
    698
    		 
        pub async fn make_operation(
    864
    		 
        #[allow(clippy::let_and_return)]
    865
    		 
        #[allow(clippy::needless_borrow)]
    866
    		 
        pub async fn make_operation(
  • aws-sdk-iottwinmaker 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://iottwinmaker-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://iottwinmaker-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://iottwinmaker.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iottwinmaker 0.24.0/src/input.rs
    60
    		 
        #[allow(clippy::let_and_return)]
    61
    		 
        #[allow(clippy::needless_borrow)]
    62
    		 
        pub async fn make_operation(
    441
    		 
        #[allow(clippy::let_and_return)]
    442
    		 
        #[allow(clippy::needless_borrow)]
    443
    		 
        pub async fn make_operation(
    753
    		 
        #[allow(clippy::let_and_return)]
    754
    		 
        #[allow(clippy::needless_borrow)]
    755
    		 
        pub async fn make_operation(
    1025
    		 
        #[allow(clippy::let_and_return)]
    1026
    		 
        #[allow(clippy::needless_borrow)]
    1027
    		 
        pub async fn make_operation(
    1265
    		 
        #[allow(clippy::let_and_return)]
    1266
    		 
        #[allow(clippy::needless_borrow)]
    1267
    		 
        pub async fn make_operation(
  • aws-sdk-iotwireless 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://api.iotwireless-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://api.iotwireless-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://api.iotwireless.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-iotwireless 0.24.0/src/input.rs
    78
    		 
        #[allow(clippy::let_and_return)]
    79
    		 
        #[allow(clippy::needless_borrow)]
    80
    		 
        pub async fn make_operation(
    255
    		 
        #[allow(clippy::let_and_return)]
    256
    		 
        #[allow(clippy::needless_borrow)]
    257
    		 
        pub async fn make_operation(
    449
    		 
        #[allow(clippy::let_and_return)]
    450
    		 
        #[allow(clippy::needless_borrow)]
    451
    		 
        pub async fn make_operation(
    645
    		 
        #[allow(clippy::let_and_return)]
    646
    		 
        #[allow(clippy::needless_borrow)]
    647
    		 
        pub async fn make_operation(
    837
    		 
        #[allow(clippy::let_and_return)]
    838
    		 
        #[allow(clippy::needless_borrow)]
    839
    		 
        pub async fn make_operation(
  • aws-sdk-ivs 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://ivs-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://ivs-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://ivs.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-ivs 0.24.0/src/input.rs
    44
    		 
        #[allow(clippy::let_and_return)]
    45
    		 
        #[allow(clippy::needless_borrow)]
    46
    		 
        pub async fn make_operation(
    210
    		 
        #[allow(clippy::let_and_return)]
    211
    		 
        #[allow(clippy::needless_borrow)]
    212
    		 
        pub async fn make_operation(
    461
    		 
        #[allow(clippy::let_and_return)]
    462
    		 
        #[allow(clippy::needless_borrow)]
    463
    		 
        pub async fn make_operation(
    704
    		 
        #[allow(clippy::let_and_return)]
    705
    		 
        #[allow(clippy::needless_borrow)]
    706
    		 
        pub async fn make_operation(
    890
    		 
        #[allow(clippy::let_and_return)]
    891
    		 
        #[allow(clippy::needless_borrow)]
    892
    		 
        pub async fn make_operation(
  • aws-sdk-ivschat 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://ivschat-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://ivschat-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://ivschat.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-ivschat 0.24.0/src/input.rs
    115
    		 
        #[allow(clippy::let_and_return)]
    116
    		 
        #[allow(clippy::needless_borrow)]
    117
    		 
        pub async fn make_operation(
    322
    		 
        #[allow(clippy::let_and_return)]
    323
    		 
        #[allow(clippy::needless_borrow)]
    324
    		 
        pub async fn make_operation(
    579
    		 
        #[allow(clippy::let_and_return)]
    580
    		 
        #[allow(clippy::needless_borrow)]
    581
    		 
        pub async fn make_operation(
    738
    		 
        #[allow(clippy::let_and_return)]
    739
    		 
        #[allow(clippy::needless_borrow)]
    740
    		 
        pub async fn make_operation(
    924
    		 
        #[allow(clippy::let_and_return)]
    925
    		 
        #[allow(clippy::needless_borrow)]
    926
    		 
        pub async fn make_operation(
  • aws-sdk-kafka 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://kafka-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://kafka.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://kafka-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-kafka 0.24.0/src/input.rs
    60
    		 
        #[allow(clippy::let_and_return)]
    61
    		 
        #[allow(clippy::needless_borrow)]
    62
    		 
        pub async fn make_operation(
    266
    		 
        #[allow(clippy::let_and_return)]
    267
    		 
        #[allow(clippy::needless_borrow)]
    268
    		 
        pub async fn make_operation(
    623
    		 
        #[allow(clippy::let_and_return)]
    624
    		 
        #[allow(clippy::needless_borrow)]
    625
    		 
        pub async fn make_operation(
    839
    		 
        #[allow(clippy::let_and_return)]
    840
    		 
        #[allow(clippy::needless_borrow)]
    841
    		 
        pub async fn make_operation(
    1054
    		 
        #[allow(clippy::let_and_return)]
    1055
    		 
        #[allow(clippy::needless_borrow)]
    1056
    		 
        pub async fn make_operation(
  • aws-sdk-kafkaconnect 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://kafkaconnect-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://kafkaconnect-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://kafkaconnect.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-kafkaconnect 0.24.0/src/input.rs
    260
    		 
        #[allow(clippy::let_and_return)]
    261
    		 
        #[allow(clippy::needless_borrow)]
    262
    		 
        pub async fn make_operation(
    461
    		 
        #[allow(clippy::let_and_return)]
    462
    		 
        #[allow(clippy::needless_borrow)]
    463
    		 
        pub async fn make_operation(
    659
    		 
        #[allow(clippy::let_and_return)]
    660
    		 
        #[allow(clippy::needless_borrow)]
    661
    		 
        pub async fn make_operation(
    836
    		 
        #[allow(clippy::let_and_return)]
    837
    		 
        #[allow(clippy::needless_borrow)]
    838
    		 
        pub async fn make_operation(
    1024
    		 
        #[allow(clippy::let_and_return)]
    1025
    		 
        #[allow(clippy::needless_borrow)]
    1026
    		 
        pub async fn make_operation(
  • aws-sdk-kendra 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://kendra-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://kendra-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://kendra.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-kendra 0.24.0/src/input.rs
    73
    		 
        #[allow(clippy::let_and_return)]
    74
    		 
        #[allow(clippy::needless_borrow)]
    75
    		 
        pub async fn make_operation(
    271
    		 
        #[allow(clippy::let_and_return)]
    272
    		 
        #[allow(clippy::needless_borrow)]
    273
    		 
        pub async fn make_operation(
    475
    		 
        #[allow(clippy::let_and_return)]
    476
    		 
        #[allow(clippy::needless_borrow)]
    477
    		 
        pub async fn make_operation(
    661
    		 
        #[allow(clippy::let_and_return)]
    662
    		 
        #[allow(clippy::needless_borrow)]
    663
    		 
        pub async fn make_operation(
    896
    		 
        #[allow(clippy::let_and_return)]
    897
    		 
        #[allow(clippy::needless_borrow)]
    898
    		 
        pub async fn make_operation(
  • aws-sdk-kendraranking 0.2.0/src/endpoint/internals.rs
    41
    		 
                                out.push_str("https://kendra-ranking-fips.");
    42
    		 
                                #[allow(clippy::needless_borrow)]
    43
    		 
                                out.push_str(&region);
    44
    		 
                                out.push('.');
    45
    		 
                                #[allow(clippy::needless_borrow)]
    46
    		 
                                out.push_str(&partition_result.dual_stack_dns_suffix());
    58
    		 
                        out.push_str("https://kendra-ranking.");
    59
    		 
                        #[allow(clippy::needless_borrow)]
    60
    		 
                        out.push_str(&region);
    61
    		 
                        out.push('.');
    62
    		 
                        #[allow(clippy::needless_borrow)]
    63
    		 
                        out.push_str(&partition_result.dual_stack_dns_suffix());
    73
    		 
                            out.push_str("https://kendra-ranking-fips.");
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&region);
  • aws-sdk-kendraranking 0.2.0/src/input.rs
    99
    		 
        #[allow(clippy::let_and_return)]
    100
    		 
        #[allow(clippy::needless_borrow)]
    101
    		 
        pub async fn make_operation(
    263
    		 
        #[allow(clippy::let_and_return)]
    264
    		 
        #[allow(clippy::needless_borrow)]
    265
    		 
        pub async fn make_operation(
    424
    		 
        #[allow(clippy::let_and_return)]
    425
    		 
        #[allow(clippy::needless_borrow)]
    426
    		 
        pub async fn make_operation(
    599
    		 
        #[allow(clippy::let_and_return)]
    600
    		 
        #[allow(clippy::needless_borrow)]
    601
    		 
        pub async fn make_operation(
    785
    		 
        #[allow(clippy::let_and_return)]
    786
    		 
        #[allow(clippy::needless_borrow)]
    787
    		 
        pub async fn make_operation(
  • aws-sdk-keyspaces 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://cassandra-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://cassandra.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://cassandra-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-keyspaces 0.24.0/src/input.rs
    63
    		 
        #[allow(clippy::let_and_return)]
    64
    		 
        #[allow(clippy::needless_borrow)]
    65
    		 
        pub async fn make_operation(
    424
    		 
        #[allow(clippy::let_and_return)]
    425
    		 
        #[allow(clippy::needless_borrow)]
    426
    		 
        pub async fn make_operation(
    589
    		 
        #[allow(clippy::let_and_return)]
    590
    		 
        #[allow(clippy::needless_borrow)]
    591
    		 
        pub async fn make_operation(
    766
    		 
        #[allow(clippy::let_and_return)]
    767
    		 
        #[allow(clippy::needless_borrow)]
    768
    		 
        pub async fn make_operation(
    931
    		 
        #[allow(clippy::let_and_return)]
    932
    		 
        #[allow(clippy::needless_borrow)]
    933
    		 
        pub async fn make_operation(
  • aws-sdk-kinesis 0.24.0/src/endpoint/internals.rs
    73
    		 
    out.push_str("https://");
    74
    		 
    #[allow(clippy::needless_borrow)]
    75
    		 
    out.push_str(&arn.account_id());
    76
    		 
    out.push('.');
    77
    		 
    #[allow(clippy::needless_borrow)]
    78
    		 
    out.push_str(&operation_type);
    79
    		 
    out.push_str("-kinesis-fips.");
    80
    		 
    #[allow(clippy::needless_borrow)]
    81
    		 
    out.push_str(&region);
    82
    		 
    out.push('.');
    83
    		 
    #[allow(clippy::needless_borrow)]
    84
    		 
    out.push_str(&partition_result.dual_stack_dns_suffix());
    101
    		 
    out.push_str("https://");
    102
    		 
    #[allow(clippy::needless_borrow)]
    103
    		 
    out.push_str(&arn.account_id());
  • aws-sdk-kinesis 0.24.0/src/input.rs
    78
    		 
        #[allow(clippy::let_and_return)]
    79
    		 
        #[allow(clippy::needless_borrow)]
    80
    		 
        pub async fn make_operation(
    269
    		 
        #[allow(clippy::let_and_return)]
    270
    		 
        #[allow(clippy::needless_borrow)]
    271
    		 
        pub async fn make_operation(
    457
    		 
        #[allow(clippy::let_and_return)]
    458
    		 
        #[allow(clippy::needless_borrow)]
    459
    		 
        pub async fn make_operation(
    645
    		 
        #[allow(clippy::let_and_return)]
    646
    		 
        #[allow(clippy::needless_borrow)]
    647
    		 
        pub async fn make_operation(
    838
    		 
        #[allow(clippy::let_and_return)]
    839
    		 
        #[allow(clippy::needless_borrow)]
    840
    		 
        pub async fn make_operation(
  • aws-sdk-kinesisanalytics 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://kinesisanalytics-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://kinesisanalytics-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://kinesisanalytics.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-kinesisanalytics 0.24.0/src/input.rs
    76
    		 
        #[allow(clippy::let_and_return)]
    77
    		 
        #[allow(clippy::needless_borrow)]
    78
    		 
        pub async fn make_operation(
    270
    		 
        #[allow(clippy::let_and_return)]
    271
    		 
        #[allow(clippy::needless_borrow)]
    272
    		 
        pub async fn make_operation(
    485
    		 
        #[allow(clippy::let_and_return)]
    486
    		 
        #[allow(clippy::needless_borrow)]
    487
    		 
        pub async fn make_operation(
    680
    		 
        #[allow(clippy::let_and_return)]
    681
    		 
        #[allow(clippy::needless_borrow)]
    682
    		 
        pub async fn make_operation(
    879
    		 
        #[allow(clippy::let_and_return)]
    880
    		 
        #[allow(clippy::needless_borrow)]
    881
    		 
        pub async fn make_operation(
  • aws-sdk-kinesisanalyticsv2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://kinesisanalytics-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://kinesisanalytics-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://kinesisanalytics.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-kinesisanalyticsv2 0.24.0/src/input.rs
    91
    		 
        #[allow(clippy::let_and_return)]
    92
    		 
        #[allow(clippy::needless_borrow)]
    93
    		 
        pub async fn make_operation(
    285
    		 
        #[allow(clippy::let_and_return)]
    286
    		 
        #[allow(clippy::needless_borrow)]
    287
    		 
        pub async fn make_operation(
    500
    		 
        #[allow(clippy::let_and_return)]
    501
    		 
        #[allow(clippy::needless_borrow)]
    502
    		 
        pub async fn make_operation(
    695
    		 
        #[allow(clippy::let_and_return)]
    696
    		 
        #[allow(clippy::needless_borrow)]
    697
    		 
        pub async fn make_operation(
    894
    		 
        #[allow(clippy::let_and_return)]
    895
    		 
        #[allow(clippy::needless_borrow)]
    896
    		 
        pub async fn make_operation(
  • aws-sdk-kinesisvideo 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://kinesisvideo-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://kinesisvideo-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://kinesisvideo.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-kinesisvideo 0.24.0/src/input.rs
    94
    		 
        #[allow(clippy::let_and_return)]
    95
    		 
        #[allow(clippy::needless_borrow)]
    96
    		 
        pub async fn make_operation(
    348
    		 
        #[allow(clippy::let_and_return)]
    349
    		 
        #[allow(clippy::needless_borrow)]
    350
    		 
        pub async fn make_operation(
    522
    		 
        #[allow(clippy::let_and_return)]
    523
    		 
        #[allow(clippy::needless_borrow)]
    524
    		 
        pub async fn make_operation(
    700
    		 
        #[allow(clippy::let_and_return)]
    701
    		 
        #[allow(clippy::needless_borrow)]
    702
    		 
        pub async fn make_operation(
    871
    		 
        #[allow(clippy::let_and_return)]
    872
    		 
        #[allow(clippy::needless_borrow)]
    873
    		 
        pub async fn make_operation(
  • aws-sdk-kinesisvideoarchivedmedia 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://kinesisvideo-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://kinesisvideo-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://kinesisvideo.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-kinesisvideoarchivedmedia 0.24.0/src/input.rs
    68
    		 
        #[allow(clippy::let_and_return)]
    69
    		 
        #[allow(clippy::needless_borrow)]
    70
    		 
        pub async fn make_operation(
    374
    		 
        #[allow(clippy::let_and_return)]
    375
    		 
        #[allow(clippy::needless_borrow)]
    376
    		 
        pub async fn make_operation(
    709
    		 
        #[allow(clippy::let_and_return)]
    710
    		 
        #[allow(clippy::needless_borrow)]
    711
    		 
        pub async fn make_operation(
    1032
    		 
        #[allow(clippy::let_and_return)]
    1033
    		 
        #[allow(clippy::needless_borrow)]
    1034
    		 
        pub async fn make_operation(
    1222
    		 
        #[allow(clippy::let_and_return)]
    1223
    		 
        #[allow(clippy::needless_borrow)]
    1224
    		 
        pub async fn make_operation(
  • aws-sdk-kinesisvideomedia 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://kinesisvideo-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://kinesisvideo-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://kinesisvideo.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-kinesisvideomedia 0.24.0/src/input.rs
    64
    		 
        #[allow(clippy::let_and_return)]
    65
    		 
        #[allow(clippy::needless_borrow)]
    66
    		 
        pub async fn make_operation(
  • aws-sdk-kinesisvideosignaling 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://kinesisvideo-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://kinesisvideo-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://kinesisvideo.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-kinesisvideosignaling 0.24.0/src/input.rs
    75
    		 
        #[allow(clippy::let_and_return)]
    76
    		 
        #[allow(clippy::needless_borrow)]
    77
    		 
        pub async fn make_operation(
    264
    		 
        #[allow(clippy::let_and_return)]
    265
    		 
        #[allow(clippy::needless_borrow)]
    266
    		 
        pub async fn make_operation(
  • aws-sdk-kinesisvideowebrtcstorage 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://kinesisvideo-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://kinesisvideo-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://kinesisvideo.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-kinesisvideowebrtcstorage 0.2.0/src/input.rs
    39
    		 
        #[allow(clippy::let_and_return)]
    40
    		 
        #[allow(clippy::needless_borrow)]
    41
    		 
        pub async fn make_operation(
  • aws-sdk-kms 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://kms-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://kms-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://kms.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-kms 0.24.0/src/input.rs
    53
    		 
        #[allow(clippy::let_and_return)]
    54
    		 
        #[allow(clippy::needless_borrow)]
    55
    		 
        pub async fn make_operation(
    220
    		 
        #[allow(clippy::let_and_return)]
    221
    		 
        #[allow(clippy::needless_borrow)]
    222
    		 
        pub async fn make_operation(
    419
    		 
        #[allow(clippy::let_and_return)]
    420
    		 
        #[allow(clippy::needless_borrow)]
    421
    		 
        pub async fn make_operation(
    816
    		 
        #[allow(clippy::let_and_return)]
    817
    		 
        #[allow(clippy::needless_borrow)]
    818
    		 
        pub async fn make_operation(
    1117
    		 
        #[allow(clippy::let_and_return)]
    1118
    		 
        #[allow(clippy::needless_borrow)]
    1119
    		 
        pub async fn make_operation(
  • aws-sdk-lakeformation 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://lakeformation-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://lakeformation-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://lakeformation.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-lakeformation 0.24.0/src/input.rs
    72
    		 
        #[allow(clippy::let_and_return)]
    73
    		 
        #[allow(clippy::needless_borrow)]
    74
    		 
        pub async fn make_operation(
    275
    		 
        #[allow(clippy::let_and_return)]
    276
    		 
        #[allow(clippy::needless_borrow)]
    277
    		 
        pub async fn make_operation(
    456
    		 
        #[allow(clippy::let_and_return)]
    457
    		 
        #[allow(clippy::needless_borrow)]
    458
    		 
        pub async fn make_operation(
    639
    		 
        #[allow(clippy::let_and_return)]
    640
    		 
        #[allow(clippy::needless_borrow)]
    641
    		 
        pub async fn make_operation(
    803
    		 
        #[allow(clippy::let_and_return)]
    804
    		 
        #[allow(clippy::needless_borrow)]
    805
    		 
        pub async fn make_operation(
  • aws-sdk-lambda 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://lambda-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://lambda-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://lambda.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-lambda 0.24.0/src/input.rs
    114
    		 
        #[allow(clippy::let_and_return)]
    115
    		 
        #[allow(clippy::needless_borrow)]
    116
    		 
        pub async fn make_operation(
    474
    		 
        #[allow(clippy::let_and_return)]
    475
    		 
        #[allow(clippy::needless_borrow)]
    476
    		 
        pub async fn make_operation(
    739
    		 
        #[allow(clippy::let_and_return)]
    740
    		 
        #[allow(clippy::needless_borrow)]
    741
    		 
        pub async fn make_operation(
    952
    		 
        #[allow(clippy::let_and_return)]
    953
    		 
        #[allow(clippy::needless_borrow)]
    954
    		 
        pub async fn make_operation(
    1514
    		 
        #[allow(clippy::let_and_return)]
    1515
    		 
        #[allow(clippy::needless_borrow)]
    1516
    		 
        pub async fn make_operation(
  • aws-sdk-lexmodelbuilding 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://models.lex-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://models-fips.lex.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    83
    		 
                                out.push_str("https://models-fips.lex.");
    84
    		 
                                #[allow(clippy::needless_borrow)]
    85
    		 
                                out.push_str(&region);
    94
    		 
                            out.push_str("https://models.lex-fips.");
    95
    		 
                            #[allow(clippy::needless_borrow)]
    96
    		 
                            out.push_str(&region);
  • aws-sdk-lexmodelbuilding 0.24.0/src/input.rs
    51
    		 
        #[allow(clippy::let_and_return)]
    52
    		 
        #[allow(clippy::needless_borrow)]
    53
    		 
        pub async fn make_operation(
    242
    		 
        #[allow(clippy::let_and_return)]
    243
    		 
        #[allow(clippy::needless_borrow)]
    244
    		 
        pub async fn make_operation(
    433
    		 
        #[allow(clippy::let_and_return)]
    434
    		 
        #[allow(clippy::needless_borrow)]
    435
    		 
        pub async fn make_operation(
    610
    		 
        #[allow(clippy::let_and_return)]
    611
    		 
        #[allow(clippy::needless_borrow)]
    612
    		 
        pub async fn make_operation(
    782
    		 
        #[allow(clippy::let_and_return)]
    783
    		 
        #[allow(clippy::needless_borrow)]
    784
    		 
        pub async fn make_operation(
  • aws-sdk-lexmodelsv2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://models-v2-lex-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://models-v2-lex-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://models-v2-lex.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-lexmodelsv2 0.24.0/src/input.rs
    88
    		 
        #[allow(clippy::let_and_return)]
    89
    		 
        #[allow(clippy::needless_borrow)]
    90
    		 
        pub async fn make_operation(
    353
    		 
        #[allow(clippy::let_and_return)]
    354
    		 
        #[allow(clippy::needless_borrow)]
    355
    		 
        pub async fn make_operation(
    618
    		 
        #[allow(clippy::let_and_return)]
    619
    		 
        #[allow(clippy::needless_borrow)]
    620
    		 
        pub async fn make_operation(
    856
    		 
        #[allow(clippy::let_and_return)]
    857
    		 
        #[allow(clippy::needless_borrow)]
    858
    		 
        pub async fn make_operation(
    1176
    		 
        #[allow(clippy::let_and_return)]
    1177
    		 
        #[allow(clippy::needless_borrow)]
    1178
    		 
        pub async fn make_operation(
  • aws-sdk-lexruntime 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://runtime.lex-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://runtime-fips.lex.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    83
    		 
                                out.push_str("https://runtime-fips.lex.");
    84
    		 
                                #[allow(clippy::needless_borrow)]
    85
    		 
                                out.push_str(&region);
    94
    		 
                            out.push_str("https://runtime.lex-fips.");
    95
    		 
                            #[allow(clippy::needless_borrow)]
    96
    		 
                            out.push_str(&region);
  • aws-sdk-lexruntime 0.24.0/src/input.rs
    61
    		 
        #[allow(clippy::let_and_return)]
    62
    		 
        #[allow(clippy::needless_borrow)]
    63
    		 
        pub async fn make_operation(
    309
    		 
        #[allow(clippy::let_and_return)]
    310
    		 
        #[allow(clippy::needless_borrow)]
    311
    		 
        pub async fn make_operation(
    745
    		 
        #[allow(clippy::let_and_return)]
    746
    		 
        #[allow(clippy::needless_borrow)]
    747
    		 
        pub async fn make_operation(
    1122
    		 
        #[allow(clippy::let_and_return)]
    1123
    		 
        #[allow(clippy::needless_borrow)]
    1124
    		 
        pub async fn make_operation(
    1523
    		 
        #[allow(clippy::let_and_return)]
    1524
    		 
        #[allow(clippy::needless_borrow)]
    1525
    		 
        pub async fn make_operation(
  • aws-sdk-lexruntimev2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://runtime-v2-lex-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://runtime-v2-lex-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://runtime-v2-lex.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-lexruntimev2 0.24.0/src/input.rs
    73
    		 
        #[allow(clippy::let_and_return)]
    74
    		 
        #[allow(clippy::needless_borrow)]
    75
    		 
        pub async fn make_operation(
    328
    		 
        #[allow(clippy::let_and_return)]
    329
    		 
        #[allow(clippy::needless_borrow)]
    330
    		 
        pub async fn make_operation(
    671
    		 
        #[allow(clippy::let_and_return)]
    672
    		 
        #[allow(clippy::needless_borrow)]
    673
    		 
        pub async fn make_operation(
    1012
    		 
        #[allow(clippy::let_and_return)]
    1013
    		 
        #[allow(clippy::needless_borrow)]
    1014
    		 
        pub async fn make_operation(
    1437
    		 
        #[allow(clippy::let_and_return)]
    1438
    		 
        #[allow(clippy::needless_borrow)]
    1439
    		 
        pub async fn make_operation(
  • aws-sdk-licensemanager 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://license-manager-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://license-manager-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://license-manager.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-licensemanager 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    214
    		 
        #[allow(clippy::let_and_return)]
    215
    		 
        #[allow(clippy::needless_borrow)]
    216
    		 
        pub async fn make_operation(
    463
    		 
        #[allow(clippy::let_and_return)]
    464
    		 
        #[allow(clippy::needless_borrow)]
    465
    		 
        pub async fn make_operation(
    714
    		 
        #[allow(clippy::let_and_return)]
    715
    		 
        #[allow(clippy::needless_borrow)]
    716
    		 
        pub async fn make_operation(
    955
    		 
        #[allow(clippy::let_and_return)]
    956
    		 
        #[allow(clippy::needless_borrow)]
    957
    		 
        pub async fn make_operation(
  • aws-sdk-licensemanagerlinuxsubscriptions 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://license-manager-linux-subscriptions-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://license-manager-linux-subscriptions-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://license-manager-linux-subscriptions.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-licensemanagerlinuxsubscriptions 0.2.0/src/input.rs
    25
    		 
        #[allow(clippy::let_and_return)]
    26
    		 
        #[allow(clippy::needless_borrow)]
    27
    		 
        pub async fn make_operation(
    238
    		 
        #[allow(clippy::let_and_return)]
    239
    		 
        #[allow(clippy::needless_borrow)]
    240
    		 
        pub async fn make_operation(
    451
    		 
        #[allow(clippy::let_and_return)]
    452
    		 
        #[allow(clippy::needless_borrow)]
    453
    		 
        pub async fn make_operation(
    651
    		 
        #[allow(clippy::let_and_return)]
    652
    		 
        #[allow(clippy::needless_borrow)]
    653
    		 
        pub async fn make_operation(
  • aws-sdk-licensemanagerusersubscriptions 0.8.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://license-manager-user-subscriptions-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://license-manager-user-subscriptions-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://license-manager-user-subscriptions.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-licensemanagerusersubscriptions 0.8.0/src/input.rs
    76
    		 
        #[allow(clippy::let_and_return)]
    77
    		 
        #[allow(clippy::needless_borrow)]
    78
    		 
        pub async fn make_operation(
    250
    		 
        #[allow(clippy::let_and_return)]
    251
    		 
        #[allow(clippy::needless_borrow)]
    252
    		 
        pub async fn make_operation(
    451
    		 
        #[allow(clippy::let_and_return)]
    452
    		 
        #[allow(clippy::needless_borrow)]
    453
    		 
        pub async fn make_operation(
    622
    		 
        #[allow(clippy::let_and_return)]
    623
    		 
        #[allow(clippy::needless_borrow)]
    624
    		 
        pub async fn make_operation(
    815
    		 
        #[allow(clippy::let_and_return)]
    816
    		 
        #[allow(clippy::needless_borrow)]
    817
    		 
        pub async fn make_operation(
  • aws-sdk-lightsail 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://lightsail-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://lightsail-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://lightsail.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-lightsail 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    234
    		 
        #[allow(clippy::let_and_return)]
    235
    		 
        #[allow(clippy::needless_borrow)]
    236
    		 
        pub async fn make_operation(
    423
    		 
        #[allow(clippy::let_and_return)]
    424
    		 
        #[allow(clippy::needless_borrow)]
    425
    		 
        pub async fn make_operation(
    615
    		 
        #[allow(clippy::let_and_return)]
    616
    		 
        #[allow(clippy::needless_borrow)]
    617
    		 
        pub async fn make_operation(
    797
    		 
        #[allow(clippy::let_and_return)]
    798
    		 
        #[allow(clippy::needless_borrow)]
    799
    		 
        pub async fn make_operation(
  • aws-sdk-location 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://geo-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://geo-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://geo.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-location 0.24.0/src/input.rs
    57
    		 
        #[allow(clippy::let_and_return)]
    58
    		 
        #[allow(clippy::needless_borrow)]
    59
    		 
        pub async fn make_operation(
    271
    		 
        #[allow(clippy::let_and_return)]
    272
    		 
        #[allow(clippy::needless_borrow)]
    273
    		 
        pub async fn make_operation(
    480
    		 
        #[allow(clippy::let_and_return)]
    481
    		 
        #[allow(clippy::needless_borrow)]
    482
    		 
        pub async fn make_operation(
    693
    		 
        #[allow(clippy::let_and_return)]
    694
    		 
        #[allow(clippy::needless_borrow)]
    695
    		 
        pub async fn make_operation(
    907
    		 
        #[allow(clippy::let_and_return)]
    908
    		 
        #[allow(clippy::needless_borrow)]
    909
    		 
        pub async fn make_operation(
  • aws-sdk-lookoutequipment 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://lookoutequipment-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://lookoutequipment-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://lookoutequipment.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-lookoutequipment 0.24.0/src/input.rs
    100
    		 
        #[allow(clippy::let_and_return)]
    101
    		 
        #[allow(clippy::needless_borrow)]
    102
    		 
        pub async fn make_operation(
    411
    		 
        #[allow(clippy::let_and_return)]
    412
    		 
        #[allow(clippy::needless_borrow)]
    413
    		 
        pub async fn make_operation(
    679
    		 
        #[allow(clippy::let_and_return)]
    680
    		 
        #[allow(clippy::needless_borrow)]
    681
    		 
        pub async fn make_operation(
    909
    		 
        #[allow(clippy::let_and_return)]
    910
    		 
        #[allow(clippy::needless_borrow)]
    911
    		 
        pub async fn make_operation(
    1276
    		 
        #[allow(clippy::let_and_return)]
    1277
    		 
        #[allow(clippy::needless_borrow)]
    1278
    		 
        pub async fn make_operation(
  • aws-sdk-lookoutmetrics 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://lookoutmetrics-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://lookoutmetrics-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://lookoutmetrics.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-lookoutmetrics 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    206
    		 
        #[allow(clippy::let_and_return)]
    207
    		 
        #[allow(clippy::needless_borrow)]
    208
    		 
        pub async fn make_operation(
    463
    		 
        #[allow(clippy::let_and_return)]
    464
    		 
        #[allow(clippy::needless_borrow)]
    465
    		 
        pub async fn make_operation(
    703
    		 
        #[allow(clippy::let_and_return)]
    704
    		 
        #[allow(clippy::needless_borrow)]
    705
    		 
        pub async fn make_operation(
    1060
    		 
        #[allow(clippy::let_and_return)]
    1061
    		 
        #[allow(clippy::needless_borrow)]
    1062
    		 
        pub async fn make_operation(
  • aws-sdk-lookoutvision 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://lookoutvision-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://lookoutvision-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://lookoutvision.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-lookoutvision 0.24.0/src/input.rs
    84
    		 
        #[allow(clippy::let_and_return)]
    85
    		 
        #[allow(clippy::needless_borrow)]
    86
    		 
        pub async fn make_operation(
    345
    		 
        #[allow(clippy::let_and_return)]
    346
    		 
        #[allow(clippy::needless_borrow)]
    347
    		 
        pub async fn make_operation(
    546
    		 
        #[allow(clippy::let_and_return)]
    547
    		 
        #[allow(clippy::needless_borrow)]
    548
    		 
        pub async fn make_operation(
    735
    		 
        #[allow(clippy::let_and_return)]
    736
    		 
        #[allow(clippy::needless_borrow)]
    737
    		 
        pub async fn make_operation(
    957
    		 
        #[allow(clippy::let_and_return)]
    958
    		 
        #[allow(clippy::needless_borrow)]
    959
    		 
        pub async fn make_operation(
  • aws-sdk-m2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://m2-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://m2-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://m2.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-m2 0.24.0/src/input.rs
    54
    		 
        #[allow(clippy::let_and_return)]
    55
    		 
        #[allow(clippy::needless_borrow)]
    56
    		 
        pub async fn make_operation(
    338
    		 
        #[allow(clippy::let_and_return)]
    339
    		 
        #[allow(clippy::needless_borrow)]
    340
    		 
        pub async fn make_operation(
    530
    		 
        #[allow(clippy::let_and_return)]
    531
    		 
        #[allow(clippy::needless_borrow)]
    532
    		 
        pub async fn make_operation(
    760
    		 
        #[allow(clippy::let_and_return)]
    761
    		 
        #[allow(clippy::needless_borrow)]
    762
    		 
        pub async fn make_operation(
    1169
    		 
        #[allow(clippy::let_and_return)]
    1170
    		 
        #[allow(clippy::needless_borrow)]
    1171
    		 
        pub async fn make_operation(
  • aws-sdk-machinelearning 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://machinelearning-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://machinelearning-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://machinelearning.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-machinelearning 0.24.0/src/input.rs
    73
    		 
        #[allow(clippy::let_and_return)]
    74
    		 
        #[allow(clippy::needless_borrow)]
    75
    		 
        pub async fn make_operation(
    297
    		 
        #[allow(clippy::let_and_return)]
    298
    		 
        #[allow(clippy::needless_borrow)]
    299
    		 
        pub async fn make_operation(
    554
    		 
        #[allow(clippy::let_and_return)]
    555
    		 
        #[allow(clippy::needless_borrow)]
    556
    		 
        pub async fn make_operation(
    811
    		 
        #[allow(clippy::let_and_return)]
    812
    		 
        #[allow(clippy::needless_borrow)]
    813
    		 
        pub async fn make_operation(
    1032
    		 
        #[allow(clippy::let_and_return)]
    1033
    		 
        #[allow(clippy::needless_borrow)]
    1034
    		 
        pub async fn make_operation(
  • aws-sdk-macie 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://macie-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://macie-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://macie.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-macie 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    233
    		 
        #[allow(clippy::let_and_return)]
    234
    		 
        #[allow(clippy::needless_borrow)]
    235
    		 
        pub async fn make_operation(
    402
    		 
        #[allow(clippy::let_and_return)]
    403
    		 
        #[allow(clippy::needless_borrow)]
    404
    		 
        pub async fn make_operation(
    593
    		 
        #[allow(clippy::let_and_return)]
    594
    		 
        #[allow(clippy::needless_borrow)]
    595
    		 
        pub async fn make_operation(
    771
    		 
        #[allow(clippy::let_and_return)]
    772
    		 
        #[allow(clippy::needless_borrow)]
    773
    		 
        pub async fn make_operation(
  • aws-sdk-macie2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://macie2-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://macie2-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://macie2.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-macie2 0.24.0/src/input.rs
    72
    		 
        #[allow(clippy::let_and_return)]
    73
    		 
        #[allow(clippy::needless_borrow)]
    74
    		 
        pub async fn make_operation(
    238
    		 
        #[allow(clippy::let_and_return)]
    239
    		 
        #[allow(clippy::needless_borrow)]
    240
    		 
        pub async fn make_operation(
    465
    		 
        #[allow(clippy::let_and_return)]
    466
    		 
        #[allow(clippy::needless_borrow)]
    467
    		 
        pub async fn make_operation(
    861
    		 
        #[allow(clippy::let_and_return)]
    862
    		 
        #[allow(clippy::needless_borrow)]
    863
    		 
        pub async fn make_operation(
    1173
    		 
        #[allow(clippy::let_and_return)]
    1174
    		 
        #[allow(clippy::needless_borrow)]
    1175
    		 
        pub async fn make_operation(
  • aws-sdk-managedblockchain 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://managedblockchain-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://managedblockchain-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://managedblockchain.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-managedblockchain 0.24.0/src/input.rs
    59
    		 
        #[allow(clippy::let_and_return)]
    60
    		 
        #[allow(clippy::needless_borrow)]
    61
    		 
        pub async fn make_operation(
    264
    		 
        #[allow(clippy::let_and_return)]
    265
    		 
        #[allow(clippy::needless_borrow)]
    266
    		 
        pub async fn make_operation(
    587
    		 
        #[allow(clippy::let_and_return)]
    588
    		 
        #[allow(clippy::needless_borrow)]
    589
    		 
        pub async fn make_operation(
    838
    		 
        #[allow(clippy::let_and_return)]
    839
    		 
        #[allow(clippy::needless_borrow)]
    840
    		 
        pub async fn make_operation(
    1109
    		 
        #[allow(clippy::let_and_return)]
    1110
    		 
        #[allow(clippy::needless_borrow)]
    1111
    		 
        pub async fn make_operation(
  • aws-sdk-marketplacecatalog 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://catalog.marketplace-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://catalog.marketplace-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://catalog.marketplace.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-marketplacecatalog 0.24.0/src/input.rs
    52
    		 
        #[allow(clippy::let_and_return)]
    53
    		 
        #[allow(clippy::needless_borrow)]
    54
    		 
        pub async fn make_operation(
    252
    		 
        #[allow(clippy::let_and_return)]
    253
    		 
        #[allow(clippy::needless_borrow)]
    254
    		 
        pub async fn make_operation(
    447
    		 
        #[allow(clippy::let_and_return)]
    448
    		 
        #[allow(clippy::needless_borrow)]
    449
    		 
        pub async fn make_operation(
    687
    		 
        #[allow(clippy::let_and_return)]
    688
    		 
        #[allow(clippy::needless_borrow)]
    689
    		 
        pub async fn make_operation(
    913
    		 
        #[allow(clippy::let_and_return)]
    914
    		 
        #[allow(clippy::needless_borrow)]
    915
    		 
        pub async fn make_operation(
  • aws-sdk-marketplacecommerceanalytics 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://marketplacecommerceanalytics-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://marketplacecommerceanalytics-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://marketplacecommerceanalytics.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-marketplacecommerceanalytics 0.24.0/src/input.rs
    202
    		 
        #[allow(clippy::let_and_return)]
    203
    		 
        #[allow(clippy::needless_borrow)]
    204
    		 
        pub async fn make_operation(
    485
    		 
        #[allow(clippy::let_and_return)]
    486
    		 
        #[allow(clippy::needless_borrow)]
    487
    		 
        pub async fn make_operation(
  • aws-sdk-marketplaceentitlement 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://entitlement.marketplace-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://entitlement.marketplace-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://entitlement.marketplace.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-marketplaceentitlement 0.24.0/src/input.rs
    96
    		 
        #[allow(clippy::let_and_return)]
    97
    		 
        #[allow(clippy::needless_borrow)]
    98
    		 
        pub async fn make_operation(
  • aws-sdk-marketplacemetering 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://metering.marketplace-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://metering.marketplace-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://metering.marketplace.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-marketplacemetering 0.24.0/src/input.rs
    58
    		 
        #[allow(clippy::let_and_return)]
    59
    		 
        #[allow(clippy::needless_borrow)]
    60
    		 
        pub async fn make_operation(
    298
    		 
        #[allow(clippy::let_and_return)]
    299
    		 
        #[allow(clippy::needless_borrow)]
    300
    		 
        pub async fn make_operation(
    484
    		 
        #[allow(clippy::let_and_return)]
    485
    		 
        #[allow(clippy::needless_borrow)]
    486
    		 
        pub async fn make_operation(
    649
    		 
        #[allow(clippy::let_and_return)]
    650
    		 
        #[allow(clippy::needless_borrow)]
    651
    		 
        pub async fn make_operation(
  • aws-sdk-mediaconnect 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://mediaconnect-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://mediaconnect-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://mediaconnect.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-mediaconnect 0.24.0/src/input.rs
    61
    		 
        #[allow(clippy::let_and_return)]
    62
    		 
        #[allow(clippy::needless_borrow)]
    63
    		 
        pub async fn make_operation(
    265
    		 
        #[allow(clippy::let_and_return)]
    266
    		 
        #[allow(clippy::needless_borrow)]
    267
    		 
        pub async fn make_operation(
    463
    		 
        #[allow(clippy::let_and_return)]
    464
    		 
        #[allow(clippy::needless_borrow)]
    465
    		 
        pub async fn make_operation(
    664
    		 
        #[allow(clippy::let_and_return)]
    665
    		 
        #[allow(clippy::needless_borrow)]
    666
    		 
        pub async fn make_operation(
    1014
    		 
        #[allow(clippy::let_and_return)]
    1015
    		 
        #[allow(clippy::needless_borrow)]
    1016
    		 
        pub async fn make_operation(
  • aws-sdk-mediaconvert 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://mediaconvert-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://mediaconvert.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://mediaconvert-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-mediaconvert 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    192
    		 
        #[allow(clippy::let_and_return)]
    193
    		 
        #[allow(clippy::needless_borrow)]
    194
    		 
        pub async fn make_operation(
    563
    		 
        #[allow(clippy::let_and_return)]
    564
    		 
        #[allow(clippy::needless_borrow)]
    565
    		 
        pub async fn make_operation(
    867
    		 
        #[allow(clippy::let_and_return)]
    868
    		 
        #[allow(clippy::needless_borrow)]
    869
    		 
        pub async fn make_operation(
    1092
    		 
        #[allow(clippy::let_and_return)]
    1093
    		 
        #[allow(clippy::needless_borrow)]
    1094
    		 
        pub async fn make_operation(
  • aws-sdk-medialive 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://medialive-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://medialive-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://medialive.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-medialive 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    282
    		 
        #[allow(clippy::let_and_return)]
    283
    		 
        #[allow(clippy::needless_borrow)]
    284
    		 
        pub async fn make_operation(
    469
    		 
        #[allow(clippy::let_and_return)]
    470
    		 
        #[allow(clippy::needless_borrow)]
    471
    		 
        pub async fn make_operation(
    656
    		 
        #[allow(clippy::let_and_return)]
    657
    		 
        #[allow(clippy::needless_borrow)]
    658
    		 
        pub async fn make_operation(
    843
    		 
        #[allow(clippy::let_and_return)]
    844
    		 
        #[allow(clippy::needless_borrow)]
    845
    		 
        pub async fn make_operation(
  • aws-sdk-mediapackage 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://mediapackage-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://mediapackage-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://mediapackage.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-mediapackage 0.24.0/src/input.rs
    67
    		 
        #[allow(clippy::let_and_return)]
    68
    		 
        #[allow(clippy::needless_borrow)]
    69
    		 
        pub async fn make_operation(
    285
    		 
        #[allow(clippy::let_and_return)]
    286
    		 
        #[allow(clippy::needless_borrow)]
    287
    		 
        pub async fn make_operation(
    498
    		 
        #[allow(clippy::let_and_return)]
    499
    		 
        #[allow(clippy::needless_borrow)]
    500
    		 
        pub async fn make_operation(
    864
    		 
        #[allow(clippy::let_and_return)]
    865
    		 
        #[allow(clippy::needless_borrow)]
    866
    		 
        pub async fn make_operation(
    1021
    		 
        #[allow(clippy::let_and_return)]
    1022
    		 
        #[allow(clippy::needless_borrow)]
    1023
    		 
        pub async fn make_operation(
  • aws-sdk-mediapackagevod 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://mediapackage-vod-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://mediapackage-vod-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://mediapackage-vod.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-mediapackagevod 0.24.0/src/input.rs
    52
    		 
        #[allow(clippy::let_and_return)]
    53
    		 
        #[allow(clippy::needless_borrow)]
    54
    		 
        pub async fn make_operation(
    312
    		 
        #[allow(clippy::let_and_return)]
    313
    		 
        #[allow(clippy::needless_borrow)]
    314
    		 
        pub async fn make_operation(
    575
    		 
        #[allow(clippy::let_and_return)]
    576
    		 
        #[allow(clippy::needless_borrow)]
    577
    		 
        pub async fn make_operation(
    793
    		 
        #[allow(clippy::let_and_return)]
    794
    		 
        #[allow(clippy::needless_borrow)]
    795
    		 
        pub async fn make_operation(
    950
    		 
        #[allow(clippy::let_and_return)]
    951
    		 
        #[allow(clippy::needless_borrow)]
    952
    		 
        pub async fn make_operation(
  • aws-sdk-mediastore 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://mediastore-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://mediastore-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://mediastore.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-mediastore 0.24.0/src/input.rs
    61
    		 
        #[allow(clippy::let_and_return)]
    62
    		 
        #[allow(clippy::needless_borrow)]
    63
    		 
        pub async fn make_operation(
    226
    		 
        #[allow(clippy::let_and_return)]
    227
    		 
        #[allow(clippy::needless_borrow)]
    228
    		 
        pub async fn make_operation(
    393
    		 
        #[allow(clippy::let_and_return)]
    394
    		 
        #[allow(clippy::needless_borrow)]
    395
    		 
        pub async fn make_operation(
    562
    		 
        #[allow(clippy::let_and_return)]
    563
    		 
        #[allow(clippy::needless_borrow)]
    564
    		 
        pub async fn make_operation(
    729
    		 
        #[allow(clippy::let_and_return)]
    730
    		 
        #[allow(clippy::needless_borrow)]
    731
    		 
        pub async fn make_operation(
  • aws-sdk-mediastoredata 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://data.mediastore-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://data.mediastore-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://data.mediastore.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-mediastoredata 0.24.0/src/input.rs
    47
    		 
        #[allow(clippy::let_and_return)]
    48
    		 
        #[allow(clippy::needless_borrow)]
    49
    		 
        pub async fn make_operation(
    219
    		 
        #[allow(clippy::let_and_return)]
    220
    		 
        #[allow(clippy::needless_borrow)]
    221
    		 
        pub async fn make_operation(
    417
    		 
        #[allow(clippy::let_and_return)]
    418
    		 
        #[allow(clippy::needless_borrow)]
    419
    		 
        pub async fn make_operation(
    618
    		 
        #[allow(clippy::let_and_return)]
    619
    		 
        #[allow(clippy::needless_borrow)]
    620
    		 
        pub async fn make_operation(
    885
    		 
        #[allow(clippy::let_and_return)]
    886
    		 
        #[allow(clippy::needless_borrow)]
    887
    		 
        pub async fn make_operation(
  • aws-sdk-mediatailor 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://api.mediatailor-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://api.mediatailor-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://api.mediatailor.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-mediatailor 0.24.0/src/input.rs
    59
    		 
        #[allow(clippy::let_and_return)]
    60
    		 
        #[allow(clippy::needless_borrow)]
    61
    		 
        pub async fn make_operation(
    313
    		 
        #[allow(clippy::let_and_return)]
    314
    		 
        #[allow(clippy::needless_borrow)]
    315
    		 
        pub async fn make_operation(
    564
    		 
        #[allow(clippy::let_and_return)]
    565
    		 
        #[allow(clippy::needless_borrow)]
    566
    		 
        pub async fn make_operation(
    827
    		 
        #[allow(clippy::let_and_return)]
    828
    		 
        #[allow(clippy::needless_borrow)]
    829
    		 
        pub async fn make_operation(
    1126
    		 
        #[allow(clippy::let_and_return)]
    1127
    		 
        #[allow(clippy::needless_borrow)]
    1128
    		 
        pub async fn make_operation(
  • aws-sdk-memorydb 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://memory-db-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://memory-db-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://memory-db.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-memorydb 0.24.0/src/input.rs
    63
    		 
        #[allow(clippy::let_and_return)]
    64
    		 
        #[allow(clippy::needless_borrow)]
    65
    		 
        pub async fn make_operation(
    291
    		 
        #[allow(clippy::let_and_return)]
    292
    		 
        #[allow(clippy::needless_borrow)]
    293
    		 
        pub async fn make_operation(
    495
    		 
        #[allow(clippy::let_and_return)]
    496
    		 
        #[allow(clippy::needless_borrow)]
    497
    		 
        pub async fn make_operation(
    981
    		 
        #[allow(clippy::let_and_return)]
    982
    		 
        #[allow(clippy::needless_borrow)]
    983
    		 
        pub async fn make_operation(
    1193
    		 
        #[allow(clippy::let_and_return)]
    1194
    		 
        #[allow(clippy::needless_borrow)]
    1195
    		 
        pub async fn make_operation(
  • aws-sdk-mgn 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://mgn-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://mgn-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://mgn.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-mgn 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    199
    		 
        #[allow(clippy::let_and_return)]
    200
    		 
        #[allow(clippy::needless_borrow)]
    201
    		 
        pub async fn make_operation(
    379
    		 
        #[allow(clippy::let_and_return)]
    380
    		 
        #[allow(clippy::needless_borrow)]
    381
    		 
        pub async fn make_operation(
    564
    		 
        #[allow(clippy::let_and_return)]
    565
    		 
        #[allow(clippy::needless_borrow)]
    566
    		 
        pub async fn make_operation(
    749
    		 
        #[allow(clippy::let_and_return)]
    750
    		 
        #[allow(clippy::needless_borrow)]
    751
    		 
        pub async fn make_operation(
  • aws-sdk-migrationhub 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://mgh-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://mgh-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://mgh.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-migrationhub 0.24.0/src/input.rs
    84
    		 
        #[allow(clippy::let_and_return)]
    85
    		 
        #[allow(clippy::needless_borrow)]
    86
    		 
        pub async fn make_operation(
    295
    		 
        #[allow(clippy::let_and_return)]
    296
    		 
        #[allow(clippy::needless_borrow)]
    297
    		 
        pub async fn make_operation(
    477
    		 
        #[allow(clippy::let_and_return)]
    478
    		 
        #[allow(clippy::needless_borrow)]
    479
    		 
        pub async fn make_operation(
    659
    		 
        #[allow(clippy::let_and_return)]
    660
    		 
        #[allow(clippy::needless_borrow)]
    661
    		 
        pub async fn make_operation(
    826
    		 
        #[allow(clippy::let_and_return)]
    827
    		 
        #[allow(clippy::needless_borrow)]
    828
    		 
        pub async fn make_operation(
  • aws-sdk-migrationhubconfig 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://migrationhub-config-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://migrationhub-config-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://migrationhub-config.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-migrationhubconfig 0.24.0/src/input.rs
    63
    		 
        #[allow(clippy::let_and_return)]
    64
    		 
        #[allow(clippy::needless_borrow)]
    65
    		 
        pub async fn make_operation(
    277
    		 
        #[allow(clippy::let_and_return)]
    278
    		 
        #[allow(clippy::needless_borrow)]
    279
    		 
        pub async fn make_operation(
    425
    		 
        #[allow(clippy::let_and_return)]
    426
    		 
        #[allow(clippy::needless_borrow)]
    427
    		 
        pub async fn make_operation(
  • aws-sdk-migrationhuborchestrator 0.5.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://migrationhub-orchestrator-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://migrationhub-orchestrator-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://migrationhub-orchestrator.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-migrationhuborchestrator 0.5.0/src/input.rs
    174
    		 
        #[allow(clippy::let_and_return)]
    175
    		 
        #[allow(clippy::needless_borrow)]
    176
    		 
        pub async fn make_operation(
    490
    		 
        #[allow(clippy::let_and_return)]
    491
    		 
        #[allow(clippy::needless_borrow)]
    492
    		 
        pub async fn make_operation(
    715
    		 
        #[allow(clippy::let_and_return)]
    716
    		 
        #[allow(clippy::needless_borrow)]
    717
    		 
        pub async fn make_operation(
    872
    		 
        #[allow(clippy::let_and_return)]
    873
    		 
        #[allow(clippy::needless_borrow)]
    874
    		 
        pub async fn make_operation(
    1064
    		 
        #[allow(clippy::let_and_return)]
    1065
    		 
        #[allow(clippy::needless_borrow)]
    1066
    		 
        pub async fn make_operation(
  • aws-sdk-migrationhubrefactorspaces 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://refactor-spaces-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://refactor-spaces-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://refactor-spaces.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-migrationhubrefactorspaces 0.24.0/src/input.rs
    150
    		 
        #[allow(clippy::let_and_return)]
    151
    		 
        #[allow(clippy::needless_borrow)]
    152
    		 
        pub async fn make_operation(
    415
    		 
        #[allow(clippy::let_and_return)]
    416
    		 
        #[allow(clippy::needless_borrow)]
    417
    		 
        pub async fn make_operation(
    708
    		 
        #[allow(clippy::let_and_return)]
    709
    		 
        #[allow(clippy::needless_borrow)]
    710
    		 
        pub async fn make_operation(
    1062
    		 
        #[allow(clippy::let_and_return)]
    1063
    		 
        #[allow(clippy::needless_borrow)]
    1064
    		 
        pub async fn make_operation(
    1280
    		 
        #[allow(clippy::let_and_return)]
    1281
    		 
        #[allow(clippy::needless_borrow)]
    1282
    		 
        pub async fn make_operation(
  • aws-sdk-migrationhubstrategy 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://migrationhub-strategy-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://migrationhub-strategy-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://migrationhub-strategy.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-migrationhubstrategy 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    214
    		 
        #[allow(clippy::let_and_return)]
    215
    		 
        #[allow(clippy::needless_borrow)]
    216
    		 
        pub async fn make_operation(
    379
    		 
        #[allow(clippy::let_and_return)]
    380
    		 
        #[allow(clippy::needless_borrow)]
    381
    		 
        pub async fn make_operation(
    541
    		 
        #[allow(clippy::let_and_return)]
    542
    		 
        #[allow(clippy::needless_borrow)]
    543
    		 
        pub async fn make_operation(
    692
    		 
        #[allow(clippy::let_and_return)]
    693
    		 
        #[allow(clippy::needless_borrow)]
    694
    		 
        pub async fn make_operation(
  • aws-sdk-mobile 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://mobile-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://mobile-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://mobile.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-mobile 0.24.0/src/input.rs
    73
    		 
        #[allow(clippy::let_and_return)]
    74
    		 
        #[allow(clippy::needless_borrow)]
    75
    		 
        pub async fn make_operation(
    253
    		 
        #[allow(clippy::let_and_return)]
    254
    		 
        #[allow(clippy::needless_borrow)]
    255
    		 
        pub async fn make_operation(
    416
    		 
        #[allow(clippy::let_and_return)]
    417
    		 
        #[allow(clippy::needless_borrow)]
    418
    		 
        pub async fn make_operation(
    591
    		 
        #[allow(clippy::let_and_return)]
    592
    		 
        #[allow(clippy::needless_borrow)]
    593
    		 
        pub async fn make_operation(
    789
    		 
        #[allow(clippy::let_and_return)]
    790
    		 
        #[allow(clippy::needless_borrow)]
    791
    		 
        pub async fn make_operation(
  • aws-sdk-mq 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://mq-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://mq-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://mq.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-mq 0.24.0/src/input.rs
    351
    		 
        #[allow(clippy::let_and_return)]
    352
    		 
        #[allow(clippy::needless_borrow)]
    353
    		 
        pub async fn make_operation(
    591
    		 
        #[allow(clippy::let_and_return)]
    592
    		 
        #[allow(clippy::needless_borrow)]
    593
    		 
        pub async fn make_operation(
    777
    		 
        #[allow(clippy::let_and_return)]
    778
    		 
        #[allow(clippy::needless_borrow)]
    779
    		 
        pub async fn make_operation(
    1011
    		 
        #[allow(clippy::let_and_return)]
    1012
    		 
        #[allow(clippy::needless_borrow)]
    1013
    		 
        pub async fn make_operation(
    1212
    		 
        #[allow(clippy::let_and_return)]
    1213
    		 
        #[allow(clippy::needless_borrow)]
    1214
    		 
        pub async fn make_operation(
  • aws-sdk-mturk 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://mturk-requester-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://mturk-requester-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://mturk-requester.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-mturk 0.24.0/src/input.rs
    54
    		 
        #[allow(clippy::let_and_return)]
    55
    		 
        #[allow(clippy::needless_borrow)]
    56
    		 
        pub async fn make_operation(
    250
    		 
        #[allow(clippy::let_and_return)]
    251
    		 
        #[allow(clippy::needless_borrow)]
    252
    		 
        pub async fn make_operation(
    453
    		 
        #[allow(clippy::let_and_return)]
    454
    		 
        #[allow(clippy::needless_borrow)]
    455
    		 
        pub async fn make_operation(
    647
    		 
        #[allow(clippy::let_and_return)]
    648
    		 
        #[allow(clippy::needless_borrow)]
    649
    		 
        pub async fn make_operation(
    1047
    		 
        #[allow(clippy::let_and_return)]
    1048
    		 
        #[allow(clippy::needless_borrow)]
    1049
    		 
        pub async fn make_operation(
  • aws-sdk-mwaa 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://airflow-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://airflow-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://airflow.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-mwaa 0.24.0/src/input.rs
    35
    		 
        #[allow(clippy::let_and_return)]
    36
    		 
        #[allow(clippy::needless_borrow)]
    37
    		 
        pub async fn make_operation(
    552
    		 
        #[allow(clippy::let_and_return)]
    553
    		 
        #[allow(clippy::needless_borrow)]
    554
    		 
        pub async fn make_operation(
    731
    		 
        #[allow(clippy::let_and_return)]
    732
    		 
        #[allow(clippy::needless_borrow)]
    733
    		 
        pub async fn make_operation(
    895
    		 
        #[allow(clippy::let_and_return)]
    896
    		 
        #[allow(clippy::needless_borrow)]
    897
    		 
        pub async fn make_operation(
    1058
    		 
        #[allow(clippy::let_and_return)]
    1059
    		 
        #[allow(clippy::needless_borrow)]
    1060
    		 
        pub async fn make_operation(
  • aws-sdk-neptune 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://rds-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://rds.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://rds-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-neptune 0.24.0/src/input.rs
    66
    		 
        #[allow(clippy::let_and_return)]
    67
    		 
        #[allow(clippy::needless_borrow)]
    68
    		 
        pub async fn make_operation(
    259
    		 
        #[allow(clippy::let_and_return)]
    260
    		 
        #[allow(clippy::needless_borrow)]
    261
    		 
        pub async fn make_operation(
    442
    		 
        #[allow(clippy::let_and_return)]
    443
    		 
        #[allow(clippy::needless_borrow)]
    444
    		 
        pub async fn make_operation(
    642
    		 
        #[allow(clippy::let_and_return)]
    643
    		 
        #[allow(clippy::needless_borrow)]
    644
    		 
        pub async fn make_operation(
    898
    		 
        #[allow(clippy::let_and_return)]
    899
    		 
        #[allow(clippy::needless_borrow)]
    900
    		 
        pub async fn make_operation(
  • aws-sdk-networkfirewall 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://network-firewall-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://network-firewall-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://network-firewall.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-networkfirewall 0.24.0/src/input.rs
    89
    		 
        #[allow(clippy::let_and_return)]
    90
    		 
        #[allow(clippy::needless_borrow)]
    91
    		 
        pub async fn make_operation(
    311
    		 
        #[allow(clippy::let_and_return)]
    312
    		 
        #[allow(clippy::needless_borrow)]
    313
    		 
        pub async fn make_operation(
    619
    		 
        #[allow(clippy::let_and_return)]
    620
    		 
        #[allow(clippy::needless_borrow)]
    621
    		 
        pub async fn make_operation(
    869
    		 
        #[allow(clippy::let_and_return)]
    870
    		 
        #[allow(clippy::needless_borrow)]
    871
    		 
        pub async fn make_operation(
    1208
    		 
        #[allow(clippy::let_and_return)]
    1209
    		 
        #[allow(clippy::needless_borrow)]
    1210
    		 
        pub async fn make_operation(
  • aws-sdk-networkmanager 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://networkmanager-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    69
    		 
                                out.push_str("https://networkmanager-fips.");
    70
    		 
                                #[allow(clippy::needless_borrow)]
    71
    		 
                                out.push_str(&region);
    86
    		 
                                out.push_str("https://networkmanager.");
    87
    		 
                                #[allow(clippy::needless_borrow)]
    88
    		 
                                out.push_str(&region);
    125
    		 
                                        out.push_str("https://networkmanager-fips.");
    126
    		 
                                        #[allow(clippy::needless_borrow)]
    127
    		 
                                        out.push_str(&region);
    143
    		 
                                out.push_str("https://networkmanager-fips.");
    144
    		 
                                #[allow(clippy::needless_borrow)]
    145
    		 
                                out.push_str(&region);
  • aws-sdk-networkmanager 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    253
    		 
        #[allow(clippy::let_and_return)]
    254
    		 
        #[allow(clippy::needless_borrow)]
    255
    		 
        pub async fn make_operation(
    480
    		 
        #[allow(clippy::let_and_return)]
    481
    		 
        #[allow(clippy::needless_borrow)]
    482
    		 
        pub async fn make_operation(
    690
    		 
        #[allow(clippy::let_and_return)]
    691
    		 
        #[allow(clippy::needless_borrow)]
    692
    		 
        pub async fn make_operation(
    918
    		 
        #[allow(clippy::let_and_return)]
    919
    		 
        #[allow(clippy::needless_borrow)]
    920
    		 
        pub async fn make_operation(
  • aws-sdk-nimble 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://nimble-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://nimble-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://nimble.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-nimble 0.24.0/src/input.rs
    70
    		 
        #[allow(clippy::let_and_return)]
    71
    		 
        #[allow(clippy::needless_borrow)]
    72
    		 
        pub async fn make_operation(
    426
    		 
        #[allow(clippy::let_and_return)]
    427
    		 
        #[allow(clippy::needless_borrow)]
    428
    		 
        pub async fn make_operation(
    702
    		 
        #[allow(clippy::let_and_return)]
    703
    		 
        #[allow(clippy::needless_borrow)]
    704
    		 
        pub async fn make_operation(
    990
    		 
        #[allow(clippy::let_and_return)]
    991
    		 
        #[allow(clippy::needless_borrow)]
    992
    		 
        pub async fn make_operation(
    1216
    		 
        #[allow(clippy::let_and_return)]
    1217
    		 
        #[allow(clippy::needless_borrow)]
    1218
    		 
        pub async fn make_operation(
  • aws-sdk-oam 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://oam-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://oam-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://oam.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-oam 0.2.0/src/input.rs
    123
    		 
        #[allow(clippy::let_and_return)]
    124
    		 
        #[allow(clippy::needless_borrow)]
    125
    		 
        pub async fn make_operation(
    313
    		 
        #[allow(clippy::let_and_return)]
    314
    		 
        #[allow(clippy::needless_borrow)]
    315
    		 
        pub async fn make_operation(
    470
    		 
        #[allow(clippy::let_and_return)]
    471
    		 
        #[allow(clippy::needless_borrow)]
    472
    		 
        pub async fn make_operation(
    627
    		 
        #[allow(clippy::let_and_return)]
    628
    		 
        #[allow(clippy::needless_borrow)]
    629
    		 
        pub async fn make_operation(
    784
    		 
        #[allow(clippy::let_and_return)]
    785
    		 
        #[allow(clippy::needless_borrow)]
    786
    		 
        pub async fn make_operation(
  • aws-sdk-omics 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://omics-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://omics-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://omics.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-omics 0.2.0/src/input.rs
    63
    		 
        #[allow(clippy::let_and_return)]
    64
    		 
        #[allow(clippy::needless_borrow)]
    65
    		 
        pub async fn make_operation(
    248
    		 
        #[allow(clippy::let_and_return)]
    249
    		 
        #[allow(clippy::needless_borrow)]
    250
    		 
        pub async fn make_operation(
    411
    		 
        #[allow(clippy::let_and_return)]
    412
    		 
        #[allow(clippy::needless_borrow)]
    413
    		 
        pub async fn make_operation(
    575
    		 
        #[allow(clippy::let_and_return)]
    576
    		 
        #[allow(clippy::needless_borrow)]
    577
    		 
        pub async fn make_operation(
    843
    		 
        #[allow(clippy::let_and_return)]
    844
    		 
        #[allow(clippy::needless_borrow)]
    845
    		 
        pub async fn make_operation(
  • aws-sdk-opensearch 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://es-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://es-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://es.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-opensearch 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    230
    		 
        #[allow(clippy::let_and_return)]
    231
    		 
        #[allow(clippy::needless_borrow)]
    232
    		 
        pub async fn make_operation(
    399
    		 
        #[allow(clippy::let_and_return)]
    400
    		 
        #[allow(clippy::needless_borrow)]
    401
    		 
        pub async fn make_operation(
    600
    		 
        #[allow(clippy::let_and_return)]
    601
    		 
        #[allow(clippy::needless_borrow)]
    602
    		 
        pub async fn make_operation(
    783
    		 
        #[allow(clippy::let_and_return)]
    784
    		 
        #[allow(clippy::needless_borrow)]
    785
    		 
        pub async fn make_operation(
  • aws-sdk-opensearchserverless 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://aoss-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://aoss-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://aoss.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-opensearchserverless 0.2.0/src/input.rs
    69
    		 
        #[allow(clippy::let_and_return)]
    70
    		 
        #[allow(clippy::needless_borrow)]
    71
    		 
        pub async fn make_operation(
    240
    		 
        #[allow(clippy::let_and_return)]
    241
    		 
        #[allow(clippy::needless_borrow)]
    242
    		 
        pub async fn make_operation(
    457
    		 
        #[allow(clippy::let_and_return)]
    458
    		 
        #[allow(clippy::needless_borrow)]
    459
    		 
        pub async fn make_operation(
    684
    		 
        #[allow(clippy::let_and_return)]
    685
    		 
        #[allow(clippy::needless_borrow)]
    686
    		 
        pub async fn make_operation(
    905
    		 
        #[allow(clippy::let_and_return)]
    906
    		 
        #[allow(clippy::needless_borrow)]
    907
    		 
        pub async fn make_operation(
  • aws-sdk-opsworks 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://opsworks-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://opsworks-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://opsworks.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-opsworks 0.24.0/src/input.rs
    58
    		 
        #[allow(clippy::let_and_return)]
    59
    		 
        #[allow(clippy::needless_borrow)]
    60
    		 
        pub async fn make_operation(
    232
    		 
        #[allow(clippy::let_and_return)]
    233
    		 
        #[allow(clippy::needless_borrow)]
    234
    		 
        pub async fn make_operation(
    408
    		 
        #[allow(clippy::let_and_return)]
    409
    		 
        #[allow(clippy::needless_borrow)]
    410
    		 
        pub async fn make_operation(
    587
    		 
        #[allow(clippy::let_and_return)]
    588
    		 
        #[allow(clippy::needless_borrow)]
    589
    		 
        pub async fn make_operation(
    1181
    		 
        #[allow(clippy::let_and_return)]
    1182
    		 
        #[allow(clippy::needless_borrow)]
    1183
    		 
        pub async fn make_operation(
  • aws-sdk-opsworkscm 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://opsworks-cm-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://opsworks-cm-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://opsworks-cm.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-opsworkscm 0.24.0/src/input.rs
    89
    		 
        #[allow(clippy::let_and_return)]
    90
    		 
        #[allow(clippy::needless_borrow)]
    91
    		 
        pub async fn make_operation(
    298
    		 
        #[allow(clippy::let_and_return)]
    299
    		 
        #[allow(clippy::needless_borrow)]
    300
    		 
        pub async fn make_operation(
    874
    		 
        #[allow(clippy::let_and_return)]
    875
    		 
        #[allow(clippy::needless_borrow)]
    876
    		 
        pub async fn make_operation(
    1036
    		 
        #[allow(clippy::let_and_return)]
    1037
    		 
        #[allow(clippy::needless_borrow)]
    1038
    		 
        pub async fn make_operation(
    1198
    		 
        #[allow(clippy::let_and_return)]
    1199
    		 
        #[allow(clippy::needless_borrow)]
    1200
    		 
        pub async fn make_operation(
  • aws-sdk-organizations 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://organizations-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    98
    		 
                                out.push_str("https://organizations.");
    99
    		 
                                #[allow(clippy::needless_borrow)]
    100
    		 
                                out.push_str(&region);
    137
    		 
                                        out.push_str("https://organizations-fips.");
    138
    		 
                                        #[allow(clippy::needless_borrow)]
    139
    		 
                                        out.push_str(&region);
    155
    		 
                                out.push_str("https://organizations-fips.");
    156
    		 
                                #[allow(clippy::needless_borrow)]
    157
    		 
                                out.push_str(&region);
    172
    		 
                                out.push_str("https://organizations.");
    173
    		 
                                #[allow(clippy::needless_borrow)]
    174
    		 
                                out.push_str(&region);
  • aws-sdk-organizations 0.24.0/src/input.rs
    39
    		 
        #[allow(clippy::let_and_return)]
    40
    		 
        #[allow(clippy::needless_borrow)]
    41
    		 
        pub async fn make_operation(
    227
    		 
        #[allow(clippy::let_and_return)]
    228
    		 
        #[allow(clippy::needless_borrow)]
    229
    		 
        pub async fn make_operation(
    391
    		 
        #[allow(clippy::let_and_return)]
    392
    		 
        #[allow(clippy::needless_borrow)]
    393
    		 
        pub async fn make_operation(
    553
    		 
        #[allow(clippy::let_and_return)]
    554
    		 
        #[allow(clippy::needless_borrow)]
    555
    		 
        pub async fn make_operation(
    837
    		 
        #[allow(clippy::let_and_return)]
    838
    		 
        #[allow(clippy::needless_borrow)]
    839
    		 
        pub async fn make_operation(
  • aws-sdk-outposts 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://outposts-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://outposts.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://outposts-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-outposts 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    254
    		 
        #[allow(clippy::let_and_return)]
    255
    		 
        #[allow(clippy::needless_borrow)]
    256
    		 
        pub async fn make_operation(
    513
    		 
        #[allow(clippy::let_and_return)]
    514
    		 
        #[allow(clippy::needless_borrow)]
    515
    		 
        pub async fn make_operation(
    772
    		 
        #[allow(clippy::let_and_return)]
    773
    		 
        #[allow(clippy::needless_borrow)]
    774
    		 
        pub async fn make_operation(
    929
    		 
        #[allow(clippy::let_and_return)]
    930
    		 
        #[allow(clippy::needless_borrow)]
    931
    		 
        pub async fn make_operation(
  • aws-sdk-panorama 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://panorama-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://panorama-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://panorama.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-panorama 0.24.0/src/input.rs
    165
    		 
        #[allow(clippy::let_and_return)]
    166
    		 
        #[allow(clippy::needless_borrow)]
    167
    		 
        pub async fn make_operation(
    362
    		 
        #[allow(clippy::let_and_return)]
    363
    		 
        #[allow(clippy::needless_borrow)]
    364
    		 
        pub async fn make_operation(
    633
    		 
        #[allow(clippy::let_and_return)]
    634
    		 
        #[allow(clippy::needless_borrow)]
    635
    		 
        pub async fn make_operation(
    819
    		 
        #[allow(clippy::let_and_return)]
    820
    		 
        #[allow(clippy::needless_borrow)]
    821
    		 
        pub async fn make_operation(
    1044
    		 
        #[allow(clippy::let_and_return)]
    1045
    		 
        #[allow(clippy::needless_borrow)]
    1046
    		 
        pub async fn make_operation(
  • aws-sdk-personalize 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://personalize-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://personalize-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://personalize.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-personalize 0.24.0/src/input.rs
    160
    		 
        #[allow(clippy::let_and_return)]
    161
    		 
        #[allow(clippy::needless_borrow)]
    162
    		 
        pub async fn make_operation(
    428
    		 
        #[allow(clippy::let_and_return)]
    429
    		 
        #[allow(clippy::needless_borrow)]
    430
    		 
        pub async fn make_operation(
    655
    		 
        #[allow(clippy::let_and_return)]
    656
    		 
        #[allow(clippy::needless_borrow)]
    657
    		 
        pub async fn make_operation(
    889
    		 
        #[allow(clippy::let_and_return)]
    890
    		 
        #[allow(clippy::needless_borrow)]
    891
    		 
        pub async fn make_operation(
    1128
    		 
        #[allow(clippy::let_and_return)]
    1129
    		 
        #[allow(clippy::needless_borrow)]
    1130
    		 
        pub async fn make_operation(
  • aws-sdk-personalizeevents 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://personalize-events-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://personalize-events-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://personalize-events.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-personalizeevents 0.24.0/src/input.rs
    92
    		 
        #[allow(clippy::let_and_return)]
    93
    		 
        #[allow(clippy::needless_borrow)]
    94
    		 
        pub async fn make_operation(
    268
    		 
        #[allow(clippy::let_and_return)]
    269
    		 
        #[allow(clippy::needless_borrow)]
    270
    		 
        pub async fn make_operation(
    444
    		 
        #[allow(clippy::let_and_return)]
    445
    		 
        #[allow(clippy::needless_borrow)]
    446
    		 
        pub async fn make_operation(
  • aws-sdk-personalizeruntime 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://personalize-runtime-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://personalize-runtime-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://personalize-runtime.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-personalizeruntime 0.24.0/src/input.rs
    146
    		 
        #[allow(clippy::let_and_return)]
    147
    		 
        #[allow(clippy::needless_borrow)]
    148
    		 
        pub async fn make_operation(
    459
    		 
        #[allow(clippy::let_and_return)]
    460
    		 
        #[allow(clippy::needless_borrow)]
    461
    		 
        pub async fn make_operation(
  • aws-sdk-pi 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://pi-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://pi-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://pi.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-pi 0.24.0/src/input.rs
    262
    		 
        #[allow(clippy::let_and_return)]
    263
    		 
        #[allow(clippy::needless_borrow)]
    264
    		 
        pub async fn make_operation(
    515
    		 
        #[allow(clippy::let_and_return)]
    516
    		 
        #[allow(clippy::needless_borrow)]
    517
    		 
        pub async fn make_operation(
    696
    		 
        #[allow(clippy::let_and_return)]
    697
    		 
        #[allow(clippy::needless_borrow)]
    698
    		 
        pub async fn make_operation(
    992
    		 
        #[allow(clippy::let_and_return)]
    993
    		 
        #[allow(clippy::needless_borrow)]
    994
    		 
        pub async fn make_operation(
    1216
    		 
        #[allow(clippy::let_and_return)]
    1217
    		 
        #[allow(clippy::needless_borrow)]
    1218
    		 
        pub async fn make_operation(
  • aws-sdk-pinpoint 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://pinpoint-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://pinpoint-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://pinpoint.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-pinpoint 0.24.0/src/input.rs
    44
    		 
        #[allow(clippy::let_and_return)]
    45
    		 
        #[allow(clippy::needless_borrow)]
    46
    		 
        pub async fn make_operation(
    219
    		 
        #[allow(clippy::let_and_return)]
    220
    		 
        #[allow(clippy::needless_borrow)]
    221
    		 
        pub async fn make_operation(
    422
    		 
        #[allow(clippy::let_and_return)]
    423
    		 
        #[allow(clippy::needless_borrow)]
    424
    		 
        pub async fn make_operation(
    623
    		 
        #[allow(clippy::let_and_return)]
    624
    		 
        #[allow(clippy::needless_borrow)]
    625
    		 
        pub async fn make_operation(
    824
    		 
        #[allow(clippy::let_and_return)]
    825
    		 
        #[allow(clippy::needless_borrow)]
    826
    		 
        pub async fn make_operation(
  • aws-sdk-pinpointemail 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://email-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://email-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://email.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-pinpointemail 0.24.0/src/input.rs
    123
    		 
        #[allow(clippy::let_and_return)]
    124
    		 
        #[allow(clippy::needless_borrow)]
    125
    		 
        pub async fn make_operation(
    320
    		 
        #[allow(clippy::let_and_return)]
    321
    		 
        #[allow(clippy::needless_borrow)]
    322
    		 
        pub async fn make_operation(
    524
    		 
        #[allow(clippy::let_and_return)]
    525
    		 
        #[allow(clippy::needless_borrow)]
    526
    		 
        pub async fn make_operation(
    736
    		 
        #[allow(clippy::let_and_return)]
    737
    		 
        #[allow(clippy::needless_borrow)]
    738
    		 
        pub async fn make_operation(
    920
    		 
        #[allow(clippy::let_and_return)]
    921
    		 
        #[allow(clippy::needless_borrow)]
    922
    		 
        pub async fn make_operation(
  • aws-sdk-pinpointsmsvoice 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://sms-voice.pinpoint-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://sms-voice.pinpoint-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://sms-voice.pinpoint.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-pinpointsmsvoice 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    240
    		 
        #[allow(clippy::let_and_return)]
    241
    		 
        #[allow(clippy::needless_borrow)]
    242
    		 
        pub async fn make_operation(
    426
    		 
        #[allow(clippy::let_and_return)]
    427
    		 
        #[allow(clippy::needless_borrow)]
    428
    		 
        pub async fn make_operation(
    613
    		 
        #[allow(clippy::let_and_return)]
    614
    		 
        #[allow(clippy::needless_borrow)]
    615
    		 
        pub async fn make_operation(
    799
    		 
        #[allow(clippy::let_and_return)]
    800
    		 
        #[allow(clippy::needless_borrow)]
    801
    		 
        pub async fn make_operation(
  • aws-sdk-pinpointsmsvoicev2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://sms-voice-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://sms-voice-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://sms-voice.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-pinpointsmsvoicev2 0.24.0/src/input.rs
    81
    		 
        #[allow(clippy::let_and_return)]
    82
    		 
        #[allow(clippy::needless_borrow)]
    83
    		 
        pub async fn make_operation(
    284
    		 
        #[allow(clippy::let_and_return)]
    285
    		 
        #[allow(clippy::needless_borrow)]
    286
    		 
        pub async fn make_operation(
    558
    		 
        #[allow(clippy::let_and_return)]
    559
    		 
        #[allow(clippy::needless_borrow)]
    560
    		 
        pub async fn make_operation(
    763
    		 
        #[allow(clippy::let_and_return)]
    764
    		 
        #[allow(clippy::needless_borrow)]
    765
    		 
        pub async fn make_operation(
    1006
    		 
        #[allow(clippy::let_and_return)]
    1007
    		 
        #[allow(clippy::needless_borrow)]
    1008
    		 
        pub async fn make_operation(
  • aws-sdk-pipes 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://pipes-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://pipes-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://pipes.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-pipes 0.2.0/src/input.rs
    207
    		 
        #[allow(clippy::let_and_return)]
    208
    		 
        #[allow(clippy::needless_borrow)]
    209
    		 
        pub async fn make_operation(
    381
    		 
        #[allow(clippy::let_and_return)]
    382
    		 
        #[allow(clippy::needless_borrow)]
    383
    		 
        pub async fn make_operation(
    541
    		 
        #[allow(clippy::let_and_return)]
    542
    		 
        #[allow(clippy::needless_borrow)]
    543
    		 
        pub async fn make_operation(
    800
    		 
        #[allow(clippy::let_and_return)]
    801
    		 
        #[allow(clippy::needless_borrow)]
    802
    		 
        pub async fn make_operation(
    1001
    		 
        #[allow(clippy::let_and_return)]
    1002
    		 
        #[allow(clippy::needless_borrow)]
    1003
    		 
        pub async fn make_operation(
  • aws-sdk-polly 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://polly-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://polly-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://polly.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-polly 0.24.0/src/input.rs
    35
    		 
        #[allow(clippy::let_and_return)]
    36
    		 
        #[allow(clippy::needless_borrow)]
    37
    		 
        pub async fn make_operation(
    242
    		 
        #[allow(clippy::let_and_return)]
    243
    		 
        #[allow(clippy::needless_borrow)]
    244
    		 
        pub async fn make_operation(
    418
    		 
        #[allow(clippy::let_and_return)]
    419
    		 
        #[allow(clippy::needless_borrow)]
    420
    		 
        pub async fn make_operation(
    583
    		 
        #[allow(clippy::let_and_return)]
    584
    		 
        #[allow(clippy::needless_borrow)]
    585
    		 
        pub async fn make_operation(
    746
    		 
        #[allow(clippy::let_and_return)]
    747
    		 
        #[allow(clippy::needless_borrow)]
    748
    		 
        pub async fn make_operation(
  • aws-sdk-pricing 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://api.pricing-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://api.pricing-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://api.pricing.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-pricing 0.24.0/src/input.rs
    80
    		 
        #[allow(clippy::let_and_return)]
    81
    		 
        #[allow(clippy::needless_borrow)]
    82
    		 
        pub async fn make_operation(
    283
    		 
        #[allow(clippy::let_and_return)]
    284
    		 
        #[allow(clippy::needless_borrow)]
    285
    		 
        pub async fn make_operation(
    507
    		 
        #[allow(clippy::let_and_return)]
    508
    		 
        #[allow(clippy::needless_borrow)]
    509
    		 
        pub async fn make_operation(
  • aws-sdk-privatenetworks 0.7.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://private-networks-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://private-networks-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://private-networks.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-privatenetworks 0.7.0/src/input.rs
    39
    		 
        #[allow(clippy::let_and_return)]
    40
    		 
        #[allow(clippy::needless_borrow)]
    41
    		 
        pub async fn make_operation(
    215
    		 
        #[allow(clippy::let_and_return)]
    216
    		 
        #[allow(clippy::needless_borrow)]
    217
    		 
        pub async fn make_operation(
    407
    		 
        #[allow(clippy::let_and_return)]
    408
    		 
        #[allow(clippy::needless_borrow)]
    409
    		 
        pub async fn make_operation(
    647
    		 
        #[allow(clippy::let_and_return)]
    648
    		 
        #[allow(clippy::needless_borrow)]
    649
    		 
        pub async fn make_operation(
    870
    		 
        #[allow(clippy::let_and_return)]
    871
    		 
        #[allow(clippy::needless_borrow)]
    872
    		 
        pub async fn make_operation(
  • aws-sdk-proton 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://proton-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://proton-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://proton.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-proton 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    204
    		 
        #[allow(clippy::let_and_return)]
    205
    		 
        #[allow(clippy::needless_borrow)]
    206
    		 
        pub async fn make_operation(
    373
    		 
        #[allow(clippy::let_and_return)]
    374
    		 
        #[allow(clippy::needless_borrow)]
    375
    		 
        pub async fn make_operation(
    552
    		 
        #[allow(clippy::let_and_return)]
    553
    		 
        #[allow(clippy::needless_borrow)]
    554
    		 
        pub async fn make_operation(
    716
    		 
        #[allow(clippy::let_and_return)]
    717
    		 
        #[allow(clippy::needless_borrow)]
    718
    		 
        pub async fn make_operation(
  • aws-sdk-qldb 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://qldb-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://qldb-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://qldb.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-qldb 0.24.0/src/input.rs
    51
    		 
        #[allow(clippy::let_and_return)]
    52
    		 
        #[allow(clippy::needless_borrow)]
    53
    		 
        pub async fn make_operation(
    358
    		 
        #[allow(clippy::let_and_return)]
    359
    		 
        #[allow(clippy::needless_borrow)]
    360
    		 
        pub async fn make_operation(
    513
    		 
        #[allow(clippy::let_and_return)]
    514
    		 
        #[allow(clippy::needless_borrow)]
    515
    		 
        pub async fn make_operation(
    689
    		 
        #[allow(clippy::let_and_return)]
    690
    		 
        #[allow(clippy::needless_borrow)]
    691
    		 
        pub async fn make_operation(
    890
    		 
        #[allow(clippy::let_and_return)]
    891
    		 
        #[allow(clippy::needless_borrow)]
    892
    		 
        pub async fn make_operation(
  • aws-sdk-qldbsession 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://session.qldb-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://session.qldb-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://session.qldb.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-qldbsession 0.24.0/src/input.rs
    147
    		 
        #[allow(clippy::let_and_return)]
    148
    		 
        #[allow(clippy::needless_borrow)]
    149
    		 
        pub async fn make_operation(
  • aws-sdk-quicksight 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://quicksight-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://quicksight-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://quicksight.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-quicksight 0.24.0/src/input.rs
    64
    		 
        #[allow(clippy::let_and_return)]
    65
    		 
        #[allow(clippy::needless_borrow)]
    66
    		 
        pub async fn make_operation(
    326
    		 
        #[allow(clippy::let_and_return)]
    327
    		 
        #[allow(clippy::needless_borrow)]
    328
    		 
        pub async fn make_operation(
    757
    		 
        #[allow(clippy::let_and_return)]
    758
    		 
        #[allow(clippy::needless_borrow)]
    759
    		 
        pub async fn make_operation(
    1071
    		 
        #[allow(clippy::let_and_return)]
    1072
    		 
        #[allow(clippy::needless_borrow)]
    1073
    		 
        pub async fn make_operation(
    1449
    		 
        #[allow(clippy::let_and_return)]
    1450
    		 
        #[allow(clippy::needless_borrow)]
    1451
    		 
        pub async fn make_operation(
  • aws-sdk-ram 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://ram-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://ram.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://ram-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-ram 0.24.0/src/input.rs
    59
    		 
        #[allow(clippy::let_and_return)]
    60
    		 
        #[allow(clippy::needless_borrow)]
    61
    		 
        pub async fn make_operation(
    300
    		 
        #[allow(clippy::let_and_return)]
    301
    		 
        #[allow(clippy::needless_borrow)]
    302
    		 
        pub async fn make_operation(
    521
    		 
        #[allow(clippy::let_and_return)]
    522
    		 
        #[allow(clippy::needless_borrow)]
    523
    		 
        pub async fn make_operation(
    811
    		 
        #[allow(clippy::let_and_return)]
    812
    		 
        #[allow(clippy::needless_borrow)]
    813
    		 
        pub async fn make_operation(
    987
    		 
        #[allow(clippy::let_and_return)]
    988
    		 
        #[allow(clippy::needless_borrow)]
    989
    		 
        pub async fn make_operation(
  • aws-sdk-rbin 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://rbin-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://rbin-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://rbin.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-rbin 0.24.0/src/input.rs
    128
    		 
        #[allow(clippy::let_and_return)]
    129
    		 
        #[allow(clippy::needless_borrow)]
    130
    		 
        pub async fn make_operation(
    285
    		 
        #[allow(clippy::let_and_return)]
    286
    		 
        #[allow(clippy::needless_borrow)]
    287
    		 
        pub async fn make_operation(
    448
    		 
        #[allow(clippy::let_and_return)]
    449
    		 
        #[allow(clippy::needless_borrow)]
    450
    		 
        pub async fn make_operation(
    669
    		 
        #[allow(clippy::let_and_return)]
    670
    		 
        #[allow(clippy::needless_borrow)]
    671
    		 
        pub async fn make_operation(
    826
    		 
        #[allow(clippy::let_and_return)]
    827
    		 
        #[allow(clippy::needless_borrow)]
    828
    		 
        pub async fn make_operation(
  • aws-sdk-rds 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://rds-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://rds.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://rds-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-rds 0.24.0/src/input.rs
    66
    		 
        #[allow(clippy::let_and_return)]
    67
    		 
        #[allow(clippy::needless_borrow)]
    68
    		 
        pub async fn make_operation(
    254
    		 
        #[allow(clippy::let_and_return)]
    255
    		 
        #[allow(clippy::needless_borrow)]
    256
    		 
        pub async fn make_operation(
    453
    		 
        #[allow(clippy::let_and_return)]
    454
    		 
        #[allow(clippy::needless_borrow)]
    455
    		 
        pub async fn make_operation(
    636
    		 
        #[allow(clippy::let_and_return)]
    637
    		 
        #[allow(clippy::needless_borrow)]
    638
    		 
        pub async fn make_operation(
    836
    		 
        #[allow(clippy::let_and_return)]
    837
    		 
        #[allow(clippy::needless_borrow)]
    838
    		 
        pub async fn make_operation(
  • aws-sdk-rdsdata 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://rds-data-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://rds-data-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://rds-data.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-rdsdata 0.24.0/src/input.rs
    146
    		 
        #[allow(clippy::let_and_return)]
    147
    		 
        #[allow(clippy::needless_borrow)]
    148
    		 
        pub async fn make_operation(
    343
    		 
        #[allow(clippy::let_and_return)]
    344
    		 
        #[allow(clippy::needless_borrow)]
    345
    		 
        pub async fn make_operation(
    529
    		 
        #[allow(clippy::let_and_return)]
    530
    		 
        #[allow(clippy::needless_borrow)]
    531
    		 
        pub async fn make_operation(
    747
    		 
        #[allow(clippy::let_and_return)]
    748
    		 
        #[allow(clippy::needless_borrow)]
    749
    		 
        pub async fn make_operation(
    1062
    		 
        #[allow(clippy::let_and_return)]
    1063
    		 
        #[allow(clippy::needless_borrow)]
    1064
    		 
        pub async fn make_operation(
  • aws-sdk-redshift 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://redshift-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://redshift.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://redshift-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-redshift 0.24.0/src/input.rs
    60
    		 
        #[allow(clippy::let_and_return)]
    61
    		 
        #[allow(clippy::needless_borrow)]
    62
    		 
        pub async fn make_operation(
    259
    		 
        #[allow(clippy::let_and_return)]
    260
    		 
        #[allow(clippy::needless_borrow)]
    261
    		 
        pub async fn make_operation(
    460
    		 
        #[allow(clippy::let_and_return)]
    461
    		 
        #[allow(clippy::needless_borrow)]
    462
    		 
        pub async fn make_operation(
    672
    		 
        #[allow(clippy::let_and_return)]
    673
    		 
        #[allow(clippy::needless_borrow)]
    674
    		 
        pub async fn make_operation(
    849
    		 
        #[allow(clippy::let_and_return)]
    850
    		 
        #[allow(clippy::needless_borrow)]
    851
    		 
        pub async fn make_operation(
  • aws-sdk-redshiftdata 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://redshift-data-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://redshift-data-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://redshift-data.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-redshiftdata 0.24.0/src/input.rs
    153
    		 
        #[allow(clippy::let_and_return)]
    154
    		 
        #[allow(clippy::needless_borrow)]
    155
    		 
        pub async fn make_operation(
    318
    		 
        #[allow(clippy::let_and_return)]
    319
    		 
        #[allow(clippy::needless_borrow)]
    320
    		 
        pub async fn make_operation(
    480
    		 
        #[allow(clippy::let_and_return)]
    481
    		 
        #[allow(clippy::needless_borrow)]
    482
    		 
        pub async fn make_operation(
    759
    		 
        #[allow(clippy::let_and_return)]
    760
    		 
        #[allow(clippy::needless_borrow)]
    761
    		 
        pub async fn make_operation(
    1049
    		 
        #[allow(clippy::let_and_return)]
    1050
    		 
        #[allow(clippy::needless_borrow)]
    1051
    		 
        pub async fn make_operation(
  • aws-sdk-redshiftserverless 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://redshift-serverless-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://redshift-serverless-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://redshift-serverless.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-redshiftserverless 0.24.0/src/input.rs
    90
    		 
        #[allow(clippy::let_and_return)]
    91
    		 
        #[allow(clippy::needless_borrow)]
    92
    		 
        pub async fn make_operation(
    314
    		 
        #[allow(clippy::let_and_return)]
    315
    		 
        #[allow(clippy::needless_borrow)]
    316
    		 
        pub async fn make_operation(
    628
    		 
        #[allow(clippy::let_and_return)]
    629
    		 
        #[allow(clippy::needless_borrow)]
    630
    		 
        pub async fn make_operation(
    841
    		 
        #[allow(clippy::let_and_return)]
    842
    		 
        #[allow(clippy::needless_borrow)]
    843
    		 
        pub async fn make_operation(
    1062
    		 
        #[allow(clippy::let_and_return)]
    1063
    		 
        #[allow(clippy::needless_borrow)]
    1064
    		 
        pub async fn make_operation(
  • aws-sdk-rekognition 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://rekognition-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://rekognition-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://rekognition.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-rekognition 0.24.0/src/input.rs
    82
    		 
        #[allow(clippy::let_and_return)]
    83
    		 
        #[allow(clippy::needless_borrow)]
    84
    		 
        pub async fn make_operation(
    363
    		 
        #[allow(clippy::let_and_return)]
    364
    		 
        #[allow(clippy::needless_borrow)]
    365
    		 
        pub async fn make_operation(
    559
    		 
        #[allow(clippy::let_and_return)]
    560
    		 
        #[allow(clippy::needless_borrow)]
    561
    		 
        pub async fn make_operation(
    751
    		 
        #[allow(clippy::let_and_return)]
    752
    		 
        #[allow(clippy::needless_borrow)]
    753
    		 
        pub async fn make_operation(
    913
    		 
        #[allow(clippy::let_and_return)]
    914
    		 
        #[allow(clippy::needless_borrow)]
    915
    		 
        pub async fn make_operation(
  • aws-sdk-resiliencehub 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://resiliencehub-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://resiliencehub-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://resiliencehub.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-resiliencehub 0.24.0/src/input.rs
    61
    		 
        #[allow(clippy::let_and_return)]
    62
    		 
        #[allow(clippy::needless_borrow)]
    63
    		 
        pub async fn make_operation(
    315
    		 
        #[allow(clippy::let_and_return)]
    316
    		 
        #[allow(clippy::needless_borrow)]
    317
    		 
        pub async fn make_operation(
    686
    		 
        #[allow(clippy::let_and_return)]
    687
    		 
        #[allow(clippy::needless_borrow)]
    688
    		 
        pub async fn make_operation(
    984
    		 
        #[allow(clippy::let_and_return)]
    985
    		 
        #[allow(clippy::needless_borrow)]
    986
    		 
        pub async fn make_operation(
    1170
    		 
        #[allow(clippy::let_and_return)]
    1171
    		 
        #[allow(clippy::needless_borrow)]
    1172
    		 
        pub async fn make_operation(
  • aws-sdk-resourceexplorer2 0.2.0/src/endpoint/internals.rs
    41
    		 
                                out.push_str("https://resource-explorer-2-fips.");
    42
    		 
                                #[allow(clippy::needless_borrow)]
    43
    		 
                                out.push_str(&region);
    44
    		 
                                out.push('.');
    45
    		 
                                #[allow(clippy::needless_borrow)]
    46
    		 
                                out.push_str(&partition_result.dual_stack_dns_suffix());
    58
    		 
                        out.push_str("https://resource-explorer-2.");
    59
    		 
                        #[allow(clippy::needless_borrow)]
    60
    		 
                        out.push_str(&region);
    61
    		 
                        out.push('.');
    62
    		 
                        #[allow(clippy::needless_borrow)]
    63
    		 
                        out.push_str(&partition_result.dual_stack_dns_suffix());
    73
    		 
                            out.push_str("https://resource-explorer-2-fips.");
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&region);
  • aws-sdk-resourceexplorer2 0.2.0/src/input.rs
    39
    		 
        #[allow(clippy::let_and_return)]
    40
    		 
        #[allow(clippy::needless_borrow)]
    41
    		 
        pub async fn make_operation(
    206
    		 
        #[allow(clippy::let_and_return)]
    207
    		 
        #[allow(clippy::needless_borrow)]
    208
    		 
        pub async fn make_operation(
    391
    		 
        #[allow(clippy::let_and_return)]
    392
    		 
        #[allow(clippy::needless_borrow)]
    393
    		 
        pub async fn make_operation(
    649
    		 
        #[allow(clippy::let_and_return)]
    650
    		 
        #[allow(clippy::needless_borrow)]
    651
    		 
        pub async fn make_operation(
    806
    		 
        #[allow(clippy::let_and_return)]
    807
    		 
        #[allow(clippy::needless_borrow)]
    808
    		 
        pub async fn make_operation(
  • aws-sdk-resourcegroups 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://resource-groups-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://resource-groups.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://resource-groups-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-resourcegroups 0.24.0/src/input.rs
    123
    		 
        #[allow(clippy::let_and_return)]
    124
    		 
        #[allow(clippy::needless_borrow)]
    125
    		 
        pub async fn make_operation(
    294
    		 
        #[allow(clippy::let_and_return)]
    295
    		 
        #[allow(clippy::needless_borrow)]
    296
    		 
        pub async fn make_operation(
    439
    		 
        #[allow(clippy::let_and_return)]
    440
    		 
        #[allow(clippy::needless_borrow)]
    441
    		 
        pub async fn make_operation(
    596
    		 
        #[allow(clippy::let_and_return)]
    597
    		 
        #[allow(clippy::needless_borrow)]
    598
    		 
        pub async fn make_operation(
    751
    		 
        #[allow(clippy::let_and_return)]
    752
    		 
        #[allow(clippy::needless_borrow)]
    753
    		 
        pub async fn make_operation(
  • aws-sdk-resourcegroupstagging 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://tagging-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://tagging-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://tagging.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-resourcegroupstagging 0.24.0/src/input.rs
    25
    		 
        #[allow(clippy::let_and_return)]
    26
    		 
        #[allow(clippy::needless_borrow)]
    27
    		 
        pub async fn make_operation(
    318
    		 
        #[allow(clippy::let_and_return)]
    319
    		 
        #[allow(clippy::needless_borrow)]
    320
    		 
        pub async fn make_operation(
    640
    		 
        #[allow(clippy::let_and_return)]
    641
    		 
        #[allow(clippy::needless_borrow)]
    642
    		 
        pub async fn make_operation(
    805
    		 
        #[allow(clippy::let_and_return)]
    806
    		 
        #[allow(clippy::needless_borrow)]
    807
    		 
        pub async fn make_operation(
    982
    		 
        #[allow(clippy::let_and_return)]
    983
    		 
        #[allow(clippy::needless_borrow)]
    984
    		 
        pub async fn make_operation(
  • aws-sdk-robomaker 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://robomaker-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://robomaker-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://robomaker.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-robomaker 0.24.0/src/input.rs
    48
    		 
        #[allow(clippy::let_and_return)]
    49
    		 
        #[allow(clippy::needless_borrow)]
    50
    		 
        pub async fn make_operation(
    214
    		 
        #[allow(clippy::let_and_return)]
    215
    		 
        #[allow(clippy::needless_borrow)]
    216
    		 
        pub async fn make_operation(
    371
    		 
        #[allow(clippy::let_and_return)]
    372
    		 
        #[allow(clippy::needless_borrow)]
    373
    		 
        pub async fn make_operation(
    528
    		 
        #[allow(clippy::let_and_return)]
    529
    		 
        #[allow(clippy::needless_borrow)]
    530
    		 
        pub async fn make_operation(
    685
    		 
        #[allow(clippy::let_and_return)]
    686
    		 
        #[allow(clippy::needless_borrow)]
    687
    		 
        pub async fn make_operation(
  • aws-sdk-rolesanywhere 0.9.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://rolesanywhere-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://rolesanywhere-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://rolesanywhere.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-rolesanywhere 0.9.0/src/input.rs
    151
    		 
        #[allow(clippy::let_and_return)]
    152
    		 
        #[allow(clippy::needless_borrow)]
    153
    		 
        pub async fn make_operation(
    355
    		 
        #[allow(clippy::let_and_return)]
    356
    		 
        #[allow(clippy::needless_borrow)]
    357
    		 
        pub async fn make_operation(
    512
    		 
        #[allow(clippy::let_and_return)]
    513
    		 
        #[allow(clippy::needless_borrow)]
    514
    		 
        pub async fn make_operation(
    672
    		 
        #[allow(clippy::let_and_return)]
    673
    		 
        #[allow(clippy::needless_borrow)]
    674
    		 
        pub async fn make_operation(
    840
    		 
        #[allow(clippy::let_and_return)]
    841
    		 
        #[allow(clippy::needless_borrow)]
    842
    		 
        pub async fn make_operation(
  • aws-sdk-route53 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://route-53-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    115
    		 
                                out.push_str("https://route-53.");
    116
    		 
                                #[allow(clippy::needless_borrow)]
    117
    		 
                                out.push_str(&region);
    167
    		 
                                        out.push_str("https://route-53-fips.");
    168
    		 
                                        #[allow(clippy::needless_borrow)]
    169
    		 
                                        out.push_str(&region);
    205
    		 
                                out.push_str("https://route-53-fips.");
    206
    		 
                                #[allow(clippy::needless_borrow)]
    207
    		 
                                out.push_str(&region);
    238
    		 
                                out.push_str("https://route-53.");
    239
    		 
                                #[allow(clippy::needless_borrow)]
    240
    		 
                                out.push_str(&region);
  • aws-sdk-route53 0.24.0/src/input.rs
    54
    		 
        #[allow(clippy::let_and_return)]
    55
    		 
        #[allow(clippy::needless_borrow)]
    56
    		 
        pub async fn make_operation(
    273
    		 
        #[allow(clippy::let_and_return)]
    274
    		 
        #[allow(clippy::needless_borrow)]
    275
    		 
        pub async fn make_operation(
    500
    		 
        #[allow(clippy::let_and_return)]
    501
    		 
        #[allow(clippy::needless_borrow)]
    502
    		 
        pub async fn make_operation(
    699
    		 
        #[allow(clippy::let_and_return)]
    700
    		 
        #[allow(clippy::needless_borrow)]
    701
    		 
        pub async fn make_operation(
    952
    		 
        #[allow(clippy::let_and_return)]
    953
    		 
        #[allow(clippy::needless_borrow)]
    954
    		 
        pub async fn make_operation(
  • aws-sdk-route53domains 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://route53domains-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://route53domains-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://route53domains.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-route53domains 0.24.0/src/input.rs
    53
    		 
        #[allow(clippy::let_and_return)]
    54
    		 
        #[allow(clippy::needless_borrow)]
    55
    		 
        pub async fn make_operation(
    233
    		 
        #[allow(clippy::let_and_return)]
    234
    		 
        #[allow(clippy::needless_borrow)]
    235
    		 
        pub async fn make_operation(
    397
    		 
        #[allow(clippy::let_and_return)]
    398
    		 
        #[allow(clippy::needless_borrow)]
    399
    		 
        pub async fn make_operation(
    592
    		 
        #[allow(clippy::let_and_return)]
    593
    		 
        #[allow(clippy::needless_borrow)]
    594
    		 
        pub async fn make_operation(
    792
    		 
        #[allow(clippy::let_and_return)]
    793
    		 
        #[allow(clippy::needless_borrow)]
    794
    		 
        pub async fn make_operation(
  • aws-sdk-route53recoverycluster 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://route53-recovery-cluster-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://route53-recovery-cluster-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://route53-recovery-cluster.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-route53recoverycluster 0.24.0/src/input.rs
    42
    		 
        #[allow(clippy::let_and_return)]
    43
    		 
        #[allow(clippy::needless_borrow)]
    44
    		 
        pub async fn make_operation(
    235
    		 
        #[allow(clippy::let_and_return)]
    236
    		 
        #[allow(clippy::needless_borrow)]
    237
    		 
        pub async fn make_operation(
    441
    		 
        #[allow(clippy::let_and_return)]
    442
    		 
        #[allow(clippy::needless_borrow)]
    443
    		 
        pub async fn make_operation(
    646
    		 
        #[allow(clippy::let_and_return)]
    647
    		 
        #[allow(clippy::needless_borrow)]
    648
    		 
        pub async fn make_operation(
  • aws-sdk-route53recoverycontrolconfig 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://route53-recovery-control-config-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://route53-recovery-control-config-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://route53-recovery-control-config.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-route53recoverycontrolconfig 0.24.0/src/input.rs
    78
    		 
        #[allow(clippy::let_and_return)]
    79
    		 
        #[allow(clippy::needless_borrow)]
    80
    		 
        pub async fn make_operation(
    296
    		 
        #[allow(clippy::let_and_return)]
    297
    		 
        #[allow(clippy::needless_borrow)]
    298
    		 
        pub async fn make_operation(
    500
    		 
        #[allow(clippy::let_and_return)]
    501
    		 
        #[allow(clippy::needless_borrow)]
    502
    		 
        pub async fn make_operation(
    723
    		 
        #[allow(clippy::let_and_return)]
    724
    		 
        #[allow(clippy::needless_borrow)]
    725
    		 
        pub async fn make_operation(
    883
    		 
        #[allow(clippy::let_and_return)]
    884
    		 
        #[allow(clippy::needless_borrow)]
    885
    		 
        pub async fn make_operation(
  • aws-sdk-route53recoveryreadiness 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://route53-recovery-readiness-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://route53-recovery-readiness-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://route53-recovery-readiness.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-route53recoveryreadiness 0.24.0/src/input.rs
    87
    		 
        #[allow(clippy::let_and_return)]
    88
    		 
        #[allow(clippy::needless_borrow)]
    89
    		 
        pub async fn make_operation(
    252
    		 
        #[allow(clippy::let_and_return)]
    253
    		 
        #[allow(clippy::needless_borrow)]
    254
    		 
        pub async fn make_operation(
    458
    		 
        #[allow(clippy::let_and_return)]
    459
    		 
        #[allow(clippy::needless_borrow)]
    460
    		 
        pub async fn make_operation(
    672
    		 
        #[allow(clippy::let_and_return)]
    673
    		 
        #[allow(clippy::needless_borrow)]
    674
    		 
        pub async fn make_operation(
    901
    		 
        #[allow(clippy::let_and_return)]
    902
    		 
        #[allow(clippy::needless_borrow)]
    903
    		 
        pub async fn make_operation(
  • aws-sdk-route53resolver 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://route53resolver-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://route53resolver-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://route53resolver.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-route53resolver 0.24.0/src/input.rs
    136
    		 
        #[allow(clippy::let_and_return)]
    137
    		 
        #[allow(clippy::needless_borrow)]
    138
    		 
        pub async fn make_operation(
    321
    		 
        #[allow(clippy::let_and_return)]
    322
    		 
        #[allow(clippy::needless_borrow)]
    323
    		 
        pub async fn make_operation(
    507
    		 
        #[allow(clippy::let_and_return)]
    508
    		 
        #[allow(clippy::needless_borrow)]
    509
    		 
        pub async fn make_operation(
    698
    		 
        #[allow(clippy::let_and_return)]
    699
    		 
        #[allow(clippy::needless_borrow)]
    700
    		 
        pub async fn make_operation(
    900
    		 
        #[allow(clippy::let_and_return)]
    901
    		 
        #[allow(clippy::needless_borrow)]
    902
    		 
        pub async fn make_operation(
  • aws-sdk-rum 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://rum-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://rum-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://rum.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-rum 0.24.0/src/input.rs
    96
    		 
        #[allow(clippy::let_and_return)]
    97
    		 
        #[allow(clippy::needless_borrow)]
    98
    		 
        pub async fn make_operation(
    335
    		 
        #[allow(clippy::let_and_return)]
    336
    		 
        #[allow(clippy::needless_borrow)]
    337
    		 
        pub async fn make_operation(
    602
    		 
        #[allow(clippy::let_and_return)]
    603
    		 
        #[allow(clippy::needless_borrow)]
    604
    		 
        pub async fn make_operation(
    909
    		 
        #[allow(clippy::let_and_return)]
    910
    		 
        #[allow(clippy::needless_borrow)]
    911
    		 
        pub async fn make_operation(
    1066
    		 
        #[allow(clippy::let_and_return)]
    1067
    		 
        #[allow(clippy::needless_borrow)]
    1068
    		 
        pub async fn make_operation(
  • aws-sdk-s3 0.24.0/src/endpoint/internals.rs
    49
    		 
                            out.push_str("Custom endpoint `");
    50
    		 
                            #[allow(clippy::needless_borrow)]
    51
    		 
                            out.push_str(&endpoint);
    89
    		 
    out.push_str("https://s3-fips.dualstack.us-east-1.");
    90
    		 
    #[allow(clippy::needless_borrow)]
    91
    		 
    out.push_str(&partition_result.dns_suffix());
    92
    		 
    out.push('/');
    93
    		 
    #[allow(clippy::needless_borrow)]
    94
    		 
    out.push_str(&uri_encoded_bucket);
    117
    		 
    out.push_str("https://s3-fips.dualstack.us-east-1.");
    118
    		 
    #[allow(clippy::needless_borrow)]
    119
    		 
    out.push_str(&partition_result.dns_suffix());
    120
    		 
    out.push('/');
    121
    		 
    #[allow(clippy::needless_borrow)]
    122
    		 
    out.push_str(&uri_encoded_bucket);
  • aws-sdk-s3 0.24.0/src/input.rs
    97
    		 
        #[allow(clippy::let_and_return)]
    98
    		 
        #[allow(clippy::needless_borrow)]
    99
    		 
        pub async fn make_operation(
    493
    		 
        #[allow(clippy::let_and_return)]
    494
    		 
        #[allow(clippy::needless_borrow)]
    495
    		 
        pub async fn make_operation(
    1467
    		 
        #[allow(clippy::let_and_return)]
    1468
    		 
        #[allow(clippy::needless_borrow)]
    1469
    		 
        pub async fn make_operation(
    1790
    		 
        #[allow(clippy::let_and_return)]
    1791
    		 
        #[allow(clippy::needless_borrow)]
    1792
    		 
        pub async fn make_operation(
    2460
    		 
        #[allow(clippy::let_and_return)]
    2461
    		 
        #[allow(clippy::needless_borrow)]
    2462
    		 
        pub async fn make_operation(
  • aws-sdk-s3control 0.24.0/src/endpoint/internals.rs
    99
    		 
                                        let mut out = String::new();
    100
    		 
                                        #[allow(clippy::needless_borrow)]
    101
    		 
                                        out.push_str(&url.scheme());
    102
    		 
                                        out.push_str("://");
    103
    		 
                                        #[allow(clippy::needless_borrow)]
    104
    		 
                                        out.push_str(&url.authority());
    105
    		 
                                        #[allow(clippy::needless_borrow)]
    106
    		 
                                        out.push_str(&url.path());
    140
    		 
                                    out.push_str("https://s3-outposts-fips.");
    141
    		 
                                    #[allow(clippy::needless_borrow)]
    142
    		 
                                    out.push_str(&region);
    143
    		 
                                    out.push('.');
    144
    		 
                                    #[allow(clippy::needless_borrow)]
    145
    		 
                                    out.push_str(&partition_result.dns_suffix());
  • aws-sdk-s3control 0.24.0/src/input.rs
    140
    		 
        #[allow(clippy::let_and_return)]
    141
    		 
        #[allow(clippy::needless_borrow)]
    142
    		 
        pub async fn make_operation(
    352
    		 
        #[allow(clippy::let_and_return)]
    353
    		 
        #[allow(clippy::needless_borrow)]
    354
    		 
        pub async fn make_operation(
    708
    		 
        #[allow(clippy::let_and_return)]
    709
    		 
        #[allow(clippy::needless_borrow)]
    710
    		 
        pub async fn make_operation(
    1047
    		 
        #[allow(clippy::let_and_return)]
    1048
    		 
        #[allow(clippy::needless_borrow)]
    1049
    		 
        pub async fn make_operation(
    1239
    		 
        #[allow(clippy::let_and_return)]
    1240
    		 
        #[allow(clippy::needless_borrow)]
    1241
    		 
        pub async fn make_operation(
  • aws-sdk-s3outposts 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://s3-outposts-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://s3-outposts-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://s3-outposts.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-s3outposts 0.24.0/src/input.rs
    98
    		 
        #[allow(clippy::let_and_return)]
    99
    		 
        #[allow(clippy::needless_borrow)]
    100
    		 
        pub async fn make_operation(
    267
    		 
        #[allow(clippy::let_and_return)]
    268
    		 
        #[allow(clippy::needless_borrow)]
    269
    		 
        pub async fn make_operation(
    462
    		 
        #[allow(clippy::let_and_return)]
    463
    		 
        #[allow(clippy::needless_borrow)]
    464
    		 
        pub async fn make_operation(
    650
    		 
        #[allow(clippy::let_and_return)]
    651
    		 
        #[allow(clippy::needless_borrow)]
    652
    		 
        pub async fn make_operation(
  • aws-sdk-sagemaker 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://api.sagemaker-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://api-fips.sagemaker.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    74
    		 
                                out.push('.');
    75
    		 
                                #[allow(clippy::needless_borrow)]
    76
    		 
                                out.push_str(&partition_result.dns_suffix());
    90
    		 
                                out.push_str("https://api-fips.sagemaker.");
    91
    		 
                                #[allow(clippy::needless_borrow)]
    92
    		 
                                out.push_str(&region);
  • aws-sdk-sagemaker 0.24.0/src/input.rs
    79
    		 
        #[allow(clippy::let_and_return)]
    80
    		 
        #[allow(clippy::needless_borrow)]
    81
    		 
        pub async fn make_operation(
    262
    		 
        #[allow(clippy::let_and_return)]
    263
    		 
        #[allow(clippy::needless_borrow)]
    264
    		 
        pub async fn make_operation(
    439
    		 
        #[allow(clippy::let_and_return)]
    440
    		 
        #[allow(clippy::needless_borrow)]
    441
    		 
        pub async fn make_operation(
    614
    		 
        #[allow(clippy::let_and_return)]
    615
    		 
        #[allow(clippy::needless_borrow)]
    616
    		 
        pub async fn make_operation(
    897
    		 
        #[allow(clippy::let_and_return)]
    898
    		 
        #[allow(clippy::needless_borrow)]
    899
    		 
        pub async fn make_operation(
  • aws-sdk-sagemakera2iruntime 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://a2i-runtime.sagemaker-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://a2i-runtime.sagemaker-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://a2i-runtime.sagemaker.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-sagemakera2iruntime 0.24.0/src/input.rs
    40
    		 
        #[allow(clippy::let_and_return)]
    41
    		 
        #[allow(clippy::needless_borrow)]
    42
    		 
        pub async fn make_operation(
    212
    		 
        #[allow(clippy::let_and_return)]
    213
    		 
        #[allow(clippy::needless_borrow)]
    214
    		 
        pub async fn make_operation(
    451
    		 
        #[allow(clippy::let_and_return)]
    452
    		 
        #[allow(clippy::needless_borrow)]
    453
    		 
        pub async fn make_operation(
    709
    		 
        #[allow(clippy::let_and_return)]
    710
    		 
        #[allow(clippy::needless_borrow)]
    711
    		 
        pub async fn make_operation(
    869
    		 
        #[allow(clippy::let_and_return)]
    870
    		 
        #[allow(clippy::needless_borrow)]
    871
    		 
        pub async fn make_operation(
  • aws-sdk-sagemakeredge 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://edge.sagemaker-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://edge.sagemaker-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://edge.sagemaker.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-sagemakeredge 0.24.0/src/input.rs
    52
    		 
        #[allow(clippy::let_and_return)]
    53
    		 
        #[allow(clippy::needless_borrow)]
    54
    		 
        pub async fn make_operation(
    226
    		 
        #[allow(clippy::let_and_return)]
    227
    		 
        #[allow(clippy::needless_borrow)]
    228
    		 
        pub async fn make_operation(
    472
    		 
        #[allow(clippy::let_and_return)]
    473
    		 
        #[allow(clippy::needless_borrow)]
    474
    		 
        pub async fn make_operation(
  • aws-sdk-sagemakerfeaturestoreruntime 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://featurestore-runtime.sagemaker-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://featurestore-runtime.sagemaker-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://featurestore-runtime.sagemaker.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-sagemakerfeaturestoreruntime 0.24.0/src/input.rs
    47
    		 
        #[allow(clippy::let_and_return)]
    48
    		 
        #[allow(clippy::needless_borrow)]
    49
    		 
        pub async fn make_operation(
    258
    		 
        #[allow(clippy::let_and_return)]
    259
    		 
        #[allow(clippy::needless_borrow)]
    260
    		 
        pub async fn make_operation(
    520
    		 
        #[allow(clippy::let_and_return)]
    521
    		 
        #[allow(clippy::needless_borrow)]
    522
    		 
        pub async fn make_operation(
    777
    		 
        #[allow(clippy::let_and_return)]
    778
    		 
        #[allow(clippy::needless_borrow)]
    779
    		 
        pub async fn make_operation(
  • aws-sdk-sagemakergeospatial 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://sagemaker-geospatial-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://sagemaker-geospatial-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://sagemaker-geospatial.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-sagemakergeospatial 0.2.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    200
    		 
        #[allow(clippy::let_and_return)]
    201
    		 
        #[allow(clippy::needless_borrow)]
    202
    		 
        pub async fn make_operation(
    407
    		 
        #[allow(clippy::let_and_return)]
    408
    		 
        #[allow(clippy::needless_borrow)]
    409
    		 
        pub async fn make_operation(
    602
    		 
        #[allow(clippy::let_and_return)]
    603
    		 
        #[allow(clippy::needless_borrow)]
    604
    		 
        pub async fn make_operation(
    762
    		 
        #[allow(clippy::let_and_return)]
    763
    		 
        #[allow(clippy::needless_borrow)]
    764
    		 
        pub async fn make_operation(
  • aws-sdk-sagemakermetrics 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://metrics.sagemaker-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://metrics.sagemaker-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://metrics.sagemaker.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-sagemakermetrics 0.2.0/src/input.rs
    61
    		 
        #[allow(clippy::let_and_return)]
    62
    		 
        #[allow(clippy::needless_borrow)]
    63
    		 
        pub async fn make_operation(
  • aws-sdk-sagemakerruntime 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://runtime.sagemaker-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://runtime-fips.sagemaker.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    83
    		 
                                out.push_str("https://runtime.sagemaker.");
    84
    		 
                                #[allow(clippy::needless_borrow)]
    85
    		 
                                out.push_str(&region);
    94
    		 
                            out.push_str("https://runtime.sagemaker-fips.");
    95
    		 
                            #[allow(clippy::needless_borrow)]
    96
    		 
                            out.push_str(&region);
  • aws-sdk-sagemakerruntime 0.24.0/src/input.rs
    184
    		 
        #[allow(clippy::let_and_return)]
    185
    		 
        #[allow(clippy::needless_borrow)]
    186
    		 
        pub async fn make_operation(
    466
    		 
        #[allow(clippy::let_and_return)]
    467
    		 
        #[allow(clippy::needless_borrow)]
    468
    		 
        pub async fn make_operation(
  • aws-sdk-savingsplans 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://savingsplans-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    69
    		 
                                out.push_str("https://savingsplans-fips.");
    70
    		 
                                #[allow(clippy::needless_borrow)]
    71
    		 
                                out.push_str(&region);
    86
    		 
                                out.push_str("https://savingsplans.");
    87
    		 
                                #[allow(clippy::needless_borrow)]
    88
    		 
                                out.push_str(&region);
    121
    		 
                                    out.push_str("https://savingsplans-fips.");
    122
    		 
                                    #[allow(clippy::needless_borrow)]
    123
    		 
                                    out.push_str(&region);
    124
    		 
                                    out.push('.');
    125
    		 
                                    #[allow(clippy::needless_borrow)]
    126
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
  • aws-sdk-savingsplans 0.24.0/src/input.rs
    125
    		 
        #[allow(clippy::let_and_return)]
    126
    		 
        #[allow(clippy::needless_borrow)]
    127
    		 
        pub async fn make_operation(
    290
    		 
        #[allow(clippy::let_and_return)]
    291
    		 
        #[allow(clippy::needless_borrow)]
    292
    		 
        pub async fn make_operation(
    499
    		 
        #[allow(clippy::let_and_return)]
    500
    		 
        #[allow(clippy::needless_borrow)]
    501
    		 
        pub async fn make_operation(
    756
    		 
        #[allow(clippy::let_and_return)]
    757
    		 
        #[allow(clippy::needless_borrow)]
    758
    		 
        pub async fn make_operation(
    1111
    		 
        #[allow(clippy::let_and_return)]
    1112
    		 
        #[allow(clippy::needless_borrow)]
    1113
    		 
        pub async fn make_operation(
  • aws-sdk-scheduler 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://scheduler-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://scheduler-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://scheduler.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-scheduler 0.2.0/src/input.rs
    208
    		 
        #[allow(clippy::let_and_return)]
    209
    		 
        #[allow(clippy::needless_borrow)]
    210
    		 
        pub async fn make_operation(
    423
    		 
        #[allow(clippy::let_and_return)]
    424
    		 
        #[allow(clippy::needless_borrow)]
    425
    		 
        pub async fn make_operation(
    627
    		 
        #[allow(clippy::let_and_return)]
    628
    		 
        #[allow(clippy::needless_borrow)]
    629
    		 
        pub async fn make_operation(
    825
    		 
        #[allow(clippy::let_and_return)]
    826
    		 
        #[allow(clippy::needless_borrow)]
    827
    		 
        pub async fn make_operation(
    1016
    		 
        #[allow(clippy::let_and_return)]
    1017
    		 
        #[allow(clippy::needless_borrow)]
    1018
    		 
        pub async fn make_operation(
  • aws-sdk-schemas 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://schemas-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://schemas-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://schemas.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-schemas 0.24.0/src/input.rs
    92
    		 
        #[allow(clippy::let_and_return)]
    93
    		 
        #[allow(clippy::needless_borrow)]
    94
    		 
        pub async fn make_operation(
    293
    		 
        #[allow(clippy::let_and_return)]
    294
    		 
        #[allow(clippy::needless_borrow)]
    295
    		 
        pub async fn make_operation(
    554
    		 
        #[allow(clippy::let_and_return)]
    555
    		 
        #[allow(clippy::needless_borrow)]
    556
    		 
        pub async fn make_operation(
    760
    		 
        #[allow(clippy::let_and_return)]
    761
    		 
        #[allow(clippy::needless_borrow)]
    762
    		 
        pub async fn make_operation(
    930
    		 
        #[allow(clippy::let_and_return)]
    931
    		 
        #[allow(clippy::needless_borrow)]
    932
    		 
        pub async fn make_operation(
  • aws-sdk-secretsmanager 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://secretsmanager-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://secretsmanager-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://secretsmanager.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-secretsmanager 0.24.0/src/input.rs
    41
    		 
        #[allow(clippy::let_and_return)]
    42
    		 
        #[allow(clippy::needless_borrow)]
    43
    		 
        pub async fn make_operation(
    412
    		 
        #[allow(clippy::let_and_return)]
    413
    		 
        #[allow(clippy::needless_borrow)]
    414
    		 
        pub async fn make_operation(
    581
    		 
        #[allow(clippy::let_and_return)]
    582
    		 
        #[allow(clippy::needless_borrow)]
    583
    		 
        pub async fn make_operation(
    780
    		 
        #[allow(clippy::let_and_return)]
    781
    		 
        #[allow(clippy::needless_borrow)]
    782
    		 
        pub async fn make_operation(
    944
    		 
        #[allow(clippy::let_and_return)]
    945
    		 
        #[allow(clippy::needless_borrow)]
    946
    		 
        pub async fn make_operation(
  • aws-sdk-securityhub 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://securityhub-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://securityhub-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://securityhub.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-securityhub 0.24.0/src/input.rs
    57
    		 
        #[allow(clippy::let_and_return)]
    58
    		 
        #[allow(clippy::needless_borrow)]
    59
    		 
        pub async fn make_operation(
    231
    		 
        #[allow(clippy::let_and_return)]
    232
    		 
        #[allow(clippy::needless_borrow)]
    233
    		 
        pub async fn make_operation(
    403
    		 
        #[allow(clippy::let_and_return)]
    404
    		 
        #[allow(clippy::needless_borrow)]
    405
    		 
        pub async fn make_operation(
    577
    		 
        #[allow(clippy::let_and_return)]
    578
    		 
        #[allow(clippy::needless_borrow)]
    579
    		 
        pub async fn make_operation(
    747
    		 
        #[allow(clippy::let_and_return)]
    748
    		 
        #[allow(clippy::needless_borrow)]
    749
    		 
        pub async fn make_operation(
  • aws-sdk-securitylake 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://securitylake-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://securitylake-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://securitylake.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-securitylake 0.2.0/src/input.rs
    136
    		 
        #[allow(clippy::let_and_return)]
    137
    		 
        #[allow(clippy::needless_borrow)]
    138
    		 
        pub async fn make_operation(
    351
    		 
        #[allow(clippy::let_and_return)]
    352
    		 
        #[allow(clippy::needless_borrow)]
    353
    		 
        pub async fn make_operation(
    581
    		 
        #[allow(clippy::let_and_return)]
    582
    		 
        #[allow(clippy::needless_borrow)]
    583
    		 
        pub async fn make_operation(
    755
    		 
        #[allow(clippy::let_and_return)]
    756
    		 
        #[allow(clippy::needless_borrow)]
    757
    		 
        pub async fn make_operation(
    916
    		 
        #[allow(clippy::let_and_return)]
    917
    		 
        #[allow(clippy::needless_borrow)]
    918
    		 
        pub async fn make_operation(
  • aws-sdk-serverlessapplicationrepository 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://serverlessrepo-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://serverlessrepo.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://serverlessrepo-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-serverlessapplicationrepository 0.24.0/src/input.rs
    272
    		 
        #[allow(clippy::let_and_return)]
    273
    		 
        #[allow(clippy::needless_borrow)]
    274
    		 
        pub async fn make_operation(
    508
    		 
        #[allow(clippy::let_and_return)]
    509
    		 
        #[allow(clippy::needless_borrow)]
    510
    		 
        pub async fn make_operation(
    932
    		 
        #[allow(clippy::let_and_return)]
    933
    		 
        #[allow(clippy::needless_borrow)]
    934
    		 
        pub async fn make_operation(
    1135
    		 
        #[allow(clippy::let_and_return)]
    1136
    		 
        #[allow(clippy::needless_borrow)]
    1137
    		 
        pub async fn make_operation(
    1321
    		 
        #[allow(clippy::let_and_return)]
    1322
    		 
        #[allow(clippy::needless_borrow)]
    1323
    		 
        pub async fn make_operation(
  • aws-sdk-servicecatalog 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://servicecatalog-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://servicecatalog-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://servicecatalog.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-servicecatalog 0.24.0/src/input.rs
    91
    		 
        #[allow(clippy::let_and_return)]
    92
    		 
        #[allow(clippy::needless_borrow)]
    93
    		 
        pub async fn make_operation(
    269
    		 
        #[allow(clippy::let_and_return)]
    270
    		 
        #[allow(clippy::needless_borrow)]
    271
    		 
        pub async fn make_operation(
    490
    		 
        #[allow(clippy::let_and_return)]
    491
    		 
        #[allow(clippy::needless_borrow)]
    492
    		 
        pub async fn make_operation(
    706
    		 
        #[allow(clippy::let_and_return)]
    707
    		 
        #[allow(clippy::needless_borrow)]
    708
    		 
        pub async fn make_operation(
    927
    		 
        #[allow(clippy::let_and_return)]
    928
    		 
        #[allow(clippy::needless_borrow)]
    929
    		 
        pub async fn make_operation(
  • aws-sdk-servicecatalogappregistry 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://servicecatalog-appregistry-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://servicecatalog-appregistry.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://servicecatalog-appregistry-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-servicecatalogappregistry 0.24.0/src/input.rs
    54
    		 
        #[allow(clippy::let_and_return)]
    55
    		 
        #[allow(clippy::needless_borrow)]
    56
    		 
        pub async fn make_operation(
    270
    		 
        #[allow(clippy::let_and_return)]
    271
    		 
        #[allow(clippy::needless_borrow)]
    272
    		 
        pub async fn make_operation(
    532
    		 
        #[allow(clippy::let_and_return)]
    533
    		 
        #[allow(clippy::needless_borrow)]
    534
    		 
        pub async fn make_operation(
    759
    		 
        #[allow(clippy::let_and_return)]
    760
    		 
        #[allow(clippy::needless_borrow)]
    761
    		 
        pub async fn make_operation(
    923
    		 
        #[allow(clippy::let_and_return)]
    924
    		 
        #[allow(clippy::needless_borrow)]
    925
    		 
        pub async fn make_operation(
  • aws-sdk-servicediscovery 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://servicediscovery-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://servicediscovery-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://servicediscovery.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-servicediscovery 0.24.0/src/input.rs
    87
    		 
        #[allow(clippy::let_and_return)]
    88
    		 
        #[allow(clippy::needless_borrow)]
    89
    		 
        pub async fn make_operation(
    329
    		 
        #[allow(clippy::let_and_return)]
    330
    		 
        #[allow(clippy::needless_borrow)]
    331
    		 
        pub async fn make_operation(
    565
    		 
        #[allow(clippy::let_and_return)]
    566
    		 
        #[allow(clippy::needless_borrow)]
    567
    		 
        pub async fn make_operation(
    890
    		 
        #[allow(clippy::let_and_return)]
    891
    		 
        #[allow(clippy::needless_borrow)]
    892
    		 
        pub async fn make_operation(
    1053
    		 
        #[allow(clippy::let_and_return)]
    1054
    		 
        #[allow(clippy::needless_borrow)]
    1055
    		 
        pub async fn make_operation(
  • aws-sdk-servicequotas 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://servicequotas-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://servicequotas.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://servicequotas-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-servicequotas 0.24.0/src/input.rs
    25
    		 
        #[allow(clippy::let_and_return)]
    26
    		 
        #[allow(clippy::needless_borrow)]
    27
    		 
        pub async fn make_operation(
    208
    		 
        #[allow(clippy::let_and_return)]
    209
    		 
        #[allow(clippy::needless_borrow)]
    210
    		 
        pub async fn make_operation(
    359
    		 
        #[allow(clippy::let_and_return)]
    360
    		 
        #[allow(clippy::needless_borrow)]
    361
    		 
        pub async fn make_operation(
    502
    		 
        #[allow(clippy::let_and_return)]
    503
    		 
        #[allow(clippy::needless_borrow)]
    504
    		 
        pub async fn make_operation(
    671
    		 
        #[allow(clippy::let_and_return)]
    672
    		 
        #[allow(clippy::needless_borrow)]
    673
    		 
        pub async fn make_operation(
  • aws-sdk-ses 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://email-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://email-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://email.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-ses 0.24.0/src/input.rs
    67
    		 
        #[allow(clippy::let_and_return)]
    68
    		 
        #[allow(clippy::needless_borrow)]
    69
    		 
        pub async fn make_operation(
    231
    		 
        #[allow(clippy::let_and_return)]
    232
    		 
        #[allow(clippy::needless_borrow)]
    233
    		 
        pub async fn make_operation(
    410
    		 
        #[allow(clippy::let_and_return)]
    411
    		 
        #[allow(clippy::needless_borrow)]
    412
    		 
        pub async fn make_operation(
    589
    		 
        #[allow(clippy::let_and_return)]
    590
    		 
        #[allow(clippy::needless_borrow)]
    591
    		 
        pub async fn make_operation(
    826
    		 
        #[allow(clippy::let_and_return)]
    827
    		 
        #[allow(clippy::needless_borrow)]
    828
    		 
        pub async fn make_operation(
  • aws-sdk-sesv2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://email-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://email-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://email.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-sesv2 0.24.0/src/input.rs
    49
    		 
        #[allow(clippy::let_and_return)]
    50
    		 
        #[allow(clippy::needless_borrow)]
    51
    		 
        pub async fn make_operation(
    322
    		 
        #[allow(clippy::let_and_return)]
    323
    		 
        #[allow(clippy::needless_borrow)]
    324
    		 
        pub async fn make_operation(
    519
    		 
        #[allow(clippy::let_and_return)]
    520
    		 
        #[allow(clippy::needless_borrow)]
    521
    		 
        pub async fn make_operation(
    767
    		 
        #[allow(clippy::let_and_return)]
    768
    		 
        #[allow(clippy::needless_borrow)]
    769
    		 
        pub async fn make_operation(
    1007
    		 
        #[allow(clippy::let_and_return)]
    1008
    		 
        #[allow(clippy::needless_borrow)]
    1009
    		 
        pub async fn make_operation(
  • aws-sdk-sfn 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://states-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    75
    		 
                            out.push_str("https://states-fips.");
    76
    		 
                            #[allow(clippy::needless_borrow)]
    77
    		 
                            out.push_str(&region);
    78
    		 
                            out.push('.');
    79
    		 
                            #[allow(clippy::needless_borrow)]
    80
    		 
                            out.push_str(&partition_result.dns_suffix());
    94
    		 
                            out.push_str("https://states.");
    95
    		 
                            #[allow(clippy::needless_borrow)]
    96
    		 
                            out.push_str(&region);
  • aws-sdk-sfn 0.24.0/src/input.rs
    80
    		 
        #[allow(clippy::let_and_return)]
    81
    		 
        #[allow(clippy::needless_borrow)]
    82
    		 
        pub async fn make_operation(
    373
    		 
        #[allow(clippy::let_and_return)]
    374
    		 
        #[allow(clippy::needless_borrow)]
    375
    		 
        pub async fn make_operation(
    535
    		 
        #[allow(clippy::let_and_return)]
    536
    		 
        #[allow(clippy::needless_borrow)]
    537
    		 
        pub async fn make_operation(
    702
    		 
        #[allow(clippy::let_and_return)]
    703
    		 
        #[allow(clippy::needless_borrow)]
    704
    		 
        pub async fn make_operation(
    866
    		 
        #[allow(clippy::let_and_return)]
    867
    		 
        #[allow(clippy::needless_borrow)]
    868
    		 
        pub async fn make_operation(
  • aws-sdk-shield 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://shield-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    95
    		 
                                out.push_str("https://shield.");
    96
    		 
                                #[allow(clippy::needless_borrow)]
    97
    		 
                                out.push_str(&region);
    130
    		 
                                    out.push_str("https://shield-fips.");
    131
    		 
                                    #[allow(clippy::needless_borrow)]
    132
    		 
                                    out.push_str(&region);
    133
    		 
                                    out.push('.');
    134
    		 
                                    #[allow(clippy::needless_borrow)]
    135
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    171
    		 
                            out.push_str("https://shield-fips.");
    172
    		 
                            #[allow(clippy::needless_borrow)]
    173
    		 
                            out.push_str(&region);
  • aws-sdk-shield 0.24.0/src/input.rs
    39
    		 
        #[allow(clippy::let_and_return)]
    40
    		 
        #[allow(clippy::needless_borrow)]
    41
    		 
        pub async fn make_operation(
    207
    		 
        #[allow(clippy::let_and_return)]
    208
    		 
        #[allow(clippy::needless_borrow)]
    209
    		 
        pub async fn make_operation(
    389
    		 
        #[allow(clippy::let_and_return)]
    390
    		 
        #[allow(clippy::needless_borrow)]
    391
    		 
        pub async fn make_operation(
    571
    		 
        #[allow(clippy::let_and_return)]
    572
    		 
        #[allow(clippy::needless_borrow)]
    573
    		 
        pub async fn make_operation(
    786
    		 
        #[allow(clippy::let_and_return)]
    787
    		 
        #[allow(clippy::needless_borrow)]
    788
    		 
        pub async fn make_operation(
  • aws-sdk-signer 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://signer-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://signer-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://signer.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-signer 0.24.0/src/input.rs
    102
    		 
        #[allow(clippy::let_and_return)]
    103
    		 
        #[allow(clippy::needless_borrow)]
    104
    		 
        pub async fn make_operation(
    287
    		 
        #[allow(clippy::let_and_return)]
    288
    		 
        #[allow(clippy::needless_borrow)]
    289
    		 
        pub async fn make_operation(
    456
    		 
        #[allow(clippy::let_and_return)]
    457
    		 
        #[allow(clippy::needless_borrow)]
    458
    		 
        pub async fn make_operation(
    621
    		 
        #[allow(clippy::let_and_return)]
    622
    		 
        #[allow(clippy::needless_borrow)]
    623
    		 
        pub async fn make_operation(
    805
    		 
        #[allow(clippy::let_and_return)]
    806
    		 
        #[allow(clippy::needless_borrow)]
    807
    		 
        pub async fn make_operation(
  • aws-sdk-simspaceweaver 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://simspaceweaver-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://simspaceweaver-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://simspaceweaver.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-simspaceweaver 0.2.0/src/input.rs
    61
    		 
        #[allow(clippy::let_and_return)]
    62
    		 
        #[allow(clippy::needless_borrow)]
    63
    		 
        pub async fn make_operation(
    260
    		 
        #[allow(clippy::let_and_return)]
    261
    		 
        #[allow(clippy::needless_borrow)]
    262
    		 
        pub async fn make_operation(
    451
    		 
        #[allow(clippy::let_and_return)]
    452
    		 
        #[allow(clippy::needless_borrow)]
    453
    		 
        pub async fn make_operation(
    652
    		 
        #[allow(clippy::let_and_return)]
    653
    		 
        #[allow(clippy::needless_borrow)]
    654
    		 
        pub async fn make_operation(
    855
    		 
        #[allow(clippy::let_and_return)]
    856
    		 
        #[allow(clippy::needless_borrow)]
    857
    		 
        pub async fn make_operation(
  • aws-sdk-sms 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://sms-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://sms-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://sms.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-sms 0.24.0/src/input.rs
    115
    		 
        #[allow(clippy::let_and_return)]
    116
    		 
        #[allow(clippy::needless_borrow)]
    117
    		 
        pub async fn make_operation(
    408
    		 
        #[allow(clippy::let_and_return)]
    409
    		 
        #[allow(clippy::needless_borrow)]
    410
    		 
        pub async fn make_operation(
    596
    		 
        #[allow(clippy::let_and_return)]
    597
    		 
        #[allow(clippy::needless_borrow)]
    598
    		 
        pub async fn make_operation(
    758
    		 
        #[allow(clippy::let_and_return)]
    759
    		 
        #[allow(clippy::needless_borrow)]
    760
    		 
        pub async fn make_operation(
    922
    		 
        #[allow(clippy::let_and_return)]
    923
    		 
        #[allow(clippy::needless_borrow)]
    924
    		 
        pub async fn make_operation(
  • aws-sdk-snowball 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://snowball-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://snowball-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://snowball.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-snowball 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    199
    		 
        #[allow(clippy::let_and_return)]
    200
    		 
        #[allow(clippy::needless_borrow)]
    201
    		 
        pub async fn make_operation(
    359
    		 
        #[allow(clippy::let_and_return)]
    360
    		 
        #[allow(clippy::needless_borrow)]
    361
    		 
        pub async fn make_operation(
    725
    		 
        #[allow(clippy::let_and_return)]
    726
    		 
        #[allow(clippy::needless_borrow)]
    727
    		 
        pub async fn make_operation(
    1150
    		 
        #[allow(clippy::let_and_return)]
    1151
    		 
        #[allow(clippy::needless_borrow)]
    1152
    		 
        pub async fn make_operation(
  • aws-sdk-snowdevicemanagement 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://snow-device-management-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://snow-device-management-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://snow-device-management.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-snowdevicemanagement 0.24.0/src/input.rs
    37
    		 
        #[allow(clippy::let_and_return)]
    38
    		 
        #[allow(clippy::needless_borrow)]
    39
    		 
        pub async fn make_operation(
    274
    		 
        #[allow(clippy::let_and_return)]
    275
    		 
        #[allow(clippy::needless_borrow)]
    276
    		 
        pub async fn make_operation(
    437
    		 
        #[allow(clippy::let_and_return)]
    438
    		 
        #[allow(clippy::needless_borrow)]
    439
    		 
        pub async fn make_operation(
    630
    		 
        #[allow(clippy::let_and_return)]
    631
    		 
        #[allow(clippy::needless_borrow)]
    632
    		 
        pub async fn make_operation(
    828
    		 
        #[allow(clippy::let_and_return)]
    829
    		 
        #[allow(clippy::needless_borrow)]
    830
    		 
        pub async fn make_operation(
  • aws-sdk-sns 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://sns-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    80
    		 
                            out.push_str("https://sns-fips.");
    81
    		 
                            #[allow(clippy::needless_borrow)]
    82
    		 
                            out.push_str(&region);
    83
    		 
                            out.push('.');
    84
    		 
                            #[allow(clippy::needless_borrow)]
    85
    		 
                            out.push_str(&partition_result.dns_suffix());
    99
    		 
                            out.push_str("https://sns.");
    100
    		 
                            #[allow(clippy::needless_borrow)]
    101
    		 
                            out.push_str(&region);
  • aws-sdk-sns 0.24.0/src/input.rs
    93
    		 
        #[allow(clippy::let_and_return)]
    94
    		 
        #[allow(clippy::needless_borrow)]
    95
    		 
        pub async fn make_operation(
    252
    		 
        #[allow(clippy::let_and_return)]
    253
    		 
        #[allow(clippy::needless_borrow)]
    254
    		 
        pub async fn make_operation(
    441
    		 
        #[allow(clippy::let_and_return)]
    442
    		 
        #[allow(clippy::needless_borrow)]
    443
    		 
        pub async fn make_operation(
    641
    		 
        #[allow(clippy::let_and_return)]
    642
    		 
        #[allow(clippy::needless_borrow)]
    643
    		 
        pub async fn make_operation(
    861
    		 
        #[allow(clippy::let_and_return)]
    862
    		 
        #[allow(clippy::needless_borrow)]
    863
    		 
        pub async fn make_operation(
  • aws-sdk-sqs 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://sqs-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://sqs.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://sqs-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-sqs 0.24.0/src/input.rs
    97
    		 
        #[allow(clippy::let_and_return)]
    98
    		 
        #[allow(clippy::needless_borrow)]
    99
    		 
        pub async fn make_operation(
    285
    		 
        #[allow(clippy::let_and_return)]
    286
    		 
        #[allow(clippy::needless_borrow)]
    287
    		 
        pub async fn make_operation(
    476
    		 
        #[allow(clippy::let_and_return)]
    477
    		 
        #[allow(clippy::needless_borrow)]
    478
    		 
        pub async fn make_operation(
    825
    		 
        #[allow(clippy::let_and_return)]
    826
    		 
        #[allow(clippy::needless_borrow)]
    827
    		 
        pub async fn make_operation(
    999
    		 
        #[allow(clippy::let_and_return)]
    1000
    		 
        #[allow(clippy::needless_borrow)]
    1001
    		 
        pub async fn make_operation(
  • aws-sdk-ssm 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://ssm-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://ssm.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://ssm-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-ssm 0.24.0/src/input.rs
    101
    		 
        #[allow(clippy::let_and_return)]
    102
    		 
        #[allow(clippy::needless_borrow)]
    103
    		 
        pub async fn make_operation(
    311
    		 
        #[allow(clippy::let_and_return)]
    312
    		 
        #[allow(clippy::needless_borrow)]
    313
    		 
        pub async fn make_operation(
    494
    		 
        #[allow(clippy::let_and_return)]
    495
    		 
        #[allow(clippy::needless_borrow)]
    496
    		 
        pub async fn make_operation(
    661
    		 
        #[allow(clippy::let_and_return)]
    662
    		 
        #[allow(clippy::needless_borrow)]
    663
    		 
        pub async fn make_operation(
    951
    		 
        #[allow(clippy::let_and_return)]
    952
    		 
        #[allow(clippy::needless_borrow)]
    953
    		 
        pub async fn make_operation(
  • aws-sdk-ssmcontacts 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://ssm-contacts-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://ssm-contacts-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://ssm-contacts.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-ssmcontacts 0.24.0/src/input.rs
    108
    		 
        #[allow(clippy::let_and_return)]
    109
    		 
        #[allow(clippy::needless_borrow)]
    110
    		 
        pub async fn make_operation(
    290
    		 
        #[allow(clippy::let_and_return)]
    291
    		 
        #[allow(clippy::needless_borrow)]
    292
    		 
        pub async fn make_operation(
    526
    		 
        #[allow(clippy::let_and_return)]
    527
    		 
        #[allow(clippy::needless_borrow)]
    528
    		 
        pub async fn make_operation(
    779
    		 
        #[allow(clippy::let_and_return)]
    780
    		 
        #[allow(clippy::needless_borrow)]
    781
    		 
        pub async fn make_operation(
    951
    		 
        #[allow(clippy::let_and_return)]
    952
    		 
        #[allow(clippy::needless_borrow)]
    953
    		 
        pub async fn make_operation(
  • aws-sdk-ssmincidents 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://ssm-incidents-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://ssm-incidents-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://ssm-incidents.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-ssmincidents 0.24.0/src/input.rs
    97
    		 
        #[allow(clippy::let_and_return)]
    98
    		 
        #[allow(clippy::needless_borrow)]
    99
    		 
        pub async fn make_operation(
    407
    		 
        #[allow(clippy::let_and_return)]
    408
    		 
        #[allow(clippy::needless_borrow)]
    409
    		 
        pub async fn make_operation(
    645
    		 
        #[allow(clippy::let_and_return)]
    646
    		 
        #[allow(clippy::needless_borrow)]
    647
    		 
        pub async fn make_operation(
    805
    		 
        #[allow(clippy::let_and_return)]
    806
    		 
        #[allow(clippy::needless_borrow)]
    807
    		 
        pub async fn make_operation(
    964
    		 
        #[allow(clippy::let_and_return)]
    965
    		 
        #[allow(clippy::needless_borrow)]
    966
    		 
        pub async fn make_operation(
  • aws-sdk-ssmsap 0.2.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://ssm-sap-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://ssm-sap-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://ssm-sap.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-ssmsap 0.2.0/src/input.rs
    69
    		 
        #[allow(clippy::let_and_return)]
    70
    		 
        #[allow(clippy::needless_borrow)]
    71
    		 
        pub async fn make_operation(
    233
    		 
        #[allow(clippy::let_and_return)]
    234
    		 
        #[allow(clippy::needless_borrow)]
    235
    		 
        pub async fn make_operation(
    425
    		 
        #[allow(clippy::let_and_return)]
    426
    		 
        #[allow(clippy::needless_borrow)]
    427
    		 
        pub async fn make_operation(
    597
    		 
        #[allow(clippy::let_and_return)]
    598
    		 
        #[allow(clippy::needless_borrow)]
    599
    		 
        pub async fn make_operation(
    793
    		 
        #[allow(clippy::let_and_return)]
    794
    		 
        #[allow(clippy::needless_borrow)]
    795
    		 
        pub async fn make_operation(
  • aws-sdk-sso 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://portal.sso-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://portal.sso-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://portal.sso.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-sso 0.24.0/src/input.rs
    72
    		 
        #[allow(clippy::let_and_return)]
    73
    		 
        #[allow(clippy::needless_borrow)]
    74
    		 
        pub async fn make_operation(
    305
    		 
        #[allow(clippy::let_and_return)]
    306
    		 
        #[allow(clippy::needless_borrow)]
    307
    		 
        pub async fn make_operation(
    520
    		 
        #[allow(clippy::let_and_return)]
    521
    		 
        #[allow(clippy::needless_borrow)]
    522
    		 
        pub async fn make_operation(
    693
    		 
        #[allow(clippy::let_and_return)]
    694
    		 
        #[allow(clippy::needless_borrow)]
    695
    		 
        pub async fn make_operation(
  • aws-sdk-ssoadmin 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://sso-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://sso.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://sso-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-ssoadmin 0.24.0/src/input.rs
    75
    		 
        #[allow(clippy::let_and_return)]
    76
    		 
        #[allow(clippy::needless_borrow)]
    77
    		 
        pub async fn make_operation(
    271
    		 
        #[allow(clippy::let_and_return)]
    272
    		 
        #[allow(clippy::needless_borrow)]
    273
    		 
        pub async fn make_operation(
    504
    		 
        #[allow(clippy::let_and_return)]
    505
    		 
        #[allow(clippy::needless_borrow)]
    506
    		 
        pub async fn make_operation(
    692
    		 
        #[allow(clippy::let_and_return)]
    693
    		 
        #[allow(clippy::needless_borrow)]
    694
    		 
        pub async fn make_operation(
    930
    		 
        #[allow(clippy::let_and_return)]
    931
    		 
        #[allow(clippy::needless_borrow)]
    932
    		 
        pub async fn make_operation(
  • aws-sdk-ssooidc 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://oidc-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://oidc-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://oidc.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-ssooidc 0.24.0/src/input.rs
    142
    		 
        #[allow(clippy::let_and_return)]
    143
    		 
        #[allow(clippy::needless_borrow)]
    144
    		 
        pub async fn make_operation(
    333
    		 
        #[allow(clippy::let_and_return)]
    334
    		 
        #[allow(clippy::needless_borrow)]
    335
    		 
        pub async fn make_operation(
    520
    		 
        #[allow(clippy::let_and_return)]
    521
    		 
        #[allow(clippy::needless_borrow)]
    522
    		 
        pub async fn make_operation(
  • aws-sdk-storagegateway 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://storagegateway-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://storagegateway-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://storagegateway.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-storagegateway 0.24.0/src/input.rs
    159
    		 
        #[allow(clippy::let_and_return)]
    160
    		 
        #[allow(clippy::needless_borrow)]
    161
    		 
        pub async fn make_operation(
    342
    		 
        #[allow(clippy::let_and_return)]
    343
    		 
        #[allow(clippy::needless_borrow)]
    344
    		 
        pub async fn make_operation(
    529
    		 
        #[allow(clippy::let_and_return)]
    530
    		 
        #[allow(clippy::needless_borrow)]
    531
    		 
        pub async fn make_operation(
    712
    		 
        #[allow(clippy::let_and_return)]
    713
    		 
        #[allow(clippy::needless_borrow)]
    714
    		 
        pub async fn make_operation(
    897
    		 
        #[allow(clippy::let_and_return)]
    898
    		 
        #[allow(clippy::needless_borrow)]
    899
    		 
        pub async fn make_operation(
  • aws-sdk-sts 0.24.0/src/endpoint/internals.rs
    435
    		 
                                    out.push_str("https://sts.");
    436
    		 
                                    #[allow(clippy::needless_borrow)]
    437
    		 
                                    out.push_str(&region);
    438
    		 
                                    out.push('.');
    439
    		 
                                    #[allow(clippy::needless_borrow)]
    440
    		 
                                    out.push_str(&partition_result.dns_suffix());
    488
    		 
                                    out.push_str("https://sts-fips.");
    489
    		 
                                    #[allow(clippy::needless_borrow)]
    490
    		 
                                    out.push_str(&region);
    491
    		 
                                    out.push('.');
    492
    		 
                                    #[allow(clippy::needless_borrow)]
    493
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    509
    		 
                                out.push_str("https://sts.");
    510
    		 
                                #[allow(clippy::needless_borrow)]
    511
    		 
                                out.push_str(&region);
  • aws-sdk-sts 0.24.0/src/input.rs
    248
    		 
        #[allow(clippy::let_and_return)]
    249
    		 
        #[allow(clippy::needless_borrow)]
    250
    		 
        pub async fn make_operation(
    507
    		 
        #[allow(clippy::let_and_return)]
    508
    		 
        #[allow(clippy::needless_borrow)]
    509
    		 
        pub async fn make_operation(
    783
    		 
        #[allow(clippy::let_and_return)]
    784
    		 
        #[allow(clippy::needless_borrow)]
    785
    		 
        pub async fn make_operation(
    946
    		 
        #[allow(clippy::let_and_return)]
    947
    		 
        #[allow(clippy::needless_borrow)]
    948
    		 
        pub async fn make_operation(
    1112
    		 
        #[allow(clippy::let_and_return)]
    1113
    		 
        #[allow(clippy::needless_borrow)]
    1114
    		 
        pub async fn make_operation(
  • aws-sdk-support 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://support-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://support-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://support.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-support 0.24.0/src/input.rs
    65
    		 
        #[allow(clippy::let_and_return)]
    66
    		 
        #[allow(clippy::needless_borrow)]
    67
    		 
        pub async fn make_operation(
    282
    		 
        #[allow(clippy::let_and_return)]
    283
    		 
        #[allow(clippy::needless_borrow)]
    284
    		 
        pub async fn make_operation(
    569
    		 
        #[allow(clippy::let_and_return)]
    570
    		 
        #[allow(clippy::needless_borrow)]
    571
    		 
        pub async fn make_operation(
    736
    		 
        #[allow(clippy::let_and_return)]
    737
    		 
        #[allow(clippy::needless_borrow)]
    738
    		 
        pub async fn make_operation(
    1003
    		 
        #[allow(clippy::let_and_return)]
    1004
    		 
        #[allow(clippy::needless_borrow)]
    1005
    		 
        pub async fn make_operation(
  • aws-sdk-supportapp 0.7.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://supportapp-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://supportapp-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://supportapp.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-supportapp 0.7.0/src/input.rs
    167
    		 
        #[allow(clippy::let_and_return)]
    168
    		 
        #[allow(clippy::needless_borrow)]
    169
    		 
        pub async fn make_operation(
    313
    		 
        #[allow(clippy::let_and_return)]
    314
    		 
        #[allow(clippy::needless_borrow)]
    315
    		 
        pub async fn make_operation(
    470
    		 
        #[allow(clippy::let_and_return)]
    471
    		 
        #[allow(clippy::needless_borrow)]
    472
    		 
        pub async fn make_operation(
    630
    		 
        #[allow(clippy::let_and_return)]
    631
    		 
        #[allow(clippy::needless_borrow)]
    632
    		 
        pub async fn make_operation(
    774
    		 
        #[allow(clippy::let_and_return)]
    775
    		 
        #[allow(clippy::needless_borrow)]
    776
    		 
        pub async fn make_operation(
  • aws-sdk-swf 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://swf-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://swf.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    82
    		 
                            out.push_str("https://swf-fips.");
    83
    		 
                            #[allow(clippy::needless_borrow)]
    84
    		 
                            out.push_str(&region);
    85
    		 
                            out.push('.');
    86
    		 
                            #[allow(clippy::needless_borrow)]
    87
    		 
                            out.push_str(&partition_result.dns_suffix());
  • aws-sdk-swf 0.24.0/src/input.rs
    153
    		 
        #[allow(clippy::let_and_return)]
    154
    		 
        #[allow(clippy::needless_borrow)]
    155
    		 
        pub async fn make_operation(
    389
    		 
        #[allow(clippy::let_and_return)]
    390
    		 
        #[allow(clippy::needless_borrow)]
    391
    		 
        pub async fn make_operation(
    565
    		 
        #[allow(clippy::let_and_return)]
    566
    		 
        #[allow(clippy::needless_borrow)]
    567
    		 
        pub async fn make_operation(
    743
    		 
        #[allow(clippy::let_and_return)]
    744
    		 
        #[allow(clippy::needless_borrow)]
    745
    		 
        pub async fn make_operation(
    924
    		 
        #[allow(clippy::let_and_return)]
    925
    		 
        #[allow(clippy::needless_borrow)]
    926
    		 
        pub async fn make_operation(
  • aws-sdk-synthetics 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://synthetics-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://synthetics-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://synthetics.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-synthetics 0.24.0/src/input.rs
    54
    		 
        #[allow(clippy::let_and_return)]
    55
    		 
        #[allow(clippy::needless_borrow)]
    56
    		 
        pub async fn make_operation(
    440
    		 
        #[allow(clippy::let_and_return)]
    441
    		 
        #[allow(clippy::needless_borrow)]
    442
    		 
        pub async fn make_operation(
    630
    		 
        #[allow(clippy::let_and_return)]
    631
    		 
        #[allow(clippy::needless_borrow)]
    632
    		 
        pub async fn make_operation(
    801
    		 
        #[allow(clippy::let_and_return)]
    802
    		 
        #[allow(clippy::needless_borrow)]
    803
    		 
        pub async fn make_operation(
    980
    		 
        #[allow(clippy::let_and_return)]
    981
    		 
        #[allow(clippy::needless_borrow)]
    982
    		 
        pub async fn make_operation(
  • aws-sdk-textract 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://textract-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://textract-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://textract.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-textract 0.24.0/src/input.rs
    90
    		 
        #[allow(clippy::let_and_return)]
    91
    		 
        #[allow(clippy::needless_borrow)]
    92
    		 
        pub async fn make_operation(
    262
    		 
        #[allow(clippy::let_and_return)]
    263
    		 
        #[allow(clippy::needless_borrow)]
    264
    		 
        pub async fn make_operation(
    433
    		 
        #[allow(clippy::let_and_return)]
    434
    		 
        #[allow(clippy::needless_borrow)]
    435
    		 
        pub async fn make_operation(
    597
    		 
        #[allow(clippy::let_and_return)]
    598
    		 
        #[allow(clippy::needless_borrow)]
    599
    		 
        pub async fn make_operation(
    785
    		 
        #[allow(clippy::let_and_return)]
    786
    		 
        #[allow(clippy::needless_borrow)]
    787
    		 
        pub async fn make_operation(
  • aws-sdk-transcribe 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://transcribe-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    71
    		 
                                out.push_str("https://fips.transcribe.");
    72
    		 
                                #[allow(clippy::needless_borrow)]
    73
    		 
                                out.push_str(&region);
    83
    		 
                                out.push_str("https://fips.transcribe.");
    84
    		 
                                #[allow(clippy::needless_borrow)]
    85
    		 
                                out.push_str(&region);
    94
    		 
                            out.push_str("https://transcribe-fips.");
    95
    		 
                            #[allow(clippy::needless_borrow)]
    96
    		 
                            out.push_str(&region);
  • aws-sdk-transcribe 0.24.0/src/input.rs
    86
    		 
        #[allow(clippy::let_and_return)]
    87
    		 
        #[allow(clippy::needless_borrow)]
    88
    		 
        pub async fn make_operation(
    328
    		 
        #[allow(clippy::let_and_return)]
    329
    		 
        #[allow(clippy::needless_borrow)]
    330
    		 
        pub async fn make_operation(
    552
    		 
        #[allow(clippy::let_and_return)]
    553
    		 
        #[allow(clippy::needless_borrow)]
    554
    		 
        pub async fn make_operation(
    809
    		 
        #[allow(clippy::let_and_return)]
    810
    		 
        #[allow(clippy::needless_borrow)]
    811
    		 
        pub async fn make_operation(
    1064
    		 
        #[allow(clippy::let_and_return)]
    1065
    		 
        #[allow(clippy::needless_borrow)]
    1066
    		 
        pub async fn make_operation(
  • aws-sdk-transcribestreaming 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://transcribestreaming-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://transcribestreaming-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://transcribestreaming.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-transcribestreaming 0.24.0/src/input.rs
    337
    		 
        #[allow(clippy::let_and_return)]
    338
    		 
        #[allow(clippy::needless_borrow)]
    339
    		 
        pub async fn make_operation(
    733
    		 
        #[allow(clippy::let_and_return)]
    734
    		 
        #[allow(clippy::needless_borrow)]
    735
    		 
        pub async fn make_operation(
    1377
    		 
        #[allow(clippy::let_and_return)]
    1378
    		 
        #[allow(clippy::needless_borrow)]
    1379
    		 
        pub async fn make_operation(
  • aws-sdk-transfer 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://transfer-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://transfer-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://transfer.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-transfer 0.24.0/src/input.rs
    171
    		 
        #[allow(clippy::let_and_return)]
    172
    		 
        #[allow(clippy::needless_borrow)]
    173
    		 
        pub async fn make_operation(
    440
    		 
        #[allow(clippy::let_and_return)]
    441
    		 
        #[allow(clippy::needless_borrow)]
    442
    		 
        pub async fn make_operation(
    662
    		 
        #[allow(clippy::let_and_return)]
    663
    		 
        #[allow(clippy::needless_borrow)]
    664
    		 
        pub async fn make_operation(
    889
    		 
        #[allow(clippy::let_and_return)]
    890
    		 
        #[allow(clippy::needless_borrow)]
    891
    		 
        pub async fn make_operation(
    1417
    		 
        #[allow(clippy::let_and_return)]
    1418
    		 
        #[allow(clippy::needless_borrow)]
    1419
    		 
        pub async fn make_operation(
  • aws-sdk-translate 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://translate-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://translate-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://translate.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-translate 0.24.0/src/input.rs
    114
    		 
        #[allow(clippy::let_and_return)]
    115
    		 
        #[allow(clippy::needless_borrow)]
    116
    		 
        pub async fn make_operation(
    279
    		 
        #[allow(clippy::let_and_return)]
    280
    		 
        #[allow(clippy::needless_borrow)]
    281
    		 
        pub async fn make_operation(
    441
    		 
        #[allow(clippy::let_and_return)]
    442
    		 
        #[allow(clippy::needless_borrow)]
    443
    		 
        pub async fn make_operation(
    605
    		 
        #[allow(clippy::let_and_return)]
    606
    		 
        #[allow(clippy::needless_borrow)]
    607
    		 
        pub async fn make_operation(
    765
    		 
        #[allow(clippy::let_and_return)]
    766
    		 
        #[allow(clippy::needless_borrow)]
    767
    		 
        pub async fn make_operation(
  • aws-sdk-voiceid 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://voiceid-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://voiceid-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://voiceid.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-voiceid 0.24.0/src/input.rs
    115
    		 
        #[allow(clippy::let_and_return)]
    116
    		 
        #[allow(clippy::needless_borrow)]
    117
    		 
        pub async fn make_operation(
    280
    		 
        #[allow(clippy::let_and_return)]
    281
    		 
        #[allow(clippy::needless_borrow)]
    282
    		 
        pub async fn make_operation(
    462
    		 
        #[allow(clippy::let_and_return)]
    463
    		 
        #[allow(clippy::needless_borrow)]
    464
    		 
        pub async fn make_operation(
    644
    		 
        #[allow(clippy::let_and_return)]
    645
    		 
        #[allow(clippy::needless_borrow)]
    646
    		 
        pub async fn make_operation(
    806
    		 
        #[allow(clippy::let_and_return)]
    807
    		 
        #[allow(clippy::needless_borrow)]
    808
    		 
        pub async fn make_operation(
  • aws-sdk-waf 0.24.0/src/endpoint/internals.rs
    51
    		 
                                        out.push_str("https://waf-fips.");
    52
    		 
                                        #[allow(clippy::needless_borrow)]
    53
    		 
                                        out.push_str(&region);
    95
    		 
                                out.push_str("https://waf.");
    96
    		 
                                #[allow(clippy::needless_borrow)]
    97
    		 
                                out.push_str(&region);
    130
    		 
                                    out.push_str("https://waf-fips.");
    131
    		 
                                    #[allow(clippy::needless_borrow)]
    132
    		 
                                    out.push_str(&region);
    133
    		 
                                    out.push('.');
    134
    		 
                                    #[allow(clippy::needless_borrow)]
    135
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    171
    		 
                            out.push_str("https://waf-fips.");
    172
    		 
                            #[allow(clippy::needless_borrow)]
    173
    		 
                            out.push_str(&region);
  • aws-sdk-waf 0.24.0/src/input.rs
    51
    		 
        #[allow(clippy::let_and_return)]
    52
    		 
        #[allow(clippy::needless_borrow)]
    53
    		 
        pub async fn make_operation(
    227
    		 
        #[allow(clippy::let_and_return)]
    228
    		 
        #[allow(clippy::needless_borrow)]
    229
    		 
        pub async fn make_operation(
    401
    		 
        #[allow(clippy::let_and_return)]
    402
    		 
        #[allow(clippy::needless_borrow)]
    403
    		 
        pub async fn make_operation(
    634
    		 
        #[allow(clippy::let_and_return)]
    635
    		 
        #[allow(clippy::needless_borrow)]
    636
    		 
        pub async fn make_operation(
    812
    		 
        #[allow(clippy::let_and_return)]
    813
    		 
        #[allow(clippy::needless_borrow)]
    814
    		 
        pub async fn make_operation(
  • aws-sdk-wafregional 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://waf-regional-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://waf-regional-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://waf-regional.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-wafregional 0.24.0/src/input.rs
    59
    		 
        #[allow(clippy::let_and_return)]
    60
    		 
        #[allow(clippy::needless_borrow)]
    61
    		 
        pub async fn make_operation(
    235
    		 
        #[allow(clippy::let_and_return)]
    236
    		 
        #[allow(clippy::needless_borrow)]
    237
    		 
        pub async fn make_operation(
    411
    		 
        #[allow(clippy::let_and_return)]
    412
    		 
        #[allow(clippy::needless_borrow)]
    413
    		 
        pub async fn make_operation(
    585
    		 
        #[allow(clippy::let_and_return)]
    586
    		 
        #[allow(clippy::needless_borrow)]
    587
    		 
        pub async fn make_operation(
    818
    		 
        #[allow(clippy::let_and_return)]
    819
    		 
        #[allow(clippy::needless_borrow)]
    820
    		 
        pub async fn make_operation(
  • aws-sdk-wafv2 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://wafv2-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://wafv2-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://wafv2.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-wafv2 0.24.0/src/input.rs
    63
    		 
        #[allow(clippy::let_and_return)]
    64
    		 
        #[allow(clippy::needless_borrow)]
    65
    		 
        pub async fn make_operation(
    256
    		 
        #[allow(clippy::let_and_return)]
    257
    		 
        #[allow(clippy::needless_borrow)]
    258
    		 
        pub async fn make_operation(
    539
    		 
        #[allow(clippy::let_and_return)]
    540
    		 
        #[allow(clippy::needless_borrow)]
    541
    		 
        pub async fn make_operation(
    779
    		 
        #[allow(clippy::let_and_return)]
    780
    		 
        #[allow(clippy::needless_borrow)]
    781
    		 
        pub async fn make_operation(
    1083
    		 
        #[allow(clippy::let_and_return)]
    1084
    		 
        #[allow(clippy::needless_borrow)]
    1085
    		 
        pub async fn make_operation(
  • aws-sdk-wellarchitected 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://wellarchitected-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://wellarchitected-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://wellarchitected.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-wellarchitected 0.24.0/src/input.rs
    60
    		 
        #[allow(clippy::let_and_return)]
    61
    		 
        #[allow(clippy::needless_borrow)]
    62
    		 
        pub async fn make_operation(
    280
    		 
        #[allow(clippy::let_and_return)]
    281
    		 
        #[allow(clippy::needless_borrow)]
    282
    		 
        pub async fn make_operation(
    513
    		 
        #[allow(clippy::let_and_return)]
    514
    		 
        #[allow(clippy::needless_borrow)]
    515
    		 
        pub async fn make_operation(
    735
    		 
        #[allow(clippy::let_and_return)]
    736
    		 
        #[allow(clippy::needless_borrow)]
    737
    		 
        pub async fn make_operation(
    1268
    		 
        #[allow(clippy::let_and_return)]
    1269
    		 
        #[allow(clippy::needless_borrow)]
    1270
    		 
        pub async fn make_operation(
  • aws-sdk-wisdom 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://wisdom-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://wisdom-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://wisdom.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-wisdom 0.24.0/src/input.rs
    121
    		 
        #[allow(clippy::let_and_return)]
    122
    		 
        #[allow(clippy::needless_borrow)]
    123
    		 
        pub async fn make_operation(
    354
    		 
        #[allow(clippy::let_and_return)]
    355
    		 
        #[allow(clippy::needless_borrow)]
    356
    		 
        pub async fn make_operation(
    664
    		 
        #[allow(clippy::let_and_return)]
    665
    		 
        #[allow(clippy::needless_borrow)]
    666
    		 
        pub async fn make_operation(
    971
    		 
        #[allow(clippy::let_and_return)]
    972
    		 
        #[allow(clippy::needless_borrow)]
    973
    		 
        pub async fn make_operation(
    1196
    		 
        #[allow(clippy::let_and_return)]
    1197
    		 
        #[allow(clippy::needless_borrow)]
    1198
    		 
        pub async fn make_operation(
  • aws-sdk-workdocs 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://workdocs-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://workdocs-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://workdocs.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-workdocs 0.24.0/src/input.rs
    75
    		 
        #[allow(clippy::let_and_return)]
    76
    		 
        #[allow(clippy::needless_borrow)]
    77
    		 
        pub async fn make_operation(
    287
    		 
        #[allow(clippy::let_and_return)]
    288
    		 
        #[allow(clippy::needless_borrow)]
    289
    		 
        pub async fn make_operation(
    518
    		 
        #[allow(clippy::let_and_return)]
    519
    		 
        #[allow(clippy::needless_borrow)]
    520
    		 
        pub async fn make_operation(
    807
    		 
        #[allow(clippy::let_and_return)]
    808
    		 
        #[allow(clippy::needless_borrow)]
    809
    		 
        pub async fn make_operation(
    1077
    		 
        #[allow(clippy::let_and_return)]
    1078
    		 
        #[allow(clippy::needless_borrow)]
    1079
    		 
        pub async fn make_operation(
  • aws-sdk-worklink 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://worklink-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://worklink-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://worklink.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-worklink 0.24.0/src/input.rs
    76
    		 
        #[allow(clippy::let_and_return)]
    77
    		 
        #[allow(clippy::needless_borrow)]
    78
    		 
        pub async fn make_operation(
    266
    		 
        #[allow(clippy::let_and_return)]
    267
    		 
        #[allow(clippy::needless_borrow)]
    268
    		 
        pub async fn make_operation(
    450
    		 
        #[allow(clippy::let_and_return)]
    451
    		 
        #[allow(clippy::needless_borrow)]
    452
    		 
        pub async fn make_operation(
    664
    		 
        #[allow(clippy::let_and_return)]
    665
    		 
        #[allow(clippy::needless_borrow)]
    666
    		 
        pub async fn make_operation(
    821
    		 
        #[allow(clippy::let_and_return)]
    822
    		 
        #[allow(clippy::needless_borrow)]
    823
    		 
        pub async fn make_operation(
  • aws-sdk-workmail 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://workmail-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://workmail-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://workmail.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-workmail 0.24.0/src/input.rs
    66
    		 
        #[allow(clippy::let_and_return)]
    67
    		 
        #[allow(clippy::needless_borrow)]
    68
    		 
        pub async fn make_operation(
    257
    		 
        #[allow(clippy::let_and_return)]
    258
    		 
        #[allow(clippy::needless_borrow)]
    259
    		 
        pub async fn make_operation(
    441
    		 
        #[allow(clippy::let_and_return)]
    442
    		 
        #[allow(clippy::needless_borrow)]
    443
    		 
        pub async fn make_operation(
    634
    		 
        #[allow(clippy::let_and_return)]
    635
    		 
        #[allow(clippy::needless_borrow)]
    636
    		 
        pub async fn make_operation(
    828
    		 
        #[allow(clippy::let_and_return)]
    829
    		 
        #[allow(clippy::needless_borrow)]
    830
    		 
        pub async fn make_operation(
  • aws-sdk-workmailmessageflow 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://workmailmessageflow-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://workmailmessageflow-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://workmailmessageflow.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-workmailmessageflow 0.24.0/src/input.rs
    39
    		 
        #[allow(clippy::let_and_return)]
    40
    		 
        #[allow(clippy::needless_borrow)]
    41
    		 
        pub async fn make_operation(
    219
    		 
        #[allow(clippy::let_and_return)]
    220
    		 
        #[allow(clippy::needless_borrow)]
    221
    		 
        pub async fn make_operation(
  • aws-sdk-workspaces 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://workspaces-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://workspaces-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://workspaces.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-workspaces 0.24.0/src/input.rs
    51
    		 
        #[allow(clippy::let_and_return)]
    52
    		 
        #[allow(clippy::needless_borrow)]
    53
    		 
        pub async fn make_operation(
    238
    		 
        #[allow(clippy::let_and_return)]
    239
    		 
        #[allow(clippy::needless_borrow)]
    240
    		 
        pub async fn make_operation(
    423
    		 
        #[allow(clippy::let_and_return)]
    424
    		 
        #[allow(clippy::needless_borrow)]
    425
    		 
        pub async fn make_operation(
    650
    		 
        #[allow(clippy::let_and_return)]
    651
    		 
        #[allow(clippy::needless_borrow)]
    652
    		 
        pub async fn make_operation(
    838
    		 
        #[allow(clippy::let_and_return)]
    839
    		 
        #[allow(clippy::needless_borrow)]
    840
    		 
        pub async fn make_operation(
  • aws-sdk-workspacesweb 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://workspaces-web-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://workspaces-web-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://workspaces-web.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-workspacesweb 0.24.0/src/input.rs
    54
    		 
        #[allow(clippy::let_and_return)]
    55
    		 
        #[allow(clippy::needless_borrow)]
    56
    		 
        pub async fn make_operation(
    265
    		 
        #[allow(clippy::let_and_return)]
    266
    		 
        #[allow(clippy::needless_borrow)]
    267
    		 
        pub async fn make_operation(
    476
    		 
        #[allow(clippy::let_and_return)]
    477
    		 
        #[allow(clippy::needless_borrow)]
    478
    		 
        pub async fn make_operation(
    690
    		 
        #[allow(clippy::let_and_return)]
    691
    		 
        #[allow(clippy::needless_borrow)]
    692
    		 
        pub async fn make_operation(
    901
    		 
        #[allow(clippy::let_and_return)]
    902
    		 
        #[allow(clippy::needless_borrow)]
    903
    		 
        pub async fn make_operation(
  • aws-sdk-xray 0.24.0/src/endpoint/internals.rs
    50
    		 
                                    out.push_str("https://xray-fips.");
    51
    		 
                                    #[allow(clippy::needless_borrow)]
    52
    		 
                                    out.push_str(&region);
    53
    		 
                                    out.push('.');
    54
    		 
                                    #[allow(clippy::needless_borrow)]
    55
    		 
                                    out.push_str(&partition_result.dual_stack_dns_suffix());
    70
    		 
                            out.push_str("https://xray-fips.");
    71
    		 
                            #[allow(clippy::needless_borrow)]
    72
    		 
                            out.push_str(&region);
    73
    		 
                            out.push('.');
    74
    		 
                            #[allow(clippy::needless_borrow)]
    75
    		 
                            out.push_str(&partition_result.dns_suffix());
    89
    		 
                            out.push_str("https://xray.");
    90
    		 
                            #[allow(clippy::needless_borrow)]
    91
    		 
                            out.push_str(&region);
  • aws-sdk-xray 0.24.0/src/input.rs
    58
    		 
        #[allow(clippy::let_and_return)]
    59
    		 
        #[allow(clippy::needless_borrow)]
    60
    		 
        pub async fn make_operation(
    295
    		 
        #[allow(clippy::let_and_return)]
    296
    		 
        #[allow(clippy::needless_borrow)]
    297
    		 
        pub async fn make_operation(
    496
    		 
        #[allow(clippy::let_and_return)]
    497
    		 
        #[allow(clippy::needless_borrow)]
    498
    		 
        pub async fn make_operation(
    665
    		 
        #[allow(clippy::let_and_return)]
    666
    		 
        #[allow(clippy::needless_borrow)]
    667
    		 
        pub async fn make_operation(
    839
    		 
        #[allow(clippy::let_and_return)]
    840
    		 
        #[allow(clippy::needless_borrow)]
    841
    		 
        pub async fn make_operation(
  • binfmt 0.1.0/src/elf.rs
    1053
    		 
            for section in bfile.sections() {
    1054
    		 
                #[allow(clippy::needless_borrow)]
    1055
    		 
                shdrs.push(ElfSectionHeader::<Class> {
  • bitcoin_scripts 0.9.0/src/hlc.rs
    13
    		 
    #![allow(clippy::needless_borrow)] // Caused by serde transparent derives
    63
    		 
    /// HTLC payment preimage
    64
    		 
    #[allow(clippy::needless_borrow)]
    65
    		 
    #[cfg_attr(
  • bitvec 1.0.1/src/ptr/single.rs
    1119
    		 
    	#[inline]
    1120
    		 
    	#[allow(clippy::needless_borrow)] // Clippy is wrong.
    1121
    		 
    	pub unsafe fn write_volatile(self, value: bool) {
    1143
    		 
    	#[inline]
    1144
    		 
    	#[allow(clippy::needless_borrow)] // Clippy is wrong.
    1145
    		 
    	#[deprecated = "`BitPtr` does not have unaligned addresses"]
  • cairo-felt 0.1.3/src/bigint_felt.rs
    472
    		 
        type Output = FeltBigInt<PH, PL>;
    473
    		 
        #[allow(clippy::needless_borrow)] // the borrow of self.val is necessary becase it's of the type BigUInt, which doesn't implement the Copy trait
    474
    		 
        fn pow(self, rhs: u32) -> Self::Output {
  • copse 0.4.0/src/polyfill.rs
    304
    		 
        #[cfg(not(feature = "is_sorted"))]
    305
    		 
        #[allow(clippy::needless_borrow)]
    306
    		 
        impl<I: Iterator> IterIsSorted for I {
  • coreutils 0.0.17/tests/by-util/test_users.rs
    22
    		 
        // note: clippy::needless_borrow *false positive*
    23
    		 
        #[allow(clippy::needless_borrow)]
    24
    		 
        let expected = TestScenario::new(&util_name)
  • cozo 0.5.0/src/query/eval.rs
    131
    		 
                if epoch == 0 {
    132
    		 
                    #[allow(clippy::needless_borrow)]
    133
    		 
                    let execution = |(k, compiled_ruleset): (_, &CompiledRuleSet)| -> Result<_> {
    214
    		 
                } else {
    215
    		 
                    #[allow(clippy::needless_borrow)]
    216
    		 
                    let execution = |(k, compiled_ruleset): (_, &CompiledRuleSet)| -> Result<_> {
  • crud-api 0.1.1/src/formats.rs
    64
    		 
          } else {
    65
    		 
            #[allow(clippy::needless_borrow)]
    66
    		 
            &[
  • cryptimitives 0.17.0/src/key/ed25519.rs
    98
    		 
        fn to_public(&self) -> Self::PK {
    99
    		 
            #[allow(clippy::needless_borrow)]
    100
    		 
            PublicKey((&self.0).into())
    147
    		 
        {
    148
    		 
            #[allow(clippy::needless_borrow)]
    149
    		 
            Signature(self.0.sign(&data, &(&self.0).into()))
  • crypto-bigint 0.5.0-pre.3/src/uint/bit_and.rs
    49
    		 
        #[allow(clippy::needless_borrow)]
    50
    		 
        fn bitand(self, rhs: &Uint<LIMBS>) -> Uint<LIMBS> {
  • crypto-bigint 0.5.0-pre.3/src/uint/bit_not.rs
    26
    		 
        #[allow(clippy::needless_borrow)]
    27
    		 
        fn not(self) -> <Self as Not>::Output {
  • crypto-bigint 0.5.0-pre.3/src/uint/bit_or.rs
    49
    		 
        #[allow(clippy::needless_borrow)]
    50
    		 
        fn bitor(self, rhs: &Uint<LIMBS>) -> Uint<LIMBS> {
  • crypto-bigint 0.5.0-pre.3/src/uint/bit_xor.rs
    49
    		 
        #[allow(clippy::needless_borrow)]
    50
    		 
        fn bitxor(self, rhs: &Uint<LIMBS>) -> Uint<LIMBS> {
  • dashu-int 0.3.1/src/third_party/num_traits.rs
    54
    		 
        #[inline]
    55
    		 
        #[allow(clippy::needless_borrow)]
    56
    		 
        fn pow(self, rhs: usize) -> UBig {
    73
    		 
        #[inline]
    74
    		 
        #[allow(clippy::needless_borrow)]
    75
    		 
        fn pow(self, rhs: usize) -> IBig {
  • docktor-api-client 0.35.2/src/input.rs
    27
    		 
        #[allow(clippy::let_and_return)]
    28
    		 
        #[allow(clippy::needless_borrow)]
    29
    		 
        pub async fn make_operation(
    117
    		 
        #[allow(clippy::let_and_return)]
    118
    		 
        #[allow(clippy::needless_borrow)]
    119
    		 
        pub async fn make_operation(
    208
    		 
        #[allow(clippy::let_and_return)]
    209
    		 
        #[allow(clippy::needless_borrow)]
    210
    		 
        pub async fn make_operation(
    333
    		 
        #[allow(clippy::let_and_return)]
    334
    		 
        #[allow(clippy::needless_borrow)]
    335
    		 
        pub async fn make_operation(
    472
    		 
        #[allow(clippy::let_and_return)]
    473
    		 
        #[allow(clippy::needless_borrow)]
    474
    		 
        pub async fn make_operation(
  • docx-rs 0.4.6/src/documents/elements/delete.rs
    99
    		 
    impl BuildXML for Delete {
    100
    		 
        #[allow(clippy::needless_borrow)]
    101
    		 
        fn build(&self) -> Vec<u8> {
  • docx-rs 0.4.6/src/documents/elements/insert.rs
    142
    		 
    impl BuildXML for Insert {
    143
    		 
        #[allow(clippy::needless_borrow)]
    144
    		 
        fn build(&self) -> Vec<u8> {
  • docx-rs 0.4.6/src/documents/elements/paragraph_property_change.rs
    49
    		 
    impl BuildXML for ParagraphPropertyChange {
    50
    		 
        #[allow(clippy::needless_borrow)]
    51
    		 
        fn build(&self) -> Vec<u8> {
  • dropbox-sdk 0.15.0/examples/demo.rs
    67
    		 
                            // limit read to 1 MiB per loop iteration so we can output progress
    68
    		 
                            #[allow(clippy::needless_borrow)] // 2022-02-09: this lint is wrong
    69
    		 
                            let mut input_chunk = (&mut body).take(1024 * 1024);
  • elrond-wasm 0.38.0/src/types/managed/wrapped/egld_or_esdt_token_identifier.rs
    33
    		 
        /// This special representation is interpreted as the EGLD token.
    34
    		 
        #[allow(clippy::needless_borrow)] // clippy is wrog here, there is no other way
    35
    		 
        pub const EGLD_REPRESENTATION: &'static [u8; 4] = &b"EGLD";
  • flowc 0.91.0/src/lib/dumper/flow_to_dot.rs
    89
    		 
                output_file.set_extension("dot.svg");
    90
    		 
                #[allow(clippy::needless_borrow)]
    91
    		 
                if Command::new(&dot)
  • foca 0.10.0/src/lib.rs
    1321
    		 
            #[cfg(feature = "tracing")]
    1322
    		 
            #[allow(clippy::needless_borrow)]
    1323
    		 
            span.record("len", &data.len());
  • git-igitt 0.1.18/src/widgets/commit_view.rs
    116
    		 
                        let wrapped = if line_idx > 1 {
    117
    		 
                            #[allow(clippy::needless_borrow)]
    118
    		 
                            textwrap::fill(text_line, &wrapping)
  • gitui 0.22.1/src/options.rs
    134
    		 
    	//TODO: fix once FP in clippy is fixed
    135
    		 
    	#[allow(clippy::needless_borrow)]
    136
    		 
    	fn save_failable(&self) -> Result<()> {
  • gql_client 1.0.7/src/error.rs
    89
    		 
    impl fmt::Debug for GraphQLError {
    90
    		 
      #[allow(clippy::needless_borrow)]
    91
    		 
      fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  • graphite_binary 0.1.0/src/slice_serialization/option.rs
    16
    		 
        #[allow(clippy::needless_borrow)] // maybe_deref is needed for some types
    17
    		 
        fn get_write_size(option: &'a Option<T>) -> usize {
    25
    		 
        #[allow(clippy::needless_borrow)] // maybe_deref is needed for some types
    26
    		 
        unsafe fn write<'b>(mut bytes: &'b mut [u8], option: &'a Option<T>) -> &'b mut [u8] {
  • gstreamer 0.19.7/src/lib.rs
    41
    		 
    #[allow(clippy::use_self)]
    42
    		 
    #[allow(clippy::needless_borrow)]
    43
    		 
    #[allow(clippy::let_unit_value)]
  • gstreamer-audio 0.19.4/src/lib.rs
    33
    		 
    #[allow(clippy::use_self)]
    34
    		 
    #[allow(clippy::needless_borrow)]
    35
    		 
    #[allow(unused_imports)]
  • gstreamer-editing-services 0.19.4/src/lib.rs
    63
    		 
    #[allow(clippy::use_self)]
    64
    		 
    #[allow(clippy::needless_borrow)]
    65
    		 
    #[allow(deprecated)]
  • gstreamer-play 0.19.4/src/lib.rs
    29
    		 
    #[allow(clippy::needless_borrow)]
    30
    		 
    #[allow(unused_imports)]
  • gstreamer-player 0.19.4/src/lib.rs
    34
    		 
    #[allow(clippy::use_self)]
    35
    		 
    #[allow(clippy::needless_borrow)]
    36
    		 
    #[allow(unused_imports)]
  • gstreamer-validate 0.19.0/src/lib.rs
    41
    		 
    #[allow(non_snake_case)]
    42
    		 
    #[allow(clippy::needless_borrow)]
    43
    		 
    #[allow(clippy::use_self)]
  • gstreamer-video 0.19.5/src/lib.rs
    33
    		 
    #[allow(clippy::use_self)]
    34
    		 
    #[allow(clippy::needless_borrow)]
    35
    		 
    #[allow(unused_imports)]
  • gstreamer-webrtc 0.19.3/src/lib.rs
    33
    		 
    #[allow(clippy::use_self)]
    34
    		 
    #[allow(clippy::needless_borrow)]
    35
    		 
    #[allow(unused_imports)]
  • ignoreit 2.4.10/src/cache.rs
    148
    		 
            // This is allowed because removing the borrow will create an error
    149
    		 
            #[allow(clippy::needless_borrow)]
    150
    		 
            let path = gitignore.path(&cache_dir);
  • kwap 0.10.0/src/core/mod.rs
    368
    		 
            .find_map(|rep| match rep {
    369
    		 
              #[allow(clippy::needless_borrow)]
    370
    		 
              | mut o @ Some(_) if resp_matches(&o) => Option::take(&mut o).map(|Addrd(resp, _)| resp),
  • lindera-cc-cedict 0.21.0/src/lib.rs
    99
    		 
    pub fn char_def() -> LinderaResult<CharacterDefinitions> {
    100
    		 
        #[allow(clippy::needless_borrow)]
    101
    		 
        CharacterDefinitions::load(&CHAR_DEFINITION_DATA)
    104
    		 
    pub fn connection() -> ConnectionCostMatrix {
    105
    		 
        #[allow(clippy::needless_borrow)]
    106
    		 
        ConnectionCostMatrix::load(&CONNECTION_DATA)
    109
    		 
    pub fn prefix_dict() -> PrefixDict {
    110
    		 
        #[allow(clippy::needless_borrow)]
    111
    		 
        PrefixDict::from_static_slice(&CC_CEDICT_DATA, &CC_CEDICT_VALS)
    114
    		 
    pub fn unknown_dict() -> LinderaResult<UnknownDictionary> {
    115
    		 
        #[allow(clippy::needless_borrow)]
    116
    		 
        UnknownDictionary::load(&UNKNOWN_DATA)
  • lindera-ipadic 0.21.0/src/lib.rs
    99
    		 
    pub fn char_def() -> LinderaResult<CharacterDefinitions> {
    100
    		 
        #[allow(clippy::needless_borrow)]
    101
    		 
        CharacterDefinitions::load(&CHAR_DEFINITION_DATA)
    104
    		 
    pub fn connection() -> ConnectionCostMatrix {
    105
    		 
        #[allow(clippy::needless_borrow)]
    106
    		 
        ConnectionCostMatrix::load(&CONNECTION_DATA)
    109
    		 
    pub fn prefix_dict() -> PrefixDict {
    110
    		 
        #[allow(clippy::needless_borrow)]
    111
    		 
        PrefixDict::from_static_slice(&IPADIC_DATA, &IPADIC_VALS)
    114
    		 
    pub fn unknown_dict() -> LinderaResult<UnknownDictionary> {
    115
    		 
        #[allow(clippy::needless_borrow)]
    116
    		 
        UnknownDictionary::load(&UNKNOWN_DATA)
  • lindera-ko-dic 0.21.0/src/lib.rs
    99
    		 
    pub fn char_def() -> LinderaResult<CharacterDefinitions> {
    100
    		 
        #[allow(clippy::needless_borrow)]
    101
    		 
        CharacterDefinitions::load(&CHAR_DEFINITION_DATA)
    104
    		 
    pub fn connection() -> ConnectionCostMatrix {
    105
    		 
        #[allow(clippy::needless_borrow)]
    106
    		 
        ConnectionCostMatrix::load(&CONNECTION_DATA)
    109
    		 
    pub fn prefix_dict() -> PrefixDict {
    110
    		 
        #[allow(clippy::needless_borrow)]
    111
    		 
        PrefixDict::from_static_slice(&KO_DIC_DATA, &KO_DIC_VALS)
    114
    		 
    pub fn unknown_dict() -> LinderaResult<UnknownDictionary> {
    115
    		 
        #[allow(clippy::needless_borrow)]
    116
    		 
        UnknownDictionary::load(&UNKNOWN_DATA)
  • lindera-unidic 0.21.0/src/lib.rs
    99
    		 
    pub fn char_def() -> LinderaResult<CharacterDefinitions> {
    100
    		 
        #[allow(clippy::needless_borrow)]
    101
    		 
        CharacterDefinitions::load(&CHAR_DEFINITION_DATA)
    104
    		 
    pub fn connection() -> ConnectionCostMatrix {
    105
    		 
        #[allow(clippy::needless_borrow)]
    106
    		 
        ConnectionCostMatrix::load(&CONNECTION_DATA)
    109
    		 
    pub fn prefix_dict() -> PrefixDict {
    110
    		 
        #[allow(clippy::needless_borrow)]
    111
    		 
        PrefixDict::from_static_slice(&UNIDIC_DATA, &UNIDIC_VALS)
    114
    		 
    pub fn unknown_dict() -> LinderaResult<UnknownDictionary> {
    115
    		 
        #[allow(clippy::needless_borrow)]
    116
    		 
        UnknownDictionary::load(&UNKNOWN_DATA)
  • malachite-nz 0.3.2/src/bin_util/demo_and_bench/integer/logic/index_of_next_false_bit.rs
    68
    		 
    #[allow(clippy::needless_borrow)]
    69
    		 
    fn benchmark_integer_index_of_next_false_bit_algorithms(
  • matrix-sdk-crypto 0.6.0/src/verification/requests.rs
    1264
    		 
            #[allow(clippy::needless_borrow)]
    1265
    		 
            let alice_request = VerificationRequest::from_request(
    1307
    		 
            #[allow(clippy::needless_borrow)]
    1308
    		 
            let alice_request = VerificationRequest::from_request(
  • mgm 0.5.0-pre.1/src/encdec.rs
    174
    		 
        } else {
    175
    		 
            #[allow(clippy::needless_borrow)]
    176
    		 
            &buffer
  • multiversx-sc 0.39.4/src/types/managed/wrapped/egld_or_esdt_token_identifier.rs
    33
    		 
        /// This special representation is interpreted as the EGLD token.
    34
    		 
        #[allow(clippy::needless_borrow)] // clippy is wrog here, there is no other way
    35
    		 
        pub const EGLD_REPRESENTATION: &'static [u8; 4] = &b"EGLD";
  • nativeshell_build 0.1.16/src/artifacts_emitter.rs
    144
    		 
                // false positives :-/
    145
    		 
                #[allow(clippy::needless_borrow)]
    146
    		 
                copy_to(&src, &artifacts_out_dir, true)?;
    147
    		 
                #[allow(clippy::needless_borrow)]
    148
    		 
                copy_to(&src, &deps_out_dir, true)?;
  • nativeshell_build 0.1.16/src/plugins_linux.rs
    79
    		 
                    if let Some(name) = name.strip_suffix(".so") {
    80
    		 
                        #[allow(clippy::needless_borrow)] // false positive
    81
    		 
                        copy_to(entry.path(), &artifacts_dir, true)?;
  • nativeshell_build 0.1.16/src/plugins_windows.rs
    97
    		 
                        // false positive :-/
    98
    		 
                        #[allow(clippy::needless_borrow)]
    99
    		 
                        copy_to(entry.path(), &artifacts_dir, true)?;
  • nix 0.26.2/test/test_unistd.rs
    1176
    		 
    //Clippy false positive https://github.com/rust-lang/rust-clippy/issues/9111
    1177
    		 
    #[allow(clippy::needless_borrow)]
    1178
    		 
    #[cfg(not(target_os = "redox"))]
  • ntex-bytes 0.1.19/src/buf/buf_mut.rs
    977
    		 
        #[test]
    978
    		 
        #[allow(clippy::needless_borrow)]
    979
    		 
        fn buf_mut_tests() {
  • ntex-bytes 0.1.19/tests/test_bytes.rs
    450
    		 
        clippy::iter_cloned_collect,
    451
    		 
        clippy::needless_borrow
    452
    		 
    )]
    505
    		 
        clippy::redundant_slicing,
    506
    		 
        clippy::needless_borrow
    507
    		 
    )]
  • objc2 0.3.0-beta.4/src/message/mod.rs
    583
    		 
                let _: () = msg_send![&mut *obj, mutable2];
    584
    		 
                #[allow(clippy::needless_borrow)]
    585
    		 
                let obj: NonNull<Object> = (&mut *obj).into();
  • ordered-float 3.4.0/tests/test.rs
    666
    		 
            let mut num_ref = panic::AssertUnwindSafe(&mut num);
    667
    		 
            #[allow(clippy::needless_borrow)] // mut-borrow needed for msrv 1.36.0
    668
    		 
            let _ = panic::catch_unwind(move || op(&mut num_ref));
  • peace_rt 0.0.6/src/cmds/clean_cmd.rs
    104
    		 
            // https://github.com/rust-lang/rust-clippy/issues/9111
    105
    		 
            #[allow(clippy::needless_borrow)]
    106
    		 
            let states_current =
    177
    		 
            // https://github.com/rust-lang/rust-clippy/issues/9111
    178
    		 
            #[allow(clippy::needless_borrow)]
    179
    		 
            let resources_result = Self::exec_internal(item_spec_graph, resources).await;
    217
    		 
            // https://github.com/rust-lang/rust-clippy/issues/9111
    218
    		 
            #[allow(clippy::needless_borrow)]
    219
    		 
            let states =
  • peace_rt 0.0.6/src/cmds/ensure_cmd.rs
    162
    		 
            // https://github.com/rust-lang/rust-clippy/issues/9111
    163
    		 
            #[allow(clippy::needless_borrow)]
    164
    		 
            let resources_result = Self::exec_internal::<Ensured, states::ts::Ensured>(
  • procspawn 0.10.2/src/proc.rs
    248
    		 
                    unsafe {
    249
    		 
                        #[allow(clippy::needless_borrow)]
    250
    		 
                        child.pre_exec(move || (&mut *func.lock().unwrap())());
  • redis-async 0.14.2/src/resp.rs
    724
    		 
            let vals = vec![String::from("a"), String::from("b")];
    725
    		 
            #[allow(clippy::needless_borrow)]
    726
    		 
            let resp_object = resp_array!["RPUSH", "xyz"].append(&vals);
  • rivet-chat 0.0.7/src/input.rs
    42
    		 
    	#[allow(clippy::let_and_return)]
    43
    		 
    	#[allow(clippy::needless_borrow)]
    44
    		 
    	pub async fn make_operation(
    200
    		 
    	#[allow(clippy::let_and_return)]
    201
    		 
    	#[allow(clippy::needless_borrow)]
    202
    		 
    	pub async fn make_operation(
    348
    		 
    	#[allow(clippy::let_and_return)]
    349
    		 
    	#[allow(clippy::needless_borrow)]
    350
    		 
    	pub async fn make_operation(
    481
    		 
    	#[allow(clippy::let_and_return)]
    482
    		 
    	#[allow(clippy::needless_borrow)]
    483
    		 
    	pub async fn make_operation(
    610
    		 
    	#[allow(clippy::let_and_return)]
    611
    		 
    	#[allow(clippy::needless_borrow)]
    612
    		 
    	pub async fn make_operation(
  • rivet-client-api-chat 0.0.1/src/input.rs
    42
    		 
    	#[allow(clippy::let_and_return)]
    43
    		 
    	#[allow(clippy::needless_borrow)]
    44
    		 
    	pub async fn make_operation(
    200
    		 
    	#[allow(clippy::let_and_return)]
    201
    		 
    	#[allow(clippy::needless_borrow)]
    202
    		 
    	pub async fn make_operation(
    345
    		 
    	#[allow(clippy::let_and_return)]
    346
    		 
    	#[allow(clippy::needless_borrow)]
    347
    		 
    	pub async fn make_operation(
    478
    		 
    	#[allow(clippy::let_and_return)]
    479
    		 
    	#[allow(clippy::needless_borrow)]
    480
    		 
    	pub async fn make_operation(
    604
    		 
    	#[allow(clippy::let_and_return)]
    605
    		 
    	#[allow(clippy::needless_borrow)]
    606
    		 
    	pub async fn make_operation(
  • rivet-group 0.0.7/src/input.rs
    55
    		 
    	#[allow(clippy::let_and_return)]
    56
    		 
    	#[allow(clippy::needless_borrow)]
    57
    		 
    	pub async fn make_operation(
    192
    		 
    	#[allow(clippy::let_and_return)]
    193
    		 
    	#[allow(clippy::needless_borrow)]
    194
    		 
    	pub async fn make_operation(
    311
    		 
    	#[allow(clippy::let_and_return)]
    312
    		 
    	#[allow(clippy::needless_borrow)]
    313
    		 
    	pub async fn make_operation(
    449
    		 
    	#[allow(clippy::let_and_return)]
    450
    		 
    	#[allow(clippy::needless_borrow)]
    451
    		 
    	pub async fn make_operation(
    578
    		 
    	#[allow(clippy::let_and_return)]
    579
    		 
    	#[allow(clippy::needless_borrow)]
    580
    		 
    	pub async fn make_operation(
  • rivet-identity 0.0.14/src/input.rs
    45
    		 
    	#[allow(clippy::let_and_return)]
    46
    		 
    	#[allow(clippy::needless_borrow)]
    47
    		 
    	pub async fn make_operation(
    162
    		 
    	#[allow(clippy::let_and_return)]
    163
    		 
    	#[allow(clippy::needless_borrow)]
    164
    		 
    	pub async fn make_operation(
    277
    		 
    	#[allow(clippy::let_and_return)]
    278
    		 
    	#[allow(clippy::needless_borrow)]
    279
    		 
    	pub async fn make_operation(
    396
    		 
    	#[allow(clippy::let_and_return)]
    397
    		 
    	#[allow(clippy::needless_borrow)]
    398
    		 
    	pub async fn make_operation(
    530
    		 
    	#[allow(clippy::let_and_return)]
    531
    		 
    	#[allow(clippy::needless_borrow)]
    532
    		 
    	pub async fn make_operation(
  • rivet-kv 0.0.8/src/input.rs
    52
    		 
    	#[allow(clippy::let_and_return)]
    53
    		 
    	#[allow(clippy::needless_borrow)]
    54
    		 
    	pub async fn make_operation(
    188
    		 
    	#[allow(clippy::let_and_return)]
    189
    		 
    	#[allow(clippy::needless_borrow)]
    190
    		 
    	pub async fn make_operation(
    328
    		 
    	#[allow(clippy::let_and_return)]
    329
    		 
    	#[allow(clippy::needless_borrow)]
    330
    		 
    	pub async fn make_operation(
    476
    		 
    	#[allow(clippy::let_and_return)]
    477
    		 
    	#[allow(clippy::needless_borrow)]
    478
    		 
    	pub async fn make_operation(
    620
    		 
    	#[allow(clippy::let_and_return)]
    621
    		 
    	#[allow(clippy::needless_borrow)]
    622
    		 
    	pub async fn make_operation(
  • rivet-matchmaker 0.0.8/src/input.rs
    109
    		 
    	#[allow(clippy::let_and_return)]
    110
    		 
    	#[allow(clippy::needless_borrow)]
    111
    		 
    	pub async fn make_operation(
    235
    		 
    	#[allow(clippy::let_and_return)]
    236
    		 
    	#[allow(clippy::needless_borrow)]
    237
    		 
    	pub async fn make_operation(
    333
    		 
    	#[allow(clippy::let_and_return)]
    334
    		 
    	#[allow(clippy::needless_borrow)]
    335
    		 
    	pub async fn make_operation(
    419
    		 
    	#[allow(clippy::let_and_return)]
    420
    		 
    	#[allow(clippy::needless_borrow)]
    421
    		 
    	pub async fn make_operation(
    505
    		 
    	#[allow(clippy::let_and_return)]
    506
    		 
    	#[allow(clippy::needless_borrow)]
    507
    		 
    	pub async fn make_operation(
  • rivet-party 0.0.7/src/input.rs
    96
    		 
    	#[allow(clippy::let_and_return)]
    97
    		 
    	#[allow(clippy::needless_borrow)]
    98
    		 
    	pub async fn make_operation(
    208
    		 
    	#[allow(clippy::let_and_return)]
    209
    		 
    	#[allow(clippy::needless_borrow)]
    210
    		 
    	pub async fn make_operation(
    334
    		 
    	#[allow(clippy::let_and_return)]
    335
    		 
    	#[allow(clippy::needless_borrow)]
    336
    		 
    	pub async fn make_operation(
    460
    		 
    	#[allow(clippy::let_and_return)]
    461
    		 
    	#[allow(clippy::needless_borrow)]
    462
    		 
    	pub async fn make_operation(
    586
    		 
    	#[allow(clippy::let_and_return)]
    587
    		 
    	#[allow(clippy::needless_borrow)]
    588
    		 
    	pub async fn make_operation(
  • scylla-cql 0.0.3/src/frame/value_tests.rs
    649
    		 
    #[test]
    650
    		 
    #[allow(clippy::needless_borrow)]
    651
    		 
    fn ref_batch_values() {
    664
    		 
    #[test]
    665
    		 
    #[allow(clippy::needless_borrow)]
    666
    		 
    fn check_ref_tuple() {
  • sea-orm 0.10.7/src/schema/entity.rs
    65
    		 
    #[allow(clippy::needless_borrow)]
    66
    		 
    pub(crate) fn create_enum_from_entity<E>(_: E, backend: DbBackend) -> Vec<TypeCreateStatement>
  • secp256k1 0.26.0/src/key.rs
    1031
    		 
            #[allow(clippy::needless_borrow)]
    1032
    		 
            KeyPair::from_seckey_str(&ctx, s)
    1075
    		 
                    #[allow(clippy::needless_borrow)]
    1076
    		 
                    KeyPair::from_seckey_slice(&ctx, data)
  • skia-safe 0.58.0/src/effects/image_filters.rs
    919
    		 
            assert_eq!(cr(CropRect::NO_CROP_RECT), CropRect::NO_CROP_RECT);
    920
    		 
            #[allow(clippy::needless_borrow)]
    921
    		 
            let cr_ref = cr(&CropRect::NO_CROP_RECT);
    929
    		 
            assert_eq!(cr(irect), CropRect(Rect::from(irect)));
    930
    		 
            #[allow(clippy::needless_borrow)]
    931
    		 
            let cr_by_ref = cr(&irect);
    939
    		 
            assert_eq!(cr(rect), CropRect(rect));
    940
    		 
            #[allow(clippy::needless_borrow)]
    941
    		 
            let cr_by_ref = cr(&rect);
  • snarkvm-algorithms 0.9.11/src/fft/polynomial/dense.rs
    554
    		 
        #[test]
    555
    		 
        #[allow(clippy::needless_borrow)]
    556
    		 
        fn divide_polynomials_random() {
  • snarkvm-circuit-algorithms 0.9.11/src/poseidon/hash_many.rs
    42
    		 
    #[allow(clippy::needless_borrow)]
    43
    		 
    impl<E: Environment, const RATE: usize> Poseidon<E, RATE> {
  • snarkvm-circuit-types-field 0.9.11/src/pow.rs
    37
    		 
    #[allow(clippy::needless_borrow)]
    38
    		 
    impl<E: Environment> Pow<&Field<E>> for Field<E> {
  • snarkvm-circuit-types-integers 0.9.11/src/and.rs
    122
    		 
        #[allow(clippy::needless_borrow)]
    123
    		 
        fn check_and<I: IntegerType + BitAnd<Output = I>>(
  • snarkvm-circuit-types-integers 0.9.11/src/or.rs
    120
    		 
        #[allow(clippy::needless_borrow)]
    121
    		 
        fn check_or<I: IntegerType + BitOr<Output = I>>(
  • snarkvm-circuit-types-integers 0.9.11/src/xor.rs
    114
    		 
        #[allow(clippy::needless_borrow)]
    115
    		 
        fn check_bitxor<I: IntegerType + BitXor<Output = I>>(
  • spdlog-rs 0.3.7/src/formatter/pattern_formatter/mod.rs
    1251
    		 
        fn test_pattern_ref_as_pattern() {
    1252
    		 
            #[allow(clippy::needless_borrow)]
    1253
    		 
            test_pattern(&String::from("literal"), "literal", None);
    1257
    		 
        fn test_pattern_mut_as_pattern() {
    1258
    		 
            #[allow(clippy::needless_borrow)]
    1259
    		 
            test_pattern(&mut String::from("literal"), "literal", None);
  • stateroom-wasm-macro 0.2.6/src/lib.rs
    168
    		 
    pub fn stateroom_wasm(_attr: TokenStream, item: TokenStream) -> TokenStream {
    169
    		 
        #[allow(clippy::needless_borrow)]
    170
    		 
        stateroom_wasm_impl(&item.into()).into()
  • substrait 0.4.0/src/lib.rs
    154
    		 
    #[allow(clippy::needless_borrow, clippy::large_enum_variant)]
    155
    		 
    pub mod proto;
  • tract-core 0.19.2/src/model/fact.rs
    376
    		 
    impl<T: Datum> DatumExt for T {
    377
    		 
        #[allow(clippy::needless_borrow)]
    378
    		 
        fn scalar_fact() -> TypedFact {
    397
    		 
    impl DatumTypeExt for DatumType {
    398
    		 
        #[allow(clippy::needless_borrow)]
    399
    		 
        fn scalar_fact(&self) -> TypedFact {
  • trillium-http 0.2.8/src/conn.rs
    391
    		 
        #[allow(clippy::needless_borrow)]
    392
    		 
        fn build_request_body(&mut self) -> ReceivedBody<'_, Transport> {
  • trustfall_core 0.1.1/src/schema/mod.rs
    352
    		 
                                let param_type = &param_defn.node.ty.node;
    353
    		 
                                #[allow(clippy::needless_borrow)]
    354
    		 
                                match (&value.node).try_into() {
  • vodozemac 0.3.0/src/megolm/group_session.rs
    181
    		 
                    // this on nightly.
    182
    		 
                    #[allow(clippy::needless_borrow)]
    183
    		 
                    let ratchet = (&pickle.ratchet).into();
  • vodozemac 0.3.0/src/megolm/inbound_group_session.rs
    351
    		 
                    // this on nightly.
    352
    		 
                    #[allow(clippy::needless_borrow)]
    353
    		 
                    let initial_ratchet = (&pickle.initial_ratchet).into();
    354
    		 
                    #[allow(clippy::needless_borrow)]
    355
    		 
                    let latest_ratchet = (&pickle.latest_ratchet).into();
  • wundergraph_cli 0.1.1/src/print_schema/print_helper.rs
    338
    		 
    #[derive(Debug, Clone)]
    339
    		 
    #[allow(clippy::needless_borrow)]
    340
    		 
    struct GraphqlType<'a> {
  • ap-relay 0.3.81/src/main.rs
    1
    		 
    // need this for ructe
    2
    		 
    #![allow(clippy::needless_borrow)]
  • async-graphql 5.0.5/src/lib.rs
    171
    		 
    #![allow(clippy::missing_const_for_fn)]
    172
    		 
    #![allow(clippy::needless_borrow)]
    173
    		 
    #![allow(clippy::future_not_send)]
  • bluez-generated 0.3.0/src/lib.rs
    1
    		 
    // Generated by introspect.sh
    2
    		 
    #![allow(clippy::upper_case_acronyms, clippy::needless_borrow)]
    3
    		 
    pub mod adapter1;
  • break-time 0.1.2/src/lib.rs
    4
    		 
    #![allow(
    5
    		 
        clippy::needless_borrow,
    6
    		 
        clippy::expect_fun_call,
  • cargo-careful 0.3.0/src/main.rs
    1
    		 
    #![allow(clippy::needless_borrow)]
  • cargo-expand 1.0.40/src/main.rs
    7
    		 
        clippy::match_like_matches_macro,
    8
    		 
        clippy::needless_borrow, // https://github.com/rust-lang/rust-clippy/issues/9710
    9
    		 
        clippy::needless_pass_by_value,
  • commit_verify 0.9.0/src/tagged_hash.rs
    17
    		 
    #![allow(clippy::needless_borrow)] // Due to amplify_derive::Display bug
  • copse 0.4.0/src/liballoc.rs
    3
    		 
        clippy::drop_non_drop,
    4
    		 
        clippy::needless_borrow,
    5
    		 
        clippy::toplevel_ref_arg,
  • cretonne-codegen 0.13.2/src/lib.rs
    16
    		 
                    identity_op,
    17
    		 
                    needless_borrow,
    18
    		 
                    cast_lossless,
  • dbs-fuse 0.2.0/src/tokio_uring/mod.rs
    59
    		 
    #![warn(missing_docs)]
    60
    		 
    #![allow(clippy::needless_borrow)]
    61
    		 
    #![allow(clippy::assign_op_pattern)]
  • empress 1.6.0/src/server/mpris.rs
    1
    		 
    #![allow(clippy::needless_borrow)] // Clippy bug
  • fltk-sys 1.3.28/build/main.rs
    1
    		 
    #![allow(clippy::needless_borrow)]
    2
    		 
    use std::{env, path::PathBuf};
  • gull 6.0.1/src/lib.rs
    1
    		 
    #![allow(clippy::new_without_default)]
    2
    		 
    #![allow(clippy::needless_borrow)]
  • internet2 0.9.0-rc.1/src/lib.rs
    21
    		 
    #![allow(unused_variables, dead_code)]
    22
    		 
    #![allow(clippy::needless_borrow)] // Caused by a bug in amplify_derive::Display
    23
    		 
                                       // TODO: when we will be ready for the release #![deny(missing_docs, dead_code)]
  • io-extras 0.17.1/src/os/windows/stdio.rs
    13
    		 
        clippy::unwrap_used,
    14
    		 
        clippy::needless_borrow,
    15
    		 
        clippy::let_underscore_drop,
  • lngcnv 1.8.3/src/lang.rs
    7
    		 
    #![warn(clippy::nursery, clippy::pedantic)]
    8
    		 
    #![allow(clippy::needless_borrow)] // &original_text must be borrowed in fn list()
    9
    		 
    #![allow(clippy::cognitive_complexity, clippy::missing_panics_doc, clippy::too_many_lines)]
  • lnp_node 0.9.0-rc.1/src/config.rs
    14
    		 
    #![allow(clippy::needless_borrow)] // due to a bug in `display(Debug)`
  • lofty 0.11.0/src/lib.rs
    113
    		 
    // TODO: This had multiple FPs right now, remove this when it is fixed
    114
    		 
    #![allow(clippy::needless_borrow)]
    115
    		 
    #![allow(
  • pict-rs-aggregator 0.2.0-beta.2/src/lib.rs
    1
    		 
    // need this for ructe
    2
    		 
    #![allow(clippy::needless_borrow)]
  • pict-rs-proxy 0.4.0-beta.1/src/main.rs
    1
    		 
    // need this for ructe
    2
    		 
    #![allow(clippy::needless_borrow)]
  • ratmom 0.1.0/src/lib.rs
    242
    		 
        clippy::match_like_matches_macro,
    243
    		 
        clippy::needless_borrow
    244
    		 
    )]
  • ruma-common 0.10.5/src/events/room.rs
    5
    		 
    // https://github.com/rust-lang/rust-clippy/issues/9111
    6
    		 
    #![allow(clippy::needless_borrow)]
  • rustc-build-sysroot 0.4.1/src/lib.rs
    1
    		 
    //! Offers an easy way to build a rustc sysroot from source.
    2
    		 
    #![allow(clippy::needless_borrow)]
  • snarkvm-algorithms 0.9.11/src/polycommit/kzg10/mod.rs
    494
    		 
        #![allow(non_camel_case_types)]
    495
    		 
        #![allow(clippy::needless_borrow)]
    496
    		 
        use super::*;
  • twitch_types 0.4.0/src/lib.rs
    151
    		 
    mod tests {
    152
    		 
        #![allow(clippy::needless_borrow)]
    153
    		 
        use super::*;
  • ux-dx 0.2.1/src/lib.rs
    33
    		 
        clippy::assign_op_pattern,
    34
    		 
        clippy::needless_borrow,
    35
    		 
        clippy::too_many_arguments,
  • x11rb 0.11.1/src/protocol/mod.rs
    11
    		 
    // This is not easy to fix, so ignore it.
    12
    		 
    #![allow(clippy::needless_borrow, clippy::needless_lifetimes)]
    13
    		 
    pub mod xproto;
  • x11rb-protocol 0.11.1/src/protocol/mod.rs
    11
    		 
    // This is not easy to fix, so ignore it.
    12
    		 
    #![allow(clippy::needless_borrow, clippy::needless_lifetimes)]
  • xlang_abi 0.2.0/src/lib.rs
    3
    		 
        clippy::module_name_repetitions,
    4
    		 
        clippy::needless_borrow,
    5
    		 
        clippy::missing_const_for_fn,