Client Test

Client Test

rev. 57db00dec64b2b5e2454f03fa228762c514e092d (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-client-test/Cargo.lock

@@ -296,296 +748,748 @@
  316    316   
dependencies = [
  317    317   
 "futures-util",
  318    318   
 "pin-project-lite",
  319    319   
 "pin-utils",
  320    320   
 "tokio",
  321    321   
 "tokio-test",
  322    322   
]
  323    323   
  324    324   
[[package]]
  325    325   
name = "aws-smithy-cbor"
  326         -
version = "0.61.0"
         326  +
version = "0.61.1"
  327    327   
dependencies = [
  328    328   
 "aws-smithy-types",
  329    329   
 "criterion",
  330    330   
 "minicbor",
  331    331   
]
  332    332   
  333    333   
[[package]]
  334    334   
name = "aws-smithy-checksums"
  335    335   
version = "0.63.3"
  336    336   
dependencies = [
  337    337   
 "aws-smithy-http",
  338    338   
 "aws-smithy-types",
  339    339   
 "bytes",
  340    340   
 "bytes-utils",
  341    341   
 "crc-fast",
  342    342   
 "hex",
  343    343   
 "http 0.2.12",
  344    344   
 "http-body 0.4.6",
  345    345   
 "md-5",
  346    346   
 "pin-project-lite",
  347    347   
 "pretty_assertions",
  348    348   
 "sha1",
  349    349   
 "sha2",
  350    350   
 "tokio",
  351    351   
 "tracing",
  352    352   
 "tracing-test",
  353    353   
]
  354    354   
  355    355   
[[package]]
  356    356   
name = "aws-smithy-client"
  357    357   
version = "0.60.3"
  358    358   
  359    359   
[[package]]
  360    360   
name = "aws-smithy-compression"
  361         -
version = "0.0.3"
         361  +
version = "0.0.4"
  362    362   
dependencies = [
  363    363   
 "aws-smithy-runtime-api",
  364    364   
 "aws-smithy-types",
  365    365   
 "bytes",
  366    366   
 "bytes-utils",
  367    367   
 "flate2",
  368    368   
 "futures-util",
  369    369   
 "http 0.2.12",
  370    370   
 "http 1.3.1",
  371    371   
 "http-body 0.4.6",
  372    372   
 "http-body 1.0.1",
  373    373   
 "http-body-util",
  374    374   
 "pin-project-lite",
  375    375   
 "pretty_assertions",
  376    376   
 "tokio",
  377    377   
 "tracing",
  378    378   
]
  379    379   
  380    380   
[[package]]
  381    381   
name = "aws-smithy-eventstream"
  382         -
version = "0.60.8"
         382  +
version = "0.60.9"
  383    383   
dependencies = [
  384    384   
 "arbitrary",
  385    385   
 "aws-smithy-types",
  386    386   
 "bytes",
  387    387   
 "bytes-utils",
  388    388   
 "crc32fast",
  389    389   
 "derive_arbitrary",
  390    390   
]
  391    391   
  392    392   
[[package]]
  393    393   
name = "aws-smithy-experimental"
  394    394   
version = "0.2.0"
  395    395   
  396    396   
[[package]]
  397    397   
name = "aws-smithy-http"
  398    398   
version = "0.62.1"
  399    399   
dependencies = [
  400    400   
 "async-stream",
  401    401   
 "aws-smithy-eventstream",
  402    402   
 "aws-smithy-runtime-api",
  403    403   
 "aws-smithy-types",
  404    404   
 "bytes",
  405    405   
 "bytes-utils",
  406    406   
 "futures-core",
  407    407   
 "futures-util",
  408    408   
 "http 0.2.12",
  409    409   
 "http 1.3.1",
  410    410   
 "http-body 0.4.6",
  411    411   
 "hyper 0.14.32",
  412    412   
 "percent-encoding",
  413    413   
 "pin-project-lite",
  414    414   
 "pin-utils",
  415    415   
 "proptest",
  416    416   
 "tokio",
  417    417   
 "tracing",
  418    418   
]
  419    419   
  420    420   
[[package]]
  421    421   
name = "aws-smithy-http-auth"
  422    422   
version = "0.60.3"
  423    423   
  424    424   
[[package]]
  425    425   
name = "aws-smithy-http-client"
  426         -
version = "1.0.3"
         426  +
version = "1.0.5"
  427    427   
dependencies = [
  428    428   
 "aws-smithy-async",
  429    429   
 "aws-smithy-protocol-test",
  430    430   
 "aws-smithy-runtime-api",
  431    431   
 "aws-smithy-types",
  432    432   
 "bytes",
  433    433   
 "h2 0.3.26",
  434    434   
 "h2 0.4.10",
  435    435   
 "http 0.2.12",
  436    436   
 "http 1.3.1",
  437    437   
 "http-body 0.4.6",
  438    438   
 "http-body 1.0.1",
  439    439   
 "http-body-util",
  440    440   
 "hyper 0.14.32",
  441    441   
 "hyper 1.6.0",
  442    442   
 "hyper-rustls 0.24.2",
  443    443   
 "hyper-rustls 0.27.6",
  444    444   
 "hyper-util",
  445    445   
 "indexmap 2.9.0",
  446    446   
 "pin-project-lite",
  447    447   
 "rustls 0.21.12",
  448    448   
 "rustls 0.23.27",
  449    449   
 "rustls-native-certs 0.8.1",
  450    450   
 "rustls-pemfile 2.2.0",
  451    451   
 "rustls-pki-types",
  452    452   
 "s2n-tls",
  453    453   
 "s2n-tls-hyper",
  454    454   
 "serde",
  455    455   
 "serde_json",
  456    456   
 "tokio",
  457    457   
 "tokio-rustls 0.26.2",
  458    458   
 "tower 0.5.2",
  459    459   
 "tracing",
  460    460   
]
  461    461   
  462    462   
[[package]]
  463    463   
name = "aws-smithy-http-server"
  464         -
version = "0.65.3"
         464  +
version = "0.65.5"
  465    465   
dependencies = [
  466    466   
 "aws-smithy-cbor",
  467    467   
 "aws-smithy-http",
  468    468   
 "aws-smithy-json",
  469    469   
 "aws-smithy-runtime-api",
  470    470   
 "aws-smithy-types",
  471    471   
 "aws-smithy-xml",
  472    472   
 "bytes",
  473    473   
 "futures-util",
  474    474   
 "http 0.2.12",
  475    475   
 "http-body 0.4.6",
  476    476   
 "hyper 0.14.32",
  477    477   
 "lambda_http",
  478    478   
 "mime",
  479    479   
 "nom",
  480    480   
 "pin-project-lite",
  481    481   
 "pretty_assertions",
  482    482   
 "regex",
  483    483   
 "serde_urlencoded",
  484    484   
 "thiserror 2.0.12",
  485    485   
 "tokio",
  486    486   
 "tower 0.4.13",
  487    487   
 "tower-http",
  488    488   
 "tracing",
  489    489   
 "uuid",
  490    490   
]
  491    491   
  492    492   
[[package]]
  493    493   
name = "aws-smithy-http-server-python"
  494         -
version = "0.65.1"
         494  +
version = "0.66.1"
  495    495   
dependencies = [
  496    496   
 "aws-smithy-http",
  497    497   
 "aws-smithy-http-server",
  498    498   
 "aws-smithy-json",
  499    499   
 "aws-smithy-types",
  500    500   
 "aws-smithy-xml",
  501    501   
 "bytes",
  502    502   
 "futures",
  503    503   
 "futures-util",
  504    504   
 "http 0.2.12",
  505    505   
 "hyper 0.14.32",
  506    506   
 "hyper-rustls 0.24.2",
  507    507   
 "lambda_http",
  508    508   
 "num_cpus",
  509    509   
 "parking_lot",
  510    510   
 "pin-project-lite",
  511    511   
 "pretty_assertions",
  512    512   
 "pyo3",
  513    513   
 "pyo3-asyncio",
  514    514   
 "rcgen",
  515    515   
 "rustls-pemfile 1.0.4",
  516    516   
 "signal-hook",
  517    517   
 "socket2",
  518    518   
 "thiserror 2.0.12",
  519    519   
 "tls-listener",
  520    520   
 "tokio",
  521    521   
 "tokio-rustls 0.24.1",
  522    522   
 "tokio-stream",
  523    523   
 "tokio-test",
  524    524   
 "tower 0.4.13",
  525    525   
 "tower-test",
  526    526   
 "tracing",
  527    527   
 "tracing-appender",
  528    528   
 "tracing-subscriber",
  529    529   
]
  530    530   
  531    531   
[[package]]
  532    532   
name = "aws-smithy-http-tower"
  533    533   
version = "0.60.3"
  534    534   
  535    535   
[[package]]
  536    536   
name = "aws-smithy-json"
  537         -
version = "0.61.3"
         537  +
version = "0.61.4"
  538    538   
dependencies = [
  539    539   
 "aws-smithy-types",
  540    540   
 "proptest",
  541    541   
 "serde_json",
  542    542   
]
  543    543   
  544    544   
[[package]]
  545    545   
name = "aws-smithy-mocks"
  546    546   
version = "0.1.1"
  547    547   
dependencies = [
  548    548   
 "aws-smithy-async",
  549    549   
 "aws-smithy-http-client",
  550    550   
 "aws-smithy-runtime",
  551    551   
 "aws-smithy-runtime-api",
  552    552   
 "aws-smithy-types",
  553    553   
 "http 1.3.1",
  554    554   
 "tokio",
  555    555   
]
  556    556   
  557    557   
[[package]]
  558    558   
name = "aws-smithy-mocks-experimental"
  559    559   
version = "0.2.4"
  560    560   
dependencies = [
  561    561   
 "aws-smithy-runtime-api",
  562    562   
 "aws-smithy-types",
  563    563   
 "tokio",
  564    564   
]
  565    565   
  566    566   
[[package]]
  567    567   
name = "aws-smithy-observability"
  568    568   
version = "0.1.3"
  569    569   
dependencies = [
  570    570   
 "aws-smithy-runtime-api",
  571    571   
 "serial_test",
  572    572   
]
  573    573   
  574    574   
[[package]]
  575    575   
name = "aws-smithy-observability-otel"
  576         -
version = "0.1.0"
         576  +
version = "0.1.1"
  577    577   
dependencies = [
  578    578   
 "async-global-executor",
  579    579   
 "async-task",
  580    580   
 "aws-smithy-observability",
  581    581   
 "criterion",
  582    582   
 "opentelemetry",
  583    583   
 "opentelemetry_sdk",
  584    584   
 "stats_alloc",
  585    585   
 "tokio",
  586    586   
 "value-bag",
  587    587   
]
  588    588   
  589    589   
[[package]]
  590    590   
name = "aws-smithy-protocol-test"
  591         -
version = "0.63.2"
         591  +
version = "0.63.4"
  592    592   
dependencies = [
  593    593   
 "assert-json-diff",
  594    594   
 "aws-smithy-runtime-api",
  595    595   
 "base64-simd",
  596    596   
 "cbor-diag",
  597    597   
 "ciborium",
  598    598   
 "http 0.2.12",
  599    599   
 "pretty_assertions",
  600    600   
 "regex-lite",
  601    601   
 "roxmltree",
  602    602   
 "serde_json",
  603    603   
 "thiserror 2.0.12",
  604    604   
]
  605    605   
  606    606   
[[package]]
  607    607   
name = "aws-smithy-query"
  608    608   
version = "0.60.7"
  609    609   
dependencies = [
  610    610   
 "aws-smithy-types",
  611    611   
 "urlencoding",
  612    612   
]
  613    613   
  614    614   
[[package]]
  615    615   
name = "aws-smithy-runtime"
  616    616   
version = "1.8.3"
  617    617   
dependencies = [
  618    618   
 "approx",
  619    619   
 "aws-smithy-async",
  620    620   
 "aws-smithy-http",
  621    621   
 "aws-smithy-http-client",
  622    622   
 "aws-smithy-observability",
  623    623   
 "aws-smithy-runtime-api",
  624    624   
 "aws-smithy-types",
  625    625   
 "bytes",
  626    626   
 "fastrand",
  627    627   
 "futures-util",
  628    628   
 "http 0.2.12",
  629    629   
 "http 1.3.1",
  630    630   
 "http-body 0.4.6",
  631    631   
 "http-body 1.0.1",
  632    632   
 "hyper 0.14.32",
  633    633   
 "pin-project-lite",
  634    634   
 "pin-utils",
  635    635   
 "pretty_assertions",
  636    636   
 "tokio",
  637    637   
 "tracing",
  638    638   
 "tracing-subscriber",
  639    639   
 "tracing-test",
  640    640   
]
  641    641   
  642    642   
[[package]]
  643    643   
name = "aws-smithy-runtime-api"
  644         -
version = "1.8.0"
         644  +
version = "1.8.1"
  645    645   
dependencies = [
  646    646   
 "aws-smithy-async",
  647    647   
 "aws-smithy-types",
  648    648   
 "bytes",
  649    649   
 "http 0.2.12",
  650    650   
 "http 1.3.1",
  651    651   
 "pin-project-lite",
  652    652   
 "proptest",
  653    653   
 "tokio",
  654    654   
 "tracing",
  655    655   
 "zeroize",
  656    656   
]
  657    657   
  658    658   
[[package]]
  659    659   
name = "aws-smithy-types"
  660         -
version = "1.3.1"
         660  +
version = "1.3.2"
  661    661   
dependencies = [
  662    662   
 "base64 0.13.1",
  663    663   
 "base64-simd",
  664    664   
 "bytes",
  665    665   
 "bytes-utils",
  666    666   
 "ciborium",
  667    667   
 "criterion",
  668    668   
 "futures-core",
  669    669   
 "http 0.2.12",
  670    670   
 "http 1.3.1",
  671    671   
 "http-body 0.4.6",
  672    672   
 "http-body 1.0.1",
  673    673   
 "http-body-util",
  674    674   
 "hyper 0.14.32",
  675    675   
 "itoa",
  676    676   
 "lazy_static",
  677    677   
 "num-integer",
  678    678   
 "pin-project-lite",
  679    679   
 "pin-utils",
  680    680   
 "proptest",
  681    681   
 "rand 0.8.5",
  682    682   
 "ryu",
  683    683   
 "serde",
  684    684   
 "serde_json",
  685    685   
 "tempfile",
  686    686   
 "time",
  687    687   
 "tokio",
  688    688   
 "tokio-stream",
  689    689   
 "tokio-util",
  690    690   
]
  691    691   
  692    692   
[[package]]
  693    693   
name = "aws-smithy-types-convert"
  694    694   
version = "0.60.9"
  695    695   
dependencies = [
  696    696   
 "aws-smithy-async",
  697    697   
 "aws-smithy-types",
  698    698   
 "chrono",
  699    699   
 "futures-core",
  700    700   
 "time",
  701    701   
]
  702    702   
  703    703   
[[package]]
  704    704   
name = "aws-smithy-wasm"
  705    705   
version = "0.1.4"
  706    706   
dependencies = [
  707    707   
 "aws-smithy-http",
  708    708   
 "aws-smithy-runtime-api",
  709    709   
 "aws-smithy-types",
  710    710   
 "bytes",
  711    711   
 "http 1.3.1",
  712    712   
 "tracing",
  713    713   
 "wasi 0.12.1+wasi-0.2.0",
  714    714   
]
  715    715   
  716    716   
[[package]]
  717    717   
name = "aws-smithy-xml"
  718         -
version = "0.60.9"
         718  +
version = "0.60.10"
  719    719   
dependencies = [
  720    720   
 "aws-smithy-protocol-test",
  721    721   
 "base64 0.13.1",
  722    722   
 "proptest",
  723    723   
 "xmlparser",
  724    724   
]
  725    725   
  726    726   
[[package]]
  727    727   
name = "aws_lambda_events"
  728    728   
version = "0.12.1"
@@ -1560,1560 +1619,1625 @@
 1580   1580   
version = "0.12.3"
 1581   1581   
source = "registry+https://github.com/rust-lang/crates.io-index"
 1582   1582   
checksum = "8a9ee70c43aaf417c914396645a0fa852624801b24ebb7ae78fe8272889ac888"
 1583   1583   
 1584   1584   
[[package]]
 1585   1585   
name = "hashbrown"
 1586   1586   
version = "0.15.3"
 1587   1587   
source = "registry+https://github.com/rust-lang/crates.io-index"
 1588   1588   
checksum = "84b26c544d002229e640969970a2e74021aadf6e2f96372b9c58eff97de08eb3"
 1589   1589   
        1590  +
[[package]]
        1591  +
name = "heck"
        1592  +
version = "0.4.1"
        1593  +
source = "registry+https://github.com/rust-lang/crates.io-index"
        1594  +
checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
        1595  +
 1590   1596   
[[package]]
 1591   1597   
name = "hermit-abi"
 1592   1598   
version = "0.1.19"
 1593   1599   
source = "registry+https://github.com/rust-lang/crates.io-index"
 1594   1600   
checksum = "62b467343b94ba476dcb2500d242dadbb39557df889310ac77c5d99100aaac33"
 1595   1601   
dependencies = [
 1596   1602   
 "libc",
 1597   1603   
]
 1598   1604   
 1599   1605   
[[package]]
@@ -1903,1909 +1965,1971 @@
 1923   1929   
source = "registry+https://github.com/rust-lang/crates.io-index"
 1924   1930   
checksum = "cea70ddb795996207ad57735b50c5982d8844f38ba9ee5f1aedcfb708a2aa11e"
 1925   1931   
dependencies = [
 1926   1932   
 "equivalent",
 1927   1933   
 "hashbrown 0.15.3",
 1928   1934   
 "serde",
 1929   1935   
]
 1930   1936   
 1931   1937   
[[package]]
 1932   1938   
name = "indoc"
 1933         -
version = "1.0.9"
        1939  +
version = "2.0.6"
 1934   1940   
source = "registry+https://github.com/rust-lang/crates.io-index"
 1935         -
checksum = "bfa799dd5ed20a7e349f3b4639aa80d74549c81716d9ec4f994c9b5815598306"
        1941  +
checksum = "f4c7245a08504955605670dbf141fceab975f15ca21570696aebe9d2e71576bd"
 1936   1942   
 1937   1943   
[[package]]
 1938   1944   
name = "inlineable"
 1939   1945   
version = "0.1.0"
 1940   1946   
dependencies = [
 1941   1947   
 "aws-smithy-cbor",
 1942   1948   
 "aws-smithy-compression",
 1943   1949   
 "aws-smithy-http",
 1944   1950   
 "aws-smithy-json",
 1945   1951   
 "aws-smithy-runtime",
@@ -2159,2165 +2221,2227 @@
 2179   2185   
]
 2180   2186   
 2181   2187   
[[package]]
 2182   2188   
name = "memchr"
 2183   2189   
version = "2.7.4"
 2184   2190   
source = "registry+https://github.com/rust-lang/crates.io-index"
 2185   2191   
checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 2186   2192   
 2187   2193   
[[package]]
 2188   2194   
name = "memoffset"
 2189         -
version = "0.8.0"
        2195  +
version = "0.9.1"
 2190   2196   
source = "registry+https://github.com/rust-lang/crates.io-index"
 2191         -
checksum = "d61c719bcfbcf5d62b3a09efa6088de8c54bc0bfcd3ea7ae39fcc186108b8de1"
        2197  +
checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
 2192   2198   
dependencies = [
 2193   2199   
 "autocfg",
 2194   2200   
]
 2195   2201   
 2196   2202   
[[package]]
 2197   2203   
name = "mime"
 2198   2204   
version = "0.3.17"
 2199   2205   
source = "registry+https://github.com/rust-lang/crates.io-index"
 2200   2206   
checksum = "6877bb514081ee2a7ff5ef9de3281f14a4dd4bceac4c09388074a6b5df8a139a"
 2201   2207
@@ -2505,2511 +2564,2576 @@
 2525   2531   
dependencies = [
 2526   2532   
 "cfg-if",
 2527   2533   
 "concurrent-queue",
 2528   2534   
 "hermit-abi 0.5.1",
 2529   2535   
 "pin-project-lite",
 2530   2536   
 "rustix 1.0.7",
 2531   2537   
 "tracing",
 2532   2538   
 "windows-sys 0.59.0",
 2533   2539   
]
 2534   2540   
        2541  +
[[package]]
        2542  +
name = "portable-atomic"
        2543  +
version = "1.11.0"
        2544  +
source = "registry+https://github.com/rust-lang/crates.io-index"
        2545  +
checksum = "350e9b48cbc6b0e028b0473b114454c6316e57336ee184ceab6e53f72c178b3e"
        2546  +
 2535   2547   
[[package]]
 2536   2548   
name = "potential_utf"
 2537   2549   
version = "0.1.2"
 2538   2550   
source = "registry+https://github.com/rust-lang/crates.io-index"
 2539   2551   
checksum = "e5a7c30837279ca13e7c867e9e40053bc68740f988cb07f7ca6df43cc734b585"
 2540   2552   
dependencies = [
 2541   2553   
 "zerovec",
 2542   2554   
]
 2543   2555   
 2544   2556   
[[package]]
@@ -2580,2592 +2723,2738 @@
 2600   2612   
 "rand_chacha 0.3.1",
 2601   2613   
 "rand_xorshift",
 2602   2614   
 "regex-syntax 0.8.5",
 2603   2615   
 "rusty-fork",
 2604   2616   
 "tempfile",
 2605   2617   
 "unarray",
 2606   2618   
]
 2607   2619   
 2608   2620   
[[package]]
 2609   2621   
name = "pyo3"
 2610         -
version = "0.18.3"
        2622  +
version = "0.20.3"
 2611   2623   
source = "registry+https://github.com/rust-lang/crates.io-index"
 2612         -
checksum = "e3b1ac5b3731ba34fdaa9785f8d74d17448cd18f30cf19e0c7e7b1fdb5272109"
        2624  +
checksum = "53bdbb96d49157e65d45cc287af5f32ffadd5f4761438b527b055fb0d4bb8233"
 2613   2625   
dependencies = [
 2614   2626   
 "cfg-if",
 2615   2627   
 "indoc",
 2616   2628   
 "libc",
 2617   2629   
 "memoffset",
 2618   2630   
 "parking_lot",
        2631  +
 "portable-atomic",
 2619   2632   
 "pyo3-build-config",
 2620   2633   
 "pyo3-ffi",
 2621   2634   
 "pyo3-macros",
 2622   2635   
 "unindent",
 2623   2636   
]
 2624   2637   
 2625   2638   
[[package]]
 2626   2639   
name = "pyo3-asyncio"
 2627         -
version = "0.18.0"
        2640  +
version = "0.20.0"
 2628   2641   
source = "registry+https://github.com/rust-lang/crates.io-index"
 2629         -
checksum = "d3564762e37035cfc486228e10b0528460fa026d681b5763873c693aa0d5c260"
        2642  +
checksum = "6ea6b68e93db3622f3bb3bf363246cf948ed5375afe7abff98ccbdd50b184995"
 2630   2643   
dependencies = [
 2631   2644   
 "async-channel 1.9.0",
 2632   2645   
 "clap 3.2.25",
 2633   2646   
 "futures",
 2634   2647   
 "inventory",
 2635   2648   
 "once_cell",
 2636   2649   
 "pin-project-lite",
 2637   2650   
 "pyo3",
 2638   2651   
 "pyo3-asyncio-macros",
 2639   2652   
 "tokio",
 2640   2653   
]
 2641   2654   
 2642   2655   
[[package]]
 2643   2656   
name = "pyo3-asyncio-macros"
 2644         -
version = "0.18.0"
        2657  +
version = "0.20.0"
 2645   2658   
source = "registry+https://github.com/rust-lang/crates.io-index"
 2646         -
checksum = "be72d4cd43a27530306bd0d20d3932182fbdd072c6b98d3638bc37efb9d559dd"
        2659  +
checksum = "56c467178e1da6252c95c29ecf898b133f742e9181dca5def15dc24e19d45a39"
 2647   2660   
dependencies = [
 2648   2661   
 "proc-macro2",
 2649   2662   
 "quote",
 2650   2663   
 "syn 1.0.109",
 2651   2664   
]
 2652   2665   
 2653   2666   
[[package]]
 2654   2667   
name = "pyo3-build-config"
 2655         -
version = "0.18.3"
        2668  +
version = "0.20.3"
 2656   2669   
source = "registry+https://github.com/rust-lang/crates.io-index"
 2657         -
checksum = "9cb946f5ac61bb61a5014924910d936ebd2b23b705f7a4a3c40b05c720b079a3"
        2670  +
checksum = "deaa5745de3f5231ce10517a1f5dd97d53e5a2fd77aa6b5842292085831d48d7"
 2658   2671   
dependencies = [
 2659   2672   
 "once_cell",
 2660   2673   
 "target-lexicon",
 2661   2674   
]
 2662   2675   
 2663   2676   
[[package]]
 2664   2677   
name = "pyo3-ffi"
 2665         -
version = "0.18.3"
        2678  +
version = "0.20.3"
 2666   2679   
source = "registry+https://github.com/rust-lang/crates.io-index"
 2667         -
checksum = "fd4d7c5337821916ea2a1d21d1092e8443cf34879e53a0ac653fbb98f44ff65c"
        2680  +
checksum = "62b42531d03e08d4ef1f6e85a2ed422eb678b8cd62b762e53891c05faf0d4afa"
 2668   2681   
dependencies = [
 2669   2682   
 "libc",
 2670   2683   
 "pyo3-build-config",
 2671   2684   
]
 2672   2685   
 2673   2686   
[[package]]
 2674   2687   
name = "pyo3-macros"
 2675         -
version = "0.18.3"
        2688  +
version = "0.20.3"
 2676   2689   
source = "registry+https://github.com/rust-lang/crates.io-index"
 2677         -
checksum = "a9d39c55dab3fc5a4b25bbd1ac10a2da452c4aca13bb450f22818a002e29648d"
        2690  +
checksum = "7305c720fa01b8055ec95e484a6eca7a83c841267f0dd5280f0c8b8551d2c158"
 2678   2691   
dependencies = [
 2679   2692   
 "proc-macro2",
 2680   2693   
 "pyo3-macros-backend",
 2681   2694   
 "quote",
 2682         -
 "syn 1.0.109",
        2695  +
 "syn 2.0.101",
 2683   2696   
]
 2684   2697   
 2685   2698   
[[package]]
 2686   2699   
name = "pyo3-macros-backend"
 2687         -
version = "0.18.3"
        2700  +
version = "0.20.3"
 2688   2701   
source = "registry+https://github.com/rust-lang/crates.io-index"
 2689         -
checksum = "97daff08a4c48320587b5224cc98d609e3c27b6d437315bd40b605c98eeb5918"
        2702  +
checksum = "7c7e9b68bb9c3149c5b0cade5d07f953d6d125eb4337723c4ccdb665f1f96185"
 2690   2703   
dependencies = [
        2704  +
 "heck",
 2691   2705   
 "proc-macro2",
        2706  +
 "pyo3-build-config",
 2692   2707   
 "quote",
 2693         -
 "syn 1.0.109",
        2708  +
 "syn 2.0.101",
 2694   2709   
]
 2695   2710   
 2696   2711   
[[package]]
 2697   2712   
name = "query_map"
 2698   2713   
version = "0.7.0"
 2699   2714   
source = "registry+https://github.com/rust-lang/crates.io-index"
 2700   2715   
checksum = "5eab6b8b1074ef3359a863758dae650c7c0c6027927a085b7af911c8e0bf3a15"
 2701   2716   
dependencies = [
 2702   2717   
 "form_urlencoded",
 2703   2718   
 "serde",
@@ -3879,3894 +3941,3956 @@
 3899   3914   
checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 3900   3915   
 3901   3916   
[[package]]
 3902   3917   
name = "unicode-ident"
 3903   3918   
version = "1.0.18"
 3904   3919   
source = "registry+https://github.com/rust-lang/crates.io-index"
 3905   3920   
checksum = "5a5f39404a5da50712a4c1eecf25e90dd62b613502b7e925fd4e4d19b5c96512"
 3906   3921   
 3907   3922   
[[package]]
 3908   3923   
name = "unindent"
 3909         -
version = "0.1.11"
        3924  +
version = "0.2.4"
 3910   3925   
source = "registry+https://github.com/rust-lang/crates.io-index"
 3911         -
checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c"
        3926  +
checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"
 3912   3927   
 3913   3928   
[[package]]
 3914   3929   
name = "untrusted"
 3915   3930   
version = "0.7.1"
 3916   3931   
source = "registry+https://github.com/rust-lang/crates.io-index"
 3917   3932   
checksum = "a156c684c91ea7d62626509bce3cb4e1d9ed5c4d978f7b4352658f96a4c26b4a"
 3918   3933   
 3919   3934   
[[package]]
 3920   3935   
name = "untrusted"
 3921   3936   
version = "0.9.0"

tmp-codegen-diff/codegen-client-test/aws_query/rust-client-codegen/src/config.rs

@@ -458,458 +564,564 @@
  478    478   
    ///     .identity_cache(
  479    479   
    ///         IdentityCache::lazy()
  480    480   
    ///             // change the load timeout to 10 seconds
  481    481   
    ///             .load_timeout(Duration::from_secs(10))
  482    482   
    ///             .build()
  483    483   
    ///     )
  484    484   
    ///     // ...
  485    485   
    ///     .build();
  486    486   
    /// let client = aws_query::Client::from_conf(config);
  487    487   
    /// ```
  488         -
         488  +
    ///
  489    489   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  490    490   
        self.set_identity_cache(identity_cache);
  491    491   
        self
  492    492   
    }
  493    493   
  494    494   
    /// Set the identity cache for auth.
  495    495   
    ///
  496    496   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  497    497   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  498    498   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  499    499   
    /// the next request will result in refreshing the identity.
  500    500   
    ///
  501    501   
    /// This configuration allows you to disable or change the default caching mechanism.
  502    502   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  503    503   
    /// trait and pass that implementation into this function.
  504    504   
    ///
  505    505   
    /// # Examples
  506    506   
    ///
  507    507   
    /// Disabling identity caching:
  508    508   
    /// ```no_run
  509    509   
    /// use aws_query::config::IdentityCache;
  510    510   
    ///
  511    511   
    /// let config = aws_query::Config::builder()
  512    512   
    ///     .identity_cache(IdentityCache::no_cache())
  513    513   
    ///     // ...
  514    514   
    ///     .build();
  515    515   
    /// let client = aws_query::Client::from_conf(config);
  516    516   
    /// ```
  517    517   
    ///
  518    518   
    /// Customizing lazy caching:
  519    519   
    /// ```no_run
  520    520   
    /// use aws_query::config::IdentityCache;
  521    521   
    /// use std::time::Duration;
  522    522   
    ///
  523    523   
    /// let config = aws_query::Config::builder()
  524    524   
    ///     .identity_cache(
  525    525   
    ///         IdentityCache::lazy()
  526    526   
    ///             // change the load timeout to 10 seconds
  527    527   
    ///             .load_timeout(Duration::from_secs(10))
  528    528   
    ///             .build()
  529    529   
    ///     )
  530    530   
    ///     // ...
  531    531   
    ///     .build();
  532    532   
    /// let client = aws_query::Client::from_conf(config);
  533    533   
    /// ```
  534         -
         534  +
    ///
  535    535   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  536    536   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  537    537   
        self
  538    538   
    }
  539    539   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  540    540   
    ///
  541    541   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  542    542   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  543    543   
    /// will run after those default interceptors.
  544    544   
    ///
@@ -850,850 +945,945 @@
  870    870   
    /// Customizing behavior major version:
  871    871   
    /// ```no_run
  872    872   
    /// use aws_query::config::BehaviorVersion;
  873    873   
    ///
  874    874   
    /// let config = aws_query::Config::builder()
  875    875   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  876    876   
    ///     // ...
  877    877   
    ///     .build();
  878    878   
    /// let client = aws_query::Client::from_conf(config);
  879    879   
    /// ```
  880         -
         880  +
    ///
  881    881   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
  882    882   
        self.set_behavior_version(Some(behavior_version));
  883    883   
        self
  884    884   
    }
  885    885   
  886    886   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
  887    887   
    ///
  888    888   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
  889    889   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
  890    890   
    /// all operations might be the ideal behavior but could break existing applications.
  891    891   
    ///
  892    892   
    /// # Examples
  893    893   
    ///
  894    894   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
  895    895   
    /// ```no_run
  896    896   
    /// use aws_query::config::BehaviorVersion;
  897    897   
    ///
  898    898   
    /// let config = aws_query::Config::builder()
  899    899   
    ///     .behavior_version(BehaviorVersion::latest())
  900    900   
    ///     // ...
  901    901   
    ///     .build();
  902    902   
    /// let client = aws_query::Client::from_conf(config);
  903    903   
    /// ```
  904    904   
    ///
  905    905   
    /// Customizing behavior major version:
  906    906   
    /// ```no_run
  907    907   
    /// use aws_query::config::BehaviorVersion;
  908    908   
    ///
  909    909   
    /// let config = aws_query::Config::builder()
  910    910   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  911    911   
    ///     // ...
  912    912   
    ///     .build();
  913    913   
    /// let client = aws_query::Client::from_conf(config);
  914    914   
    /// ```
  915         -
         915  +
    ///
  916    916   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
  917    917   
        self.behavior_version = behavior_version;
  918    918   
        self
  919    919   
    }
  920    920   
  921    921   
    /// Convenience method to set the latest behavior major version
  922    922   
    ///
  923    923   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
  924    924   
    pub fn behavior_version_latest(mut self) -> Self {
  925    925   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -982,982 +1042,1042 @@
 1002   1002   
    }
 1003   1003   
 1004   1004   
    fn runtime_components(
 1005   1005   
        &self,
 1006   1006   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1007   1007   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
 1008   1008   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
 1009   1009   
    }
 1010   1010   
}
 1011   1011   
 1012         -
/// Cross-operation shared-state singletons
        1012  +
// Cross-operation shared-state singletons
 1013   1013   
 1014   1014   
/// A plugin that enables configuration for a single operation invocation
 1015   1015   
///
 1016   1016   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 1017   1017   
/// In the case of default values requested, they will be obtained from `client_config`.
 1018   1018   
#[derive(Debug)]
 1019   1019   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1020   1020   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1021   1021   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1022   1022   
}

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/config.rs

@@ -458,458 +564,564 @@
  478    478   
    ///     .identity_cache(
  479    479   
    ///         IdentityCache::lazy()
  480    480   
    ///             // change the load timeout to 10 seconds
  481    481   
    ///             .load_timeout(Duration::from_secs(10))
  482    482   
    ///             .build()
  483    483   
    ///     )
  484    484   
    ///     // ...
  485    485   
    ///     .build();
  486    486   
    /// let client = dynamo::Client::from_conf(config);
  487    487   
    /// ```
  488         -
         488  +
    ///
  489    489   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  490    490   
        self.set_identity_cache(identity_cache);
  491    491   
        self
  492    492   
    }
  493    493   
  494    494   
    /// Set the identity cache for auth.
  495    495   
    ///
  496    496   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  497    497   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  498    498   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  499    499   
    /// the next request will result in refreshing the identity.
  500    500   
    ///
  501    501   
    /// This configuration allows you to disable or change the default caching mechanism.
  502    502   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  503    503   
    /// trait and pass that implementation into this function.
  504    504   
    ///
  505    505   
    /// # Examples
  506    506   
    ///
  507    507   
    /// Disabling identity caching:
  508    508   
    /// ```no_run
  509    509   
    /// use dynamo::config::IdentityCache;
  510    510   
    ///
  511    511   
    /// let config = dynamo::Config::builder()
  512    512   
    ///     .identity_cache(IdentityCache::no_cache())
  513    513   
    ///     // ...
  514    514   
    ///     .build();
  515    515   
    /// let client = dynamo::Client::from_conf(config);
  516    516   
    /// ```
  517    517   
    ///
  518    518   
    /// Customizing lazy caching:
  519    519   
    /// ```no_run
  520    520   
    /// use dynamo::config::IdentityCache;
  521    521   
    /// use std::time::Duration;
  522    522   
    ///
  523    523   
    /// let config = dynamo::Config::builder()
  524    524   
    ///     .identity_cache(
  525    525   
    ///         IdentityCache::lazy()
  526    526   
    ///             // change the load timeout to 10 seconds
  527    527   
    ///             .load_timeout(Duration::from_secs(10))
  528    528   
    ///             .build()
  529    529   
    ///     )
  530    530   
    ///     // ...
  531    531   
    ///     .build();
  532    532   
    /// let client = dynamo::Client::from_conf(config);
  533    533   
    /// ```
  534         -
         534  +
    ///
  535    535   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  536    536   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  537    537   
        self
  538    538   
    }
  539    539   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  540    540   
    ///
  541    541   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  542    542   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  543    543   
    /// will run after those default interceptors.
  544    544   
    ///
@@ -850,850 +945,945 @@
  870    870   
    /// Customizing behavior major version:
  871    871   
    /// ```no_run
  872    872   
    /// use dynamo::config::BehaviorVersion;
  873    873   
    ///
  874    874   
    /// let config = dynamo::Config::builder()
  875    875   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  876    876   
    ///     // ...
  877    877   
    ///     .build();
  878    878   
    /// let client = dynamo::Client::from_conf(config);
  879    879   
    /// ```
  880         -
         880  +
    ///
  881    881   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
  882    882   
        self.set_behavior_version(Some(behavior_version));
  883    883   
        self
  884    884   
    }
  885    885   
  886    886   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
  887    887   
    ///
  888    888   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
  889    889   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
  890    890   
    /// all operations might be the ideal behavior but could break existing applications.
  891    891   
    ///
  892    892   
    /// # Examples
  893    893   
    ///
  894    894   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
  895    895   
    /// ```no_run
  896    896   
    /// use dynamo::config::BehaviorVersion;
  897    897   
    ///
  898    898   
    /// let config = dynamo::Config::builder()
  899    899   
    ///     .behavior_version(BehaviorVersion::latest())
  900    900   
    ///     // ...
  901    901   
    ///     .build();
  902    902   
    /// let client = dynamo::Client::from_conf(config);
  903    903   
    /// ```
  904    904   
    ///
  905    905   
    /// Customizing behavior major version:
  906    906   
    /// ```no_run
  907    907   
    /// use dynamo::config::BehaviorVersion;
  908    908   
    ///
  909    909   
    /// let config = dynamo::Config::builder()
  910    910   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  911    911   
    ///     // ...
  912    912   
    ///     .build();
  913    913   
    /// let client = dynamo::Client::from_conf(config);
  914    914   
    /// ```
  915         -
         915  +
    ///
  916    916   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
  917    917   
        self.behavior_version = behavior_version;
  918    918   
        self
  919    919   
    }
  920    920   
  921    921   
    /// Convenience method to set the latest behavior major version
  922    922   
    ///
  923    923   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
  924    924   
    pub fn behavior_version_latest(mut self) -> Self {
  925    925   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -982,982 +1042,1042 @@
 1002   1002   
    }
 1003   1003   
 1004   1004   
    fn runtime_components(
 1005   1005   
        &self,
 1006   1006   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1007   1007   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
 1008   1008   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
 1009   1009   
    }
 1010   1010   
}
 1011   1011   
 1012         -
/// Cross-operation shared-state singletons
        1012  +
// Cross-operation shared-state singletons
 1013   1013   
 1014   1014   
/// A plugin that enables configuration for a single operation invocation
 1015   1015   
///
 1016   1016   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 1017   1017   
/// In the case of default values requested, they will be obtained from `client_config`.
 1018   1018   
#[derive(Debug)]
 1019   1019   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1020   1020   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1021   1021   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1022   1022   
}

tmp-codegen-diff/codegen-client-test/dynamo/rust-client-codegen/src/lens.rs

@@ -25,25 +80,71 @@
   45     45   
    let input = match &input.last_evaluated_key {
   46     46   
        ::std::option::Option::None => return ::std::option::Option::None,
   47     47   
        ::std::option::Option::Some(t) => t,
   48     48   
    };
   49     49   
    ::std::option::Option::Some(input)
   50     50   
}
   51     51   
   52     52   
pub(crate) fn lens_list_tables_output_output_table_names(
   53     53   
    input: crate::operation::list_tables::ListTablesOutput,
   54     54   
) -> ::std::option::Option<::std::vec::Vec<::std::string::String>> {
   55         -
    let input = match input.table_names {
   56         -
        ::std::option::Option::None => return ::std::option::Option::None,
   57         -
        ::std::option::Option::Some(t) => t,
   58         -
    };
          55  +
    let input = input.table_names?;
   59     56   
    ::std::option::Option::Some(input)
   60     57   
}
   61     58   
   62     59   
pub(crate) fn lens_query_output_output_items(
   63     60   
    input: crate::operation::query::QueryOutput,
   64     61   
) -> ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>> {
   65         -
    let input = match input.items {
   66         -
        ::std::option::Option::None => return ::std::option::Option::None,
   67         -
        ::std::option::Option::Some(t) => t,
   68         -
    };
          62  +
    let input = input.items?;
   69     63   
    ::std::option::Option::Some(input)
   70     64   
}
   71     65   
   72     66   
pub(crate) fn lens_scan_output_output_items(
   73     67   
    input: crate::operation::scan::ScanOutput,
   74     68   
) -> ::std::option::Option<::std::vec::Vec<::std::collections::HashMap<::std::string::String, crate::types::AttributeValue>>> {
   75         -
    let input = match input.items {
   76         -
        ::std::option::Option::None => return ::std::option::Option::None,
   77         -
        ::std::option::Option::Some(t) => t,
   78         -
    };
          69  +
    let input = input.items?;
   79     70   
    ::std::option::Option::Some(input)
   80     71   
}

tmp-codegen-diff/codegen-client-test/ebs/rust-client-codegen/src/config.rs

@@ -458,458 +564,564 @@
  478    478   
    ///     .identity_cache(
  479    479   
    ///         IdentityCache::lazy()
  480    480   
    ///             // change the load timeout to 10 seconds
  481    481   
    ///             .load_timeout(Duration::from_secs(10))
  482    482   
    ///             .build()
  483    483   
    ///     )
  484    484   
    ///     // ...
  485    485   
    ///     .build();
  486    486   
    /// let client = ebs::Client::from_conf(config);
  487    487   
    /// ```
  488         -
         488  +
    ///
  489    489   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  490    490   
        self.set_identity_cache(identity_cache);
  491    491   
        self
  492    492   
    }
  493    493   
  494    494   
    /// Set the identity cache for auth.
  495    495   
    ///
  496    496   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  497    497   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  498    498   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  499    499   
    /// the next request will result in refreshing the identity.
  500    500   
    ///
  501    501   
    /// This configuration allows you to disable or change the default caching mechanism.
  502    502   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  503    503   
    /// trait and pass that implementation into this function.
  504    504   
    ///
  505    505   
    /// # Examples
  506    506   
    ///
  507    507   
    /// Disabling identity caching:
  508    508   
    /// ```no_run
  509    509   
    /// use ebs::config::IdentityCache;
  510    510   
    ///
  511    511   
    /// let config = ebs::Config::builder()
  512    512   
    ///     .identity_cache(IdentityCache::no_cache())
  513    513   
    ///     // ...
  514    514   
    ///     .build();
  515    515   
    /// let client = ebs::Client::from_conf(config);
  516    516   
    /// ```
  517    517   
    ///
  518    518   
    /// Customizing lazy caching:
  519    519   
    /// ```no_run
  520    520   
    /// use ebs::config::IdentityCache;
  521    521   
    /// use std::time::Duration;
  522    522   
    ///
  523    523   
    /// let config = ebs::Config::builder()
  524    524   
    ///     .identity_cache(
  525    525   
    ///         IdentityCache::lazy()
  526    526   
    ///             // change the load timeout to 10 seconds
  527    527   
    ///             .load_timeout(Duration::from_secs(10))
  528    528   
    ///             .build()
  529    529   
    ///     )
  530    530   
    ///     // ...
  531    531   
    ///     .build();
  532    532   
    /// let client = ebs::Client::from_conf(config);
  533    533   
    /// ```
  534         -
         534  +
    ///
  535    535   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  536    536   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  537    537   
        self
  538    538   
    }
  539    539   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  540    540   
    ///
  541    541   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  542    542   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  543    543   
    /// will run after those default interceptors.
  544    544   
    ///
@@ -850,850 +945,945 @@
  870    870   
    /// Customizing behavior major version:
  871    871   
    /// ```no_run
  872    872   
    /// use ebs::config::BehaviorVersion;
  873    873   
    ///
  874    874   
    /// let config = ebs::Config::builder()
  875    875   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  876    876   
    ///     // ...
  877    877   
    ///     .build();
  878    878   
    /// let client = ebs::Client::from_conf(config);
  879    879   
    /// ```
  880         -
         880  +
    ///
  881    881   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
  882    882   
        self.set_behavior_version(Some(behavior_version));
  883    883   
        self
  884    884   
    }
  885    885   
  886    886   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
  887    887   
    ///
  888    888   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
  889    889   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
  890    890   
    /// all operations might be the ideal behavior but could break existing applications.
  891    891   
    ///
  892    892   
    /// # Examples
  893    893   
    ///
  894    894   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
  895    895   
    /// ```no_run
  896    896   
    /// use ebs::config::BehaviorVersion;
  897    897   
    ///
  898    898   
    /// let config = ebs::Config::builder()
  899    899   
    ///     .behavior_version(BehaviorVersion::latest())
  900    900   
    ///     // ...
  901    901   
    ///     .build();
  902    902   
    /// let client = ebs::Client::from_conf(config);
  903    903   
    /// ```
  904    904   
    ///
  905    905   
    /// Customizing behavior major version:
  906    906   
    /// ```no_run
  907    907   
    /// use ebs::config::BehaviorVersion;
  908    908   
    ///
  909    909   
    /// let config = ebs::Config::builder()
  910    910   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  911    911   
    ///     // ...
  912    912   
    ///     .build();
  913    913   
    /// let client = ebs::Client::from_conf(config);
  914    914   
    /// ```
  915         -
         915  +
    ///
  916    916   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
  917    917   
        self.behavior_version = behavior_version;
  918    918   
        self
  919    919   
    }
  920    920   
  921    921   
    /// Convenience method to set the latest behavior major version
  922    922   
    ///
  923    923   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
  924    924   
    pub fn behavior_version_latest(mut self) -> Self {
  925    925   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -982,982 +1042,1042 @@
 1002   1002   
    }
 1003   1003   
 1004   1004   
    fn runtime_components(
 1005   1005   
        &self,
 1006   1006   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1007   1007   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
 1008   1008   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
 1009   1009   
    }
 1010   1010   
}
 1011   1011   
 1012         -
/// Cross-operation shared-state singletons
        1012  +
// Cross-operation shared-state singletons
 1013   1013   
 1014   1014   
/// A plugin that enables configuration for a single operation invocation
 1015   1015   
///
 1016   1016   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 1017   1017   
/// In the case of default values requested, they will be obtained from `client_config`.
 1018   1018   
#[derive(Debug)]
 1019   1019   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1020   1020   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1021   1021   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1022   1022   
}

tmp-codegen-diff/codegen-client-test/ec2_query/rust-client-codegen/src/config.rs

@@ -458,458 +564,564 @@
  478    478   
    ///     .identity_cache(
  479    479   
    ///         IdentityCache::lazy()
  480    480   
    ///             // change the load timeout to 10 seconds
  481    481   
    ///             .load_timeout(Duration::from_secs(10))
  482    482   
    ///             .build()
  483    483   
    ///     )
  484    484   
    ///     // ...
  485    485   
    ///     .build();
  486    486   
    /// let client = ec2_query::Client::from_conf(config);
  487    487   
    /// ```
  488         -
         488  +
    ///
  489    489   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  490    490   
        self.set_identity_cache(identity_cache);
  491    491   
        self
  492    492   
    }
  493    493   
  494    494   
    /// Set the identity cache for auth.
  495    495   
    ///
  496    496   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  497    497   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  498    498   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  499    499   
    /// the next request will result in refreshing the identity.
  500    500   
    ///
  501    501   
    /// This configuration allows you to disable or change the default caching mechanism.
  502    502   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  503    503   
    /// trait and pass that implementation into this function.
  504    504   
    ///
  505    505   
    /// # Examples
  506    506   
    ///
  507    507   
    /// Disabling identity caching:
  508    508   
    /// ```no_run
  509    509   
    /// use ec2_query::config::IdentityCache;
  510    510   
    ///
  511    511   
    /// let config = ec2_query::Config::builder()
  512    512   
    ///     .identity_cache(IdentityCache::no_cache())
  513    513   
    ///     // ...
  514    514   
    ///     .build();
  515    515   
    /// let client = ec2_query::Client::from_conf(config);
  516    516   
    /// ```
  517    517   
    ///
  518    518   
    /// Customizing lazy caching:
  519    519   
    /// ```no_run
  520    520   
    /// use ec2_query::config::IdentityCache;
  521    521   
    /// use std::time::Duration;
  522    522   
    ///
  523    523   
    /// let config = ec2_query::Config::builder()
  524    524   
    ///     .identity_cache(
  525    525   
    ///         IdentityCache::lazy()
  526    526   
    ///             // change the load timeout to 10 seconds
  527    527   
    ///             .load_timeout(Duration::from_secs(10))
  528    528   
    ///             .build()
  529    529   
    ///     )
  530    530   
    ///     // ...
  531    531   
    ///     .build();
  532    532   
    /// let client = ec2_query::Client::from_conf(config);
  533    533   
    /// ```
  534         -
         534  +
    ///
  535    535   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  536    536   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  537    537   
        self
  538    538   
    }
  539    539   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  540    540   
    ///
  541    541   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  542    542   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  543    543   
    /// will run after those default interceptors.
  544    544   
    ///
@@ -850,850 +945,945 @@
  870    870   
    /// Customizing behavior major version:
  871    871   
    /// ```no_run
  872    872   
    /// use ec2_query::config::BehaviorVersion;
  873    873   
    ///
  874    874   
    /// let config = ec2_query::Config::builder()
  875    875   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  876    876   
    ///     // ...
  877    877   
    ///     .build();
  878    878   
    /// let client = ec2_query::Client::from_conf(config);
  879    879   
    /// ```
  880         -
         880  +
    ///
  881    881   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
  882    882   
        self.set_behavior_version(Some(behavior_version));
  883    883   
        self
  884    884   
    }
  885    885   
  886    886   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
  887    887   
    ///
  888    888   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
  889    889   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
  890    890   
    /// all operations might be the ideal behavior but could break existing applications.
  891    891   
    ///
  892    892   
    /// # Examples
  893    893   
    ///
  894    894   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
  895    895   
    /// ```no_run
  896    896   
    /// use ec2_query::config::BehaviorVersion;
  897    897   
    ///
  898    898   
    /// let config = ec2_query::Config::builder()
  899    899   
    ///     .behavior_version(BehaviorVersion::latest())
  900    900   
    ///     // ...
  901    901   
    ///     .build();
  902    902   
    /// let client = ec2_query::Client::from_conf(config);
  903    903   
    /// ```
  904    904   
    ///
  905    905   
    /// Customizing behavior major version:
  906    906   
    /// ```no_run
  907    907   
    /// use ec2_query::config::BehaviorVersion;
  908    908   
    ///
  909    909   
    /// let config = ec2_query::Config::builder()
  910    910   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  911    911   
    ///     // ...
  912    912   
    ///     .build();
  913    913   
    /// let client = ec2_query::Client::from_conf(config);
  914    914   
    /// ```
  915         -
         915  +
    ///
  916    916   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
  917    917   
        self.behavior_version = behavior_version;
  918    918   
        self
  919    919   
    }
  920    920   
  921    921   
    /// Convenience method to set the latest behavior major version
  922    922   
    ///
  923    923   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
  924    924   
    pub fn behavior_version_latest(mut self) -> Self {
  925    925   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -982,982 +1042,1042 @@
 1002   1002   
    }
 1003   1003   
 1004   1004   
    fn runtime_components(
 1005   1005   
        &self,
 1006   1006   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1007   1007   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
 1008   1008   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
 1009   1009   
    }
 1010   1010   
}
 1011   1011   
 1012         -
/// Cross-operation shared-state singletons
        1012  +
// Cross-operation shared-state singletons
 1013   1013   
 1014   1014   
/// A plugin that enables configuration for a single operation invocation
 1015   1015   
///
 1016   1016   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 1017   1017   
/// In the case of default values requested, they will be obtained from `client_config`.
 1018   1018   
#[derive(Debug)]
 1019   1019   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1020   1020   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1021   1021   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1022   1022   
}

tmp-codegen-diff/codegen-client-test/endpoint-rules/rust-client-codegen/src/config.rs

@@ -207,207 +301,302 @@
  227    227   
        #[allow(deprecated)]
  228    228   
        self.set_endpoint_resolver(endpoint_url.map(|url| {
  229    229   
            ::aws_smithy_runtime_api::shared::IntoShared::into_shared(
  230    230   
                ::aws_smithy_runtime::client::orchestrator::endpoints::StaticUriEndpointResolver::uri(url),
  231    231   
            )
  232    232   
        }));
  233    233   
        self
  234    234   
    }
  235    235   
    /// Sets the endpoint resolver to use when making requests.
  236    236   
    ///
  237         -
         237  +
    ///
  238    238   
    /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
  239    239   
    /// rules for `endpoint_rules`.
  240         -
         240  +
    ///
  241    241   
    ///
  242    242   
    /// Note: setting an endpoint resolver will replace any endpoint URL that has been set.
  243    243   
    /// This method accepts an endpoint resolver [specific to this service](crate::config::endpoint::ResolveEndpoint). If you want to
  244    244   
    /// provide a shared endpoint resolver, use [`Self::set_endpoint_resolver`].
  245    245   
    ///
  246    246   
    /// # Examples
  247    247   
    /// Create a custom endpoint resolver that resolves a different endpoing per-stage, e.g. staging vs. production.
  248    248   
    /// ```no_run
  249    249   
    /// use endpoint_rules::config::endpoint::{ResolveEndpoint, EndpointFuture, Params, Endpoint};
  250    250   
    /// #[derive(Debug)]
  251    251   
    /// struct StageResolver { stage: String }
  252    252   
    /// impl ResolveEndpoint for StageResolver {
  253    253   
    ///     fn resolve_endpoint(&self, params: &Params) -> EndpointFuture<'_> {
  254    254   
    ///         let stage = &self.stage;
  255    255   
    ///         EndpointFuture::ready(Ok(Endpoint::builder().url(format!("{stage}.myservice.com")).build()))
  256    256   
    ///     }
  257    257   
    /// }
  258    258   
    /// let resolver = StageResolver { stage: std::env::var("STAGE").unwrap() };
  259    259   
    /// let config = endpoint_rules::Config::builder().endpoint_resolver(resolver).build();
  260    260   
    /// let client = endpoint_rules::Client::from_conf(config);
  261    261   
    /// ```
  262    262   
    pub fn endpoint_resolver(mut self, endpoint_resolver: impl crate::config::endpoint::ResolveEndpoint + 'static) -> Self {
  263    263   
        self.set_endpoint_resolver(::std::option::Option::Some(endpoint_resolver.into_shared_resolver()));
  264    264   
        self
  265    265   
    }
  266    266   
  267    267   
    /// Sets the endpoint resolver to use when making requests.
  268    268   
    ///
  269         -
         269  +
    ///
  270    270   
    /// When unset, the client will used a generated endpoint resolver based on the endpoint resolution
  271    271   
    /// rules for `endpoint_rules`.
         272  +
    ///
  272    273   
    pub fn set_endpoint_resolver(
  273    274   
        &mut self,
  274    275   
        endpoint_resolver: ::std::option::Option<::aws_smithy_runtime_api::client::endpoint::SharedEndpointResolver>,
  275    276   
    ) -> &mut Self {
  276    277   
        self.runtime_components.set_endpoint_resolver(endpoint_resolver);
  277    278   
        self
  278    279   
    }
  279    280   
    /// Set the retry_config for the builder
  280    281   
    ///
  281    282   
    /// # Examples
@@ -447,448 +553,554 @@
  467    468   
    ///     .identity_cache(
  468    469   
    ///         IdentityCache::lazy()
  469    470   
    ///             // change the load timeout to 10 seconds
  470    471   
    ///             .load_timeout(Duration::from_secs(10))
  471    472   
    ///             .build()
  472    473   
    ///     )
  473    474   
    ///     // ...
  474    475   
    ///     .build();
  475    476   
    /// let client = endpoint_rules::Client::from_conf(config);
  476    477   
    /// ```
  477         -
         478  +
    ///
  478    479   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  479    480   
        self.set_identity_cache(identity_cache);
  480    481   
        self
  481    482   
    }
  482    483   
  483    484   
    /// Set the identity cache for auth.
  484    485   
    ///
  485    486   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  486    487   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  487    488   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  488    489   
    /// the next request will result in refreshing the identity.
  489    490   
    ///
  490    491   
    /// This configuration allows you to disable or change the default caching mechanism.
  491    492   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  492    493   
    /// trait and pass that implementation into this function.
  493    494   
    ///
  494    495   
    /// # Examples
  495    496   
    ///
  496    497   
    /// Disabling identity caching:
  497    498   
    /// ```no_run
  498    499   
    /// use endpoint_rules::config::IdentityCache;
  499    500   
    ///
  500    501   
    /// let config = endpoint_rules::Config::builder()
  501    502   
    ///     .identity_cache(IdentityCache::no_cache())
  502    503   
    ///     // ...
  503    504   
    ///     .build();
  504    505   
    /// let client = endpoint_rules::Client::from_conf(config);
  505    506   
    /// ```
  506    507   
    ///
  507    508   
    /// Customizing lazy caching:
  508    509   
    /// ```no_run
  509    510   
    /// use endpoint_rules::config::IdentityCache;
  510    511   
    /// use std::time::Duration;
  511    512   
    ///
  512    513   
    /// let config = endpoint_rules::Config::builder()
  513    514   
    ///     .identity_cache(
  514    515   
    ///         IdentityCache::lazy()
  515    516   
    ///             // change the load timeout to 10 seconds
  516    517   
    ///             .load_timeout(Duration::from_secs(10))
  517    518   
    ///             .build()
  518    519   
    ///     )
  519    520   
    ///     // ...
  520    521   
    ///     .build();
  521    522   
    /// let client = endpoint_rules::Client::from_conf(config);
  522    523   
    /// ```
  523         -
         524  +
    ///
  524    525   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  525    526   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  526    527   
        self
  527    528   
    }
  528    529   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  529    530   
    ///
  530    531   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  531    532   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  532    533   
    /// will run after those default interceptors.
  533    534   
    ///
@@ -839,840 +934,935 @@
  859    860   
    /// Customizing behavior major version:
  860    861   
    /// ```no_run
  861    862   
    /// use endpoint_rules::config::BehaviorVersion;
  862    863   
    ///
  863    864   
    /// let config = endpoint_rules::Config::builder()
  864    865   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  865    866   
    ///     // ...
  866    867   
    ///     .build();
  867    868   
    /// let client = endpoint_rules::Client::from_conf(config);
  868    869   
    /// ```
  869         -
         870  +
    ///
  870    871   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
  871    872   
        self.set_behavior_version(Some(behavior_version));
  872    873   
        self
  873    874   
    }
  874    875   
  875    876   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
  876    877   
    ///
  877    878   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
  878    879   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
  879    880   
    /// all operations might be the ideal behavior but could break existing applications.
  880    881   
    ///
  881    882   
    /// # Examples
  882    883   
    ///
  883    884   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
  884    885   
    /// ```no_run
  885    886   
    /// use endpoint_rules::config::BehaviorVersion;
  886    887   
    ///
  887    888   
    /// let config = endpoint_rules::Config::builder()
  888    889   
    ///     .behavior_version(BehaviorVersion::latest())
  889    890   
    ///     // ...
  890    891   
    ///     .build();
  891    892   
    /// let client = endpoint_rules::Client::from_conf(config);
  892    893   
    /// ```
  893    894   
    ///
  894    895   
    /// Customizing behavior major version:
  895    896   
    /// ```no_run
  896    897   
    /// use endpoint_rules::config::BehaviorVersion;
  897    898   
    ///
  898    899   
    /// let config = endpoint_rules::Config::builder()
  899    900   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  900    901   
    ///     // ...
  901    902   
    ///     .build();
  902    903   
    /// let client = endpoint_rules::Client::from_conf(config);
  903    904   
    /// ```
  904         -
         905  +
    ///
  905    906   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
  906    907   
        self.behavior_version = behavior_version;
  907    908   
        self
  908    909   
    }
  909    910   
  910    911   
    /// Convenience method to set the latest behavior major version
  911    912   
    ///
  912    913   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
  913    914   
    pub fn behavior_version_latest(mut self) -> Self {
  914    915   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -975,976 +1035,1036 @@
  995    996   
    }
  996    997   
  997    998   
    fn runtime_components(
  998    999   
        &self,
  999   1000   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1000   1001   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
 1001   1002   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
 1002   1003   
    }
 1003   1004   
}
 1004   1005   
 1005         -
/// Cross-operation shared-state singletons
        1006  +
// Cross-operation shared-state singletons
 1006   1007   
 1007   1008   
/// A plugin that enables configuration for a single operation invocation
 1008   1009   
///
 1009   1010   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 1010   1011   
/// In the case of default values requested, they will be obtained from `client_config`.
 1011   1012   
#[derive(Debug)]
 1012   1013   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1013   1014   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1014   1015   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1015   1016   
}

tmp-codegen-diff/codegen-client-test/json_rpc10/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@
  462    462   
    ///     .identity_cache(
  463    463   
    ///         IdentityCache::lazy()
  464    464   
    ///             // change the load timeout to 10 seconds
  465    465   
    ///             .load_timeout(Duration::from_secs(10))
  466    466   
    ///             .build()
  467    467   
    ///     )
  468    468   
    ///     // ...
  469    469   
    ///     .build();
  470    470   
    /// let client = json_rpc10::Client::from_conf(config);
  471    471   
    /// ```
  472         -
         472  +
    ///
  473    473   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  474    474   
        self.set_identity_cache(identity_cache);
  475    475   
        self
  476    476   
    }
  477    477   
  478    478   
    /// Set the identity cache for auth.
  479    479   
    ///
  480    480   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  481    481   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  482    482   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  483    483   
    /// the next request will result in refreshing the identity.
  484    484   
    ///
  485    485   
    /// This configuration allows you to disable or change the default caching mechanism.
  486    486   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  487    487   
    /// trait and pass that implementation into this function.
  488    488   
    ///
  489    489   
    /// # Examples
  490    490   
    ///
  491    491   
    /// Disabling identity caching:
  492    492   
    /// ```no_run
  493    493   
    /// use json_rpc10::config::IdentityCache;
  494    494   
    ///
  495    495   
    /// let config = json_rpc10::Config::builder()
  496    496   
    ///     .identity_cache(IdentityCache::no_cache())
  497    497   
    ///     // ...
  498    498   
    ///     .build();
  499    499   
    /// let client = json_rpc10::Client::from_conf(config);
  500    500   
    /// ```
  501    501   
    ///
  502    502   
    /// Customizing lazy caching:
  503    503   
    /// ```no_run
  504    504   
    /// use json_rpc10::config::IdentityCache;
  505    505   
    /// use std::time::Duration;
  506    506   
    ///
  507    507   
    /// let config = json_rpc10::Config::builder()
  508    508   
    ///     .identity_cache(
  509    509   
    ///         IdentityCache::lazy()
  510    510   
    ///             // change the load timeout to 10 seconds
  511    511   
    ///             .load_timeout(Duration::from_secs(10))
  512    512   
    ///             .build()
  513    513   
    ///     )
  514    514   
    ///     // ...
  515    515   
    ///     .build();
  516    516   
    /// let client = json_rpc10::Client::from_conf(config);
  517    517   
    /// ```
  518         -
         518  +
    ///
  519    519   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  520    520   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  521    521   
        self
  522    522   
    }
  523    523   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  524    524   
    ///
  525    525   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  526    526   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  527    527   
    /// will run after those default interceptors.
  528    528   
    ///
@@ -834,834 +929,929 @@
  854    854   
    /// Customizing behavior major version:
  855    855   
    /// ```no_run
  856    856   
    /// use json_rpc10::config::BehaviorVersion;
  857    857   
    ///
  858    858   
    /// let config = json_rpc10::Config::builder()
  859    859   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  860    860   
    ///     // ...
  861    861   
    ///     .build();
  862    862   
    /// let client = json_rpc10::Client::from_conf(config);
  863    863   
    /// ```
  864         -
         864  +
    ///
  865    865   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
  866    866   
        self.set_behavior_version(Some(behavior_version));
  867    867   
        self
  868    868   
    }
  869    869   
  870    870   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
  871    871   
    ///
  872    872   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
  873    873   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
  874    874   
    /// all operations might be the ideal behavior but could break existing applications.
  875    875   
    ///
  876    876   
    /// # Examples
  877    877   
    ///
  878    878   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
  879    879   
    /// ```no_run
  880    880   
    /// use json_rpc10::config::BehaviorVersion;
  881    881   
    ///
  882    882   
    /// let config = json_rpc10::Config::builder()
  883    883   
    ///     .behavior_version(BehaviorVersion::latest())
  884    884   
    ///     // ...
  885    885   
    ///     .build();
  886    886   
    /// let client = json_rpc10::Client::from_conf(config);
  887    887   
    /// ```
  888    888   
    ///
  889    889   
    /// Customizing behavior major version:
  890    890   
    /// ```no_run
  891    891   
    /// use json_rpc10::config::BehaviorVersion;
  892    892   
    ///
  893    893   
    /// let config = json_rpc10::Config::builder()
  894    894   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  895    895   
    ///     // ...
  896    896   
    ///     .build();
  897    897   
    /// let client = json_rpc10::Client::from_conf(config);
  898    898   
    /// ```
  899         -
         899  +
    ///
  900    900   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
  901    901   
        self.behavior_version = behavior_version;
  902    902   
        self
  903    903   
    }
  904    904   
  905    905   
    /// Convenience method to set the latest behavior major version
  906    906   
    ///
  907    907   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
  908    908   
    pub fn behavior_version_latest(mut self) -> Self {
  909    909   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -964,964 +1024,1024 @@
  984    984   
    }
  985    985   
  986    986   
    fn runtime_components(
  987    987   
        &self,
  988    988   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  989    989   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  990    990   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
  991    991   
    }
  992    992   
}
  993    993   
  994         -
/// Cross-operation shared-state singletons
         994  +
// Cross-operation shared-state singletons
  995    995   
  996    996   
/// A plugin that enables configuration for a single operation invocation
  997    997   
///
  998    998   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
  999    999   
/// In the case of default values requested, they will be obtained from `client_config`.
 1000   1000   
#[derive(Debug)]
 1001   1001   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1002   1002   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1003   1003   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1004   1004   
}

tmp-codegen-diff/codegen-client-test/json_rpc11/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@
  462    462   
    ///     .identity_cache(
  463    463   
    ///         IdentityCache::lazy()
  464    464   
    ///             // change the load timeout to 10 seconds
  465    465   
    ///             .load_timeout(Duration::from_secs(10))
  466    466   
    ///             .build()
  467    467   
    ///     )
  468    468   
    ///     // ...
  469    469   
    ///     .build();
  470    470   
    /// let client = json_rpc11::Client::from_conf(config);
  471    471   
    /// ```
  472         -
         472  +
    ///
  473    473   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  474    474   
        self.set_identity_cache(identity_cache);
  475    475   
        self
  476    476   
    }
  477    477   
  478    478   
    /// Set the identity cache for auth.
  479    479   
    ///
  480    480   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  481    481   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  482    482   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  483    483   
    /// the next request will result in refreshing the identity.
  484    484   
    ///
  485    485   
    /// This configuration allows you to disable or change the default caching mechanism.
  486    486   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  487    487   
    /// trait and pass that implementation into this function.
  488    488   
    ///
  489    489   
    /// # Examples
  490    490   
    ///
  491    491   
    /// Disabling identity caching:
  492    492   
    /// ```no_run
  493    493   
    /// use json_rpc11::config::IdentityCache;
  494    494   
    ///
  495    495   
    /// let config = json_rpc11::Config::builder()
  496    496   
    ///     .identity_cache(IdentityCache::no_cache())
  497    497   
    ///     // ...
  498    498   
    ///     .build();
  499    499   
    /// let client = json_rpc11::Client::from_conf(config);
  500    500   
    /// ```
  501    501   
    ///
  502    502   
    /// Customizing lazy caching:
  503    503   
    /// ```no_run
  504    504   
    /// use json_rpc11::config::IdentityCache;
  505    505   
    /// use std::time::Duration;
  506    506   
    ///
  507    507   
    /// let config = json_rpc11::Config::builder()
  508    508   
    ///     .identity_cache(
  509    509   
    ///         IdentityCache::lazy()
  510    510   
    ///             // change the load timeout to 10 seconds
  511    511   
    ///             .load_timeout(Duration::from_secs(10))
  512    512   
    ///             .build()
  513    513   
    ///     )
  514    514   
    ///     // ...
  515    515   
    ///     .build();
  516    516   
    /// let client = json_rpc11::Client::from_conf(config);
  517    517   
    /// ```
  518         -
         518  +
    ///
  519    519   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  520    520   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  521    521   
        self
  522    522   
    }
  523    523   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  524    524   
    ///
  525    525   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  526    526   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  527    527   
    /// will run after those default interceptors.
  528    528   
    ///
@@ -834,834 +929,929 @@
  854    854   
    /// Customizing behavior major version:
  855    855   
    /// ```no_run
  856    856   
    /// use json_rpc11::config::BehaviorVersion;
  857    857   
    ///
  858    858   
    /// let config = json_rpc11::Config::builder()
  859    859   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  860    860   
    ///     // ...
  861    861   
    ///     .build();
  862    862   
    /// let client = json_rpc11::Client::from_conf(config);
  863    863   
    /// ```
  864         -
         864  +
    ///
  865    865   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
  866    866   
        self.set_behavior_version(Some(behavior_version));
  867    867   
        self
  868    868   
    }
  869    869   
  870    870   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
  871    871   
    ///
  872    872   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
  873    873   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
  874    874   
    /// all operations might be the ideal behavior but could break existing applications.
  875    875   
    ///
  876    876   
    /// # Examples
  877    877   
    ///
  878    878   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
  879    879   
    /// ```no_run
  880    880   
    /// use json_rpc11::config::BehaviorVersion;
  881    881   
    ///
  882    882   
    /// let config = json_rpc11::Config::builder()
  883    883   
    ///     .behavior_version(BehaviorVersion::latest())
  884    884   
    ///     // ...
  885    885   
    ///     .build();
  886    886   
    /// let client = json_rpc11::Client::from_conf(config);
  887    887   
    /// ```
  888    888   
    ///
  889    889   
    /// Customizing behavior major version:
  890    890   
    /// ```no_run
  891    891   
    /// use json_rpc11::config::BehaviorVersion;
  892    892   
    ///
  893    893   
    /// let config = json_rpc11::Config::builder()
  894    894   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  895    895   
    ///     // ...
  896    896   
    ///     .build();
  897    897   
    /// let client = json_rpc11::Client::from_conf(config);
  898    898   
    /// ```
  899         -
         899  +
    ///
  900    900   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
  901    901   
        self.behavior_version = behavior_version;
  902    902   
        self
  903    903   
    }
  904    904   
  905    905   
    /// Convenience method to set the latest behavior major version
  906    906   
    ///
  907    907   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
  908    908   
    pub fn behavior_version_latest(mut self) -> Self {
  909    909   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -964,964 +1024,1024 @@
  984    984   
    }
  985    985   
  986    986   
    fn runtime_components(
  987    987   
        &self,
  988    988   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  989    989   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  990    990   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
  991    991   
    }
  992    992   
}
  993    993   
  994         -
/// Cross-operation shared-state singletons
         994  +
// Cross-operation shared-state singletons
  995    995   
  996    996   
/// A plugin that enables configuration for a single operation invocation
  997    997   
///
  998    998   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
  999    999   
/// In the case of default values requested, they will be obtained from `client_config`.
 1000   1000   
#[derive(Debug)]
 1001   1001   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1002   1002   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1003   1003   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1004   1004   
}

tmp-codegen-diff/codegen-client-test/misc/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@
  462    462   
    ///     .identity_cache(
  463    463   
    ///         IdentityCache::lazy()
  464    464   
    ///             // change the load timeout to 10 seconds
  465    465   
    ///             .load_timeout(Duration::from_secs(10))
  466    466   
    ///             .build()
  467    467   
    ///     )
  468    468   
    ///     // ...
  469    469   
    ///     .build();
  470    470   
    /// let client = misc::Client::from_conf(config);
  471    471   
    /// ```
  472         -
         472  +
    ///
  473    473   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  474    474   
        self.set_identity_cache(identity_cache);
  475    475   
        self
  476    476   
    }
  477    477   
  478    478   
    /// Set the identity cache for auth.
  479    479   
    ///
  480    480   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  481    481   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  482    482   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  483    483   
    /// the next request will result in refreshing the identity.
  484    484   
    ///
  485    485   
    /// This configuration allows you to disable or change the default caching mechanism.
  486    486   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  487    487   
    /// trait and pass that implementation into this function.
  488    488   
    ///
  489    489   
    /// # Examples
  490    490   
    ///
  491    491   
    /// Disabling identity caching:
  492    492   
    /// ```no_run
  493    493   
    /// use misc::config::IdentityCache;
  494    494   
    ///
  495    495   
    /// let config = misc::Config::builder()
  496    496   
    ///     .identity_cache(IdentityCache::no_cache())
  497    497   
    ///     // ...
  498    498   
    ///     .build();
  499    499   
    /// let client = misc::Client::from_conf(config);
  500    500   
    /// ```
  501    501   
    ///
  502    502   
    /// Customizing lazy caching:
  503    503   
    /// ```no_run
  504    504   
    /// use misc::config::IdentityCache;
  505    505   
    /// use std::time::Duration;
  506    506   
    ///
  507    507   
    /// let config = misc::Config::builder()
  508    508   
    ///     .identity_cache(
  509    509   
    ///         IdentityCache::lazy()
  510    510   
    ///             // change the load timeout to 10 seconds
  511    511   
    ///             .load_timeout(Duration::from_secs(10))
  512    512   
    ///             .build()
  513    513   
    ///     )
  514    514   
    ///     // ...
  515    515   
    ///     .build();
  516    516   
    /// let client = misc::Client::from_conf(config);
  517    517   
    /// ```
  518         -
         518  +
    ///
  519    519   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  520    520   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  521    521   
        self
  522    522   
    }
  523    523   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  524    524   
    ///
  525    525   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  526    526   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  527    527   
    /// will run after those default interceptors.
  528    528   
    ///
@@ -834,834 +929,929 @@
  854    854   
    /// Customizing behavior major version:
  855    855   
    /// ```no_run
  856    856   
    /// use misc::config::BehaviorVersion;
  857    857   
    ///
  858    858   
    /// let config = misc::Config::builder()
  859    859   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  860    860   
    ///     // ...
  861    861   
    ///     .build();
  862    862   
    /// let client = misc::Client::from_conf(config);
  863    863   
    /// ```
  864         -
         864  +
    ///
  865    865   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
  866    866   
        self.set_behavior_version(Some(behavior_version));
  867    867   
        self
  868    868   
    }
  869    869   
  870    870   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
  871    871   
    ///
  872    872   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
  873    873   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
  874    874   
    /// all operations might be the ideal behavior but could break existing applications.
  875    875   
    ///
  876    876   
    /// # Examples
  877    877   
    ///
  878    878   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
  879    879   
    /// ```no_run
  880    880   
    /// use misc::config::BehaviorVersion;
  881    881   
    ///
  882    882   
    /// let config = misc::Config::builder()
  883    883   
    ///     .behavior_version(BehaviorVersion::latest())
  884    884   
    ///     // ...
  885    885   
    ///     .build();
  886    886   
    /// let client = misc::Client::from_conf(config);
  887    887   
    /// ```
  888    888   
    ///
  889    889   
    /// Customizing behavior major version:
  890    890   
    /// ```no_run
  891    891   
    /// use misc::config::BehaviorVersion;
  892    892   
    ///
  893    893   
    /// let config = misc::Config::builder()
  894    894   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  895    895   
    ///     // ...
  896    896   
    ///     .build();
  897    897   
    /// let client = misc::Client::from_conf(config);
  898    898   
    /// ```
  899         -
         899  +
    ///
  900    900   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
  901    901   
        self.behavior_version = behavior_version;
  902    902   
        self
  903    903   
    }
  904    904   
  905    905   
    /// Convenience method to set the latest behavior major version
  906    906   
    ///
  907    907   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
  908    908   
    pub fn behavior_version_latest(mut self) -> Self {
  909    909   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -964,964 +1024,1024 @@
  984    984   
    }
  985    985   
  986    986   
    fn runtime_components(
  987    987   
        &self,
  988    988   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  989    989   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  990    990   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
  991    991   
    }
  992    992   
}
  993    993   
  994         -
/// Cross-operation shared-state singletons
         994  +
// Cross-operation shared-state singletons
  995    995   
  996    996   
/// A plugin that enables configuration for a single operation invocation
  997    997   
///
  998    998   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
  999    999   
/// In the case of default values requested, they will be obtained from `client_config`.
 1000   1000   
#[derive(Debug)]
 1001   1001   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1002   1002   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1003   1003   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1004   1004   
}

tmp-codegen-diff/codegen-client-test/naming_test_casing/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@
  462    462   
    ///     .identity_cache(
  463    463   
    ///         IdentityCache::lazy()
  464    464   
    ///             // change the load timeout to 10 seconds
  465    465   
    ///             .load_timeout(Duration::from_secs(10))
  466    466   
    ///             .build()
  467    467   
    ///     )
  468    468   
    ///     // ...
  469    469   
    ///     .build();
  470    470   
    /// let client = naming_test_casing::Client::from_conf(config);
  471    471   
    /// ```
  472         -
         472  +
    ///
  473    473   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  474    474   
        self.set_identity_cache(identity_cache);
  475    475   
        self
  476    476   
    }
  477    477   
  478    478   
    /// Set the identity cache for auth.
  479    479   
    ///
  480    480   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  481    481   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  482    482   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  483    483   
    /// the next request will result in refreshing the identity.
  484    484   
    ///
  485    485   
    /// This configuration allows you to disable or change the default caching mechanism.
  486    486   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  487    487   
    /// trait and pass that implementation into this function.
  488    488   
    ///
  489    489   
    /// # Examples
  490    490   
    ///
  491    491   
    /// Disabling identity caching:
  492    492   
    /// ```no_run
  493    493   
    /// use naming_test_casing::config::IdentityCache;
  494    494   
    ///
  495    495   
    /// let config = naming_test_casing::Config::builder()
  496    496   
    ///     .identity_cache(IdentityCache::no_cache())
  497    497   
    ///     // ...
  498    498   
    ///     .build();
  499    499   
    /// let client = naming_test_casing::Client::from_conf(config);
  500    500   
    /// ```
  501    501   
    ///
  502    502   
    /// Customizing lazy caching:
  503    503   
    /// ```no_run
  504    504   
    /// use naming_test_casing::config::IdentityCache;
  505    505   
    /// use std::time::Duration;
  506    506   
    ///
  507    507   
    /// let config = naming_test_casing::Config::builder()
  508    508   
    ///     .identity_cache(
  509    509   
    ///         IdentityCache::lazy()
  510    510   
    ///             // change the load timeout to 10 seconds
  511    511   
    ///             .load_timeout(Duration::from_secs(10))
  512    512   
    ///             .build()
  513    513   
    ///     )
  514    514   
    ///     // ...
  515    515   
    ///     .build();
  516    516   
    /// let client = naming_test_casing::Client::from_conf(config);
  517    517   
    /// ```
  518         -
         518  +
    ///
  519    519   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  520    520   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  521    521   
        self
  522    522   
    }
  523    523   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  524    524   
    ///
  525    525   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  526    526   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  527    527   
    /// will run after those default interceptors.
  528    528   
    ///
@@ -834,834 +929,929 @@
  854    854   
    /// Customizing behavior major version:
  855    855   
    /// ```no_run
  856    856   
    /// use naming_test_casing::config::BehaviorVersion;
  857    857   
    ///
  858    858   
    /// let config = naming_test_casing::Config::builder()
  859    859   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  860    860   
    ///     // ...
  861    861   
    ///     .build();
  862    862   
    /// let client = naming_test_casing::Client::from_conf(config);
  863    863   
    /// ```
  864         -
         864  +
    ///
  865    865   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
  866    866   
        self.set_behavior_version(Some(behavior_version));
  867    867   
        self
  868    868   
    }
  869    869   
  870    870   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
  871    871   
    ///
  872    872   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
  873    873   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
  874    874   
    /// all operations might be the ideal behavior but could break existing applications.
  875    875   
    ///
  876    876   
    /// # Examples
  877    877   
    ///
  878    878   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
  879    879   
    /// ```no_run
  880    880   
    /// use naming_test_casing::config::BehaviorVersion;
  881    881   
    ///
  882    882   
    /// let config = naming_test_casing::Config::builder()
  883    883   
    ///     .behavior_version(BehaviorVersion::latest())
  884    884   
    ///     // ...
  885    885   
    ///     .build();
  886    886   
    /// let client = naming_test_casing::Client::from_conf(config);
  887    887   
    /// ```
  888    888   
    ///
  889    889   
    /// Customizing behavior major version:
  890    890   
    /// ```no_run
  891    891   
    /// use naming_test_casing::config::BehaviorVersion;
  892    892   
    ///
  893    893   
    /// let config = naming_test_casing::Config::builder()
  894    894   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  895    895   
    ///     // ...
  896    896   
    ///     .build();
  897    897   
    /// let client = naming_test_casing::Client::from_conf(config);
  898    898   
    /// ```
  899         -
         899  +
    ///
  900    900   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
  901    901   
        self.behavior_version = behavior_version;
  902    902   
        self
  903    903   
    }
  904    904   
  905    905   
    /// Convenience method to set the latest behavior major version
  906    906   
    ///
  907    907   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
  908    908   
    pub fn behavior_version_latest(mut self) -> Self {
  909    909   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -966,966 +1026,1026 @@
  986    986   
    }
  987    987   
  988    988   
    fn runtime_components(
  989    989   
        &self,
  990    990   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  991    991   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  992    992   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
  993    993   
    }
  994    994   
}
  995    995   
  996         -
/// Cross-operation shared-state singletons
         996  +
// Cross-operation shared-state singletons
  997    997   
  998    998   
/// A plugin that enables configuration for a single operation invocation
  999    999   
///
 1000   1000   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 1001   1001   
/// In the case of default values requested, they will be obtained from `client_config`.
 1002   1002   
#[derive(Debug)]
 1003   1003   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1004   1004   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1005   1005   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1006   1006   
}

tmp-codegen-diff/codegen-client-test/naming_test_ops/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@
  462    462   
    ///     .identity_cache(
  463    463   
    ///         IdentityCache::lazy()
  464    464   
    ///             // change the load timeout to 10 seconds
  465    465   
    ///             .load_timeout(Duration::from_secs(10))
  466    466   
    ///             .build()
  467    467   
    ///     )
  468    468   
    ///     // ...
  469    469   
    ///     .build();
  470    470   
    /// let client = naming_test_ops::Client::from_conf(config);
  471    471   
    /// ```
  472         -
         472  +
    ///
  473    473   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  474    474   
        self.set_identity_cache(identity_cache);
  475    475   
        self
  476    476   
    }
  477    477   
  478    478   
    /// Set the identity cache for auth.
  479    479   
    ///
  480    480   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  481    481   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  482    482   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  483    483   
    /// the next request will result in refreshing the identity.
  484    484   
    ///
  485    485   
    /// This configuration allows you to disable or change the default caching mechanism.
  486    486   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  487    487   
    /// trait and pass that implementation into this function.
  488    488   
    ///
  489    489   
    /// # Examples
  490    490   
    ///
  491    491   
    /// Disabling identity caching:
  492    492   
    /// ```no_run
  493    493   
    /// use naming_test_ops::config::IdentityCache;
  494    494   
    ///
  495    495   
    /// let config = naming_test_ops::Config::builder()
  496    496   
    ///     .identity_cache(IdentityCache::no_cache())
  497    497   
    ///     // ...
  498    498   
    ///     .build();
  499    499   
    /// let client = naming_test_ops::Client::from_conf(config);
  500    500   
    /// ```
  501    501   
    ///
  502    502   
    /// Customizing lazy caching:
  503    503   
    /// ```no_run
  504    504   
    /// use naming_test_ops::config::IdentityCache;
  505    505   
    /// use std::time::Duration;
  506    506   
    ///
  507    507   
    /// let config = naming_test_ops::Config::builder()
  508    508   
    ///     .identity_cache(
  509    509   
    ///         IdentityCache::lazy()
  510    510   
    ///             // change the load timeout to 10 seconds
  511    511   
    ///             .load_timeout(Duration::from_secs(10))
  512    512   
    ///             .build()
  513    513   
    ///     )
  514    514   
    ///     // ...
  515    515   
    ///     .build();
  516    516   
    /// let client = naming_test_ops::Client::from_conf(config);
  517    517   
    /// ```
  518         -
         518  +
    ///
  519    519   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  520    520   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  521    521   
        self
  522    522   
    }
  523    523   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  524    524   
    ///
  525    525   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  526    526   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  527    527   
    /// will run after those default interceptors.
  528    528   
    ///
@@ -834,834 +929,929 @@
  854    854   
    /// Customizing behavior major version:
  855    855   
    /// ```no_run
  856    856   
    /// use naming_test_ops::config::BehaviorVersion;
  857    857   
    ///
  858    858   
    /// let config = naming_test_ops::Config::builder()
  859    859   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  860    860   
    ///     // ...
  861    861   
    ///     .build();
  862    862   
    /// let client = naming_test_ops::Client::from_conf(config);
  863    863   
    /// ```
  864         -
         864  +
    ///
  865    865   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
  866    866   
        self.set_behavior_version(Some(behavior_version));
  867    867   
        self
  868    868   
    }
  869    869   
  870    870   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
  871    871   
    ///
  872    872   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
  873    873   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
  874    874   
    /// all operations might be the ideal behavior but could break existing applications.
  875    875   
    ///
  876    876   
    /// # Examples
  877    877   
    ///
  878    878   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
  879    879   
    /// ```no_run
  880    880   
    /// use naming_test_ops::config::BehaviorVersion;
  881    881   
    ///
  882    882   
    /// let config = naming_test_ops::Config::builder()
  883    883   
    ///     .behavior_version(BehaviorVersion::latest())
  884    884   
    ///     // ...
  885    885   
    ///     .build();
  886    886   
    /// let client = naming_test_ops::Client::from_conf(config);
  887    887   
    /// ```
  888    888   
    ///
  889    889   
    /// Customizing behavior major version:
  890    890   
    /// ```no_run
  891    891   
    /// use naming_test_ops::config::BehaviorVersion;
  892    892   
    ///
  893    893   
    /// let config = naming_test_ops::Config::builder()
  894    894   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  895    895   
    ///     // ...
  896    896   
    ///     .build();
  897    897   
    /// let client = naming_test_ops::Client::from_conf(config);
  898    898   
    /// ```
  899         -
         899  +
    ///
  900    900   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
  901    901   
        self.behavior_version = behavior_version;
  902    902   
        self
  903    903   
    }
  904    904   
  905    905   
    /// Convenience method to set the latest behavior major version
  906    906   
    ///
  907    907   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
  908    908   
    pub fn behavior_version_latest(mut self) -> Self {
  909    909   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -966,966 +1026,1026 @@
  986    986   
    }
  987    987   
  988    988   
    fn runtime_components(
  989    989   
        &self,
  990    990   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  991    991   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  992    992   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
  993    993   
    }
  994    994   
}
  995    995   
  996         -
/// Cross-operation shared-state singletons
         996  +
// Cross-operation shared-state singletons
  997    997   
  998    998   
/// A plugin that enables configuration for a single operation invocation
  999    999   
///
 1000   1000   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 1001   1001   
/// In the case of default values requested, they will be obtained from `client_config`.
 1002   1002   
#[derive(Debug)]
 1003   1003   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1004   1004   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1005   1005   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1006   1006   
}

tmp-codegen-diff/codegen-client-test/naming_test_structs/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@
  462    462   
    ///     .identity_cache(
  463    463   
    ///         IdentityCache::lazy()
  464    464   
    ///             // change the load timeout to 10 seconds
  465    465   
    ///             .load_timeout(Duration::from_secs(10))
  466    466   
    ///             .build()
  467    467   
    ///     )
  468    468   
    ///     // ...
  469    469   
    ///     .build();
  470    470   
    /// let client = naming_test_structs::Client::from_conf(config);
  471    471   
    /// ```
  472         -
         472  +
    ///
  473    473   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  474    474   
        self.set_identity_cache(identity_cache);
  475    475   
        self
  476    476   
    }
  477    477   
  478    478   
    /// Set the identity cache for auth.
  479    479   
    ///
  480    480   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  481    481   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  482    482   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  483    483   
    /// the next request will result in refreshing the identity.
  484    484   
    ///
  485    485   
    /// This configuration allows you to disable or change the default caching mechanism.
  486    486   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  487    487   
    /// trait and pass that implementation into this function.
  488    488   
    ///
  489    489   
    /// # Examples
  490    490   
    ///
  491    491   
    /// Disabling identity caching:
  492    492   
    /// ```no_run
  493    493   
    /// use naming_test_structs::config::IdentityCache;
  494    494   
    ///
  495    495   
    /// let config = naming_test_structs::Config::builder()
  496    496   
    ///     .identity_cache(IdentityCache::no_cache())
  497    497   
    ///     // ...
  498    498   
    ///     .build();
  499    499   
    /// let client = naming_test_structs::Client::from_conf(config);
  500    500   
    /// ```
  501    501   
    ///
  502    502   
    /// Customizing lazy caching:
  503    503   
    /// ```no_run
  504    504   
    /// use naming_test_structs::config::IdentityCache;
  505    505   
    /// use std::time::Duration;
  506    506   
    ///
  507    507   
    /// let config = naming_test_structs::Config::builder()
  508    508   
    ///     .identity_cache(
  509    509   
    ///         IdentityCache::lazy()
  510    510   
    ///             // change the load timeout to 10 seconds
  511    511   
    ///             .load_timeout(Duration::from_secs(10))
  512    512   
    ///             .build()
  513    513   
    ///     )
  514    514   
    ///     // ...
  515    515   
    ///     .build();
  516    516   
    /// let client = naming_test_structs::Client::from_conf(config);
  517    517   
    /// ```
  518         -
         518  +
    ///
  519    519   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  520    520   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  521    521   
        self
  522    522   
    }
  523    523   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  524    524   
    ///
  525    525   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  526    526   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  527    527   
    /// will run after those default interceptors.
  528    528   
    ///
@@ -834,834 +929,929 @@
  854    854   
    /// Customizing behavior major version:
  855    855   
    /// ```no_run
  856    856   
    /// use naming_test_structs::config::BehaviorVersion;
  857    857   
    ///
  858    858   
    /// let config = naming_test_structs::Config::builder()
  859    859   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  860    860   
    ///     // ...
  861    861   
    ///     .build();
  862    862   
    /// let client = naming_test_structs::Client::from_conf(config);
  863    863   
    /// ```
  864         -
         864  +
    ///
  865    865   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
  866    866   
        self.set_behavior_version(Some(behavior_version));
  867    867   
        self
  868    868   
    }
  869    869   
  870    870   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
  871    871   
    ///
  872    872   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
  873    873   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
  874    874   
    /// all operations might be the ideal behavior but could break existing applications.
  875    875   
    ///
  876    876   
    /// # Examples
  877    877   
    ///
  878    878   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
  879    879   
    /// ```no_run
  880    880   
    /// use naming_test_structs::config::BehaviorVersion;
  881    881   
    ///
  882    882   
    /// let config = naming_test_structs::Config::builder()
  883    883   
    ///     .behavior_version(BehaviorVersion::latest())
  884    884   
    ///     // ...
  885    885   
    ///     .build();
  886    886   
    /// let client = naming_test_structs::Client::from_conf(config);
  887    887   
    /// ```
  888    888   
    ///
  889    889   
    /// Customizing behavior major version:
  890    890   
    /// ```no_run
  891    891   
    /// use naming_test_structs::config::BehaviorVersion;
  892    892   
    ///
  893    893   
    /// let config = naming_test_structs::Config::builder()
  894    894   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  895    895   
    ///     // ...
  896    896   
    ///     .build();
  897    897   
    /// let client = naming_test_structs::Client::from_conf(config);
  898    898   
    /// ```
  899         -
         899  +
    ///
  900    900   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
  901    901   
        self.behavior_version = behavior_version;
  902    902   
        self
  903    903   
    }
  904    904   
  905    905   
    /// Convenience method to set the latest behavior major version
  906    906   
    ///
  907    907   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
  908    908   
    pub fn behavior_version_latest(mut self) -> Self {
  909    909   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -966,966 +1026,1026 @@
  986    986   
    }
  987    987   
  988    988   
    fn runtime_components(
  989    989   
        &self,
  990    990   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  991    991   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  992    992   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
  993    993   
    }
  994    994   
}
  995    995   
  996         -
/// Cross-operation shared-state singletons
         996  +
// Cross-operation shared-state singletons
  997    997   
  998    998   
/// A plugin that enables configuration for a single operation invocation
  999    999   
///
 1000   1000   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 1001   1001   
/// In the case of default values requested, they will be obtained from `client_config`.
 1002   1002   
#[derive(Debug)]
 1003   1003   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1004   1004   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1005   1005   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1006   1006   
}

tmp-codegen-diff/codegen-client-test/pokemon-service-awsjson-client/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@
  462    462   
    ///     .identity_cache(
  463    463   
    ///         IdentityCache::lazy()
  464    464   
    ///             // change the load timeout to 10 seconds
  465    465   
    ///             .load_timeout(Duration::from_secs(10))
  466    466   
    ///             .build()
  467    467   
    ///     )
  468    468   
    ///     // ...
  469    469   
    ///     .build();
  470    470   
    /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
  471    471   
    /// ```
  472         -
         472  +
    ///
  473    473   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  474    474   
        self.set_identity_cache(identity_cache);
  475    475   
        self
  476    476   
    }
  477    477   
  478    478   
    /// Set the identity cache for auth.
  479    479   
    ///
  480    480   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  481    481   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  482    482   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  483    483   
    /// the next request will result in refreshing the identity.
  484    484   
    ///
  485    485   
    /// This configuration allows you to disable or change the default caching mechanism.
  486    486   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  487    487   
    /// trait and pass that implementation into this function.
  488    488   
    ///
  489    489   
    /// # Examples
  490    490   
    ///
  491    491   
    /// Disabling identity caching:
  492    492   
    /// ```no_run
  493    493   
    /// use pokemon_service_awsjson_client::config::IdentityCache;
  494    494   
    ///
  495    495   
    /// let config = pokemon_service_awsjson_client::Config::builder()
  496    496   
    ///     .identity_cache(IdentityCache::no_cache())
  497    497   
    ///     // ...
  498    498   
    ///     .build();
  499    499   
    /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
  500    500   
    /// ```
  501    501   
    ///
  502    502   
    /// Customizing lazy caching:
  503    503   
    /// ```no_run
  504    504   
    /// use pokemon_service_awsjson_client::config::IdentityCache;
  505    505   
    /// use std::time::Duration;
  506    506   
    ///
  507    507   
    /// let config = pokemon_service_awsjson_client::Config::builder()
  508    508   
    ///     .identity_cache(
  509    509   
    ///         IdentityCache::lazy()
  510    510   
    ///             // change the load timeout to 10 seconds
  511    511   
    ///             .load_timeout(Duration::from_secs(10))
  512    512   
    ///             .build()
  513    513   
    ///     )
  514    514   
    ///     // ...
  515    515   
    ///     .build();
  516    516   
    /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
  517    517   
    /// ```
  518         -
         518  +
    ///
  519    519   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  520    520   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  521    521   
        self
  522    522   
    }
  523    523   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  524    524   
    ///
  525    525   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  526    526   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  527    527   
    /// will run after those default interceptors.
  528    528   
    ///
@@ -834,834 +929,929 @@
  854    854   
    /// Customizing behavior major version:
  855    855   
    /// ```no_run
  856    856   
    /// use pokemon_service_awsjson_client::config::BehaviorVersion;
  857    857   
    ///
  858    858   
    /// let config = pokemon_service_awsjson_client::Config::builder()
  859    859   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  860    860   
    ///     // ...
  861    861   
    ///     .build();
  862    862   
    /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
  863    863   
    /// ```
  864         -
         864  +
    ///
  865    865   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
  866    866   
        self.set_behavior_version(Some(behavior_version));
  867    867   
        self
  868    868   
    }
  869    869   
  870    870   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
  871    871   
    ///
  872    872   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
  873    873   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
  874    874   
    /// all operations might be the ideal behavior but could break existing applications.
  875    875   
    ///
  876    876   
    /// # Examples
  877    877   
    ///
  878    878   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
  879    879   
    /// ```no_run
  880    880   
    /// use pokemon_service_awsjson_client::config::BehaviorVersion;
  881    881   
    ///
  882    882   
    /// let config = pokemon_service_awsjson_client::Config::builder()
  883    883   
    ///     .behavior_version(BehaviorVersion::latest())
  884    884   
    ///     // ...
  885    885   
    ///     .build();
  886    886   
    /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
  887    887   
    /// ```
  888    888   
    ///
  889    889   
    /// Customizing behavior major version:
  890    890   
    /// ```no_run
  891    891   
    /// use pokemon_service_awsjson_client::config::BehaviorVersion;
  892    892   
    ///
  893    893   
    /// let config = pokemon_service_awsjson_client::Config::builder()
  894    894   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  895    895   
    ///     // ...
  896    896   
    ///     .build();
  897    897   
    /// let client = pokemon_service_awsjson_client::Client::from_conf(config);
  898    898   
    /// ```
  899         -
         899  +
    ///
  900    900   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
  901    901   
        self.behavior_version = behavior_version;
  902    902   
        self
  903    903   
    }
  904    904   
  905    905   
    /// Convenience method to set the latest behavior major version
  906    906   
    ///
  907    907   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
  908    908   
    pub fn behavior_version_latest(mut self) -> Self {
  909    909   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -966,966 +1026,1026 @@
  986    986   
    }
  987    987   
  988    988   
    fn runtime_components(
  989    989   
        &self,
  990    990   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  991    991   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  992    992   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
  993    993   
    }
  994    994   
}
  995    995   
  996         -
/// Cross-operation shared-state singletons
         996  +
// Cross-operation shared-state singletons
  997    997   
  998    998   
/// A plugin that enables configuration for a single operation invocation
  999    999   
///
 1000   1000   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 1001   1001   
/// In the case of default values requested, they will be obtained from `client_config`.
 1002   1002   
#[derive(Debug)]
 1003   1003   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1004   1004   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1005   1005   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1006   1006   
}

tmp-codegen-diff/codegen-client-test/pokemon-service-client/rust-client-codegen/src/config.rs

@@ -442,442 +548,548 @@
  462    462   
    ///     .identity_cache(
  463    463   
    ///         IdentityCache::lazy()
  464    464   
    ///             // change the load timeout to 10 seconds
  465    465   
    ///             .load_timeout(Duration::from_secs(10))
  466    466   
    ///             .build()
  467    467   
    ///     )
  468    468   
    ///     // ...
  469    469   
    ///     .build();
  470    470   
    /// let client = pokemon_service_client::Client::from_conf(config);
  471    471   
    /// ```
  472         -
         472  +
    ///
  473    473   
    pub fn identity_cache(mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> Self {
  474    474   
        self.set_identity_cache(identity_cache);
  475    475   
        self
  476    476   
    }
  477    477   
  478    478   
    /// Set the identity cache for auth.
  479    479   
    ///
  480    480   
    /// The identity cache defaults to a lazy caching implementation that will resolve
  481    481   
    /// an identity when it is requested, and place it in the cache thereafter. Subsequent
  482    482   
    /// requests will take the value from the cache while it is still valid. Once it expires,
  483    483   
    /// the next request will result in refreshing the identity.
  484    484   
    ///
  485    485   
    /// This configuration allows you to disable or change the default caching mechanism.
  486    486   
    /// To use a custom caching mechanism, implement the [`ResolveCachedIdentity`](crate::config::ResolveCachedIdentity)
  487    487   
    /// trait and pass that implementation into this function.
  488    488   
    ///
  489    489   
    /// # Examples
  490    490   
    ///
  491    491   
    /// Disabling identity caching:
  492    492   
    /// ```no_run
  493    493   
    /// use pokemon_service_client::config::IdentityCache;
  494    494   
    ///
  495    495   
    /// let config = pokemon_service_client::Config::builder()
  496    496   
    ///     .identity_cache(IdentityCache::no_cache())
  497    497   
    ///     // ...
  498    498   
    ///     .build();
  499    499   
    /// let client = pokemon_service_client::Client::from_conf(config);
  500    500   
    /// ```
  501    501   
    ///
  502    502   
    /// Customizing lazy caching:
  503    503   
    /// ```no_run
  504    504   
    /// use pokemon_service_client::config::IdentityCache;
  505    505   
    /// use std::time::Duration;
  506    506   
    ///
  507    507   
    /// let config = pokemon_service_client::Config::builder()
  508    508   
    ///     .identity_cache(
  509    509   
    ///         IdentityCache::lazy()
  510    510   
    ///             // change the load timeout to 10 seconds
  511    511   
    ///             .load_timeout(Duration::from_secs(10))
  512    512   
    ///             .build()
  513    513   
    ///     )
  514    514   
    ///     // ...
  515    515   
    ///     .build();
  516    516   
    /// let client = pokemon_service_client::Client::from_conf(config);
  517    517   
    /// ```
  518         -
         518  +
    ///
  519    519   
    pub fn set_identity_cache(&mut self, identity_cache: impl crate::config::ResolveCachedIdentity + 'static) -> &mut Self {
  520    520   
        self.runtime_components.set_identity_cache(::std::option::Option::Some(identity_cache));
  521    521   
        self
  522    522   
    }
  523    523   
    /// Add an [interceptor](crate::config::Intercept) that runs at specific stages of the request execution pipeline.
  524    524   
    ///
  525    525   
    /// Interceptors targeted at a certain stage are executed according to the pre-defined priority.
  526    526   
    /// The SDK provides a default set of interceptors. An interceptor configured by this method
  527    527   
    /// will run after those default interceptors.
  528    528   
    ///
@@ -834,834 +929,929 @@
  854    854   
    /// Customizing behavior major version:
  855    855   
    /// ```no_run
  856    856   
    /// use pokemon_service_client::config::BehaviorVersion;
  857    857   
    ///
  858    858   
    /// let config = pokemon_service_client::Config::builder()
  859    859   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  860    860   
    ///     // ...
  861    861   
    ///     .build();
  862    862   
    /// let client = pokemon_service_client::Client::from_conf(config);
  863    863   
    /// ```
  864         -
         864  +
    ///
  865    865   
    pub fn behavior_version(mut self, behavior_version: crate::config::BehaviorVersion) -> Self {
  866    866   
        self.set_behavior_version(Some(behavior_version));
  867    867   
        self
  868    868   
    }
  869    869   
  870    870   
    /// Sets the [`behavior major version`](crate::config::BehaviorVersion).
  871    871   
    ///
  872    872   
    /// Over time, new best-practice behaviors are introduced. However, these behaviors might not be backwards
  873    873   
    /// compatible. For example, a change which introduces new default timeouts or a new retry-mode for
  874    874   
    /// all operations might be the ideal behavior but could break existing applications.
  875    875   
    ///
  876    876   
    /// # Examples
  877    877   
    ///
  878    878   
    /// Set the behavior major version to `latest`. This is equivalent to enabling the `behavior-version-latest` cargo feature.
  879    879   
    /// ```no_run
  880    880   
    /// use pokemon_service_client::config::BehaviorVersion;
  881    881   
    ///
  882    882   
    /// let config = pokemon_service_client::Config::builder()
  883    883   
    ///     .behavior_version(BehaviorVersion::latest())
  884    884   
    ///     // ...
  885    885   
    ///     .build();
  886    886   
    /// let client = pokemon_service_client::Client::from_conf(config);
  887    887   
    /// ```
  888    888   
    ///
  889    889   
    /// Customizing behavior major version:
  890    890   
    /// ```no_run
  891    891   
    /// use pokemon_service_client::config::BehaviorVersion;
  892    892   
    ///
  893    893   
    /// let config = pokemon_service_client::Config::builder()
  894    894   
    ///     .behavior_version(BehaviorVersion::v2023_11_09())
  895    895   
    ///     // ...
  896    896   
    ///     .build();
  897    897   
    /// let client = pokemon_service_client::Client::from_conf(config);
  898    898   
    /// ```
  899         -
         899  +
    ///
  900    900   
    pub fn set_behavior_version(&mut self, behavior_version: Option<crate::config::BehaviorVersion>) -> &mut Self {
  901    901   
        self.behavior_version = behavior_version;
  902    902   
        self
  903    903   
    }
  904    904   
  905    905   
    /// Convenience method to set the latest behavior major version
  906    906   
    ///
  907    907   
    /// This is equivalent to enabling the `behavior-version-latest` Cargo feature
  908    908   
    pub fn behavior_version_latest(mut self) -> Self {
  909    909   
        self.set_behavior_version(Some(crate::config::BehaviorVersion::latest()));
@@ -966,966 +1026,1026 @@
  986    986   
    }
  987    987   
  988    988   
    fn runtime_components(
  989    989   
        &self,
  990    990   
        _: &::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
  991    991   
    ) -> ::std::borrow::Cow<'_, ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder> {
  992    992   
        ::std::borrow::Cow::Borrowed(&self.runtime_components)
  993    993   
    }
  994    994   
}
  995    995   
  996         -
/// Cross-operation shared-state singletons
         996  +
// Cross-operation shared-state singletons
  997    997   
  998    998   
/// A plugin that enables configuration for a single operation invocation
  999    999   
///
 1000   1000   
/// The `config` method will return a `FrozenLayer` by storing values from `config_override`.
 1001   1001   
/// In the case of default values requested, they will be obtained from `client_config`.
 1002   1002   
#[derive(Debug)]
 1003   1003   
pub(crate) struct ConfigOverrideRuntimePlugin {
 1004   1004   
    pub(crate) config: ::aws_smithy_types::config_bag::FrozenLayer,
 1005   1005   
    pub(crate) components: ::aws_smithy_runtime_api::client::runtime_components::RuntimeComponentsBuilder,
 1006   1006   
}