Server Test Python

Server Test Python

rev. d838bf488731ae5e751cce0fe13f339a5b9be858 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/src/output.rs

@@ -1,1 +289,336 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
#[::pyo3::pyclass]
           3  +
/// :param payload typing.Optional\[str\]:
    3      4   
/// :rtype None:
    4      5   
#[allow(missing_docs)] // documentation missing in model
    5      6   
#[derive(
    6      7   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
    7      8   
)]
    8         -
pub struct HttpQueryParamsOnlyOperationOutput {}
           9  +
pub struct StringPayloadOutput {
          10  +
    #[pyo3(get, set)]
          11  +
    /// :type typing.Optional\[str\]:
          12  +
    #[allow(missing_docs)] // documentation missing in model
          13  +
    pub payload: ::std::option::Option<::std::string::String>,
          14  +
}
          15  +
impl StringPayloadOutput {
          16  +
    #[allow(missing_docs)] // documentation missing in model
          17  +
    pub fn payload(&self) -> ::std::option::Option<&str> {
          18  +
        self.payload.as_deref()
          19  +
    }
          20  +
}
    9     21   
#[allow(clippy::new_without_default)]
   10     22   
#[allow(clippy::too_many_arguments)]
   11     23   
#[::pyo3::pymethods]
   12         -
impl HttpQueryParamsOnlyOperationOutput {
          24  +
impl StringPayloadOutput {
   13     25   
    #[new]
   14         -
    pub fn new() -> Self {
   15         -
        Self {}
          26  +
    pub fn new(payload: ::std::option::Option<::std::string::String>) -> Self {
          27  +
        Self { payload }
   16     28   
    }
   17     29   
    fn __repr__(&self) -> String {
   18     30   
        format!("{self:?}")
   19     31   
    }
   20     32   
    fn __str__(&self) -> String {
   21     33   
        format!("{self:?}")
   22     34   
    }
   23     35   
}
   24         -
impl<'source> ::pyo3::FromPyObject<'source>
   25         -
    for std::boxed::Box<HttpQueryParamsOnlyOperationOutput>
   26         -
{
          36  +
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<StringPayloadOutput> {
   27     37   
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
   28         -
        ob.extract::<HttpQueryParamsOnlyOperationOutput>()
   29         -
            .map(Box::new)
          38  +
        ob.extract::<StringPayloadOutput>().map(Box::new)
   30     39   
    }
   31     40   
}
   32     41   
   33         -
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<HttpQueryParamsOnlyOperationOutput> {
          42  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<StringPayloadOutput> {
   34     43   
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
   35     44   
        (*self).into_py(py)
   36     45   
    }
   37     46   
}
   38         -
impl HttpQueryParamsOnlyOperationOutput {
   39         -
    /// Creates a new builder-style object to manufacture [`HttpQueryParamsOnlyOperationOutput`](crate::output::HttpQueryParamsOnlyOperationOutput).
   40         -
    pub fn builder() -> crate::output::http_query_params_only_operation_output::Builder {
   41         -
        crate::output::http_query_params_only_operation_output::Builder::default()
          47  +
impl StringPayloadOutput {
          48  +
    /// Creates a new builder-style object to manufacture [`StringPayloadOutput`](crate::output::StringPayloadOutput).
          49  +
    pub fn builder() -> crate::output::string_payload_output::Builder {
          50  +
        crate::output::string_payload_output::Builder::default()
   42     51   
    }
   43     52   
}
   44     53   
   45     54   
#[::pyo3::pyclass]
          55  +
/// :param field int:
   46     56   
/// :rtype None:
   47     57   
#[allow(missing_docs)] // documentation missing in model
   48     58   
#[derive(
   49     59   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
   50     60   
)]
   51         -
pub struct QueryPrecedenceOutput {}
          61  +
pub struct PrimitiveIntHeaderOutput {
          62  +
    #[pyo3(get, set)]
          63  +
    /// :type int:
          64  +
    #[allow(missing_docs)] // documentation missing in model
          65  +
    pub field: i32,
          66  +
}
          67  +
impl PrimitiveIntHeaderOutput {
          68  +
    #[allow(missing_docs)] // documentation missing in model
          69  +
    pub fn field(&self) -> i32 {
          70  +
        self.field
          71  +
    }
          72  +
}
   52     73   
#[allow(clippy::new_without_default)]
   53     74   
#[allow(clippy::too_many_arguments)]
   54     75   
#[::pyo3::pymethods]
   55         -
impl QueryPrecedenceOutput {
          76  +
impl PrimitiveIntHeaderOutput {
   56     77   
    #[new]
   57         -
    pub fn new() -> Self {
   58         -
        Self {}
          78  +
    pub fn new(field: i32) -> Self {
          79  +
        Self { field }
   59     80   
    }
   60     81   
    fn __repr__(&self) -> String {
   61     82   
        format!("{self:?}")
   62     83   
    }
   63     84   
    fn __str__(&self) -> String {
   64     85   
        format!("{self:?}")
   65     86   
    }
   66     87   
}
   67         -
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<QueryPrecedenceOutput> {
          88  +
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<PrimitiveIntHeaderOutput> {
   68     89   
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
   69         -
        ob.extract::<QueryPrecedenceOutput>().map(Box::new)
          90  +
        ob.extract::<PrimitiveIntHeaderOutput>().map(Box::new)
   70     91   
    }
   71     92   
}
   72     93   
   73         -
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<QueryPrecedenceOutput> {
          94  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<PrimitiveIntHeaderOutput> {
   74     95   
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
   75     96   
        (*self).into_py(py)
   76     97   
    }
   77     98   
}
   78         -
impl QueryPrecedenceOutput {
   79         -
    /// Creates a new builder-style object to manufacture [`QueryPrecedenceOutput`](crate::output::QueryPrecedenceOutput).
   80         -
    pub fn builder() -> crate::output::query_precedence_output::Builder {
   81         -
        crate::output::query_precedence_output::Builder::default()
          99  +
impl PrimitiveIntHeaderOutput {
         100  +
    /// Creates a new builder-style object to manufacture [`PrimitiveIntHeaderOutput`](crate::output::PrimitiveIntHeaderOutput).
         101  +
    pub fn builder() -> crate::output::primitive_int_header_output::Builder {
         102  +
        crate::output::primitive_int_header_output::Builder::default()
   82    103   
    }
   83    104   
}
   84    105   
   85    106   
#[::pyo3::pyclass]
   86         -
/// :param empty typing.Optional\[rest_json_extras.model.EmptyStruct\]:
   87    107   
/// :rtype None:
   88    108   
#[allow(missing_docs)] // documentation missing in model
   89    109   
#[derive(
   90    110   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
   91    111   
)]
   92         -
pub struct EmptyStructWithContentOnWireOpOutput {
   93         -
    #[pyo3(get, set)]
   94         -
    /// :type typing.Optional\[rest_json_extras.model.EmptyStruct\]:
   95         -
    #[allow(missing_docs)] // documentation missing in model
   96         -
    pub empty: ::std::option::Option<crate::model::EmptyStruct>,
   97         -
}
   98         -
impl EmptyStructWithContentOnWireOpOutput {
   99         -
    #[allow(missing_docs)] // documentation missing in model
  100         -
    pub fn empty(&self) -> ::std::option::Option<&crate::model::EmptyStruct> {
  101         -
        self.empty.as_ref()
  102         -
    }
  103         -
}
         112  +
pub struct EnumQueryOutput {}
  104    113   
#[allow(clippy::new_without_default)]
  105    114   
#[allow(clippy::too_many_arguments)]
  106    115   
#[::pyo3::pymethods]
  107         -
impl EmptyStructWithContentOnWireOpOutput {
         116  +
impl EnumQueryOutput {
  108    117   
    #[new]
  109         -
    pub fn new(empty: ::std::option::Option<crate::model::EmptyStruct>) -> Self {
  110         -
        Self { empty }
         118  +
    pub fn new() -> Self {
         119  +
        Self {}
  111    120   
    }
  112    121   
    fn __repr__(&self) -> String {
  113    122   
        format!("{self:?}")
  114    123   
    }
  115    124   
    fn __str__(&self) -> String {
  116    125   
        format!("{self:?}")
  117    126   
    }
  118    127   
}
  119         -
impl<'source> ::pyo3::FromPyObject<'source>
  120         -
    for std::boxed::Box<EmptyStructWithContentOnWireOpOutput>
  121         -
{
         128  +
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<EnumQueryOutput> {
  122    129   
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
  123         -
        ob.extract::<EmptyStructWithContentOnWireOpOutput>()
  124         -
            .map(Box::new)
         130  +
        ob.extract::<EnumQueryOutput>().map(Box::new)
  125    131   
    }
  126    132   
}
  127    133   
  128         -
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<EmptyStructWithContentOnWireOpOutput> {
         134  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<EnumQueryOutput> {
  129    135   
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
  130    136   
        (*self).into_py(py)
  131    137   
    }
  132    138   
}
  133         -
impl EmptyStructWithContentOnWireOpOutput {
  134         -
    /// Creates a new builder-style object to manufacture [`EmptyStructWithContentOnWireOpOutput`](crate::output::EmptyStructWithContentOnWireOpOutput).
  135         -
    pub fn builder() -> crate::output::empty_struct_with_content_on_wire_op_output::Builder {
  136         -
        crate::output::empty_struct_with_content_on_wire_op_output::Builder::default()
         139  +
impl EnumQueryOutput {
         140  +
    /// Creates a new builder-style object to manufacture [`EnumQueryOutput`](crate::output::EnumQueryOutput).
         141  +
    pub fn builder() -> crate::output::enum_query_output::Builder {
         142  +
        crate::output::enum_query_output::Builder::default()
  137    143   
    }
  138    144   
}
  139    145   
  140    146   
#[::pyo3::pyclass]
         147  +
/// :param field int:
  141    148   
/// :rtype None:
  142    149   
#[allow(missing_docs)] // documentation missing in model
  143    150   
#[derive(
  144    151   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  145    152   
)]
  146         -
pub struct CaseInsensitiveErrorOperationOutput {}
         153  +
pub struct StatusResponseOutput {
         154  +
    #[pyo3(get, set)]
         155  +
    /// :type int:
         156  +
    #[allow(missing_docs)] // documentation missing in model
         157  +
    pub field: i32,
         158  +
}
         159  +
impl StatusResponseOutput {
         160  +
    #[allow(missing_docs)] // documentation missing in model
         161  +
    pub fn field(&self) -> i32 {
         162  +
        self.field
         163  +
    }
         164  +
}
  147    165   
#[allow(clippy::new_without_default)]
  148    166   
#[allow(clippy::too_many_arguments)]
  149    167   
#[::pyo3::pymethods]
  150         -
impl CaseInsensitiveErrorOperationOutput {
         168  +
impl StatusResponseOutput {
  151    169   
    #[new]
  152         -
    pub fn new() -> Self {
  153         -
        Self {}
         170  +
    pub fn new(field: i32) -> Self {
         171  +
        Self { field }
  154    172   
    }
  155    173   
    fn __repr__(&self) -> String {
  156    174   
        format!("{self:?}")
  157    175   
    }
  158    176   
    fn __str__(&self) -> String {
  159    177   
        format!("{self:?}")
  160    178   
    }
  161    179   
}
  162         -
impl<'source> ::pyo3::FromPyObject<'source>
  163         -
    for std::boxed::Box<CaseInsensitiveErrorOperationOutput>
  164         -
{
         180  +
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<StatusResponseOutput> {
  165    181   
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
  166         -
        ob.extract::<CaseInsensitiveErrorOperationOutput>()
  167         -
            .map(Box::new)
         182  +
        ob.extract::<StatusResponseOutput>().map(Box::new)
  168    183   
    }
  169    184   
}
  170    185   
  171         -
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<CaseInsensitiveErrorOperationOutput> {
         186  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<StatusResponseOutput> {
  172    187   
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
  173    188   
        (*self).into_py(py)
  174    189   
    }
  175    190   
}
  176         -
impl CaseInsensitiveErrorOperationOutput {
  177         -
    /// Creates a new builder-style object to manufacture [`CaseInsensitiveErrorOperationOutput`](crate::output::CaseInsensitiveErrorOperationOutput).
  178         -
    pub fn builder() -> crate::output::case_insensitive_error_operation_output::Builder {
  179         -
        crate::output::case_insensitive_error_operation_output::Builder::default()
         191  +
impl StatusResponseOutput {
         192  +
    /// Creates a new builder-style object to manufacture [`StatusResponseOutput`](crate::output::StatusResponseOutput).
         193  +
    pub fn builder() -> crate::output::status_response_output::Builder {
         194  +
        crate::output::status_response_output::Builder::default()
  180    195   
    }
  181    196   
}
  182    197   
  183    198   
#[::pyo3::pyclass]
  184         -
/// :param list typing.Optional\[typing.List\[str\]\]:
  185         -
/// :param map typing.Optional\[typing.Dict\[str, str\]\]:
  186         -
/// :param union typing.Optional\[rest_json_extras.model.SingleElementUnion\]:
         199  +
/// :param map typing.Optional\[typing.Dict\[rest_json_extras.model.StringEnum, str\]\]:
  187    200   
/// :rtype None:
  188    201   
#[allow(missing_docs)] // documentation missing in model
  189    202   
#[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]
  190         -
pub struct NullInNonSparseOutput {
  191         -
    #[pyo3(get, set)]
  192         -
    /// :type typing.Optional\[typing.List\[str\]\]:
  193         -
    #[allow(missing_docs)] // documentation missing in model
  194         -
    pub list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         203  +
pub struct MapWithEnumKeyOpOutput {
  195    204   
    #[pyo3(get, set)]
  196         -
    /// :type typing.Optional\[typing.Dict\[str, str\]\]:
         205  +
    /// :type typing.Optional\[typing.Dict\[rest_json_extras.model.StringEnum, str\]\]:
  197    206   
    #[allow(missing_docs)] // documentation missing in model
  198    207   
    pub map: ::std::option::Option<
  199         -
        ::std::collections::HashMap<::std::string::String, ::std::string::String>,
         208  +
        ::std::collections::HashMap<crate::model::StringEnum, ::std::string::String>,
  200    209   
    >,
  201         -
    #[pyo3(get, set)]
  202         -
    /// :type typing.Optional\[rest_json_extras.model.SingleElementUnion\]:
  203         -
    #[allow(missing_docs)] // documentation missing in model
  204         -
    pub union: ::std::option::Option<crate::model::SingleElementUnion>,
  205    210   
}
  206         -
impl NullInNonSparseOutput {
  207         -
    #[allow(missing_docs)] // documentation missing in model
  208         -
    pub fn list(&self) -> ::std::option::Option<&[::std::string::String]> {
  209         -
        self.list.as_deref()
  210         -
    }
         211  +
impl MapWithEnumKeyOpOutput {
  211    212   
    #[allow(missing_docs)] // documentation missing in model
  212    213   
    pub fn map(
  213    214   
        &self,
  214    215   
    ) -> ::std::option::Option<
  215         -
        &::std::collections::HashMap<::std::string::String, ::std::string::String>,
         216  +
        &::std::collections::HashMap<crate::model::StringEnum, ::std::string::String>,
  216    217   
    > {
  217    218   
        self.map.as_ref()
  218    219   
    }
  219         -
    #[allow(missing_docs)] // documentation missing in model
  220         -
    pub fn union(&self) -> ::std::option::Option<&crate::model::SingleElementUnion> {
  221         -
        self.union.as_ref()
  222         -
    }
  223    220   
}
  224    221   
#[allow(clippy::new_without_default)]
  225    222   
#[allow(clippy::too_many_arguments)]
  226    223   
#[::pyo3::pymethods]
  227         -
impl NullInNonSparseOutput {
         224  +
impl MapWithEnumKeyOpOutput {
  228    225   
    #[new]
  229    226   
    pub fn new(
  230         -
        list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
  231    227   
        map: ::std::option::Option<
  232         -
            ::std::collections::HashMap<::std::string::String, ::std::string::String>,
         228  +
            ::std::collections::HashMap<crate::model::StringEnum, ::std::string::String>,
  233    229   
        >,
  234         -
        union: ::std::option::Option<crate::model::SingleElementUnion>,
  235    230   
    ) -> Self {
  236         -
        Self { list, map, union }
         231  +
        Self { map }
  237    232   
    }
  238    233   
    fn __repr__(&self) -> String {
  239    234   
        format!("{self:?}")
  240    235   
    }
  241    236   
    fn __str__(&self) -> String {
  242    237   
        format!("{self:?}")
  243    238   
    }
  244    239   
}
  245         -
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<NullInNonSparseOutput> {
         240  +
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<MapWithEnumKeyOpOutput> {
  246    241   
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
  247         -
        ob.extract::<NullInNonSparseOutput>().map(Box::new)
         242  +
        ob.extract::<MapWithEnumKeyOpOutput>().map(Box::new)
  248    243   
    }
  249    244   
}
  250    245   
  251         -
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<NullInNonSparseOutput> {
         246  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<MapWithEnumKeyOpOutput> {
  252    247   
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
  253    248   
        (*self).into_py(py)
  254    249   
    }
  255    250   
}
  256         -
impl NullInNonSparseOutput {
  257         -
    /// Creates a new builder-style object to manufacture [`NullInNonSparseOutput`](crate::output::NullInNonSparseOutput).
  258         -
    pub fn builder() -> crate::output::null_in_non_sparse_output::Builder {
  259         -
        crate::output::null_in_non_sparse_output::Builder::default()
         251  +
impl MapWithEnumKeyOpOutput {
         252  +
    /// Creates a new builder-style object to manufacture [`MapWithEnumKeyOpOutput`](crate::output::MapWithEnumKeyOpOutput).
         253  +
    pub fn builder() -> crate::output::map_with_enum_key_op_output::Builder {
         254  +
        crate::output::map_with_enum_key_op_output::Builder::default()
         255  +
    }
         256  +
}
         257  +
         258  +
#[::pyo3::pyclass]
         259  +
/// :param value int:
         260  +
/// :rtype None:
         261  +
#[allow(missing_docs)] // documentation missing in model
         262  +
#[derive(
         263  +
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
         264  +
)]
         265  +
pub struct PrimitiveIntOpOutput {
         266  +
    #[pyo3(get, set)]
         267  +
    /// :type int:
         268  +
    #[allow(missing_docs)] // documentation missing in model
         269  +
    pub value: i32,
         270  +
}
         271  +
impl PrimitiveIntOpOutput {
         272  +
    #[allow(missing_docs)] // documentation missing in model
         273  +
    pub fn value(&self) -> i32 {
         274  +
        self.value
         275  +
    }
         276  +
}
         277  +
#[allow(clippy::new_without_default)]
         278  +
#[allow(clippy::too_many_arguments)]
         279  +
#[::pyo3::pymethods]
         280  +
impl PrimitiveIntOpOutput {
         281  +
    #[new]
         282  +
    pub fn new(value: i32) -> Self {
         283  +
        Self { value }
         284  +
    }
         285  +
    fn __repr__(&self) -> String {
         286  +
        format!("{self:?}")
         287  +
    }
         288  +
    fn __str__(&self) -> String {
         289  +
        format!("{self:?}")
         290  +
    }
         291  +
}
         292  +
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<PrimitiveIntOpOutput> {
         293  +
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         294  +
        ob.extract::<PrimitiveIntOpOutput>().map(Box::new)
         295  +
    }
         296  +
}
         297  +
         298  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<PrimitiveIntOpOutput> {
         299  +
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         300  +
        (*self).into_py(py)
         301  +
    }
         302  +
}
         303  +
impl PrimitiveIntOpOutput {
         304  +
    /// Creates a new builder-style object to manufacture [`PrimitiveIntOpOutput`](crate::output::PrimitiveIntOpOutput).
         305  +
    pub fn builder() -> crate::output::primitive_int_op_output::Builder {
         306  +
        crate::output::primitive_int_op_output::Builder::default()
  260    307   
    }
  261    308   
}
  262    309   
  263    310   
#[::pyo3::pyclass]
  264    311   
/// :param r#enum typing.Optional\[rest_json_extras.model.EnumWithEscapedChars\]:
  265    312   
/// :param some_string typing.Optional\[str\]:
  266    313   
/// :rtype None:
  267    314   
#[allow(missing_docs)] // documentation missing in model
  268    315   
#[derive(
  269    316   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
@@ -301,348 +1010,944 @@
  321    368   
    }
  322    369   
}
  323    370   
impl EscapedStringValuesOutput {
  324    371   
    /// Creates a new builder-style object to manufacture [`EscapedStringValuesOutput`](crate::output::EscapedStringValuesOutput).
  325    372   
    pub fn builder() -> crate::output::escaped_string_values_output::Builder {
  326    373   
        crate::output::escaped_string_values_output::Builder::default()
  327    374   
    }
  328    375   
}
  329    376   
  330    377   
#[::pyo3::pyclass]
  331         -
/// :param value int:
         378  +
/// :param list typing.Optional\[typing.List\[str\]\]:
         379  +
/// :param map typing.Optional\[typing.Dict\[str, str\]\]:
         380  +
/// :param union typing.Optional\[rest_json_extras.model.SingleElementUnion\]:
  332    381   
/// :rtype None:
  333    382   
#[allow(missing_docs)] // documentation missing in model
  334         -
#[derive(
  335         -
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  336         -
)]
  337         -
pub struct PrimitiveIntOpOutput {
         383  +
#[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]
         384  +
pub struct NullInNonSparseOutput {
  338    385   
    #[pyo3(get, set)]
  339         -
    /// :type int:
  340         -
    #[allow(missing_docs)] // documentation missing in model
  341         -
    pub value: i32,
  342         -
}
  343         -
impl PrimitiveIntOpOutput {
         386  +
    /// :type typing.Optional\[typing.List\[str\]\]:
  344    387   
    #[allow(missing_docs)] // documentation missing in model
  345         -
    pub fn value(&self) -> i32 {
  346         -
        self.value
  347         -
    }
  348         -
}
  349         -
#[allow(clippy::new_without_default)]
  350         -
#[allow(clippy::too_many_arguments)]
  351         -
#[::pyo3::pymethods]
  352         -
impl PrimitiveIntOpOutput {
  353         -
    #[new]
  354         -
    pub fn new(value: i32) -> Self {
  355         -
        Self { value }
  356         -
    }
  357         -
    fn __repr__(&self) -> String {
  358         -
        format!("{self:?}")
  359         -
    }
  360         -
    fn __str__(&self) -> String {
  361         -
        format!("{self:?}")
  362         -
    }
  363         -
}
  364         -
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<PrimitiveIntOpOutput> {
  365         -
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
  366         -
        ob.extract::<PrimitiveIntOpOutput>().map(Box::new)
  367         -
    }
  368         -
}
  369         -
  370         -
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<PrimitiveIntOpOutput> {
  371         -
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
  372         -
        (*self).into_py(py)
  373         -
    }
  374         -
}
  375         -
impl PrimitiveIntOpOutput {
  376         -
    /// Creates a new builder-style object to manufacture [`PrimitiveIntOpOutput`](crate::output::PrimitiveIntOpOutput).
  377         -
    pub fn builder() -> crate::output::primitive_int_op_output::Builder {
  378         -
        crate::output::primitive_int_op_output::Builder::default()
  379         -
    }
  380         -
}
  381         -
  382         -
#[::pyo3::pyclass]
  383         -
/// :param map typing.Optional\[typing.Dict\[rest_json_extras.model.StringEnum, str\]\]:
  384         -
/// :rtype None:
  385         -
#[allow(missing_docs)] // documentation missing in model
  386         -
#[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]
  387         -
pub struct MapWithEnumKeyOpOutput {
         388  +
    pub list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
  388    389   
    #[pyo3(get, set)]
  389         -
    /// :type typing.Optional\[typing.Dict\[rest_json_extras.model.StringEnum, str\]\]:
         390  +
    /// :type typing.Optional\[typing.Dict\[str, str\]\]:
  390    391   
    #[allow(missing_docs)] // documentation missing in model
  391    392   
    pub map: ::std::option::Option<
  392         -
        ::std::collections::HashMap<crate::model::StringEnum, ::std::string::String>,
         393  +
        ::std::collections::HashMap<::std::string::String, ::std::string::String>,
  393    394   
    >,
         395  +
    #[pyo3(get, set)]
         396  +
    /// :type typing.Optional\[rest_json_extras.model.SingleElementUnion\]:
         397  +
    #[allow(missing_docs)] // documentation missing in model
         398  +
    pub union: ::std::option::Option<crate::model::SingleElementUnion>,
  394    399   
}
  395         -
impl MapWithEnumKeyOpOutput {
         400  +
impl NullInNonSparseOutput {
         401  +
    #[allow(missing_docs)] // documentation missing in model
         402  +
    pub fn list(&self) -> ::std::option::Option<&[::std::string::String]> {
         403  +
        self.list.as_deref()
         404  +
    }
  396    405   
    #[allow(missing_docs)] // documentation missing in model
  397    406   
    pub fn map(
  398    407   
        &self,
  399    408   
    ) -> ::std::option::Option<
  400         -
        &::std::collections::HashMap<crate::model::StringEnum, ::std::string::String>,
         409  +
        &::std::collections::HashMap<::std::string::String, ::std::string::String>,
  401    410   
    > {
  402    411   
        self.map.as_ref()
  403    412   
    }
         413  +
    #[allow(missing_docs)] // documentation missing in model
         414  +
    pub fn union(&self) -> ::std::option::Option<&crate::model::SingleElementUnion> {
         415  +
        self.union.as_ref()
         416  +
    }
  404    417   
}
  405    418   
#[allow(clippy::new_without_default)]
  406    419   
#[allow(clippy::too_many_arguments)]
  407    420   
#[::pyo3::pymethods]
  408         -
impl MapWithEnumKeyOpOutput {
         421  +
impl NullInNonSparseOutput {
  409    422   
    #[new]
  410    423   
    pub fn new(
         424  +
        list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
  411    425   
        map: ::std::option::Option<
  412         -
            ::std::collections::HashMap<crate::model::StringEnum, ::std::string::String>,
         426  +
            ::std::collections::HashMap<::std::string::String, ::std::string::String>,
  413    427   
        >,
         428  +
        union: ::std::option::Option<crate::model::SingleElementUnion>,
  414    429   
    ) -> Self {
  415         -
        Self { map }
  416         -
    }
  417         -
    fn __repr__(&self) -> String {
  418         -
        format!("{self:?}")
  419         -
    }
  420         -
    fn __str__(&self) -> String {
  421         -
        format!("{self:?}")
  422         -
    }
  423         -
}
  424         -
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<MapWithEnumKeyOpOutput> {
  425         -
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
  426         -
        ob.extract::<MapWithEnumKeyOpOutput>().map(Box::new)
  427         -
    }
  428         -
}
  429         -
  430         -
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<MapWithEnumKeyOpOutput> {
  431         -
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
  432         -
        (*self).into_py(py)
  433         -
    }
  434         -
}
  435         -
impl MapWithEnumKeyOpOutput {
  436         -
    /// Creates a new builder-style object to manufacture [`MapWithEnumKeyOpOutput`](crate::output::MapWithEnumKeyOpOutput).
  437         -
    pub fn builder() -> crate::output::map_with_enum_key_op_output::Builder {
  438         -
        crate::output::map_with_enum_key_op_output::Builder::default()
  439         -
    }
  440         -
}
  441         -
  442         -
#[::pyo3::pyclass]
  443         -
/// :param field int:
  444         -
/// :rtype None:
  445         -
#[allow(missing_docs)] // documentation missing in model
  446         -
#[derive(
  447         -
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  448         -
)]
  449         -
pub struct StatusResponseOutput {
  450         -
    #[pyo3(get, set)]
  451         -
    /// :type int:
  452         -
    #[allow(missing_docs)] // documentation missing in model
  453         -
    pub field: i32,
  454         -
}
  455         -
impl StatusResponseOutput {
  456         -
    #[allow(missing_docs)] // documentation missing in model
  457         -
    pub fn field(&self) -> i32 {
  458         -
        self.field
  459         -
    }
  460         -
}
  461         -
#[allow(clippy::new_without_default)]
  462         -
#[allow(clippy::too_many_arguments)]
  463         -
#[::pyo3::pymethods]
  464         -
impl StatusResponseOutput {
  465         -
    #[new]
  466         -
    pub fn new(field: i32) -> Self {
  467         -
        Self { field }
         430  +
        Self { list, map, union }
  468    431   
    }
  469    432   
    fn __repr__(&self) -> String {
  470    433   
        format!("{self:?}")
  471    434   
    }
  472    435   
    fn __str__(&self) -> String {
  473    436   
        format!("{self:?}")
  474    437   
    }
  475    438   
}
  476         -
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<StatusResponseOutput> {
         439  +
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<NullInNonSparseOutput> {
  477    440   
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
  478         -
        ob.extract::<StatusResponseOutput>().map(Box::new)
         441  +
        ob.extract::<NullInNonSparseOutput>().map(Box::new)
  479    442   
    }
  480    443   
}
  481    444   
  482         -
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<StatusResponseOutput> {
         445  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<NullInNonSparseOutput> {
  483    446   
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
  484    447   
        (*self).into_py(py)
  485    448   
    }
  486    449   
}
  487         -
impl StatusResponseOutput {
  488         -
    /// Creates a new builder-style object to manufacture [`StatusResponseOutput`](crate::output::StatusResponseOutput).
  489         -
    pub fn builder() -> crate::output::status_response_output::Builder {
  490         -
        crate::output::status_response_output::Builder::default()
         450  +
impl NullInNonSparseOutput {
         451  +
    /// Creates a new builder-style object to manufacture [`NullInNonSparseOutput`](crate::output::NullInNonSparseOutput).
         452  +
    pub fn builder() -> crate::output::null_in_non_sparse_output::Builder {
         453  +
        crate::output::null_in_non_sparse_output::Builder::default()
  491    454   
    }
  492    455   
}
  493    456   
  494    457   
#[::pyo3::pyclass]
  495    458   
/// :rtype None:
  496    459   
#[allow(missing_docs)] // documentation missing in model
  497    460   
#[derive(
  498    461   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  499    462   
)]
  500         -
pub struct EnumQueryOutput {}
         463  +
pub struct CaseInsensitiveErrorOperationOutput {}
  501    464   
#[allow(clippy::new_without_default)]
  502    465   
#[allow(clippy::too_many_arguments)]
  503    466   
#[::pyo3::pymethods]
  504         -
impl EnumQueryOutput {
         467  +
impl CaseInsensitiveErrorOperationOutput {
  505    468   
    #[new]
  506    469   
    pub fn new() -> Self {
  507    470   
        Self {}
  508    471   
    }
  509    472   
    fn __repr__(&self) -> String {
  510    473   
        format!("{self:?}")
  511    474   
    }
  512    475   
    fn __str__(&self) -> String {
  513    476   
        format!("{self:?}")
  514    477   
    }
  515    478   
}
  516         -
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<EnumQueryOutput> {
         479  +
impl<'source> ::pyo3::FromPyObject<'source>
         480  +
    for std::boxed::Box<CaseInsensitiveErrorOperationOutput>
         481  +
{
  517    482   
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
  518         -
        ob.extract::<EnumQueryOutput>().map(Box::new)
         483  +
        ob.extract::<CaseInsensitiveErrorOperationOutput>()
         484  +
            .map(Box::new)
  519    485   
    }
  520    486   
}
  521    487   
  522         -
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<EnumQueryOutput> {
         488  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<CaseInsensitiveErrorOperationOutput> {
  523    489   
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
  524    490   
        (*self).into_py(py)
  525    491   
    }
  526    492   
}
  527         -
impl EnumQueryOutput {
  528         -
    /// Creates a new builder-style object to manufacture [`EnumQueryOutput`](crate::output::EnumQueryOutput).
  529         -
    pub fn builder() -> crate::output::enum_query_output::Builder {
  530         -
        crate::output::enum_query_output::Builder::default()
         493  +
impl CaseInsensitiveErrorOperationOutput {
         494  +
    /// Creates a new builder-style object to manufacture [`CaseInsensitiveErrorOperationOutput`](crate::output::CaseInsensitiveErrorOperationOutput).
         495  +
    pub fn builder() -> crate::output::case_insensitive_error_operation_output::Builder {
         496  +
        crate::output::case_insensitive_error_operation_output::Builder::default()
  531    497   
    }
  532    498   
}
  533    499   
  534    500   
#[::pyo3::pyclass]
  535         -
/// :param field int:
         501  +
/// :param empty typing.Optional\[rest_json_extras.model.EmptyStruct\]:
  536    502   
/// :rtype None:
  537    503   
#[allow(missing_docs)] // documentation missing in model
  538    504   
#[derive(
  539    505   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  540    506   
)]
  541         -
pub struct PrimitiveIntHeaderOutput {
         507  +
pub struct EmptyStructWithContentOnWireOpOutput {
  542    508   
    #[pyo3(get, set)]
  543         -
    /// :type int:
         509  +
    /// :type typing.Optional\[rest_json_extras.model.EmptyStruct\]:
  544    510   
    #[allow(missing_docs)] // documentation missing in model
  545         -
    pub field: i32,
         511  +
    pub empty: ::std::option::Option<crate::model::EmptyStruct>,
  546    512   
}
  547         -
impl PrimitiveIntHeaderOutput {
         513  +
impl EmptyStructWithContentOnWireOpOutput {
  548    514   
    #[allow(missing_docs)] // documentation missing in model
  549         -
    pub fn field(&self) -> i32 {
  550         -
        self.field
         515  +
    pub fn empty(&self) -> ::std::option::Option<&crate::model::EmptyStruct> {
         516  +
        self.empty.as_ref()
  551    517   
    }
  552    518   
}
  553    519   
#[allow(clippy::new_without_default)]
  554    520   
#[allow(clippy::too_many_arguments)]
  555    521   
#[::pyo3::pymethods]
  556         -
impl PrimitiveIntHeaderOutput {
         522  +
impl EmptyStructWithContentOnWireOpOutput {
  557    523   
    #[new]
  558         -
    pub fn new(field: i32) -> Self {
  559         -
        Self { field }
         524  +
    pub fn new(empty: ::std::option::Option<crate::model::EmptyStruct>) -> Self {
         525  +
        Self { empty }
  560    526   
    }
  561    527   
    fn __repr__(&self) -> String {
  562    528   
        format!("{self:?}")
  563    529   
    }
  564    530   
    fn __str__(&self) -> String {
  565    531   
        format!("{self:?}")
  566    532   
    }
  567    533   
}
  568         -
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<PrimitiveIntHeaderOutput> {
         534  +
impl<'source> ::pyo3::FromPyObject<'source>
         535  +
    for std::boxed::Box<EmptyStructWithContentOnWireOpOutput>
         536  +
{
  569    537   
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
  570         -
        ob.extract::<PrimitiveIntHeaderOutput>().map(Box::new)
         538  +
        ob.extract::<EmptyStructWithContentOnWireOpOutput>()
         539  +
            .map(Box::new)
  571    540   
    }
  572    541   
}
  573    542   
  574         -
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<PrimitiveIntHeaderOutput> {
         543  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<EmptyStructWithContentOnWireOpOutput> {
  575    544   
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
  576    545   
        (*self).into_py(py)
  577    546   
    }
  578    547   
}
  579         -
impl PrimitiveIntHeaderOutput {
  580         -
    /// Creates a new builder-style object to manufacture [`PrimitiveIntHeaderOutput`](crate::output::PrimitiveIntHeaderOutput).
  581         -
    pub fn builder() -> crate::output::primitive_int_header_output::Builder {
  582         -
        crate::output::primitive_int_header_output::Builder::default()
         548  +
impl EmptyStructWithContentOnWireOpOutput {
         549  +
    /// Creates a new builder-style object to manufacture [`EmptyStructWithContentOnWireOpOutput`](crate::output::EmptyStructWithContentOnWireOpOutput).
         550  +
    pub fn builder() -> crate::output::empty_struct_with_content_on_wire_op_output::Builder {
         551  +
        crate::output::empty_struct_with_content_on_wire_op_output::Builder::default()
  583    552   
    }
  584    553   
}
  585    554   
  586    555   
#[::pyo3::pyclass]
  587         -
/// :param payload typing.Optional\[str\]:
  588    556   
/// :rtype None:
  589    557   
#[allow(missing_docs)] // documentation missing in model
  590    558   
#[derive(
  591    559   
    ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
  592    560   
)]
  593         -
pub struct StringPayloadOutput {
  594         -
    #[pyo3(get, set)]
  595         -
    /// :type typing.Optional\[str\]:
  596         -
    #[allow(missing_docs)] // documentation missing in model
  597         -
    pub payload: ::std::option::Option<::std::string::String>,
  598         -
}
  599         -
impl StringPayloadOutput {
  600         -
    #[allow(missing_docs)] // documentation missing in model
  601         -
    pub fn payload(&self) -> ::std::option::Option<&str> {
  602         -
        self.payload.as_deref()
  603         -
    }
  604         -
}
         561  +
pub struct QueryPrecedenceOutput {}
  605    562   
#[allow(clippy::new_without_default)]
  606    563   
#[allow(clippy::too_many_arguments)]
  607    564   
#[::pyo3::pymethods]
  608         -
impl StringPayloadOutput {
         565  +
impl QueryPrecedenceOutput {
  609    566   
    #[new]
  610         -
    pub fn new(payload: ::std::option::Option<::std::string::String>) -> Self {
  611         -
        Self { payload }
         567  +
    pub fn new() -> Self {
         568  +
        Self {}
  612    569   
    }
  613    570   
    fn __repr__(&self) -> String {
  614    571   
        format!("{self:?}")
  615    572   
    }
  616    573   
    fn __str__(&self) -> String {
  617    574   
        format!("{self:?}")
  618    575   
    }
  619    576   
}
  620         -
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<StringPayloadOutput> {
         577  +
impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<QueryPrecedenceOutput> {
  621    578   
    fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
  622         -
        ob.extract::<StringPayloadOutput>().map(Box::new)
         579  +
        ob.extract::<QueryPrecedenceOutput>().map(Box::new)
  623    580   
    }
  624    581   
}
  625    582   
  626         -
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<StringPayloadOutput> {
         583  +
impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<QueryPrecedenceOutput> {
  627    584   
    fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
  628    585   
        (*self).into_py(py)
  629    586   
    }
  630    587   
}
  631         -
impl StringPayloadOutput {
  632         -
    /// Creates a new builder-style object to manufacture [`StringPayloadOutput`](crate::output::StringPayloadOutput).
  633         -
    pub fn builder() -> crate::output::string_payload_output::Builder {
  634         -
        crate::output::string_payload_output::Builder::default()
         588  +
impl QueryPrecedenceOutput {
         589  +
    /// Creates a new builder-style object to manufacture [`QueryPrecedenceOutput`](crate::output::QueryPrecedenceOutput).
         590  +
    pub fn builder() -> crate::output::query_precedence_output::Builder {
         591  +
        crate::output::query_precedence_output::Builder::default()
  635    592   
    }
  636    593   
}
  637         -
/// See [`HttpQueryParamsOnlyOperationOutput`](crate::output::HttpQueryParamsOnlyOperationOutput).
  638         -
pub mod http_query_params_only_operation_output {
         594  +
/// See [`StringPayloadOutput`](crate::output::StringPayloadOutput).
         595  +
pub mod string_payload_output {
  639    596   
  640         -
    impl ::std::convert::From<Builder> for crate::output::HttpQueryParamsOnlyOperationOutput {
         597  +
    impl ::std::convert::From<Builder> for crate::output::StringPayloadOutput {
  641    598   
        fn from(builder: Builder) -> Self {
  642    599   
            builder.build()
  643    600   
        }
  644    601   
    }
  645         -
    /// A builder for [`HttpQueryParamsOnlyOperationOutput`](crate::output::HttpQueryParamsOnlyOperationOutput).
         602  +
    /// A builder for [`StringPayloadOutput`](crate::output::StringPayloadOutput).
  646    603   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
  647         -
    pub struct Builder {}
         604  +
    pub struct Builder {
         605  +
        pub(crate) payload: ::std::option::Option<::std::string::String>,
         606  +
    }
  648    607   
    impl Builder {
  649         -
        /// Consumes the builder and constructs a [`HttpQueryParamsOnlyOperationOutput`](crate::output::HttpQueryParamsOnlyOperationOutput).
  650         -
        pub fn build(self) -> crate::output::HttpQueryParamsOnlyOperationOutput {
         608  +
        #[allow(missing_docs)] // documentation missing in model
         609  +
        pub fn payload(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
         610  +
            self.payload = input;
         611  +
            self
         612  +
        }
         613  +
        /// Consumes the builder and constructs a [`StringPayloadOutput`](crate::output::StringPayloadOutput).
         614  +
        pub fn build(self) -> crate::output::StringPayloadOutput {
  651    615   
            self.build_enforcing_required_and_enum_traits()
  652    616   
        }
  653         -
        fn build_enforcing_required_and_enum_traits(
  654         -
            self,
  655         -
        ) -> crate::output::HttpQueryParamsOnlyOperationOutput {
  656         -
            crate::output::HttpQueryParamsOnlyOperationOutput {}
         617  +
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::StringPayloadOutput {
         618  +
            crate::output::StringPayloadOutput {
         619  +
                payload: self.payload,
         620  +
            }
  657    621   
        }
  658    622   
    }
  659    623   
}
  660         -
/// See [`QueryPrecedenceOutput`](crate::output::QueryPrecedenceOutput).
  661         -
pub mod query_precedence_output {
         624  +
/// See [`PrimitiveIntHeaderOutput`](crate::output::PrimitiveIntHeaderOutput).
         625  +
pub mod primitive_int_header_output {
  662    626   
  663         -
    impl ::std::convert::From<Builder> for crate::output::QueryPrecedenceOutput {
         627  +
    impl ::std::convert::From<Builder> for crate::output::PrimitiveIntHeaderOutput {
  664    628   
        fn from(builder: Builder) -> Self {
  665    629   
            builder.build()
  666    630   
        }
  667    631   
    }
  668         -
    /// A builder for [`QueryPrecedenceOutput`](crate::output::QueryPrecedenceOutput).
         632  +
    /// A builder for [`PrimitiveIntHeaderOutput`](crate::output::PrimitiveIntHeaderOutput).
  669    633   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
  670         -
    pub struct Builder {}
         634  +
    pub struct Builder {
         635  +
        pub(crate) field: ::std::option::Option<i32>,
         636  +
    }
  671    637   
    impl Builder {
  672         -
        /// Consumes the builder and constructs a [`QueryPrecedenceOutput`](crate::output::QueryPrecedenceOutput).
  673         -
        pub fn build(self) -> crate::output::QueryPrecedenceOutput {
         638  +
        #[allow(missing_docs)] // documentation missing in model
         639  +
        pub fn field(mut self, input: i32) -> Self {
         640  +
            self.field = Some(input);
         641  +
            self
         642  +
        }
         643  +
        /// Consumes the builder and constructs a [`PrimitiveIntHeaderOutput`](crate::output::PrimitiveIntHeaderOutput).
         644  +
        pub fn build(self) -> crate::output::PrimitiveIntHeaderOutput {
  674    645   
            self.build_enforcing_required_and_enum_traits()
  675    646   
        }
  676         -
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::QueryPrecedenceOutput {
  677         -
            crate::output::QueryPrecedenceOutput {}
         647  +
        fn build_enforcing_required_and_enum_traits(
         648  +
            self,
         649  +
        ) -> crate::output::PrimitiveIntHeaderOutput {
         650  +
            crate::output::PrimitiveIntHeaderOutput {
         651  +
                field: self.field.unwrap_or(0i32),
         652  +
            }
  678    653   
        }
  679    654   
    }
  680    655   
}
  681         -
/// See [`EmptyStructWithContentOnWireOpOutput`](crate::output::EmptyStructWithContentOnWireOpOutput).
  682         -
pub mod empty_struct_with_content_on_wire_op_output {
         656  +
/// See [`EnumQueryOutput`](crate::output::EnumQueryOutput).
         657  +
pub mod enum_query_output {
  683    658   
  684         -
    impl ::std::convert::From<Builder> for crate::output::EmptyStructWithContentOnWireOpOutput {
         659  +
    impl ::std::convert::From<Builder> for crate::output::EnumQueryOutput {
  685    660   
        fn from(builder: Builder) -> Self {
  686    661   
            builder.build()
  687    662   
        }
  688    663   
    }
  689         -
    /// A builder for [`EmptyStructWithContentOnWireOpOutput`](crate::output::EmptyStructWithContentOnWireOpOutput).
         664  +
    /// A builder for [`EnumQueryOutput`](crate::output::EnumQueryOutput).
  690    665   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
  691         -
    pub struct Builder {
  692         -
        pub(crate) empty: ::std::option::Option<crate::model::EmptyStruct>,
  693         -
    }
         666  +
    pub struct Builder {}
  694    667   
    impl Builder {
  695         -
        #[allow(missing_docs)] // documentation missing in model
  696         -
        pub fn empty(mut self, input: ::std::option::Option<crate::model::EmptyStruct>) -> Self {
  697         -
            self.empty = input;
  698         -
            self
  699         -
        }
  700         -
        /// Consumes the builder and constructs a [`EmptyStructWithContentOnWireOpOutput`](crate::output::EmptyStructWithContentOnWireOpOutput).
  701         -
        pub fn build(self) -> crate::output::EmptyStructWithContentOnWireOpOutput {
         668  +
        /// Consumes the builder and constructs a [`EnumQueryOutput`](crate::output::EnumQueryOutput).
         669  +
        pub fn build(self) -> crate::output::EnumQueryOutput {
  702    670   
            self.build_enforcing_required_and_enum_traits()
  703    671   
        }
  704         -
        fn build_enforcing_required_and_enum_traits(
  705         -
            self,
  706         -
        ) -> crate::output::EmptyStructWithContentOnWireOpOutput {
  707         -
            crate::output::EmptyStructWithContentOnWireOpOutput { empty: self.empty }
         672  +
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::EnumQueryOutput {
         673  +
            crate::output::EnumQueryOutput {}
  708    674   
        }
  709    675   
    }
  710    676   
}
  711         -
/// See [`CaseInsensitiveErrorOperationOutput`](crate::output::CaseInsensitiveErrorOperationOutput).
  712         -
pub mod case_insensitive_error_operation_output {
         677  +
/// See [`StatusResponseOutput`](crate::output::StatusResponseOutput).
         678  +
pub mod status_response_output {
  713    679   
  714         -
    impl ::std::convert::From<Builder> for crate::output::CaseInsensitiveErrorOperationOutput {
         680  +
    impl ::std::convert::From<Builder> for crate::output::StatusResponseOutput {
  715    681   
        fn from(builder: Builder) -> Self {
  716    682   
            builder.build()
  717    683   
        }
  718    684   
    }
  719         -
    /// A builder for [`CaseInsensitiveErrorOperationOutput`](crate::output::CaseInsensitiveErrorOperationOutput).
         685  +
    /// A builder for [`StatusResponseOutput`](crate::output::StatusResponseOutput).
  720    686   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
  721         -
    pub struct Builder {}
         687  +
    pub struct Builder {
         688  +
        pub(crate) field: ::std::option::Option<i32>,
         689  +
    }
  722    690   
    impl Builder {
  723         -
        /// Consumes the builder and constructs a [`CaseInsensitiveErrorOperationOutput`](crate::output::CaseInsensitiveErrorOperationOutput).
  724         -
        pub fn build(self) -> crate::output::CaseInsensitiveErrorOperationOutput {
         691  +
        #[allow(missing_docs)] // documentation missing in model
         692  +
        pub fn field(mut self, input: i32) -> Self {
         693  +
            self.field = Some(input);
         694  +
            self
         695  +
        }
         696  +
        /// Consumes the builder and constructs a [`StatusResponseOutput`](crate::output::StatusResponseOutput).
         697  +
        pub fn build(self) -> crate::output::StatusResponseOutput {
  725    698   
            self.build_enforcing_required_and_enum_traits()
  726    699   
        }
  727         -
        fn build_enforcing_required_and_enum_traits(
  728         -
            self,
  729         -
        ) -> crate::output::CaseInsensitiveErrorOperationOutput {
  730         -
            crate::output::CaseInsensitiveErrorOperationOutput {}
         700  +
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::StatusResponseOutput {
         701  +
            crate::output::StatusResponseOutput {
         702  +
                field: self.field.unwrap_or(0i32),
         703  +
            }
  731    704   
        }
  732    705   
    }
  733    706   
}
  734         -
/// See [`NullInNonSparseOutput`](crate::output::NullInNonSparseOutput).
  735         -
pub mod null_in_non_sparse_output {
         707  +
/// See [`MapWithEnumKeyOpOutput`](crate::output::MapWithEnumKeyOpOutput).
         708  +
pub mod map_with_enum_key_op_output {
  736    709   
  737         -
    impl ::std::convert::From<Builder> for crate::output::NullInNonSparseOutput {
         710  +
    impl ::std::convert::From<Builder> for crate::output::MapWithEnumKeyOpOutput {
  738    711   
        fn from(builder: Builder) -> Self {
  739    712   
            builder.build()
  740    713   
        }
  741    714   
    }
  742         -
    /// A builder for [`NullInNonSparseOutput`](crate::output::NullInNonSparseOutput).
         715  +
    /// A builder for [`MapWithEnumKeyOpOutput`](crate::output::MapWithEnumKeyOpOutput).
  743    716   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
  744    717   
    pub struct Builder {
  745         -
        pub(crate) list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
  746    718   
        pub(crate) map: ::std::option::Option<
  747         -
            ::std::collections::HashMap<::std::string::String, ::std::string::String>,
         719  +
            ::std::collections::HashMap<crate::model::StringEnum, ::std::string::String>,
  748    720   
        >,
  749         -
        pub(crate) union: ::std::option::Option<crate::model::SingleElementUnion>,
  750    721   
    }
  751    722   
    impl Builder {
  752         -
        #[allow(missing_docs)] // documentation missing in model
  753         -
        pub fn list(
  754         -
            mut self,
  755         -
            input: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
  756         -
        ) -> Self {
  757         -
            self.list = input;
  758         -
            self
  759         -
        }
  760    723   
        #[allow(missing_docs)] // documentation missing in model
  761    724   
        pub fn map(
  762    725   
            mut self,
  763    726   
            input: ::std::option::Option<
  764         -
                ::std::collections::HashMap<::std::string::String, ::std::string::String>,
         727  +
                ::std::collections::HashMap<crate::model::StringEnum, ::std::string::String>,
  765    728   
            >,
  766    729   
        ) -> Self {
  767    730   
            self.map = input;
  768    731   
            self
  769    732   
        }
         733  +
        /// Consumes the builder and constructs a [`MapWithEnumKeyOpOutput`](crate::output::MapWithEnumKeyOpOutput).
         734  +
        pub fn build(self) -> crate::output::MapWithEnumKeyOpOutput {
         735  +
            self.build_enforcing_required_and_enum_traits()
         736  +
        }
         737  +
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::MapWithEnumKeyOpOutput {
         738  +
            crate::output::MapWithEnumKeyOpOutput { map: self.map }
         739  +
        }
         740  +
    }
         741  +
}
         742  +
/// See [`PrimitiveIntOpOutput`](crate::output::PrimitiveIntOpOutput).
         743  +
pub mod primitive_int_op_output {
         744  +
         745  +
    impl ::std::convert::From<Builder> for crate::output::PrimitiveIntOpOutput {
         746  +
        fn from(builder: Builder) -> Self {
         747  +
            builder.build()
         748  +
        }
         749  +
    }
         750  +
    /// A builder for [`PrimitiveIntOpOutput`](crate::output::PrimitiveIntOpOutput).
         751  +
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
         752  +
    pub struct Builder {
         753  +
        pub(crate) value: ::std::option::Option<i32>,
         754  +
    }
         755  +
    impl Builder {
  770    756   
        #[allow(missing_docs)] // documentation missing in model
  771         -
        pub fn union(
  772         -
            mut self,
  773         -
            input: ::std::option::Option<crate::model::SingleElementUnion>,
  774         -
        ) -> Self {
  775         -
            self.union = input;
         757  +
        pub fn value(mut self, input: i32) -> Self {
         758  +
            self.value = Some(input);
  776    759   
            self
  777    760   
        }
  778         -
        /// Consumes the builder and constructs a [`NullInNonSparseOutput`](crate::output::NullInNonSparseOutput).
  779         -
        pub fn build(self) -> crate::output::NullInNonSparseOutput {
         761  +
        /// Consumes the builder and constructs a [`PrimitiveIntOpOutput`](crate::output::PrimitiveIntOpOutput).
         762  +
        pub fn build(self) -> crate::output::PrimitiveIntOpOutput {
  780    763   
            self.build_enforcing_required_and_enum_traits()
  781    764   
        }
  782         -
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::NullInNonSparseOutput {
  783         -
            crate::output::NullInNonSparseOutput {
  784         -
                list: self.list,
  785         -
                map: self.map,
  786         -
                union: self.union,
         765  +
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::PrimitiveIntOpOutput {
         766  +
            crate::output::PrimitiveIntOpOutput {
         767  +
                value: self.value.unwrap_or(0i32),
  787    768   
            }
  788    769   
        }
  789    770   
    }
  790    771   
}
  791    772   
/// See [`EscapedStringValuesOutput`](crate::output::EscapedStringValuesOutput).
  792    773   
pub mod escaped_string_values_output {
  793    774   
  794    775   
    impl ::std::convert::From<Builder> for crate::output::EscapedStringValuesOutput {
  795    776   
        fn from(builder: Builder) -> Self {
  796    777   
            builder.build()
  797    778   
        }
  798    779   
    }
  799    780   
    /// A builder for [`EscapedStringValuesOutput`](crate::output::EscapedStringValuesOutput).
  800    781   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
  801    782   
    pub struct Builder {
  802    783   
        pub(crate) r#enum: ::std::option::Option<crate::model::EnumWithEscapedChars>,
  803    784   
        pub(crate) some_string: ::std::option::Option<::std::string::String>,
  804    785   
    }
  805    786   
    impl Builder {
  806    787   
        #[allow(missing_docs)] // documentation missing in model
  807    788   
        pub fn r#enum(
  808    789   
            mut self,
  809    790   
            input: ::std::option::Option<crate::model::EnumWithEscapedChars>,
  810    791   
        ) -> Self {
  811    792   
            self.r#enum = input;
  812    793   
            self
  813    794   
        }
  814    795   
        #[allow(missing_docs)] // documentation missing in model
  815    796   
        pub fn some_string(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  816    797   
            self.some_string = input;
  817    798   
            self
  818    799   
        }
  819    800   
        /// Consumes the builder and constructs a [`EscapedStringValuesOutput`](crate::output::EscapedStringValuesOutput).
  820    801   
        pub fn build(self) -> crate::output::EscapedStringValuesOutput {
  821    802   
            self.build_enforcing_required_and_enum_traits()
  822    803   
        }
  823    804   
        fn build_enforcing_required_and_enum_traits(
  824    805   
            self,
  825    806   
        ) -> crate::output::EscapedStringValuesOutput {
  826    807   
            crate::output::EscapedStringValuesOutput {
  827    808   
                r#enum: self.r#enum,
  828    809   
                some_string: self.some_string,
  829    810   
            }
  830    811   
        }
  831    812   
    }
  832    813   
}
  833         -
/// See [`PrimitiveIntOpOutput`](crate::output::PrimitiveIntOpOutput).
  834         -
pub mod primitive_int_op_output {
         814  +
/// See [`NullInNonSparseOutput`](crate::output::NullInNonSparseOutput).
         815  +
pub mod null_in_non_sparse_output {
  835    816   
  836         -
    impl ::std::convert::From<Builder> for crate::output::PrimitiveIntOpOutput {
         817  +
    impl ::std::convert::From<Builder> for crate::output::NullInNonSparseOutput {
  837    818   
        fn from(builder: Builder) -> Self {
  838    819   
            builder.build()
  839    820   
        }
  840    821   
    }
  841         -
    /// A builder for [`PrimitiveIntOpOutput`](crate::output::PrimitiveIntOpOutput).
         822  +
    /// A builder for [`NullInNonSparseOutput`](crate::output::NullInNonSparseOutput).
  842    823   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
  843    824   
    pub struct Builder {
  844         -
        pub(crate) value: ::std::option::Option<i32>,
         825  +
        pub(crate) list: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         826  +
        pub(crate) map: ::std::option::Option<
         827  +
            ::std::collections::HashMap<::std::string::String, ::std::string::String>,
         828  +
        >,
         829  +
        pub(crate) union: ::std::option::Option<crate::model::SingleElementUnion>,
  845    830   
    }
  846    831   
    impl Builder {
  847    832   
        #[allow(missing_docs)] // documentation missing in model
  848         -
        pub fn value(mut self, input: i32) -> Self {
  849         -
            self.value = Some(input);
         833  +
        pub fn list(
         834  +
            mut self,
         835  +
            input: ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         836  +
        ) -> Self {
         837  +
            self.list = input;
  850    838   
            self
  851    839   
        }
  852         -
        /// Consumes the builder and constructs a [`PrimitiveIntOpOutput`](crate::output::PrimitiveIntOpOutput).
  853         -
        pub fn build(self) -> crate::output::PrimitiveIntOpOutput {
  854         -
            self.build_enforcing_required_and_enum_traits()
  855         -
        }
  856         -
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::PrimitiveIntOpOutput {
  857         -
            crate::output::PrimitiveIntOpOutput {
  858         -
                value: self.value.unwrap_or(0i32),
  859         -
            }
  860         -
        }
  861         -
    }
  862         -
}
  863         -
/// See [`MapWithEnumKeyOpOutput`](crate::output::MapWithEnumKeyOpOutput).
  864         -
pub mod map_with_enum_key_op_output {
  865         -
  866         -
    impl ::std::convert::From<Builder> for crate::output::MapWithEnumKeyOpOutput {
  867         -
        fn from(builder: Builder) -> Self {
  868         -
            builder.build()
  869         -
        }
  870         -
    }
  871         -
    /// A builder for [`MapWithEnumKeyOpOutput`](crate::output::MapWithEnumKeyOpOutput).
  872         -
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
  873         -
    pub struct Builder {
  874         -
        pub(crate) map: ::std::option::Option<
  875         -
            ::std::collections::HashMap<crate::model::StringEnum, ::std::string::String>,
  876         -
        >,
  877         -
    }
  878         -
    impl Builder {
  879    840   
        #[allow(missing_docs)] // documentation missing in model
  880    841   
        pub fn map(
  881    842   
            mut self,
  882    843   
            input: ::std::option::Option<
  883         -
                ::std::collections::HashMap<crate::model::StringEnum, ::std::string::String>,
         844  +
                ::std::collections::HashMap<::std::string::String, ::std::string::String>,
  884    845   
            >,
  885    846   
        ) -> Self {
  886    847   
            self.map = input;
  887    848   
            self
  888    849   
        }
  889         -
        /// Consumes the builder and constructs a [`MapWithEnumKeyOpOutput`](crate::output::MapWithEnumKeyOpOutput).
  890         -
        pub fn build(self) -> crate::output::MapWithEnumKeyOpOutput {
  891         -
            self.build_enforcing_required_and_enum_traits()
  892         -
        }
  893         -
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::MapWithEnumKeyOpOutput {
  894         -
            crate::output::MapWithEnumKeyOpOutput { map: self.map }
  895         -
        }
  896         -
    }
  897         -
}
  898         -
/// See [`StatusResponseOutput`](crate::output::StatusResponseOutput).
  899         -
pub mod status_response_output {
  900         -
  901         -
    impl ::std::convert::From<Builder> for crate::output::StatusResponseOutput {
  902         -
        fn from(builder: Builder) -> Self {
  903         -
            builder.build()
  904         -
        }
  905         -
    }
  906         -
    /// A builder for [`StatusResponseOutput`](crate::output::StatusResponseOutput).
  907         -
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
  908         -
    pub struct Builder {
  909         -
        pub(crate) field: ::std::option::Option<i32>,
  910         -
    }
  911         -
    impl Builder {
  912    850   
        #[allow(missing_docs)] // documentation missing in model
  913         -
        pub fn field(mut self, input: i32) -> Self {
  914         -
            self.field = Some(input);
         851  +
        pub fn union(
         852  +
            mut self,
         853  +
            input: ::std::option::Option<crate::model::SingleElementUnion>,
         854  +
        ) -> Self {
         855  +
            self.union = input;
  915    856   
            self
  916    857   
        }
  917         -
        /// Consumes the builder and constructs a [`StatusResponseOutput`](crate::output::StatusResponseOutput).
  918         -
        pub fn build(self) -> crate::output::StatusResponseOutput {
         858  +
        /// Consumes the builder and constructs a [`NullInNonSparseOutput`](crate::output::NullInNonSparseOutput).
         859  +
        pub fn build(self) -> crate::output::NullInNonSparseOutput {
  919    860   
            self.build_enforcing_required_and_enum_traits()
  920    861   
        }
  921         -
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::StatusResponseOutput {
  922         -
            crate::output::StatusResponseOutput {
  923         -
                field: self.field.unwrap_or(0i32),
         862  +
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::NullInNonSparseOutput {
         863  +
            crate::output::NullInNonSparseOutput {
         864  +
                list: self.list,
         865  +
                map: self.map,
         866  +
                union: self.union,
  924    867   
            }
  925    868   
        }
  926    869   
    }
  927    870   
}
  928         -
/// See [`EnumQueryOutput`](crate::output::EnumQueryOutput).
  929         -
pub mod enum_query_output {
         871  +
/// See [`CaseInsensitiveErrorOperationOutput`](crate::output::CaseInsensitiveErrorOperationOutput).
         872  +
pub mod case_insensitive_error_operation_output {
  930    873   
  931         -
    impl ::std::convert::From<Builder> for crate::output::EnumQueryOutput {
         874  +
    impl ::std::convert::From<Builder> for crate::output::CaseInsensitiveErrorOperationOutput {
  932    875   
        fn from(builder: Builder) -> Self {
  933    876   
            builder.build()
  934    877   
        }
  935    878   
    }
  936         -
    /// A builder for [`EnumQueryOutput`](crate::output::EnumQueryOutput).
         879  +
    /// A builder for [`CaseInsensitiveErrorOperationOutput`](crate::output::CaseInsensitiveErrorOperationOutput).
  937    880   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
  938    881   
    pub struct Builder {}
  939    882   
    impl Builder {
  940         -
        /// Consumes the builder and constructs a [`EnumQueryOutput`](crate::output::EnumQueryOutput).
  941         -
        pub fn build(self) -> crate::output::EnumQueryOutput {
         883  +
        /// Consumes the builder and constructs a [`CaseInsensitiveErrorOperationOutput`](crate::output::CaseInsensitiveErrorOperationOutput).
         884  +
        pub fn build(self) -> crate::output::CaseInsensitiveErrorOperationOutput {
  942    885   
            self.build_enforcing_required_and_enum_traits()
  943    886   
        }
  944         -
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::EnumQueryOutput {
  945         -
            crate::output::EnumQueryOutput {}
         887  +
        fn build_enforcing_required_and_enum_traits(
         888  +
            self,
         889  +
        ) -> crate::output::CaseInsensitiveErrorOperationOutput {
         890  +
            crate::output::CaseInsensitiveErrorOperationOutput {}
  946    891   
        }
  947    892   
    }
  948    893   
}
  949         -
/// See [`PrimitiveIntHeaderOutput`](crate::output::PrimitiveIntHeaderOutput).
  950         -
pub mod primitive_int_header_output {
         894  +
/// See [`EmptyStructWithContentOnWireOpOutput`](crate::output::EmptyStructWithContentOnWireOpOutput).
         895  +
pub mod empty_struct_with_content_on_wire_op_output {
  951    896   
  952         -
    impl ::std::convert::From<Builder> for crate::output::PrimitiveIntHeaderOutput {
         897  +
    impl ::std::convert::From<Builder> for crate::output::EmptyStructWithContentOnWireOpOutput {
  953    898   
        fn from(builder: Builder) -> Self {
  954    899   
            builder.build()
  955    900   
        }
  956    901   
    }
  957         -
    /// A builder for [`PrimitiveIntHeaderOutput`](crate::output::PrimitiveIntHeaderOutput).
         902  +
    /// A builder for [`EmptyStructWithContentOnWireOpOutput`](crate::output::EmptyStructWithContentOnWireOpOutput).
  958    903   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
  959    904   
    pub struct Builder {
  960         -
        pub(crate) field: ::std::option::Option<i32>,
         905  +
        pub(crate) empty: ::std::option::Option<crate::model::EmptyStruct>,
  961    906   
    }
  962    907   
    impl Builder {
  963    908   
        #[allow(missing_docs)] // documentation missing in model
  964         -
        pub fn field(mut self, input: i32) -> Self {
  965         -
            self.field = Some(input);
         909  +
        pub fn empty(mut self, input: ::std::option::Option<crate::model::EmptyStruct>) -> Self {
         910  +
            self.empty = input;
  966    911   
            self
  967    912   
        }
  968         -
        /// Consumes the builder and constructs a [`PrimitiveIntHeaderOutput`](crate::output::PrimitiveIntHeaderOutput).
  969         -
        pub fn build(self) -> crate::output::PrimitiveIntHeaderOutput {
         913  +
        /// Consumes the builder and constructs a [`EmptyStructWithContentOnWireOpOutput`](crate::output::EmptyStructWithContentOnWireOpOutput).
         914  +
        pub fn build(self) -> crate::output::EmptyStructWithContentOnWireOpOutput {
  970    915   
            self.build_enforcing_required_and_enum_traits()
  971    916   
        }
  972    917   
        fn build_enforcing_required_and_enum_traits(
  973    918   
            self,
  974         -
        ) -> crate::output::PrimitiveIntHeaderOutput {
  975         -
            crate::output::PrimitiveIntHeaderOutput {
  976         -
                field: self.field.unwrap_or(0i32),
  977         -
            }
         919  +
        ) -> crate::output::EmptyStructWithContentOnWireOpOutput {
         920  +
            crate::output::EmptyStructWithContentOnWireOpOutput { empty: self.empty }
  978    921   
        }
  979    922   
    }
  980    923   
}
  981         -
/// See [`StringPayloadOutput`](crate::output::StringPayloadOutput).
  982         -
pub mod string_payload_output {
         924  +
/// See [`QueryPrecedenceOutput`](crate::output::QueryPrecedenceOutput).
         925  +
pub mod query_precedence_output {
  983    926   
  984         -
    impl ::std::convert::From<Builder> for crate::output::StringPayloadOutput {
         927  +
    impl ::std::convert::From<Builder> for crate::output::QueryPrecedenceOutput {
  985    928   
        fn from(builder: Builder) -> Self {
  986    929   
            builder.build()
  987    930   
        }
  988    931   
    }
  989         -
    /// A builder for [`StringPayloadOutput`](crate::output::StringPayloadOutput).
         932  +
    /// A builder for [`QueryPrecedenceOutput`](crate::output::QueryPrecedenceOutput).
  990    933   
    #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
  991         -
    pub struct Builder {
  992         -
        pub(crate) payload: ::std::option::Option<::std::string::String>,
  993         -
    }
         934  +
    pub struct Builder {}
  994    935   
    impl Builder {
  995         -
        #[allow(missing_docs)] // documentation missing in model
  996         -
        pub fn payload(mut self, input: ::std::option::Option<::std::string::String>) -> Self {
  997         -
            self.payload = input;
  998         -
            self
  999         -
        }
 1000         -
        /// Consumes the builder and constructs a [`StringPayloadOutput`](crate::output::StringPayloadOutput).
 1001         -
        pub fn build(self) -> crate::output::StringPayloadOutput {
         936  +
        /// Consumes the builder and constructs a [`QueryPrecedenceOutput`](crate::output::QueryPrecedenceOutput).
         937  +
        pub fn build(self) -> crate::output::QueryPrecedenceOutput {
 1002    938   
            self.build_enforcing_required_and_enum_traits()
 1003    939   
        }
 1004         -
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::StringPayloadOutput {
 1005         -
            crate::output::StringPayloadOutput {
 1006         -
                payload: self.payload,
 1007         -
            }
         940  +
        fn build_enforcing_required_and_enum_traits(self) -> crate::output::QueryPrecedenceOutput {
         941  +
            crate::output::QueryPrecedenceOutput {}
 1008    942   
        }
 1009    943   
    }
 1010    944   
}

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/src/protocol_serde.rs

@@ -1,1 +41,39 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
pub(crate) mod shape_case_insensitive_error_operation;
    3      3   
    4      4   
pub(crate) mod shape_empty_struct_with_content_on_wire_op;
    5      5   
    6      6   
pub(crate) mod shape_enum_query;
    7      7   
    8      8   
pub(crate) mod shape_escaped_string_values;
    9      9   
   10         -
pub(crate) mod shape_http_query_params_only_operation;
   11         -
   12     10   
pub(crate) mod shape_map_with_enum_key_op;
   13     11   
   14     12   
pub(crate) mod shape_null_in_non_sparse;
   15     13   
   16     14   
pub(crate) mod shape_primitive_int_header;
   17     15   
   18     16   
pub(crate) mod shape_primitive_int_op;
   19     17   
   20     18   
pub(crate) mod shape_query_precedence;
   21     19

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/src/python_module_export.rs

@@ -1,1 +71,69 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
#[::pyo3::pymodule]
    3      3   
#[pyo3(name = "rest_json_extras")]
    4      4   
pub fn python_library(py: ::pyo3::Python<'_>, m: &::pyo3::types::PyModule) -> ::pyo3::PyResult<()> {
    5      5   
    let input = ::pyo3::types::PyModule::new(py, "input")?;
    6      6   
    let output = ::pyo3::types::PyModule::new(py, "output")?;
    7      7   
    let error = ::pyo3::types::PyModule::new(py, "error")?;
    8      8   
    error.add_class::<crate::error::ExtraError>()?;
           9  +
    input.add_class::<crate::input::StringPayloadInput>()?;
          10  +
    output.add_class::<crate::output::StringPayloadOutput>()?;
    9     11   
    error.add_class::<crate::error::InternalServerError>()?;
   10         -
    output.add_class::<crate::output::HttpQueryParamsOnlyOperationOutput>()?;
   11         -
    input.add_class::<crate::input::HttpQueryParamsOnlyOperationInput>()?;
   12         -
    output.add_class::<crate::output::QueryPrecedenceOutput>()?;
   13         -
    input.add_class::<crate::input::QueryPrecedenceInput>()?;
          12  +
    input.add_class::<crate::input::PrimitiveIntHeaderInput>()?;
          13  +
    output.add_class::<crate::output::PrimitiveIntHeaderOutput>()?;
          14  +
    error.add_class::<crate::error::ValidationException>()?;
          15  +
    input.add_class::<crate::input::EnumQueryInput>()?;
          16  +
    output.add_class::<crate::output::EnumQueryOutput>()?;
          17  +
    input.add_class::<crate::input::StatusResponseInput>()?;
          18  +
    output.add_class::<crate::output::StatusResponseOutput>()?;
          19  +
    input.add_class::<crate::input::MapWithEnumKeyOpInput>()?;
          20  +
    output.add_class::<crate::output::MapWithEnumKeyOpOutput>()?;
          21  +
    input.add_class::<crate::input::PrimitiveIntOpInput>()?;
          22  +
    output.add_class::<crate::output::PrimitiveIntOpOutput>()?;
          23  +
    input.add_class::<crate::input::EscapedStringValuesInput>()?;
          24  +
    output.add_class::<crate::output::EscapedStringValuesOutput>()?;
          25  +
    input.add_class::<crate::input::NullInNonSparseInput>()?;
          26  +
    output.add_class::<crate::output::NullInNonSparseOutput>()?;
          27  +
    input.add_class::<crate::input::CaseInsensitiveErrorOperationInput>()?;
          28  +
    output.add_class::<crate::output::CaseInsensitiveErrorOperationOutput>()?;
          29  +
    error.add_class::<crate::error::CaseInsensitiveError>()?;
          30  +
    input.add_class::<crate::input::EmptyStructWithContentOnWireOpInput>()?;
   14     31   
    output.add_class::<crate::output::EmptyStructWithContentOnWireOpOutput>()?;
          32  +
    input.add_class::<crate::input::QueryPrecedenceInput>()?;
          33  +
    output.add_class::<crate::output::QueryPrecedenceOutput>()?;
   15     34   
    let model = ::pyo3::types::PyModule::new(py, "model")?;
   16         -
    model.add_class::<crate::model::EmptyStruct>()?;
   17         -
    input.add_class::<crate::input::EmptyStructWithContentOnWireOpInput>()?;
   18         -
    error.add_class::<crate::error::CaseInsensitiveError>()?;
   19         -
    output.add_class::<crate::output::CaseInsensitiveErrorOperationOutput>()?;
   20         -
    input.add_class::<crate::input::CaseInsensitiveErrorOperationInput>()?;
   21         -
    output.add_class::<crate::output::NullInNonSparseOutput>()?;
          35  +
    model.add_class::<crate::model::StringEnum>()?;
          36  +
    model.add_class::<crate::model::EnumWithEscapedChars>()?;
   22     37   
    model.add_class::<crate::model::PyUnionMarkerSingleElementUnion>()?;
   23         -
    input.add_class::<crate::input::NullInNonSparseInput>()?;
   24         -
    error.add_class::<crate::error::ValidationException>()?;
          38  +
    model.add_class::<crate::model::EmptyStruct>()?;
   25     39   
    model.add_class::<crate::model::ValidationExceptionField>()?;
   26         -
    output.add_class::<crate::output::EscapedStringValuesOutput>()?;
   27         -
    model.add_class::<crate::model::EnumWithEscapedChars>()?;
   28         -
    input.add_class::<crate::input::EscapedStringValuesInput>()?;
   29         -
    output.add_class::<crate::output::PrimitiveIntOpOutput>()?;
   30         -
    input.add_class::<crate::input::PrimitiveIntOpInput>()?;
   31         -
    output.add_class::<crate::output::MapWithEnumKeyOpOutput>()?;
   32         -
    model.add_class::<crate::model::StringEnum>()?;
   33         -
    input.add_class::<crate::input::MapWithEnumKeyOpInput>()?;
   34         -
    output.add_class::<crate::output::StatusResponseOutput>()?;
   35         -
    input.add_class::<crate::input::StatusResponseInput>()?;
   36         -
    output.add_class::<crate::output::EnumQueryOutput>()?;
   37         -
    input.add_class::<crate::input::EnumQueryInput>()?;
   38         -
    output.add_class::<crate::output::PrimitiveIntHeaderOutput>()?;
   39         -
    input.add_class::<crate::input::PrimitiveIntHeaderInput>()?;
   40         -
    output.add_class::<crate::output::StringPayloadOutput>()?;
   41         -
    input.add_class::<crate::input::StringPayloadInput>()?;
   42     40   
    ::pyo3::py_run!(
   43     41   
        py,
   44     42   
        input,
   45     43   
        "import sys; sys.modules['rest_json_extras.input'] = input"
   46     44   
    );
   47     45   
    m.add_submodule(input)?;
   48     46   
    ::pyo3::py_run!(
   49     47   
        py,
   50     48   
        output,
   51     49   
        "import sys; sys.modules['rest_json_extras.output'] = output"

tmp-codegen-diff/codegen-server-test-python/rest_json_extras/rust-server-codegen-python/src/python_operation_adaptor.rs

@@ -1,1 +348,273 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2         -
/// Python handler for operation `HttpQueryParamsOnlyOperation`.
    3         -
pub(crate) async fn http_query_params_only_operation(
    4         -
    input: crate::input::HttpQueryParamsOnlyOperationInput,
    5         -
    state: ::aws_smithy_legacy_http_server::Extension<
    6         -
        ::aws_smithy_http_server_python::context::PyContext,
    7         -
    >,
    8         -
    handler: ::aws_smithy_http_server_python::PyHandler,
    9         -
) -> std::result::Result<
   10         -
    crate::output::HttpQueryParamsOnlyOperationOutput,
   11         -
    crate::error::HttpQueryParamsOnlyOperationError,
   12         -
> {
   13         -
    // Async block used to run the handler and catch any Python error.
   14         -
    let result = if handler.is_coroutine {
   15         -
        ::tracing::trace!(
   16         -
            name = "http_query_params_only_operation",
   17         -
            "executing python handler coroutine"
   18         -
        );
   19         -
        let result = ::pyo3::Python::with_gil(|py| {
   20         -
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
   21         -
            let coroutine = if handler.args == 1 {
   22         -
                pyhandler.call1((input,))?
   23         -
            } else {
   24         -
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
   25         -
            };
   26         -
            ::pyo3_asyncio::tokio::into_future(coroutine)
   27         -
        })?;
   28         -
        result.await.and_then(|r| {
   29         -
            ::pyo3::Python::with_gil(|py| {
   30         -
                r.extract::<crate::output::HttpQueryParamsOnlyOperationOutput>(py)
   31         -
            })
   32         -
        })
   33         -
    } else {
   34         -
        ::tracing::trace!(
   35         -
            name = "http_query_params_only_operation",
   36         -
            "executing python handler function"
   37         -
        );
   38         -
        ::pyo3::Python::with_gil(|py| {
   39         -
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
   40         -
            let output = if handler.args == 1 {
   41         -
                pyhandler.call1((input,))?
   42         -
            } else {
   43         -
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
   44         -
            };
   45         -
            output.extract::<crate::output::HttpQueryParamsOnlyOperationOutput>()
   46         -
        })
   47         -
    };
   48         -
    // Catch and record a Python traceback.
   49         -
    result.map_err(|e| {
   50         -
        let rich_py_err =
   51         -
            ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
   52         -
                e.clone_ref(py)
   53         -
            }));
   54         -
        ::tracing::error!(error = ?rich_py_err, "handler error");
   55         -
        e.into()
   56         -
    })
   57         -
}
   58         -
   59         -
/// Python handler for operation `QueryPrecedence`.
   60         -
pub(crate) async fn query_precedence(
   61         -
    input: crate::input::QueryPrecedenceInput,
           2  +
/// Python handler for operation `StringPayload`.
           3  +
pub(crate) async fn string_payload(
           4  +
    input: crate::input::StringPayloadInput,
   62      5   
    state: ::aws_smithy_legacy_http_server::Extension<
   63      6   
        ::aws_smithy_http_server_python::context::PyContext,
   64      7   
    >,
   65      8   
    handler: ::aws_smithy_http_server_python::PyHandler,
   66         -
) -> std::result::Result<crate::output::QueryPrecedenceOutput, crate::error::QueryPrecedenceError> {
           9  +
) -> std::result::Result<crate::output::StringPayloadOutput, crate::error::StringPayloadError> {
   67     10   
    // Async block used to run the handler and catch any Python error.
   68     11   
    let result = if handler.is_coroutine {
   69     12   
        ::tracing::trace!(
   70         -
            name = "query_precedence",
          13  +
            name = "string_payload",
   71     14   
            "executing python handler coroutine"
   72     15   
        );
   73     16   
        let result = ::pyo3::Python::with_gil(|py| {
   74     17   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
   75     18   
            let coroutine = if handler.args == 1 {
   76     19   
                pyhandler.call1((input,))?
   77     20   
            } else {
   78     21   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
   79     22   
            };
   80     23   
            ::pyo3_asyncio::tokio::into_future(coroutine)
   81     24   
        })?;
   82     25   
        result.await.and_then(|r| {
   83         -
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::QueryPrecedenceOutput>(py))
          26  +
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::StringPayloadOutput>(py))
   84     27   
        })
   85     28   
    } else {
   86         -
        ::tracing::trace!(
   87         -
            name = "query_precedence",
   88         -
            "executing python handler function"
   89         -
        );
          29  +
        ::tracing::trace!(name = "string_payload", "executing python handler function");
   90     30   
        ::pyo3::Python::with_gil(|py| {
   91     31   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
   92     32   
            let output = if handler.args == 1 {
   93     33   
                pyhandler.call1((input,))?
   94     34   
            } else {
   95     35   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
   96     36   
            };
   97         -
            output.extract::<crate::output::QueryPrecedenceOutput>()
          37  +
            output.extract::<crate::output::StringPayloadOutput>()
   98     38   
        })
   99     39   
    };
  100     40   
    // Catch and record a Python traceback.
  101     41   
    result.map_err(|e| {
  102     42   
        let rich_py_err =
  103     43   
            ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
  104     44   
                e.clone_ref(py)
  105     45   
            }));
  106     46   
        ::tracing::error!(error = ?rich_py_err, "handler error");
  107     47   
        e.into()
  108     48   
    })
  109     49   
}
  110     50   
  111         -
/// Python handler for operation `EmptyStructWithContentOnWireOp`.
  112         -
pub(crate) async fn empty_struct_with_content_on_wire_op(
  113         -
    input: crate::input::EmptyStructWithContentOnWireOpInput,
          51  +
/// Python handler for operation `PrimitiveIntHeader`.
          52  +
pub(crate) async fn primitive_int_header(
          53  +
    input: crate::input::PrimitiveIntHeaderInput,
  114     54   
    state: ::aws_smithy_legacy_http_server::Extension<
  115     55   
        ::aws_smithy_http_server_python::context::PyContext,
  116     56   
    >,
  117     57   
    handler: ::aws_smithy_http_server_python::PyHandler,
  118     58   
) -> std::result::Result<
  119         -
    crate::output::EmptyStructWithContentOnWireOpOutput,
  120         -
    crate::error::EmptyStructWithContentOnWireOpError,
          59  +
    crate::output::PrimitiveIntHeaderOutput,
          60  +
    crate::error::PrimitiveIntHeaderError,
  121     61   
> {
  122     62   
    // Async block used to run the handler and catch any Python error.
  123     63   
    let result = if handler.is_coroutine {
  124     64   
        ::tracing::trace!(
  125         -
            name = "empty_struct_with_content_on_wire_op",
          65  +
            name = "primitive_int_header",
  126     66   
            "executing python handler coroutine"
  127     67   
        );
  128     68   
        let result = ::pyo3::Python::with_gil(|py| {
  129     69   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  130     70   
            let coroutine = if handler.args == 1 {
  131     71   
                pyhandler.call1((input,))?
  132     72   
            } else {
  133     73   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  134     74   
            };
  135     75   
            ::pyo3_asyncio::tokio::into_future(coroutine)
  136     76   
        })?;
  137     77   
        result.await.and_then(|r| {
  138         -
            ::pyo3::Python::with_gil(|py| {
  139         -
                r.extract::<crate::output::EmptyStructWithContentOnWireOpOutput>(py)
  140         -
            })
          78  +
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::PrimitiveIntHeaderOutput>(py))
  141     79   
        })
  142     80   
    } else {
  143     81   
        ::tracing::trace!(
  144         -
            name = "empty_struct_with_content_on_wire_op",
          82  +
            name = "primitive_int_header",
  145     83   
            "executing python handler function"
  146     84   
        );
  147     85   
        ::pyo3::Python::with_gil(|py| {
  148     86   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  149     87   
            let output = if handler.args == 1 {
  150     88   
                pyhandler.call1((input,))?
  151     89   
            } else {
  152     90   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  153     91   
            };
  154         -
            output.extract::<crate::output::EmptyStructWithContentOnWireOpOutput>()
          92  +
            output.extract::<crate::output::PrimitiveIntHeaderOutput>()
  155     93   
        })
  156     94   
    };
  157     95   
    // Catch and record a Python traceback.
  158     96   
    result.map_err(|e| {
  159     97   
        let rich_py_err =
  160     98   
            ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
  161     99   
                e.clone_ref(py)
  162    100   
            }));
  163    101   
        ::tracing::error!(error = ?rich_py_err, "handler error");
  164    102   
        e.into()
  165    103   
    })
  166    104   
}
  167    105   
  168         -
/// Python handler for operation `CaseInsensitiveErrorOperation`.
  169         -
pub(crate) async fn case_insensitive_error_operation(
  170         -
    input: crate::input::CaseInsensitiveErrorOperationInput,
         106  +
/// Python handler for operation `EnumQuery`.
         107  +
pub(crate) async fn enum_query(
         108  +
    input: crate::input::EnumQueryInput,
  171    109   
    state: ::aws_smithy_legacy_http_server::Extension<
  172    110   
        ::aws_smithy_http_server_python::context::PyContext,
  173    111   
    >,
  174    112   
    handler: ::aws_smithy_http_server_python::PyHandler,
  175         -
) -> std::result::Result<
  176         -
    crate::output::CaseInsensitiveErrorOperationOutput,
  177         -
    crate::error::CaseInsensitiveErrorOperationError,
  178         -
> {
         113  +
) -> std::result::Result<crate::output::EnumQueryOutput, crate::error::EnumQueryError> {
  179    114   
    // Async block used to run the handler and catch any Python error.
  180    115   
    let result = if handler.is_coroutine {
  181         -
        ::tracing::trace!(
  182         -
            name = "case_insensitive_error_operation",
  183         -
            "executing python handler coroutine"
  184         -
        );
         116  +
        ::tracing::trace!(name = "enum_query", "executing python handler coroutine");
  185    117   
        let result = ::pyo3::Python::with_gil(|py| {
  186    118   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  187    119   
            let coroutine = if handler.args == 1 {
  188    120   
                pyhandler.call1((input,))?
  189    121   
            } else {
  190    122   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  191    123   
            };
  192    124   
            ::pyo3_asyncio::tokio::into_future(coroutine)
  193    125   
        })?;
  194    126   
        result.await.and_then(|r| {
  195         -
            ::pyo3::Python::with_gil(|py| {
  196         -
                r.extract::<crate::output::CaseInsensitiveErrorOperationOutput>(py)
  197         -
            })
         127  +
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::EnumQueryOutput>(py))
  198    128   
        })
  199    129   
    } else {
  200         -
        ::tracing::trace!(
  201         -
            name = "case_insensitive_error_operation",
  202         -
            "executing python handler function"
  203         -
        );
         130  +
        ::tracing::trace!(name = "enum_query", "executing python handler function");
  204    131   
        ::pyo3::Python::with_gil(|py| {
  205    132   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  206    133   
            let output = if handler.args == 1 {
  207    134   
                pyhandler.call1((input,))?
  208    135   
            } else {
  209    136   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  210    137   
            };
  211         -
            output.extract::<crate::output::CaseInsensitiveErrorOperationOutput>()
         138  +
            output.extract::<crate::output::EnumQueryOutput>()
  212    139   
        })
  213    140   
    };
  214    141   
    // Catch and record a Python traceback.
  215    142   
    result.map_err(|e| {
  216    143   
        let rich_py_err =
  217    144   
            ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
  218    145   
                e.clone_ref(py)
  219    146   
            }));
  220    147   
        ::tracing::error!(error = ?rich_py_err, "handler error");
  221    148   
        e.into()
  222    149   
    })
  223    150   
}
  224    151   
  225         -
/// Python handler for operation `NullInNonSparse`.
  226         -
pub(crate) async fn null_in_non_sparse(
  227         -
    input: crate::input::NullInNonSparseInput,
         152  +
/// Python handler for operation `StatusResponse`.
         153  +
pub(crate) async fn status_response(
         154  +
    input: crate::input::StatusResponseInput,
  228    155   
    state: ::aws_smithy_legacy_http_server::Extension<
  229    156   
        ::aws_smithy_http_server_python::context::PyContext,
  230    157   
    >,
  231    158   
    handler: ::aws_smithy_http_server_python::PyHandler,
  232         -
) -> std::result::Result<crate::output::NullInNonSparseOutput, crate::error::NullInNonSparseError> {
         159  +
) -> std::result::Result<crate::output::StatusResponseOutput, crate::error::StatusResponseError> {
  233    160   
    // Async block used to run the handler and catch any Python error.
  234    161   
    let result = if handler.is_coroutine {
  235    162   
        ::tracing::trace!(
  236         -
            name = "null_in_non_sparse",
         163  +
            name = "status_response",
  237    164   
            "executing python handler coroutine"
  238    165   
        );
  239    166   
        let result = ::pyo3::Python::with_gil(|py| {
  240    167   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  241    168   
            let coroutine = if handler.args == 1 {
  242    169   
                pyhandler.call1((input,))?
  243    170   
            } else {
  244    171   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  245    172   
            };
  246    173   
            ::pyo3_asyncio::tokio::into_future(coroutine)
  247    174   
        })?;
  248    175   
        result.await.and_then(|r| {
  249         -
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::NullInNonSparseOutput>(py))
         176  +
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::StatusResponseOutput>(py))
  250    177   
        })
  251    178   
    } else {
  252    179   
        ::tracing::trace!(
  253         -
            name = "null_in_non_sparse",
         180  +
            name = "status_response",
  254    181   
            "executing python handler function"
  255    182   
        );
  256    183   
        ::pyo3::Python::with_gil(|py| {
  257    184   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  258    185   
            let output = if handler.args == 1 {
  259    186   
                pyhandler.call1((input,))?
  260    187   
            } else {
  261    188   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  262    189   
            };
  263         -
            output.extract::<crate::output::NullInNonSparseOutput>()
         190  +
            output.extract::<crate::output::StatusResponseOutput>()
  264    191   
        })
  265    192   
    };
  266    193   
    // Catch and record a Python traceback.
  267    194   
    result.map_err(|e| {
  268    195   
        let rich_py_err =
  269    196   
            ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
  270    197   
                e.clone_ref(py)
  271    198   
            }));
  272    199   
        ::tracing::error!(error = ?rich_py_err, "handler error");
  273    200   
        e.into()
  274    201   
    })
  275    202   
}
  276    203   
  277         -
/// Python handler for operation `EscapedStringValues`.
  278         -
pub(crate) async fn escaped_string_values(
  279         -
    input: crate::input::EscapedStringValuesInput,
         204  +
/// Python handler for operation `MapWithEnumKeyOp`.
         205  +
pub(crate) async fn map_with_enum_key_op(
         206  +
    input: crate::input::MapWithEnumKeyOpInput,
  280    207   
    state: ::aws_smithy_legacy_http_server::Extension<
  281    208   
        ::aws_smithy_http_server_python::context::PyContext,
  282    209   
    >,
  283    210   
    handler: ::aws_smithy_http_server_python::PyHandler,
  284         -
) -> std::result::Result<
  285         -
    crate::output::EscapedStringValuesOutput,
  286         -
    crate::error::EscapedStringValuesError,
  287         -
> {
         211  +
) -> std::result::Result<crate::output::MapWithEnumKeyOpOutput, crate::error::MapWithEnumKeyOpError>
         212  +
{
  288    213   
    // Async block used to run the handler and catch any Python error.
  289    214   
    let result = if handler.is_coroutine {
  290    215   
        ::tracing::trace!(
  291         -
            name = "escaped_string_values",
         216  +
            name = "map_with_enum_key_op",
  292    217   
            "executing python handler coroutine"
  293    218   
        );
  294    219   
        let result = ::pyo3::Python::with_gil(|py| {
  295    220   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  296    221   
            let coroutine = if handler.args == 1 {
  297    222   
                pyhandler.call1((input,))?
  298    223   
            } else {
  299    224   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  300    225   
            };
  301    226   
            ::pyo3_asyncio::tokio::into_future(coroutine)
  302    227   
        })?;
  303    228   
        result.await.and_then(|r| {
  304         -
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::EscapedStringValuesOutput>(py))
         229  +
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::MapWithEnumKeyOpOutput>(py))
  305    230   
        })
  306    231   
    } else {
  307    232   
        ::tracing::trace!(
  308         -
            name = "escaped_string_values",
         233  +
            name = "map_with_enum_key_op",
  309    234   
            "executing python handler function"
  310    235   
        );
  311    236   
        ::pyo3::Python::with_gil(|py| {
  312    237   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  313    238   
            let output = if handler.args == 1 {
  314    239   
                pyhandler.call1((input,))?
  315    240   
            } else {
  316    241   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  317    242   
            };
  318         -
            output.extract::<crate::output::EscapedStringValuesOutput>()
         243  +
            output.extract::<crate::output::MapWithEnumKeyOpOutput>()
  319    244   
        })
  320    245   
    };
  321    246   
    // Catch and record a Python traceback.
  322    247   
    result.map_err(|e| {
  323    248   
        let rich_py_err =
  324    249   
            ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
  325    250   
                e.clone_ref(py)
  326    251   
            }));
  327    252   
        ::tracing::error!(error = ?rich_py_err, "handler error");
  328    253   
        e.into()
@@ -354,279 +637,580 @@
  374    299   
    result.map_err(|e| {
  375    300   
        let rich_py_err =
  376    301   
            ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
  377    302   
                e.clone_ref(py)
  378    303   
            }));
  379    304   
        ::tracing::error!(error = ?rich_py_err, "handler error");
  380    305   
        e.into()
  381    306   
    })
  382    307   
}
  383    308   
  384         -
/// Python handler for operation `MapWithEnumKeyOp`.
  385         -
pub(crate) async fn map_with_enum_key_op(
  386         -
    input: crate::input::MapWithEnumKeyOpInput,
         309  +
/// Python handler for operation `EscapedStringValues`.
         310  +
pub(crate) async fn escaped_string_values(
         311  +
    input: crate::input::EscapedStringValuesInput,
  387    312   
    state: ::aws_smithy_legacy_http_server::Extension<
  388    313   
        ::aws_smithy_http_server_python::context::PyContext,
  389    314   
    >,
  390    315   
    handler: ::aws_smithy_http_server_python::PyHandler,
  391         -
) -> std::result::Result<crate::output::MapWithEnumKeyOpOutput, crate::error::MapWithEnumKeyOpError>
  392         -
{
         316  +
) -> std::result::Result<
         317  +
    crate::output::EscapedStringValuesOutput,
         318  +
    crate::error::EscapedStringValuesError,
         319  +
> {
  393    320   
    // Async block used to run the handler and catch any Python error.
  394    321   
    let result = if handler.is_coroutine {
  395    322   
        ::tracing::trace!(
  396         -
            name = "map_with_enum_key_op",
         323  +
            name = "escaped_string_values",
  397    324   
            "executing python handler coroutine"
  398    325   
        );
  399    326   
        let result = ::pyo3::Python::with_gil(|py| {
  400    327   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  401    328   
            let coroutine = if handler.args == 1 {
  402    329   
                pyhandler.call1((input,))?
  403    330   
            } else {
  404    331   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  405    332   
            };
  406    333   
            ::pyo3_asyncio::tokio::into_future(coroutine)
  407    334   
        })?;
  408    335   
        result.await.and_then(|r| {
  409         -
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::MapWithEnumKeyOpOutput>(py))
         336  +
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::EscapedStringValuesOutput>(py))
  410    337   
        })
  411    338   
    } else {
  412    339   
        ::tracing::trace!(
  413         -
            name = "map_with_enum_key_op",
         340  +
            name = "escaped_string_values",
  414    341   
            "executing python handler function"
  415    342   
        );
  416    343   
        ::pyo3::Python::with_gil(|py| {
  417    344   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  418    345   
            let output = if handler.args == 1 {
  419    346   
                pyhandler.call1((input,))?
  420    347   
            } else {
  421    348   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  422    349   
            };
  423         -
            output.extract::<crate::output::MapWithEnumKeyOpOutput>()
         350  +
            output.extract::<crate::output::EscapedStringValuesOutput>()
  424    351   
        })
  425    352   
    };
  426    353   
    // Catch and record a Python traceback.
  427    354   
    result.map_err(|e| {
  428    355   
        let rich_py_err =
  429    356   
            ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
  430    357   
                e.clone_ref(py)
  431    358   
            }));
  432    359   
        ::tracing::error!(error = ?rich_py_err, "handler error");
  433    360   
        e.into()
  434    361   
    })
  435    362   
}
  436    363   
  437         -
/// Python handler for operation `StatusResponse`.
  438         -
pub(crate) async fn status_response(
  439         -
    input: crate::input::StatusResponseInput,
         364  +
/// Python handler for operation `NullInNonSparse`.
         365  +
pub(crate) async fn null_in_non_sparse(
         366  +
    input: crate::input::NullInNonSparseInput,
  440    367   
    state: ::aws_smithy_legacy_http_server::Extension<
  441    368   
        ::aws_smithy_http_server_python::context::PyContext,
  442    369   
    >,
  443    370   
    handler: ::aws_smithy_http_server_python::PyHandler,
  444         -
) -> std::result::Result<crate::output::StatusResponseOutput, crate::error::StatusResponseError> {
         371  +
) -> std::result::Result<crate::output::NullInNonSparseOutput, crate::error::NullInNonSparseError> {
  445    372   
    // Async block used to run the handler and catch any Python error.
  446    373   
    let result = if handler.is_coroutine {
  447    374   
        ::tracing::trace!(
  448         -
            name = "status_response",
         375  +
            name = "null_in_non_sparse",
  449    376   
            "executing python handler coroutine"
  450    377   
        );
  451    378   
        let result = ::pyo3::Python::with_gil(|py| {
  452    379   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  453    380   
            let coroutine = if handler.args == 1 {
  454    381   
                pyhandler.call1((input,))?
  455    382   
            } else {
  456    383   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  457    384   
            };
  458    385   
            ::pyo3_asyncio::tokio::into_future(coroutine)
  459    386   
        })?;
  460    387   
        result.await.and_then(|r| {
  461         -
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::StatusResponseOutput>(py))
         388  +
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::NullInNonSparseOutput>(py))
  462    389   
        })
  463    390   
    } else {
  464    391   
        ::tracing::trace!(
  465         -
            name = "status_response",
         392  +
            name = "null_in_non_sparse",
  466    393   
            "executing python handler function"
  467    394   
        );
  468    395   
        ::pyo3::Python::with_gil(|py| {
  469    396   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  470    397   
            let output = if handler.args == 1 {
  471    398   
                pyhandler.call1((input,))?
  472    399   
            } else {
  473    400   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  474    401   
            };
  475         -
            output.extract::<crate::output::StatusResponseOutput>()
         402  +
            output.extract::<crate::output::NullInNonSparseOutput>()
  476    403   
        })
  477    404   
    };
  478    405   
    // Catch and record a Python traceback.
  479    406   
    result.map_err(|e| {
  480    407   
        let rich_py_err =
  481    408   
            ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
  482    409   
                e.clone_ref(py)
  483    410   
            }));
  484    411   
        ::tracing::error!(error = ?rich_py_err, "handler error");
  485    412   
        e.into()
  486    413   
    })
  487    414   
}
  488    415   
  489         -
/// Python handler for operation `EnumQuery`.
  490         -
pub(crate) async fn enum_query(
  491         -
    input: crate::input::EnumQueryInput,
         416  +
/// Python handler for operation `CaseInsensitiveErrorOperation`.
         417  +
pub(crate) async fn case_insensitive_error_operation(
         418  +
    input: crate::input::CaseInsensitiveErrorOperationInput,
  492    419   
    state: ::aws_smithy_legacy_http_server::Extension<
  493    420   
        ::aws_smithy_http_server_python::context::PyContext,
  494    421   
    >,
  495    422   
    handler: ::aws_smithy_http_server_python::PyHandler,
  496         -
) -> std::result::Result<crate::output::EnumQueryOutput, crate::error::EnumQueryError> {
         423  +
) -> std::result::Result<
         424  +
    crate::output::CaseInsensitiveErrorOperationOutput,
         425  +
    crate::error::CaseInsensitiveErrorOperationError,
         426  +
> {
  497    427   
    // Async block used to run the handler and catch any Python error.
  498    428   
    let result = if handler.is_coroutine {
  499         -
        ::tracing::trace!(name = "enum_query", "executing python handler coroutine");
         429  +
        ::tracing::trace!(
         430  +
            name = "case_insensitive_error_operation",
         431  +
            "executing python handler coroutine"
         432  +
        );
  500    433   
        let result = ::pyo3::Python::with_gil(|py| {
  501    434   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  502    435   
            let coroutine = if handler.args == 1 {
  503    436   
                pyhandler.call1((input,))?
  504    437   
            } else {
  505    438   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  506    439   
            };
  507    440   
            ::pyo3_asyncio::tokio::into_future(coroutine)
  508    441   
        })?;
  509    442   
        result.await.and_then(|r| {
  510         -
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::EnumQueryOutput>(py))
         443  +
            ::pyo3::Python::with_gil(|py| {
         444  +
                r.extract::<crate::output::CaseInsensitiveErrorOperationOutput>(py)
         445  +
            })
  511    446   
        })
  512    447   
    } else {
  513         -
        ::tracing::trace!(name = "enum_query", "executing python handler function");
         448  +
        ::tracing::trace!(
         449  +
            name = "case_insensitive_error_operation",
         450  +
            "executing python handler function"
         451  +
        );
  514    452   
        ::pyo3::Python::with_gil(|py| {
  515    453   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  516    454   
            let output = if handler.args == 1 {
  517    455   
                pyhandler.call1((input,))?
  518    456   
            } else {
  519    457   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  520    458   
            };
  521         -
            output.extract::<crate::output::EnumQueryOutput>()
         459  +
            output.extract::<crate::output::CaseInsensitiveErrorOperationOutput>()
  522    460   
        })
  523    461   
    };
  524    462   
    // Catch and record a Python traceback.
  525    463   
    result.map_err(|e| {
  526    464   
        let rich_py_err =
  527    465   
            ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
  528    466   
                e.clone_ref(py)
  529    467   
            }));
  530    468   
        ::tracing::error!(error = ?rich_py_err, "handler error");
  531    469   
        e.into()
  532    470   
    })
  533    471   
}
  534    472   
  535         -
/// Python handler for operation `PrimitiveIntHeader`.
  536         -
pub(crate) async fn primitive_int_header(
  537         -
    input: crate::input::PrimitiveIntHeaderInput,
         473  +
/// Python handler for operation `EmptyStructWithContentOnWireOp`.
         474  +
pub(crate) async fn empty_struct_with_content_on_wire_op(
         475  +
    input: crate::input::EmptyStructWithContentOnWireOpInput,
  538    476   
    state: ::aws_smithy_legacy_http_server::Extension<
  539    477   
        ::aws_smithy_http_server_python::context::PyContext,
  540    478   
    >,
  541    479   
    handler: ::aws_smithy_http_server_python::PyHandler,
  542    480   
) -> std::result::Result<
  543         -
    crate::output::PrimitiveIntHeaderOutput,
  544         -
    crate::error::PrimitiveIntHeaderError,
         481  +
    crate::output::EmptyStructWithContentOnWireOpOutput,
         482  +
    crate::error::EmptyStructWithContentOnWireOpError,
  545    483   
> {
  546    484   
    // Async block used to run the handler and catch any Python error.
  547    485   
    let result = if handler.is_coroutine {
  548    486   
        ::tracing::trace!(
  549         -
            name = "primitive_int_header",
         487  +
            name = "empty_struct_with_content_on_wire_op",
  550    488   
            "executing python handler coroutine"
  551    489   
        );
  552    490   
        let result = ::pyo3::Python::with_gil(|py| {
  553    491   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  554    492   
            let coroutine = if handler.args == 1 {
  555    493   
                pyhandler.call1((input,))?
  556    494   
            } else {
  557    495   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  558    496   
            };
  559    497   
            ::pyo3_asyncio::tokio::into_future(coroutine)
  560    498   
        })?;
  561    499   
        result.await.and_then(|r| {
  562         -
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::PrimitiveIntHeaderOutput>(py))
         500  +
            ::pyo3::Python::with_gil(|py| {
         501  +
                r.extract::<crate::output::EmptyStructWithContentOnWireOpOutput>(py)
         502  +
            })
  563    503   
        })
  564    504   
    } else {
  565    505   
        ::tracing::trace!(
  566         -
            name = "primitive_int_header",
         506  +
            name = "empty_struct_with_content_on_wire_op",
  567    507   
            "executing python handler function"
  568    508   
        );
  569    509   
        ::pyo3::Python::with_gil(|py| {
  570    510   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  571    511   
            let output = if handler.args == 1 {
  572    512   
                pyhandler.call1((input,))?
  573    513   
            } else {
  574    514   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  575    515   
            };
  576         -
            output.extract::<crate::output::PrimitiveIntHeaderOutput>()
         516  +
            output.extract::<crate::output::EmptyStructWithContentOnWireOpOutput>()
  577    517   
        })
  578    518   
    };
  579    519   
    // Catch and record a Python traceback.
  580    520   
    result.map_err(|e| {
  581    521   
        let rich_py_err =
  582    522   
            ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
  583    523   
                e.clone_ref(py)
  584    524   
            }));
  585    525   
        ::tracing::error!(error = ?rich_py_err, "handler error");
  586    526   
        e.into()
  587    527   
    })
  588    528   
}
  589    529   
  590         -
/// Python handler for operation `StringPayload`.
  591         -
pub(crate) async fn string_payload(
  592         -
    input: crate::input::StringPayloadInput,
         530  +
/// Python handler for operation `QueryPrecedence`.
         531  +
pub(crate) async fn query_precedence(
         532  +
    input: crate::input::QueryPrecedenceInput,
  593    533   
    state: ::aws_smithy_legacy_http_server::Extension<
  594    534   
        ::aws_smithy_http_server_python::context::PyContext,
  595    535   
    >,
  596    536   
    handler: ::aws_smithy_http_server_python::PyHandler,
  597         -
) -> std::result::Result<crate::output::StringPayloadOutput, crate::error::StringPayloadError> {
         537  +
) -> std::result::Result<crate::output::QueryPrecedenceOutput, crate::error::QueryPrecedenceError> {
  598    538   
    // Async block used to run the handler and catch any Python error.
  599    539   
    let result = if handler.is_coroutine {
  600    540   
        ::tracing::trace!(
  601         -
            name = "string_payload",
         541  +
            name = "query_precedence",
  602    542   
            "executing python handler coroutine"
  603    543   
        );
  604    544   
        let result = ::pyo3::Python::with_gil(|py| {
  605    545   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  606    546   
            let coroutine = if handler.args == 1 {
  607    547   
                pyhandler.call1((input,))?
  608    548   
            } else {
  609    549   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  610    550   
            };
  611    551   
            ::pyo3_asyncio::tokio::into_future(coroutine)
  612    552   
        })?;
  613    553   
        result.await.and_then(|r| {
  614         -
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::StringPayloadOutput>(py))
         554  +
            ::pyo3::Python::with_gil(|py| r.extract::<crate::output::QueryPrecedenceOutput>(py))
  615    555   
        })
  616    556   
    } else {
  617         -
        ::tracing::trace!(name = "string_payload", "executing python handler function");
         557  +
        ::tracing::trace!(
         558  +
            name = "query_precedence",
         559  +
            "executing python handler function"
         560  +
        );
  618    561   
        ::pyo3::Python::with_gil(|py| {
  619    562   
            let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
  620    563   
            let output = if handler.args == 1 {
  621    564   
                pyhandler.call1((input,))?
  622    565   
            } else {
  623    566   
                pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
  624    567   
            };
  625         -
            output.extract::<crate::output::StringPayloadOutput>()
         568  +
            output.extract::<crate::output::QueryPrecedenceOutput>()
  626    569   
        })
  627    570   
    };
  628    571   
    // Catch and record a Python traceback.
  629    572   
    result.map_err(|e| {
  630    573   
        let rich_py_err =
  631    574   
            ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
  632    575   
                e.clone_ref(py)
  633    576   
            }));
  634    577   
        ::tracing::error!(error = ?rich_py_err, "handler error");
  635    578   
        e.into()