Server Test Python

rev. dfb5149b65b7bcc09edd15b8e071ad43b5ac5943 (ignoring whitespace)

Files changed:

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

@@ -1,1 +866,883 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `ContentTypeParameters`.
 pub(crate) async fn content_type_parameters(
     input: crate::input::ContentTypeParametersInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::ContentTypeParametersOutput,
     crate::error::ContentTypeParametersError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "content_type_parameters",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::ContentTypeParametersOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "content_type_parameters",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::ContentTypeParametersOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-56
+}
-57
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `PutWithContentEncoding`.
 pub(crate) async fn put_with_content_encoding(
     input: crate::input::PutWithContentEncodingInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::PutWithContentEncodingOutput,
     crate::error::PutWithContentEncodingError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "put_with_content_encoding",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::PutWithContentEncodingOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "put_with_content_encoding",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::PutWithContentEncodingOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-112
+}
-113
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `FractionalSeconds`.
 pub(crate) async fn fractional_seconds(
     input: crate::input::FractionalSecondsInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::FractionalSecondsOutput, crate::error::FractionalSecondsError>
-121
+{
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "fractional_seconds",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::FractionalSecondsOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "fractional_seconds",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::FractionalSecondsOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-164
+}
-165
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `DatetimeOffsets`.
 pub(crate) async fn datetime_offsets(
     input: crate::input::DatetimeOffsetsInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::DatetimeOffsetsOutput, crate::error::DatetimeOffsetsError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "datetime_offsets",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::DatetimeOffsetsOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "datetime_offsets",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::DatetimeOffsetsOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-215
+}
-216
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `HostWithPathOperation`.
 pub(crate) async fn host_with_path_operation(
     input: crate::input::HostWithPathOperationInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::HostWithPathOperationOutput,
     crate::error::HostWithPathOperationError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "host_with_path_operation",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::HostWithPathOperationOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "host_with_path_operation",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::HostWithPathOperationOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-271
+}
-272
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `EndpointWithHostLabelOperation`.
 pub(crate) async fn endpoint_with_host_label_operation(
     input: crate::input::EndpointWithHostLabelOperationInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::EndpointWithHostLabelOperationOutput,
     crate::error::EndpointWithHostLabelOperationError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "endpoint_with_host_label_operation",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::EndpointWithHostLabelOperationOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "endpoint_with_host_label_operation",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::EndpointWithHostLabelOperationOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-327
+}
-328
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `EndpointOperation`.
 pub(crate) async fn endpoint_operation(
     input: crate::input::EndpointOperationInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::EndpointOperationOutput, crate::error::EndpointOperationError>
-336
+{
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "endpoint_operation",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::EndpointOperationOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "endpoint_operation",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::EndpointOperationOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-379
+}
-380
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `JsonUnions`.
 pub(crate) async fn json_unions(
     input: crate::input::JsonUnionsInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::JsonUnionsOutput, crate::error::JsonUnionsError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(name = "json_unions", "executing python handler coroutine");
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::JsonUnionsOutput>(py))
         })
     } else {
         ::tracing::trace!(name = "json_unions", "executing python handler function");
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::JsonUnionsOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-424
+}
-425
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `GreetingWithErrors`.
 pub(crate) async fn greeting_with_errors(
     input: crate::input::GreetingWithErrorsInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::GreetingWithErrorsOutput,
     crate::error::GreetingWithErrorsError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "greeting_with_errors",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::GreetingWithErrorsOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "greeting_with_errors",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::GreetingWithErrorsOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-478
+}
-479
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `SparseNullsOperation`.
 pub(crate) async fn sparse_nulls_operation(
     input: crate::input::SparseNullsOperationInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::SparseNullsOperationOutput,
     crate::error::SparseNullsOperationError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "sparse_nulls_operation",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::SparseNullsOperationOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "sparse_nulls_operation",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::SparseNullsOperationOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-534
+}
-535
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `NullOperation`.
 pub(crate) async fn null_operation(
     input: crate::input::NullOperationInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::NullOperationOutput, crate::error::NullOperationError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "null_operation",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::NullOperationOutput>(py))
         })
     } else {
         ::tracing::trace!(name = "null_operation", "executing python handler function");
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::NullOperationOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-582
+}
-583
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `JsonEnums`.
 pub(crate) async fn json_enums(
     input: crate::input::JsonEnumsInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::JsonEnumsOutput, crate::error::JsonEnumsError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(name = "json_enums", "executing python handler coroutine");
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::JsonEnumsOutput>(py))
         })
     } else {
         ::tracing::trace!(name = "json_enums", "executing python handler function");
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::JsonEnumsOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-627
+}
-628
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `PutAndGetInlineDocuments`.
 pub(crate) async fn put_and_get_inline_documents(
     input: crate::input::PutAndGetInlineDocumentsInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::PutAndGetInlineDocumentsOutput,
     crate::error::PutAndGetInlineDocumentsError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "put_and_get_inline_documents",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::PutAndGetInlineDocumentsOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "put_and_get_inline_documents",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::PutAndGetInlineDocumentsOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-683
+}
-684
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `OperationWithOptionalInputOutput`.
 pub(crate) async fn operation_with_optional_input_output(
     input: crate::input::OperationWithOptionalInputOutputInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::OperationWithOptionalInputOutputOutput,
     crate::error::OperationWithOptionalInputOutputError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "operation_with_optional_input_output",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::OperationWithOptionalInputOutputOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "operation_with_optional_input_output",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::OperationWithOptionalInputOutputOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-739
+}
-740
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `SimpleScalarProperties`.
 pub(crate) async fn simple_scalar_properties(
     input: crate::input::SimpleScalarPropertiesInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::SimpleScalarPropertiesOutput,
     crate::error::SimpleScalarPropertiesError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "simple_scalar_properties",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::SimpleScalarPropertiesOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "simple_scalar_properties",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::SimpleScalarPropertiesOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-795
+}
-796
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `KitchenSinkOperation`.
 pub(crate) async fn kitchen_sink_operation(
     input: crate::input::KitchenSinkOperationInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<
     crate::output::KitchenSinkOperationOutput,
     crate::error::KitchenSinkOperationError,
 > {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "kitchen_sink_operation",
             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| {
                 r.extract::<crate::output::KitchenSinkOperationOutput>(py)
             })
         })
     } else {
         ::tracing::trace!(
             name = "kitchen_sink_operation",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let output = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             output.extract::<crate::output::KitchenSinkOperationOutput>()
         })
     };
     // Catch and record a Python traceback.
     result.map_err(|e| {
         let rich_py_err =
             ::aws_smithy_http_server_python::rich_py_err(::pyo3::Python::with_gil(|py| {
                 e.clone_ref(py)
             }));
         ::tracing::error!(error = ?rich_py_err, "handler error");
         e.into()
     })
-851
+}
-852
 /* PythonServerOperationHandlerGenerator.kt:61 */
 /// Python handler for operation `EmptyOperation`.
 pub(crate) async fn empty_operation(
     input: crate::input::EmptyOperationInput,
     state: ::aws_smithy_http_server::Extension<::aws_smithy_http_server_python::context::PyContext>,
     handler: ::aws_smithy_http_server_python::PyHandler,
 ) -> std::result::Result<crate::output::EmptyOperationOutput, crate::error::EmptyOperationError> {
     // Async block used to run the handler and catch any Python error.
     let result = if handler.is_coroutine {
         ::tracing::trace!(
             name = "empty_operation",

↧ Expand context

             "executing python handler coroutine"
         );
         let result = ::pyo3::Python::with_gil(|py| {
             let pyhandler: &::pyo3::types::PyFunction = handler.extract(py)?;
             let coroutine = if handler.args == 1 {
                 pyhandler.call1((input,))?
             } else {
                 pyhandler.call1((input, ::pyo3::ToPyObject::to_object(&state.0, py)))?
             };
             ::pyo3_asyncio::tokio::into_future(coroutine)
         })?;
         result.await.and_then(|r| {
             ::pyo3::Python::with_gil(|py| r.extract::<crate::output::EmptyOperationOutput>(py))
         })
     } else {
         ::tracing::trace!(
             name = "empty_operation",
             "executing python handler function"
         );
         ::pyo3::Python::with_gil(|py| {

tmp-codegen-diff/codegen-server-test-python/json_rpc11/rust-server-codegen-python/src/python_server_application.rs

@@ -1,1 +58,63 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* PythonApplicationGenerator.kt:386 */
 #[allow(clippy::tabs_in_doc_comments)]
 /// Main Python application, used to register operations and context and start multiple
 /// workers on the same shared socket.
 ///
 /// Operations can be registered using the application object as a decorator (`@app.operation_name`).
 ///
 /// Here's a full example to get you started:
 ///
 /// ```python
 /* PythonApplicationGenerator.kt:399 */
 /// from json_rpc11 import input
 /// from json_rpc11 import output
 /* PythonApplicationGenerator.kt:406 */
 /// from json_rpc11 import error
 /* PythonApplicationGenerator.kt:408 */
 /// from json_rpc11 import middleware
 /// from json_rpc11 import App
 ///
 /// @dataclass
 /// class Context:
 ///     counter: int = 0
 ///
 /// app = App()
 /// app.context(Context())
 ///
 /// @app.request_middleware
 /// def request_middleware(request: middleware::Request):
 ///     if request.get_header("x-amzn-id") != "secret":
 ///         raise middleware.MiddlewareException("Unsupported `x-amz-id` header", 401)
 ///
 /* PythonApplicationGenerator.kt:441 */
 /// # The example tests how servers must support requests
 /// # containing a `Content-Type` header with parameters.
 /// @app.content_type_parameters
 /// def content_type_parameters(input: input::ContentTypeParametersInput, ctx: Context) -> output::ContentTypeParametersOutput:
 ///     raise NotImplementedError
 ///
 /// @app.datetime_offsets
 /// def datetime_offsets(input: input::DatetimeOffsetsInput, ctx: Context) -> output::DatetimeOffsetsOutput:
 ///     raise NotImplementedError
 ///

↧ Expand context

 /// @app.empty_operation
 /// def empty_operation(input: input::EmptyOperationInput, ctx: Context) -> output::EmptyOperationOutput:
 ///     raise NotImplementedError
 ///
 /// @app.endpoint_operation
 /// def endpoint_operation(input: input::EndpointOperationInput, ctx: Context) -> output::EndpointOperationOutput:
 ///     raise NotImplementedError
 ///
 /// @app.endpoint_with_host_label_operation
 /// def endpoint_with_host_label_operation(input: input::EndpointWithHostLabelOperationInput, ctx: Context) -> output::EndpointWithHostLabelOperationOutput:
 ///     raise NotImplementedError
 ///
 /// @app.fractional_seconds
 /// def fractional_seconds(input: input::FractionalSecondsInput, ctx: Context) -> output::FractionalSecondsOutput:
 ///     raise NotImplementedError
 ///
 /// # This operation has three possible return values:
 /// #
 /// # 1. A successful response in the form of GreetingWithErrorsOutput
 /// # 2. An InvalidGreeting error.

@@ -79,84 +465,500 @@

↥ Expand context

 ///     raise NotImplementedError
 ///
 /// @app.kitchen_sink_operation
 /// def kitchen_sink_operation(input: input::KitchenSinkOperationInput, ctx: Context) -> output::KitchenSinkOperationOutput:
 ///     raise NotImplementedError
 ///
 /// @app.null_operation
 /// def null_operation(input: input::NullOperationInput, ctx: Context) -> output::NullOperationOutput:
 ///     raise NotImplementedError
 ///
 /// @app.operation_with_optional_input_output
 /// def operation_with_optional_input_output(input: input::OperationWithOptionalInputOutputInput, ctx: Context) -> output::OperationWithOptionalInputOutputOutput:
 ///     raise NotImplementedError
 ///
 /// # This example serializes an inline document as part of the payload.
 /// @app.put_and_get_inline_documents
 /// def put_and_get_inline_documents(input: input::PutAndGetInlineDocumentsInput, ctx: Context) -> output::PutAndGetInlineDocumentsOutput:
 ///     raise NotImplementedError
 ///
 /// @app.put_with_content_encoding

 /// def put_with_content_encoding(input: input::PutWithContentEncodingInput, ctx: Context) -> output::PutWithContentEncodingOutput:
 ///     raise NotImplementedError
 ///
 /// @app.simple_scalar_properties
 /// def simple_scalar_properties(input: input::SimpleScalarPropertiesInput, ctx: Context) -> output::SimpleScalarPropertiesOutput:
 ///     raise NotImplementedError
 ///
 /// @app.sparse_nulls_operation
 /// def sparse_nulls_operation(input: input::SparseNullsOperationInput, ctx: Context) -> output::SparseNullsOperationOutput:
 ///     raise NotImplementedError
 /* PythonApplicationGenerator.kt:428 */
 ///
 /// app.run()
 /// ```
 ///
 /// Any of operations above can be written as well prepending the `async` keyword and
 /// the Python application will automatically handle it and schedule it on the event loop for you.
 /* PythonApplicationGenerator.kt:112 */
 #[::pyo3::pyclass]
 #[derive(Debug)]
 /// :generic Ctx:
 /// :extends typing.Generic\[Ctx\]:
 /// :rtype None:
 pub struct App {
     handlers: ::std::collections::HashMap<String, ::aws_smithy_http_server_python::PyHandler>,
     middlewares: Vec<::aws_smithy_http_server_python::PyMiddlewareHandler>,
     context: Option<::pyo3::PyObject>,
     workers: ::parking_lot::Mutex<Vec<::pyo3::PyObject>>,
-132
+}
 /* PythonApplicationGenerator.kt:149 */
 impl Default for App {
     fn default() -> Self {
         Self {
             handlers: Default::default(),
             middlewares: vec![],
             context: None,
             workers: ::parking_lot::Mutex::new(vec![]),
-141
+        }
-142
+    }
-143
+}
 /* PythonApplicationGenerator.kt:131 */
 impl Clone for App {
     fn clone(&self) -> Self {
         Self {
             handlers: self.handlers.clone(),
             middlewares: self.middlewares.clone(),
             context: self.context.clone(),
             workers: ::parking_lot::Mutex::new(vec![]),
-152
+        }
-153
+    }
-154
+}
 /* PythonApplicationGenerator.kt:168 */
 impl ::aws_smithy_http_server_python::PyApp for App {
     /* PythonApplicationGenerator.kt:174 */
     fn workers(&self) -> &::parking_lot::Mutex<Vec<::pyo3::PyObject>> {
         &self.workers
-160
+    }
     fn context(&self) -> &Option<::pyo3::PyObject> {
         &self.context
-163
+    }
     fn handlers(
         &mut self,
     ) -> &mut ::std::collections::HashMap<String, ::aws_smithy_http_server_python::PyHandler> {
         &mut self.handlers
-168
+    }
     /* PythonApplicationGenerator.kt:189 */
     fn build_service(
         &mut self,
         event_loop: &::pyo3::PyAny,
     ) -> ::pyo3::PyResult<
         ::tower::util::BoxCloneService<
             ::http::Request<::aws_smithy_http_server::body::Body>,
             ::http::Response<::aws_smithy_http_server::body::BoxBody>,
             std::convert::Infallible,
         >,
     > {
         /* PythonApplicationGenerator.kt:201 */
         let builder = crate::service::JsonProtocol::builder_without_plugins();
         /* PythonApplicationGenerator.kt:209 */
         let content_type_parameters_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("content_type_parameters")
             .expect("Python handler for operation `content_type_parameters` not found")
             .clone();
         let builder = builder.content_type_parameters(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 content_type_parameters_locals.clone(),
                 crate::python_operation_adaptor::content_type_parameters(
                     input,
                     state,
                     handler.clone(),
                 ),
-197
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let datetime_offsets_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("datetime_offsets")
             .expect("Python handler for operation `datetime_offsets` not found")
             .clone();
         let builder = builder.datetime_offsets(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 datetime_offsets_locals.clone(),
                 crate::python_operation_adaptor::datetime_offsets(input, state, handler.clone()),
-210
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let empty_operation_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("empty_operation")
             .expect("Python handler for operation `empty_operation` not found")
             .clone();
         let builder = builder.empty_operation(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 empty_operation_locals.clone(),
                 crate::python_operation_adaptor::empty_operation(input, state, handler.clone()),
-223
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let endpoint_operation_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("endpoint_operation")
             .expect("Python handler for operation `endpoint_operation` not found")
             .clone();
         let builder = builder.endpoint_operation(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 endpoint_operation_locals.clone(),
                 crate::python_operation_adaptor::endpoint_operation(input, state, handler.clone()),
-236
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let endpoint_with_host_label_operation_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("endpoint_with_host_label_operation")
             .expect("Python handler for operation `endpoint_with_host_label_operation` not found")
             .clone();
         let builder = builder.endpoint_with_host_label_operation(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 endpoint_with_host_label_operation_locals.clone(),
                 crate::python_operation_adaptor::endpoint_with_host_label_operation(
                     input,
                     state,
                     handler.clone(),
                 ),
-253
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let fractional_seconds_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("fractional_seconds")
             .expect("Python handler for operation `fractional_seconds` not found")
             .clone();
         let builder = builder.fractional_seconds(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 fractional_seconds_locals.clone(),
                 crate::python_operation_adaptor::fractional_seconds(input, state, handler.clone()),
-266
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let greeting_with_errors_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("greeting_with_errors")
             .expect("Python handler for operation `greeting_with_errors` not found")
             .clone();
         let builder = builder.greeting_with_errors(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 greeting_with_errors_locals.clone(),
                 crate::python_operation_adaptor::greeting_with_errors(
                     input,
                     state,
                     handler.clone(),
                 ),
-283
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let host_with_path_operation_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("host_with_path_operation")
             .expect("Python handler for operation `host_with_path_operation` not found")
             .clone();
         let builder = builder.host_with_path_operation(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 host_with_path_operation_locals.clone(),
                 crate::python_operation_adaptor::host_with_path_operation(
                     input,
                     state,
                     handler.clone(),
                 ),
-300
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let json_enums_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("json_enums")
             .expect("Python handler for operation `json_enums` not found")
             .clone();
         let builder = builder.json_enums(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 json_enums_locals.clone(),
                 crate::python_operation_adaptor::json_enums(input, state, handler.clone()),
-313
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let json_unions_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("json_unions")
             .expect("Python handler for operation `json_unions` not found")
             .clone();
         let builder = builder.json_unions(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 json_unions_locals.clone(),
                 crate::python_operation_adaptor::json_unions(input, state, handler.clone()),
-326
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let kitchen_sink_operation_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("kitchen_sink_operation")
             .expect("Python handler for operation `kitchen_sink_operation` not found")
             .clone();
         let builder = builder.kitchen_sink_operation(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 kitchen_sink_operation_locals.clone(),
                 crate::python_operation_adaptor::kitchen_sink_operation(
                     input,
                     state,
                     handler.clone(),
                 ),
-343
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let null_operation_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("null_operation")
             .expect("Python handler for operation `null_operation` not found")
             .clone();
         let builder = builder.null_operation(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 null_operation_locals.clone(),
                 crate::python_operation_adaptor::null_operation(input, state, handler.clone()),
-356
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let operation_with_optional_input_output_locals =
             ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("operation_with_optional_input_output")
             .expect("Python handler for operation `operation_with_optional_input_output` not found")
             .clone();
         let builder = builder.operation_with_optional_input_output(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 operation_with_optional_input_output_locals.clone(),
                 crate::python_operation_adaptor::operation_with_optional_input_output(
                     input,
                     state,
                     handler.clone(),
                 ),
-374
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let put_and_get_inline_documents_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("put_and_get_inline_documents")
             .expect("Python handler for operation `put_and_get_inline_documents` not found")
             .clone();
         let builder = builder.put_and_get_inline_documents(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 put_and_get_inline_documents_locals.clone(),
                 crate::python_operation_adaptor::put_and_get_inline_documents(
                     input,
                     state,
                     handler.clone(),
                 ),
-391
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let put_with_content_encoding_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("put_with_content_encoding")
             .expect("Python handler for operation `put_with_content_encoding` not found")
             .clone();
         let builder = builder.put_with_content_encoding(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 put_with_content_encoding_locals.clone(),
                 crate::python_operation_adaptor::put_with_content_encoding(
                     input,
                     state,
                     handler.clone(),
                 ),
-408
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let simple_scalar_properties_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("simple_scalar_properties")
             .expect("Python handler for operation `simple_scalar_properties` not found")
             .clone();
         let builder = builder.simple_scalar_properties(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 simple_scalar_properties_locals.clone(),
                 crate::python_operation_adaptor::simple_scalar_properties(
                     input,
                     state,
                     handler.clone(),
                 ),
-425
+            )
         });
         /* PythonApplicationGenerator.kt:209 */
         let sparse_nulls_operation_locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
         let handler = self
             .handlers
             .get("sparse_nulls_operation")
             .expect("Python handler for operation `sparse_nulls_operation` not found")
             .clone();
         let builder = builder.sparse_nulls_operation(move |input, state| {
             ::pyo3_asyncio::tokio::scope(
                 sparse_nulls_operation_locals.clone(),
                 crate::python_operation_adaptor::sparse_nulls_operation(
                     input,
                     state,
                     handler.clone(),
                 ),
-442
+            )
         });
         /* PythonApplicationGenerator.kt:220 */
         let mut service = ::tower::util::BoxCloneService::new(builder.build().expect("one or more operations do not have a registered handler; this is a bug in the Python code generator, please file a bug report under https://github.com/smithy-lang/smithy-rs/issues"));
-446
-447
+        {
             use ::tower::Layer;
             ::tracing::trace!("adding middlewares to rust python router");
             let mut middlewares = self.middlewares.clone();
             // Reverse the middlewares, so they run with same order as they defined
             middlewares.reverse();
             for handler in middlewares {
                 ::tracing::trace!(name = &handler.name, "adding python middleware");
                 let locals = ::pyo3_asyncio::TaskLocals::new(event_loop);
                 let layer = ::aws_smithy_http_server_python::PyMiddlewareLayer::<
                     ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1,
                 >::new(handler, locals);
                 service = ::tower::util::BoxCloneService::new(layer.layer(service));
-460
+            }
-461
+        }
         Ok(service)
         /* PythonApplicationGenerator.kt:189 */
-464
+    }
     /* PythonApplicationGenerator.kt:168 */
-466
+}
 /* PythonApplicationGenerator.kt:247 */
 #[::pyo3::pymethods]
 impl App {
     /* PythonApplicationGenerator.kt:260 */
     /// Create a new [App].
     #[new]
     pub fn new() -> Self {
         Self::default()
-475
+    }
-476
     /// Register a context object that will be shared between handlers.
     ///
     /// :param context Ctx:
     /// :rtype None:

↧ Expand context

     #[pyo3(text_signature = "($self, context)")]
     pub fn context(&mut self, context: ::pyo3::PyObject) {
         self.context = Some(context);
-484
+    }
-485
     /// Register a Python function to be executed inside a Tower middleware layer.
     ///
     /// :param func typing.Callable\[\[json_rpc11.middleware.Request, typing.Callable\[\[json_rpc11.middleware.Request\], typing.Awaitable\[json_rpc11.middleware.Response\]\]\], typing.Awaitable\[json_rpc11.middleware.Response\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn middleware(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         let handler = ::aws_smithy_http_server_python::PyMiddlewareHandler::new(py, func)?;
         ::tracing::trace!(
             name = &handler.name,
             is_coroutine = handler.is_coroutine,
             "registering middleware function",

@@ -488,523 +756,809 @@

↥ Expand context

         workers: Option<usize>,
         tls: Option<::aws_smithy_http_server_python::tls::PyTlsConfig>,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.run_server(py, address, port, backlog, workers, tls)
-528
+    }
-529
     /// Lambda entrypoint: start the server on Lambda.
     ///
     /// :rtype None:
     #[pyo3(text_signature = "($self)")]
     pub fn run_lambda(&mut self, py: ::pyo3::Python) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.run_lambda_handler(py)
-537
+    }
-538
     /// Build the service and start a single worker.
     #[pyo3(text_signature = "($self, socket, worker_number, tls=None)")]
     pub fn start_worker(
         &mut self,

         py: pyo3::Python,
         socket: &pyo3::PyCell<::aws_smithy_http_server_python::PySocket>,
         worker_number: isize,
         tls: Option<::aws_smithy_http_server_python::tls::PyTlsConfig>,
     ) -> pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         let event_loop = self.configure_python_event_loop(py)?;
         let service = self.build_and_configure_service(py, event_loop)?;
         self.start_hyper_worker(py, socket, event_loop, service, worker_number, tls)
-552
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `content_type_parameters` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.ContentTypeParametersInput, Ctx\], typing.Union\[json_rpc11.output.ContentTypeParametersOutput, typing.Awaitable\[json_rpc11.output.ContentTypeParametersOutput\]\]\], typing.Callable\[\[json_rpc11.input.ContentTypeParametersInput\], typing.Union\[json_rpc11.output.ContentTypeParametersOutput, typing.Awaitable\[json_rpc11.output.ContentTypeParametersOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn content_type_parameters(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "content_type_parameters", func)
-567
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `datetime_offsets` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.DatetimeOffsetsInput, Ctx\], typing.Union\[json_rpc11.output.DatetimeOffsetsOutput, typing.Awaitable\[json_rpc11.output.DatetimeOffsetsOutput\]\]\], typing.Callable\[\[json_rpc11.input.DatetimeOffsetsInput\], typing.Union\[json_rpc11.output.DatetimeOffsetsOutput, typing.Awaitable\[json_rpc11.output.DatetimeOffsetsOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn datetime_offsets(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "datetime_offsets", func)
-582
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `empty_operation` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.EmptyOperationInput, Ctx\], typing.Union\[json_rpc11.output.EmptyOperationOutput, typing.Awaitable\[json_rpc11.output.EmptyOperationOutput\]\]\], typing.Callable\[\[json_rpc11.input.EmptyOperationInput\], typing.Union\[json_rpc11.output.EmptyOperationOutput, typing.Awaitable\[json_rpc11.output.EmptyOperationOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn empty_operation(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "empty_operation", func)
-597
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `endpoint_operation` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.EndpointOperationInput, Ctx\], typing.Union\[json_rpc11.output.EndpointOperationOutput, typing.Awaitable\[json_rpc11.output.EndpointOperationOutput\]\]\], typing.Callable\[\[json_rpc11.input.EndpointOperationInput\], typing.Union\[json_rpc11.output.EndpointOperationOutput, typing.Awaitable\[json_rpc11.output.EndpointOperationOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn endpoint_operation(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "endpoint_operation", func)
-612
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `endpoint_with_host_label_operation` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.EndpointWithHostLabelOperationInput, Ctx\], typing.Union\[json_rpc11.output.EndpointWithHostLabelOperationOutput, typing.Awaitable\[json_rpc11.output.EndpointWithHostLabelOperationOutput\]\]\], typing.Callable\[\[json_rpc11.input.EndpointWithHostLabelOperationInput\], typing.Union\[json_rpc11.output.EndpointWithHostLabelOperationOutput, typing.Awaitable\[json_rpc11.output.EndpointWithHostLabelOperationOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn endpoint_with_host_label_operation(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "endpoint_with_host_label_operation", func)
-627
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `fractional_seconds` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.FractionalSecondsInput, Ctx\], typing.Union\[json_rpc11.output.FractionalSecondsOutput, typing.Awaitable\[json_rpc11.output.FractionalSecondsOutput\]\]\], typing.Callable\[\[json_rpc11.input.FractionalSecondsInput\], typing.Union\[json_rpc11.output.FractionalSecondsOutput, typing.Awaitable\[json_rpc11.output.FractionalSecondsOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn fractional_seconds(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "fractional_seconds", func)
-642
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `greeting_with_errors` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.GreetingWithErrorsInput, Ctx\], typing.Union\[json_rpc11.output.GreetingWithErrorsOutput, typing.Awaitable\[json_rpc11.output.GreetingWithErrorsOutput\]\]\], typing.Callable\[\[json_rpc11.input.GreetingWithErrorsInput\], typing.Union\[json_rpc11.output.GreetingWithErrorsOutput, typing.Awaitable\[json_rpc11.output.GreetingWithErrorsOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn greeting_with_errors(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "greeting_with_errors", func)
-657
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `host_with_path_operation` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.HostWithPathOperationInput, Ctx\], typing.Union\[json_rpc11.output.HostWithPathOperationOutput, typing.Awaitable\[json_rpc11.output.HostWithPathOperationOutput\]\]\], typing.Callable\[\[json_rpc11.input.HostWithPathOperationInput\], typing.Union\[json_rpc11.output.HostWithPathOperationOutput, typing.Awaitable\[json_rpc11.output.HostWithPathOperationOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn host_with_path_operation(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "host_with_path_operation", func)
-672
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `json_enums` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.JsonEnumsInput, Ctx\], typing.Union\[json_rpc11.output.JsonEnumsOutput, typing.Awaitable\[json_rpc11.output.JsonEnumsOutput\]\]\], typing.Callable\[\[json_rpc11.input.JsonEnumsInput\], typing.Union\[json_rpc11.output.JsonEnumsOutput, typing.Awaitable\[json_rpc11.output.JsonEnumsOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn json_enums(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "json_enums", func)
-687
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `json_unions` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.JsonUnionsInput, Ctx\], typing.Union\[json_rpc11.output.JsonUnionsOutput, typing.Awaitable\[json_rpc11.output.JsonUnionsOutput\]\]\], typing.Callable\[\[json_rpc11.input.JsonUnionsInput\], typing.Union\[json_rpc11.output.JsonUnionsOutput, typing.Awaitable\[json_rpc11.output.JsonUnionsOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn json_unions(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "json_unions", func)
-702
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `kitchen_sink_operation` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.KitchenSinkOperationInput, Ctx\], typing.Union\[json_rpc11.output.KitchenSinkOperationOutput, typing.Awaitable\[json_rpc11.output.KitchenSinkOperationOutput\]\]\], typing.Callable\[\[json_rpc11.input.KitchenSinkOperationInput\], typing.Union\[json_rpc11.output.KitchenSinkOperationOutput, typing.Awaitable\[json_rpc11.output.KitchenSinkOperationOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn kitchen_sink_operation(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "kitchen_sink_operation", func)
-717
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `null_operation` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.NullOperationInput, Ctx\], typing.Union\[json_rpc11.output.NullOperationOutput, typing.Awaitable\[json_rpc11.output.NullOperationOutput\]\]\], typing.Callable\[\[json_rpc11.input.NullOperationInput\], typing.Union\[json_rpc11.output.NullOperationOutput, typing.Awaitable\[json_rpc11.output.NullOperationOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn null_operation(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "null_operation", func)
-732
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `operation_with_optional_input_output` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.OperationWithOptionalInputOutputInput, Ctx\], typing.Union\[json_rpc11.output.OperationWithOptionalInputOutputOutput, typing.Awaitable\[json_rpc11.output.OperationWithOptionalInputOutputOutput\]\]\], typing.Callable\[\[json_rpc11.input.OperationWithOptionalInputOutputInput\], typing.Union\[json_rpc11.output.OperationWithOptionalInputOutputOutput, typing.Awaitable\[json_rpc11.output.OperationWithOptionalInputOutputOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn operation_with_optional_input_output(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "operation_with_optional_input_output", func)
-747
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `put_and_get_inline_documents` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.PutAndGetInlineDocumentsInput, Ctx\], typing.Union\[json_rpc11.output.PutAndGetInlineDocumentsOutput, typing.Awaitable\[json_rpc11.output.PutAndGetInlineDocumentsOutput\]\]\], typing.Callable\[\[json_rpc11.input.PutAndGetInlineDocumentsInput\], typing.Union\[json_rpc11.output.PutAndGetInlineDocumentsOutput, typing.Awaitable\[json_rpc11.output.PutAndGetInlineDocumentsOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn put_and_get_inline_documents(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "put_and_get_inline_documents", func)
-762
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `put_with_content_encoding` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.PutWithContentEncodingInput, Ctx\], typing.Union\[json_rpc11.output.PutWithContentEncodingOutput, typing.Awaitable\[json_rpc11.output.PutWithContentEncodingOutput\]\]\], typing.Callable\[\[json_rpc11.input.PutWithContentEncodingInput\], typing.Union\[json_rpc11.output.PutWithContentEncodingOutput, typing.Awaitable\[json_rpc11.output.PutWithContentEncodingOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn put_with_content_encoding(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "put_with_content_encoding", func)
-777
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `simple_scalar_properties` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.SimpleScalarPropertiesInput, Ctx\], typing.Union\[json_rpc11.output.SimpleScalarPropertiesOutput, typing.Awaitable\[json_rpc11.output.SimpleScalarPropertiesOutput\]\]\], typing.Callable\[\[json_rpc11.input.SimpleScalarPropertiesInput\], typing.Union\[json_rpc11.output.SimpleScalarPropertiesOutput, typing.Awaitable\[json_rpc11.output.SimpleScalarPropertiesOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn simple_scalar_properties(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "simple_scalar_properties", func)
-792
+    }
     /* PythonApplicationGenerator.kt:366 */
     /// Method to register `sparse_nulls_operation` Python implementation inside the handlers map.
     /// It can be used as a function decorator in Python.
     ///
     /// :param func typing.Union\[typing.Callable\[\[json_rpc11.input.SparseNullsOperationInput, Ctx\], typing.Union\[json_rpc11.output.SparseNullsOperationOutput, typing.Awaitable\[json_rpc11.output.SparseNullsOperationOutput\]\]\], typing.Callable\[\[json_rpc11.input.SparseNullsOperationInput\], typing.Union\[json_rpc11.output.SparseNullsOperationOutput, typing.Awaitable\[json_rpc11.output.SparseNullsOperationOutput\]\]\]\]:
     /// :rtype None:
     #[pyo3(text_signature = "($self, func)")]
     pub fn sparse_nulls_operation(
         &mut self,
         py: ::pyo3::Python,
         func: ::pyo3::PyObject,
     ) -> ::pyo3::PyResult<()> {
         use ::aws_smithy_http_server_python::PyApp;
         self.register_operation(py, "sparse_nulls_operation", func)
-807
+    }
     /* PythonApplicationGenerator.kt:247 */
-809
+}

tmp-codegen-diff/codegen-server-test-python/json_rpc11/rust-server-codegen-python/src/service.rs

@@ -1,1 +31,32 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ServerServiceGenerator.kt:795 */
 /// The service builder for [`JsonProtocol`].
 ///
 /// Constructed via [`JsonProtocol::builder`].
 pub struct JsonProtocolBuilder<Body, L, HttpPl, ModelPl> {
     content_type_parameters: Option<::aws_smithy_http_server::routing::Route<Body>>,
     datetime_offsets: Option<::aws_smithy_http_server::routing::Route<Body>>,
     empty_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
     endpoint_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
     endpoint_with_host_label_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
     fractional_seconds: Option<::aws_smithy_http_server::routing::Route<Body>>,

↧ Expand context

     greeting_with_errors: Option<::aws_smithy_http_server::routing::Route<Body>>,
     host_with_path_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
     json_enums: Option<::aws_smithy_http_server::routing::Route<Body>>,
     json_unions: Option<::aws_smithy_http_server::routing::Route<Body>>,
     kitchen_sink_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
     null_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
     operation_with_optional_input_output: Option<::aws_smithy_http_server::routing::Route<Body>>,
     put_and_get_inline_documents: Option<::aws_smithy_http_server::routing::Route<Body>>,
     put_with_content_encoding: Option<::aws_smithy_http_server::routing::Route<Body>>,
     simple_scalar_properties: Option<::aws_smithy_http_server::routing::Route<Body>>,
     sparse_nulls_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
     layer: L,
     http_plugin: HttpPl,
     model_plugin: ModelPl,
-27
+}
-28
 impl<Body, L, HttpPl, ModelPl> JsonProtocolBuilder<Body, L, HttpPl, ModelPl> {
     /// Sets the [`ContentTypeParameters`](crate::operation_shape::ContentTypeParameters) operation.
     ///
     /// This should be an async function satisfying the [`Handler`](::aws_smithy_http_server::operation::Handler) trait.

@@ -3478,3479 +3537,3539 @@

↥ Expand context

-3479
+}
 impl<L>
     ::aws_smithy_http_server::service::ContainsOperation<
         crate::operation_shape::SimpleScalarProperties,
     > for JsonProtocol<L>
-3484
+{
     const VALUE: Operation = Operation::SimpleScalarProperties;
-3486
+}
 impl<L>
     ::aws_smithy_http_server::service::ContainsOperation<
         crate::operation_shape::SparseNullsOperation,
     > for JsonProtocol<L>
-3491
+{
     const VALUE: Operation = Operation::SparseNullsOperation;
-3493
+}
-3494
 impl<S> ::aws_smithy_http_server::service::ServiceShape for JsonProtocol<S> {
     const ID: ::aws_smithy_http_server::shape_id::ShapeId =
         ::aws_smithy_http_server::shape_id::ShapeId::new(
             "aws.protocoltests.json#JsonProtocol",

             "aws.protocoltests.json",
             "JsonProtocol",
         );
-3502
     const VERSION: Option<&'static str> = Some("2018-01-01");
-3504
     type Protocol = ::aws_smithy_http_server::protocol::aws_json_11::AwsJson1_1;
-3506
     type Operations = Operation;
-3508
+}
 /* ServiceConfigGenerator.kt:178 */
 /// Configuration for the [`JsonProtocol`]. This is the central place where to register and
 /// configure [`::tower::Layer`]s, HTTP plugins, and model plugins.
 ///
 /// ```rust,no_run
 /// # use json_rpc11::JsonProtocolConfig;
 /// # use ::aws_smithy_http_server::plugin::IdentityPlugin;
 /// # use ::tower::layer::util::Identity;
 /// # let authentication_plugin = IdentityPlugin;
 /// # let authorization_plugin = IdentityPlugin;
 /// # let server_request_id_provider_layer = Identity::new();

↧ Expand context

 /// let config = JsonProtocolConfig::builder()
 ///     // Layers get executed first...
 ///     .layer(server_request_id_provider_layer)
 ///     // ...then HTTP plugins...
 ///     .http_plugin(authentication_plugin)
 ///     // ...and right after deserialization, model plugins.
 ///     .model_plugin(authorization_plugin)
 ///     .build();
 /// ```
 ///
 /// See the [`plugin`] system for details.
 ///
 /// [`plugin`]: ::aws_smithy_http_server::plugin
 #[derive(::std::fmt::Debug)]
 pub struct JsonProtocolConfig<L, H, M> {
     layers: L,
     http_plugins: H,
     model_plugins: M,
-3538
+}
-3539

@@ -3593,3595 +3652,3655 @@

↥ Expand context

-3595
     /// Add a model [plugin] to the service.
     ///
     /// [plugin]: ::aws_smithy_http_server::plugin
     // We eagerly require `NewPlugin: ModelMarker`, despite not really needing it, because compiler
     // errors get _substantially_ better if the user makes a mistake.
     pub fn model_plugin<NewPlugin: ::aws_smithy_http_server::plugin::ModelMarker>(
         self,
         model_plugin: NewPlugin,
     ) -> JsonProtocolConfigBuilder<L, H, ::aws_smithy_http_server::plugin::PluginStack<NewPlugin, M>>
-3605
+    {
         JsonProtocolConfigBuilder {
             layers: self.layers,
             http_plugins: self.http_plugins,
             model_plugins: ::aws_smithy_http_server::plugin::PluginStack::new(
                 model_plugin,
                 self.model_plugins,
             ),
-3613
+        }
-3614
+    }

-3615
     /// Build the configuration.
     pub fn build(self) -> super::JsonProtocolConfig<L, H, M> {
         super::JsonProtocolConfig {
             layers: self.layers,
             http_plugins: self.http_plugins,
             model_plugins: self.model_plugins,
-3622
+        }
-3623
+    }
-3624
+}
 /* ScopeMacroGenerator.kt:81 */
 /// A macro to help with scoping [plugins](crate::server::plugin) to a subset of all operations.
 ///
 /// In contrast to [`crate::server::scope`](crate::server::scope), this macro has knowledge
 /// of the service and any operations _not_ specified will be placed in the opposing group.
 ///
 /// # Example
 ///
 /// ```rust
 /// scope! {
 ///     /// Includes [`ContentTypeParameters`], excluding all other operations.

↧ Expand context

 ///     struct ScopeA {
 ///         includes: [ContentTypeParameters]
 ///     }
 /// }
 ///
 /// scope! {
 ///     /// Excludes [`ContentTypeParameters`], excluding all other operations.
 ///     struct ScopeB {
 ///         excludes: [ContentTypeParameters]
 ///     }
 /// }
 ///
 /// # use json_rpc11::server::plugin::{Plugin, Scoped};
 /// # use json_rpc11::scope;
 /// # struct MockPlugin;
 /// # impl<S, Op, T> Plugin<S, Op, T> for MockPlugin { type Output = u32; fn apply(&self, input: T) -> u32 { 3 } }
 /// # let scoped_a = Scoped::new::<ScopeA>(MockPlugin);
 /// # let scoped_b = Scoped::new::<ScopeB>(MockPlugin);
 /// # let a = Plugin::<(), json_rpc11::operation_shape::ContentTypeParameters, u64>::apply(&scoped_a, 6);
 /// # let b = Plugin::<(), json_rpc11::operation_shape::ContentTypeParameters, u64>::apply(&scoped_b, 6);

tmp-codegen-diff/codegen-server-test-python/json_rpc11/rust-server-codegen-python/src/types.rs

@@ -1,1 +0,7 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* SmithyTypesPubUseExtra.kt:66 */
 pub use ::aws_smithy_types::date_time::Format as DateTimeFormat;
 /* ServerRequiredCustomizations.kt:69 */
 pub use ::aws_smithy_types::error::display::DisplayErrorContext;
 pub use ::aws_smithy_types::Blob;
 pub use ::aws_smithy_types::DateTime;
 /* SmithyTypesPubUseExtra.kt:69 */ pub use ::aws_smithy_types::DateTime;

tmp-codegen-diff/codegen-server-test-python/json_rpc11/rust-server-codegen-python/src/unconstrained.rs

@@ -1,1 +182,223 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
-2
 /* UnconstrainedUnionGenerator.kt:121 */
 impl crate::constrained::Constrained for crate::model::MyUnion {
     type Unconstrained = crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained;
-6
+}
-7
 impl From<crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained>
     for crate::constrained::MaybeConstrained<crate::model::MyUnion>
-10
+{
     fn from(value: crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained) -> Self {
         Self::Unconstrained(value)
-13
+    }
-14
+}
-15
 pub(crate) mod my_union_unconstrained {
-17
     /* UnconstrainedUnionGenerator.kt:82 */
     #[allow(clippy::enum_variant_names)]
     #[derive(Debug, Clone)]
     pub(crate) enum MyUnionUnconstrained {
         /* UnconstrainedUnionGenerator.kt:95 */
         BlobValue(::aws_smithy_http_server_python::types::Blob),
         BooleanValue(bool),
         EnumValue(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:95 */ BooleanValue(bool),
         /* UnconstrainedUnionGenerator.kt:95 */ EnumValue(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:95 */
         ListValue(::std::vec::Vec<::std::string::String>),
         /* UnconstrainedUnionGenerator.kt:95 */
         MapValue(::std::collections::HashMap<::std::string::String, ::std::string::String>),
         NumberValue(i32),
         StringValue(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:95 */ NumberValue(i32),
         /* UnconstrainedUnionGenerator.kt:95 */ StringValue(::std::string::String),
         /* UnconstrainedUnionGenerator.kt:95 */
         StructureValue(crate::model::GreetingStruct),
         /* UnconstrainedUnionGenerator.kt:95 */
         TimestampValue(::aws_smithy_http_server_python::types::DateTime),
         /* UnconstrainedUnionGenerator.kt:82 */
-37
+    }
     /* UnconstrainedUnionGenerator.kt:103 */
     impl ::std::convert::TryFrom<MyUnionUnconstrained> for crate::model::MyUnion {
         type Error = crate::model::my_union_internal::ConstraintViolation;
-41
         fn try_from(value: MyUnionUnconstrained) -> ::std::result::Result<Self, Self::Error> {
             Ok(
         match value {
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::BlobValue(unconstrained) => Self::BlobValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::BooleanValue(unconstrained) => Self::BooleanValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::EnumValue(unconstrained) => Self::EnumValue(
                 unconstrained
                                         .try_into()
-54
-55
                                         .map_err(Self::Error::EnumValue)?
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::ListValue(unconstrained) => Self::ListValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::MapValue(unconstrained) => Self::MapValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::NumberValue(unconstrained) => Self::NumberValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::StringValue(unconstrained) => Self::StringValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::StructureValue(unconstrained) => Self::StructureValue(
                 unconstrained
             ),
             crate::unconstrained::my_union_unconstrained::MyUnionUnconstrained::TimestampValue(unconstrained) => Self::TimestampValue(
                 unconstrained
             ),
-76
+        }
-77
+    )
-78
+        }
-79
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-82
+}
 pub(crate) mod foo_enum_map_unconstrained {
-84
     /* UnconstrainedMapGenerator.kt:79 */
     #[derive(Debug, Clone)]
     pub(crate) struct FooEnumMapUnconstrained(
         pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
     );
-90
     impl From<FooEnumMapUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::foo_enum_map_constrained::FooEnumMapConstrained,
-94
+        >
-95
+    {
         fn from(value: FooEnumMapUnconstrained) -> Self {
             Self::Unconstrained(value)
-98
+        }
-99
+    }
     /* UnconstrainedMapGenerator.kt:101 */
     impl std::convert::TryFrom<FooEnumMapUnconstrained>
         for crate::constrained::foo_enum_map_constrained::FooEnumMapConstrained
-103
+    {
         /* UnconstrainedMapGenerator.kt:102 */
         type Error = crate::model::foo_enum_map_internal::ConstraintViolation;
         /* UnconstrainedMapGenerator.kt:104 */
         fn try_from(value: FooEnumMapUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedMapGenerator.kt:186 */
             let res: ::std::result::Result<
                 ::std::collections::HashMap<::std::string::String, crate::model::FooEnum>,
                 Self::Error,
             > = value
                 .0
                 .into_iter()
                 .map(|(k, v)| match crate::model::FooEnum::try_from(v) {
                     Ok(v) => Ok((k, v)),
                     Err(inner_constraint_violation) => {
                         Err(Self::Error::Value(k, inner_constraint_violation))
-119
+                    }
                 })
                 .collect();
             let hm = res?;
             /* UnconstrainedMapGenerator.kt:247 */
             Ok(Self(hm))
             /* UnconstrainedMapGenerator.kt:104 */
-126
+        }
         /* UnconstrainedMapGenerator.kt:101 */
-128
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-131
+}
 pub(crate) mod foo_enum_set_unconstrained {
-133
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct FooEnumSetUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
-137
     impl From<FooEnumSetUnconstrained>
         for crate::constrained::MaybeConstrained<crate::model::FooEnumSet>
-140
+    {
         fn from(value: FooEnumSetUnconstrained) -> Self {
             Self::Unconstrained(value)
-143
+        }
-144
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<FooEnumSetUnconstrained> for crate::model::FooEnumSet {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::foo_enum_set_internal::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: FooEnumSetUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:127 */
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::model::FooEnum>,
                 (usize, crate::model::foo_enum_internal::ConstraintViolation),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner =
                 res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
             /* UnconstrainedCollectionGenerator.kt:189 */
             Self::try_from(inner)
             /* UnconstrainedCollectionGenerator.kt:100 */
-170
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-172
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-175
+}
 pub(crate) mod foo_enum_list_unconstrained {
-177
     /* UnconstrainedCollectionGenerator.kt:77 */
     #[derive(Debug, Clone)]
     pub(crate) struct FooEnumListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
-181
     impl From<FooEnumListUnconstrained>
         for crate::constrained::MaybeConstrained<
             crate::constrained::foo_enum_list_constrained::FooEnumListConstrained,
-185
+        >
-186
+    {
         fn from(value: FooEnumListUnconstrained) -> Self {
             Self::Unconstrained(value)
-189
+        }
-190
+    }
     /* UnconstrainedCollectionGenerator.kt:97 */
     impl std::convert::TryFrom<FooEnumListUnconstrained>
         for crate::constrained::foo_enum_list_constrained::FooEnumListConstrained
-194
+    {
         /* UnconstrainedCollectionGenerator.kt:98 */
         type Error = crate::model::foo_enum_list_internal::ConstraintViolation;
         /* UnconstrainedCollectionGenerator.kt:100 */
         fn try_from(value: FooEnumListUnconstrained) -> std::result::Result<Self, Self::Error> {
             /* UnconstrainedCollectionGenerator.kt:127 */
             let res: ::std::result::Result<
                 ::std::vec::Vec<crate::model::FooEnum>,
                 (usize, crate::model::foo_enum_internal::ConstraintViolation),
             > = value
                 .0
                 .into_iter()
                 .enumerate()
                 .map(|(idx, inner)| {
                     inner
                         .try_into()
                         .map_err(|inner_violation| (idx, inner_violation))
                 })
                 .collect();
             let inner =
                 res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
             /* UnconstrainedCollectionGenerator.kt:191 */
             Ok(Self(inner))
             /* UnconstrainedCollectionGenerator.kt:100 */
-218
+        }
         /* UnconstrainedCollectionGenerator.kt:97 */
-220
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-223
+}

tmp-codegen-diff/codegen-server-test-python/misc/rust-server-codegen-python/Cargo.toml

@@ -6,6 +58,58 @@

↥ Expand context

 description = "test"
 edition = "2021"
-8
 [package.metadata.smithy]
 codegen-version = "ci"
 [dependencies.aws-smithy-http]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http"
 [dependencies.aws-smithy-http-server]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-server"
 [dependencies.aws-smithy-http-server-python]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-http-server-python"
 [dependencies.aws-smithy-json]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-json"
 [dependencies.aws-smithy-runtime-api]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-runtime-api"
 [dependencies.aws-smithy-types]
 path = "/home/build/workspace/smithy-rs/rust-runtime/aws-smithy-types"
 [dependencies.futures-util]
 version = "0.3"
 [dependencies.http]

 version = "0.2.9"
 [dependencies.hyper]
 version = "0.14.26"
 [dependencies.mime]
 version = "0.3"
 [dependencies.parking_lot]
 version = "0.12"
 [dependencies.pin-project-lite]
 version = "0.2"
 [dependencies.pyo3]
 version = "0.18"
 version = "0.20"
 [dependencies.pyo3-asyncio]
 version = "0.18"
 version = "0.20"
 features = ["attributes", "tokio-runtime"]
 [dependencies.tower]
 version = "0.4"
 [dependencies.tracing]
 version = "0.1"
 [dev-dependencies.hyper]
 version = "0.14.12"
 [dev-dependencies.tokio]
 version = "1.23.1"
 [features]

↧ Expand context

 rt-tokio = ["aws-smithy-types/rt-tokio"]
 aws-lambda = ["aws-smithy-http-server/aws-lambda"]
 request-id = ["aws-smithy-http-server/request-id"]
 extension-module = ["pyo3/extension-module"]
 default = ["rt-tokio", "request-id", "extension-module"]
 [lib]
 name = "misc"
 crate-type = ["cdylib"]
-57
-58

tmp-codegen-diff/codegen-server-test-python/misc/rust-server-codegen-python/python/misc/error/init.pyi

@@ -1,1 +28,28 @@

↥ Expand context

-3
 class InternalServerError(Exception):
     message: str
-6
     def __init__(self, message: str) -> None:
         ...
-9
-10
 class ValidationException(Exception):
     """
     A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     /* StructureGenerator.kt:197 */A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     """
-15
     field_list: typing.Optional[typing.List[misc.model.ValidationExceptionField]]
     """
     A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
     /* StructureGenerator.kt:231 */A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
     """
-20
     message: str
     """
     A summary of the validation failure.
     /* StructureGenerator.kt:231 */A summary of the validation failure.
     """
-25
     def __init__(self, message: str, field_list: typing.Optional[typing.List[misc.model.ValidationExceptionField]] = ...) -> None:
         ...
-28

tmp-codegen-diff/codegen-server-test-python/misc/rust-server-codegen-python/python/misc/model/init.pyi

@@ -91,91 +136,136 @@

↥ Expand context

     a_document: misc.types.DateTime
-92
     a_double: float
-94
     a_float: float
-96
     a_long: int
-98
     a_short: int
-100
     a_string: str
-102
     a_string_list: typing.List[str]
-104
     a_string_map: typing.Dict[str, misc.types.DateTime]
-106
     a_string_set: typing.List[str]
-108
     a_timestamp: misc.types.DateTime
-110

     a_union: misc.model.AUnion
-112
     an_int: int
-114
     def __init__(self, a_string: str, a_boolean: bool, a_byte: int, a_short: int, an_int: int, a_long: int, a_float: float, a_double: float, a_timestamp: misc.types.DateTime, a_document: misc.types.DateTime, a_string_list: typing.List[str], a_string_map: typing.Dict[str, misc.types.DateTime], a_string_set: typing.List[str], a_blob: misc.types.Blob, a_union: misc.model.AUnion) -> None:
         ...
-117
-118
 class ValidationExceptionField:
     """
     Describes one specific validation failure for an input member.
     /* StructureGenerator.kt:197 */Describes one specific validation failure for an input member.
     """
-123
     message: str
     """
     A detailed description of the validation failure.
     /* StructureGenerator.kt:231 */A detailed description of the validation failure.
     """
-128
     path: str
     """
     A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     /* StructureGenerator.kt:231 */A JSONPointer expression to the structure member whose value failed to satisfy the modeled constraints.
     """
-133
     def __init__(self, path: str, message: str) -> None:
         ...
-136

tmp-codegen-diff/codegen-server-test-python/misc/rust-server-codegen-python/src/error.rs

@@ -1,1 +643,1148 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* ServerOperationErrorGenerator.kt:63 */
 /// Error type for the `ResponseCodeDefaultOperation` operation.
 /* ServerOperationErrorGenerator.kt:64 */
 /// Each variant represents an error that can occur for the `ResponseCodeDefaultOperation` operation.
 /* RustType.kt:516 */
 #[derive(::std::fmt::Debug)]
 pub enum ResponseCodeDefaultOperationError {
 pub /* ServerOperationErrorGenerator.kt:66 */ enum ResponseCodeDefaultOperationError {
     /* ServerOperationErrorGenerator.kt:68 */
     #[allow(missing_docs)] // documentation missing in model
     /* ServerOperationErrorGenerator.kt:71 */
     InternalServerError(crate::error::InternalServerError),
     /* ServerOperationErrorGenerator.kt:66 */
-14
+}
 /* ServerOperationErrorGenerator.kt:75 */
 impl ::std::fmt::Display for ResponseCodeDefaultOperationError {
     /* ServerOperationErrorGenerator.kt:76 */
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             ResponseCodeDefaultOperationError::InternalServerError(_inner) => _inner.fmt(f),
             /* ServerOperationErrorGenerator.kt:142 */
             ResponseCodeDefaultOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:78 */
-+
+            {
                 _inner.fmt(f)
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-28
+        }
         /* ServerOperationErrorGenerator.kt:76 */
-30
+    }
     /* ServerOperationErrorGenerator.kt:75 */
-32
+}
 /* ServerOperationErrorGenerator.kt:83 */
 impl ResponseCodeDefaultOperationError {
     /* ServerOperationErrorGenerator.kt:87 */
     /// Returns `true` if the error kind is `ResponseCodeDefaultOperationError::InternalServerError`.
     /* ServerOperationErrorGenerator.kt:88 */
     pub fn is_internal_server_error(&self) -> bool {
         /* ServerOperationErrorGenerator.kt:89 */
         matches!(
             &self,
             ResponseCodeDefaultOperationError::InternalServerError(_)
-43
+        )
         /* ServerOperationErrorGenerator.kt:88 */
-45
+    }
     /* ServerOperationErrorGenerator.kt:92 */
     /// Returns the error name string by matching the correct variant.
     /* ServerOperationErrorGenerator.kt:93 */
     pub fn name(&self) -> &'static str {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             ResponseCodeDefaultOperationError::InternalServerError(_inner) => _inner.name(),
             /* ServerOperationErrorGenerator.kt:142 */
             ResponseCodeDefaultOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:95 */
-+
+            {
                 _inner.name()
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-59
+        }
         /* ServerOperationErrorGenerator.kt:93 */
-61
+    }
     /* ServerOperationErrorGenerator.kt:83 */
-63
+}
 /* ServerOperationErrorGenerator.kt:100 */
 impl ::std::error::Error for ResponseCodeDefaultOperationError {
     /* ServerOperationErrorGenerator.kt:101 */
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             ResponseCodeDefaultOperationError::InternalServerError(_inner) => Some(_inner),
             /* ServerOperationErrorGenerator.kt:142 */
             ResponseCodeDefaultOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:103 */
-+
+            {
                 Some(_inner)
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-77
+        }
         /* ServerOperationErrorGenerator.kt:101 */
-79
+    }
     /* ServerOperationErrorGenerator.kt:100 */
-81
+}
 /* ServerOperationErrorGenerator.kt:110 */
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::ResponseCodeDefaultOperationError
-85
+{
     /* ServerOperationErrorGenerator.kt:111 */
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::ResponseCodeDefaultOperationError {
         /* ServerOperationErrorGenerator.kt:112 */
         Self::InternalServerError(variant)
         /* ServerOperationErrorGenerator.kt:111 */
-93
+    }
     /* ServerOperationErrorGenerator.kt:110 */
-95
+}
-96
 /* PythonServerOperationErrorGenerator.kt:38 */
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::ResponseCodeDefaultOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::ResponseCodeDefaultOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
-102
             crate::error::InternalServerError {
                 message: error.to_string(),
-105
+            }
             .into()
         })
-108
+    }
-109
+}
-110
 /* RustType.kt:516 */
 #[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
 /* PythonServerStructureGenerator.kt:63 */
 /// :param message str:
 /// :rtype None:
 /* StructureGenerator.kt:197 */
 #[allow(missing_docs)] // documentation missing in model
 /* RustType.kt:516 */
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct InternalServerError {
 pub /* StructureGenerator.kt:201 */ struct InternalServerError {
     /* RustType.kt:516 */
     #[pyo3(get, set)]
     /* PythonServerStructureGenerator.kt:80 */
     /// :type str:
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
     pub message: ::std::string::String,
     /* StructureGenerator.kt:201 */
-131
+}
 /* RustType.kt:516 */
 #[allow(clippy::new_without_default)]
 /* RustType.kt:516 */
 #[allow(clippy::too_many_arguments)]
 /* RustType.kt:516 */
 #[::pyo3::pymethods]
 /* PythonServerStructureGenerator.kt:88 */
 impl InternalServerError {
     #[new]
     pub fn new(message: ::std::string::String) -> Self {
         Self { message }
-143
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-146
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-149
+    }
-150
+}
 /* ErrorImplGenerator.kt:99 */
 impl InternalServerError {
     /* ErrorImplGenerator.kt:128 */
     /// Returns the error message.
     pub fn message(&self) -> &str {
         &self.message
-157
+    }
     /* ErrorImplGenerator.kt:141 */
     #[doc(hidden)]
     /// Returns the error name.
     pub fn name(&self) -> &'static str {
         "InternalServerError"
-163
+    }
     /* ErrorImplGenerator.kt:99 */
-165
+}
 /* ErrorImplGenerator.kt:153 */
 impl ::std::fmt::Display for InternalServerError {
     /* ErrorImplGenerator.kt:154 */
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         /* ErrorImplGenerator.kt:161 */
         ::std::write!(f, "InternalServerError")?;
         /* ErrorImplGenerator.kt:166 */
-173
+        {
             /* ErrorImplGenerator.kt:167 */
             ::std::write!(f, ": {}", &self.message)?;
             /* ErrorImplGenerator.kt:166 */
-177
+        }
         /* ErrorImplGenerator.kt:171 */
         Ok(())
         /* ErrorImplGenerator.kt:154 */
-181
+    }
     /* ErrorImplGenerator.kt:153 */
-183
+}
 /* ErrorImplGenerator.kt:175 */
 impl ::std::error::Error for InternalServerError {}
 /* ServerCodegenVisitor.kt:370 */
 impl InternalServerError {
     /// Creates a new builder-style object to manufacture [`InternalServerError`](crate::error::InternalServerError).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:211 */Creates a new builder-style object to manufacture [`InternalServerError`](crate::error::InternalServerError).
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
     pub fn builder() -> crate::error::internal_server_error::Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:213 */
         crate::error::internal_server_error::Builder::default()
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
-194
+    }
     /* ServerCodegenVisitor.kt:370 */
-196
+}
-197
 /* ServerOperationErrorGenerator.kt:63 */
 /// Error type for the `ResponseCodeHttpFallbackOperation` operation.
 /* ServerOperationErrorGenerator.kt:64 */
 /// Each variant represents an error that can occur for the `ResponseCodeHttpFallbackOperation` operation.
 /* RustType.kt:516 */
 #[derive(::std::fmt::Debug)]
 pub enum ResponseCodeHttpFallbackOperationError {
 pub /* ServerOperationErrorGenerator.kt:66 */ enum ResponseCodeHttpFallbackOperationError {
     /* ServerOperationErrorGenerator.kt:68 */
     #[allow(missing_docs)] // documentation missing in model
     /* ServerOperationErrorGenerator.kt:71 */
     InternalServerError(crate::error::InternalServerError),
     /* ServerOperationErrorGenerator.kt:66 */
-210
+}
 /* ServerOperationErrorGenerator.kt:75 */
 impl ::std::fmt::Display for ResponseCodeHttpFallbackOperationError {
     /* ServerOperationErrorGenerator.kt:76 */
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             ResponseCodeHttpFallbackOperationError::InternalServerError(_inner) => _inner.fmt(f),
             /* ServerOperationErrorGenerator.kt:142 */
             ResponseCodeHttpFallbackOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:78 */
-+
+            {
                 _inner.fmt(f)
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-224
+        }
         /* ServerOperationErrorGenerator.kt:76 */
-226
+    }
     /* ServerOperationErrorGenerator.kt:75 */
-228
+}
 /* ServerOperationErrorGenerator.kt:83 */
 impl ResponseCodeHttpFallbackOperationError {
     /* ServerOperationErrorGenerator.kt:87 */
     /// Returns `true` if the error kind is `ResponseCodeHttpFallbackOperationError::InternalServerError`.
     /* ServerOperationErrorGenerator.kt:88 */
     pub fn is_internal_server_error(&self) -> bool {
         /* ServerOperationErrorGenerator.kt:89 */
         matches!(
             &self,
             ResponseCodeHttpFallbackOperationError::InternalServerError(_)
-239
+        )
         /* ServerOperationErrorGenerator.kt:88 */
-241
+    }
     /* ServerOperationErrorGenerator.kt:92 */
     /// Returns the error name string by matching the correct variant.
     /* ServerOperationErrorGenerator.kt:93 */
     pub fn name(&self) -> &'static str {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             ResponseCodeHttpFallbackOperationError::InternalServerError(_inner) => _inner.name(),
             /* ServerOperationErrorGenerator.kt:142 */
             ResponseCodeHttpFallbackOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:95 */
-+
+            {
                 _inner.name()
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-255
+        }
         /* ServerOperationErrorGenerator.kt:93 */
-257
+    }
     /* ServerOperationErrorGenerator.kt:83 */
-259
+}
 /* ServerOperationErrorGenerator.kt:100 */
 impl ::std::error::Error for ResponseCodeHttpFallbackOperationError {
     /* ServerOperationErrorGenerator.kt:101 */
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             ResponseCodeHttpFallbackOperationError::InternalServerError(_inner) => Some(_inner),
             /* ServerOperationErrorGenerator.kt:142 */
             ResponseCodeHttpFallbackOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:103 */
-+
+            {
                 Some(_inner)
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-273
+        }
         /* ServerOperationErrorGenerator.kt:101 */
-275
+    }
     /* ServerOperationErrorGenerator.kt:100 */
-277
+}
 /* ServerOperationErrorGenerator.kt:110 */
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::ResponseCodeHttpFallbackOperationError
-281
+{
     /* ServerOperationErrorGenerator.kt:111 */
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::ResponseCodeHttpFallbackOperationError {
         /* ServerOperationErrorGenerator.kt:112 */
         Self::InternalServerError(variant)
         /* ServerOperationErrorGenerator.kt:111 */
-289
+    }
     /* ServerOperationErrorGenerator.kt:110 */
-291
+}
-292
 /* PythonServerOperationErrorGenerator.kt:38 */
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::ResponseCodeHttpFallbackOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::ResponseCodeHttpFallbackOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
-298
             crate::error::InternalServerError {
                 message: error.to_string(),
-301
+            }
             .into()
         })
-304
+    }
-305
+}
-306
 /* ServerOperationErrorGenerator.kt:63 */
 /// Error type for the `ResponseCodeRequiredOperation` operation.
 /* ServerOperationErrorGenerator.kt:64 */
 /// Each variant represents an error that can occur for the `ResponseCodeRequiredOperation` operation.
 /* RustType.kt:516 */
 #[derive(::std::fmt::Debug)]
 pub enum ResponseCodeRequiredOperationError {
 pub /* ServerOperationErrorGenerator.kt:66 */ enum ResponseCodeRequiredOperationError {
     /* ServerOperationErrorGenerator.kt:68 */
     #[allow(missing_docs)] // documentation missing in model
     /* ServerOperationErrorGenerator.kt:71 */
     InternalServerError(crate::error::InternalServerError),
     /* ServerOperationErrorGenerator.kt:66 */
-319
+}
 /* ServerOperationErrorGenerator.kt:75 */
 impl ::std::fmt::Display for ResponseCodeRequiredOperationError {
     /* ServerOperationErrorGenerator.kt:76 */
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             ResponseCodeRequiredOperationError::InternalServerError(_inner) => _inner.fmt(f),
             /* ServerOperationErrorGenerator.kt:142 */
             ResponseCodeRequiredOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:78 */
-+
+            {
                 _inner.fmt(f)
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-333
+        }
         /* ServerOperationErrorGenerator.kt:76 */
-335
+    }
     /* ServerOperationErrorGenerator.kt:75 */
-337
+}
 /* ServerOperationErrorGenerator.kt:83 */
 impl ResponseCodeRequiredOperationError {
     /* ServerOperationErrorGenerator.kt:87 */
     /// Returns `true` if the error kind is `ResponseCodeRequiredOperationError::InternalServerError`.
     /* ServerOperationErrorGenerator.kt:88 */
     pub fn is_internal_server_error(&self) -> bool {
         /* ServerOperationErrorGenerator.kt:89 */
         matches!(
             &self,
             ResponseCodeRequiredOperationError::InternalServerError(_)
-348
+        )
         /* ServerOperationErrorGenerator.kt:88 */
-350
+    }
     /* ServerOperationErrorGenerator.kt:92 */
     /// Returns the error name string by matching the correct variant.
     /* ServerOperationErrorGenerator.kt:93 */
     pub fn name(&self) -> &'static str {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             ResponseCodeRequiredOperationError::InternalServerError(_inner) => _inner.name(),
             /* ServerOperationErrorGenerator.kt:142 */
             ResponseCodeRequiredOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:95 */
-+
+            {
                 _inner.name()
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-364
+        }
         /* ServerOperationErrorGenerator.kt:93 */
-366
+    }
     /* ServerOperationErrorGenerator.kt:83 */
-368
+}
 /* ServerOperationErrorGenerator.kt:100 */
 impl ::std::error::Error for ResponseCodeRequiredOperationError {
     /* ServerOperationErrorGenerator.kt:101 */
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             ResponseCodeRequiredOperationError::InternalServerError(_inner) => Some(_inner),
             /* ServerOperationErrorGenerator.kt:142 */
             ResponseCodeRequiredOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:103 */
-+
+            {
                 Some(_inner)
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-382
+        }
         /* ServerOperationErrorGenerator.kt:101 */
-384
+    }
     /* ServerOperationErrorGenerator.kt:100 */
-386
+}
 /* ServerOperationErrorGenerator.kt:110 */
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::ResponseCodeRequiredOperationError
-390
+{
     /* ServerOperationErrorGenerator.kt:111 */
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::ResponseCodeRequiredOperationError {
         /* ServerOperationErrorGenerator.kt:112 */
         Self::InternalServerError(variant)
         /* ServerOperationErrorGenerator.kt:111 */
-398
+    }
     /* ServerOperationErrorGenerator.kt:110 */
-400
+}
-401
 /* PythonServerOperationErrorGenerator.kt:38 */
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::ResponseCodeRequiredOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::ResponseCodeRequiredOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
-407
             crate::error::InternalServerError {
                 message: error.to_string(),
-410
+            }
             .into()
         })
-413
+    }
-414
+}
-415
 /* ServerOperationErrorGenerator.kt:63 */
 /// Error type for the `RequiredHeaderCollectionOperation` operation.
 /* ServerOperationErrorGenerator.kt:64 */
 /// Each variant represents an error that can occur for the `RequiredHeaderCollectionOperation` operation.
 /* RustType.kt:516 */
 #[derive(::std::fmt::Debug)]
 pub enum RequiredHeaderCollectionOperationError {
     /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 pub /* ServerOperationErrorGenerator.kt:66 */ enum RequiredHeaderCollectionOperationError {
     /// /* ServerOperationErrorGenerator.kt:68 */A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     /* ServerOperationErrorGenerator.kt:71 */
     ValidationException(crate::error::ValidationException),
     /* ServerOperationErrorGenerator.kt:68 */
     #[allow(missing_docs)] // documentation missing in model
     /* ServerOperationErrorGenerator.kt:71 */
     InternalServerError(crate::error::InternalServerError),
     /* ServerOperationErrorGenerator.kt:66 */
-431
+}
 /* ServerOperationErrorGenerator.kt:75 */
 impl ::std::fmt::Display for RequiredHeaderCollectionOperationError {
     /* ServerOperationErrorGenerator.kt:76 */
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             RequiredHeaderCollectionOperationError::ValidationException(_inner) => _inner.fmt(f),
             RequiredHeaderCollectionOperationError::InternalServerError(_inner) => _inner.fmt(f),
             /* ServerOperationErrorGenerator.kt:142 */
             RequiredHeaderCollectionOperationError::ValidationException(_inner) =>
             /* ServerOperationErrorGenerator.kt:78 */
-+
+            {
                 _inner.fmt(f)
-+
+            }
-+
+            ,
             /* ServerOperationErrorGenerator.kt:142 */
             RequiredHeaderCollectionOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:78 */
-+
+            {
                 _inner.fmt(f)
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-452
+        }
         /* ServerOperationErrorGenerator.kt:76 */
-454
+    }
     /* ServerOperationErrorGenerator.kt:75 */
-456
+}
 /* ServerOperationErrorGenerator.kt:83 */
 impl RequiredHeaderCollectionOperationError {
     /* ServerOperationErrorGenerator.kt:87 */
     /// Returns `true` if the error kind is `RequiredHeaderCollectionOperationError::ValidationException`.
     /* ServerOperationErrorGenerator.kt:88 */
     pub fn is_validation_exception(&self) -> bool {
         /* ServerOperationErrorGenerator.kt:89 */
         matches!(
             &self,
             RequiredHeaderCollectionOperationError::ValidationException(_)
-467
+        )
         /* ServerOperationErrorGenerator.kt:88 */
-469
+    }
     /* ServerOperationErrorGenerator.kt:87 */
     /// Returns `true` if the error kind is `RequiredHeaderCollectionOperationError::InternalServerError`.
     /* ServerOperationErrorGenerator.kt:88 */
     pub fn is_internal_server_error(&self) -> bool {
         /* ServerOperationErrorGenerator.kt:89 */
         matches!(
             &self,
             RequiredHeaderCollectionOperationError::InternalServerError(_)
-478
+        )
         /* ServerOperationErrorGenerator.kt:88 */
-480
+    }
     /* ServerOperationErrorGenerator.kt:92 */
     /// Returns the error name string by matching the correct variant.
     /* ServerOperationErrorGenerator.kt:93 */
     pub fn name(&self) -> &'static str {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             RequiredHeaderCollectionOperationError::ValidationException(_inner) => _inner.name(),
             RequiredHeaderCollectionOperationError::InternalServerError(_inner) => _inner.name(),
             /* ServerOperationErrorGenerator.kt:142 */
             RequiredHeaderCollectionOperationError::ValidationException(_inner) =>
             /* ServerOperationErrorGenerator.kt:95 */
-+
+            {
                 _inner.name()
-492
+            }
-+
+            ,
             /* ServerOperationErrorGenerator.kt:142 */
             RequiredHeaderCollectionOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:95 */
-+
+            {
                 _inner.name()
-499
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-+
+        }
         /* ServerOperationErrorGenerator.kt:93 */
-+
+    }
     /* ServerOperationErrorGenerator.kt:83 */
-505
+}
 /* ServerOperationErrorGenerator.kt:100 */
 impl ::std::error::Error for RequiredHeaderCollectionOperationError {
     /* ServerOperationErrorGenerator.kt:101 */
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             RequiredHeaderCollectionOperationError::ValidationException(_inner) => Some(_inner),
             RequiredHeaderCollectionOperationError::InternalServerError(_inner) => Some(_inner),
             /* ServerOperationErrorGenerator.kt:142 */
             RequiredHeaderCollectionOperationError::ValidationException(_inner) =>
             /* ServerOperationErrorGenerator.kt:103 */
-+
+            {
                 Some(_inner)
-517
+            }
-+
+            ,
             /* ServerOperationErrorGenerator.kt:142 */
             RequiredHeaderCollectionOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:103 */
-+
+            {
                 Some(_inner)
-524
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-+
+        }
         /* ServerOperationErrorGenerator.kt:101 */
-+
+    }
     /* ServerOperationErrorGenerator.kt:100 */
-530
+}
 /* ServerOperationErrorGenerator.kt:110 */
 impl ::std::convert::From<crate::error::ValidationException>
     for crate::error::RequiredHeaderCollectionOperationError
-534
+{
     /* ServerOperationErrorGenerator.kt:111 */
     fn from(
         variant: crate::error::ValidationException,
     ) -> crate::error::RequiredHeaderCollectionOperationError {
         /* ServerOperationErrorGenerator.kt:112 */
         Self::ValidationException(variant)
         /* ServerOperationErrorGenerator.kt:111 */
-542
+    }
     /* ServerOperationErrorGenerator.kt:110 */
-544
+}
 /* ServerOperationErrorGenerator.kt:110 */
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::RequiredHeaderCollectionOperationError
-548
+{
     /* ServerOperationErrorGenerator.kt:111 */
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::RequiredHeaderCollectionOperationError {
         /* ServerOperationErrorGenerator.kt:112 */
         Self::InternalServerError(variant)
         /* ServerOperationErrorGenerator.kt:111 */
-556
+    }
     /* ServerOperationErrorGenerator.kt:110 */
-558
+}
-559
 /* PythonServerOperationErrorGenerator.kt:38 */
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::RequiredHeaderCollectionOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::RequiredHeaderCollectionOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
             if let Ok(error) = error.extract::<crate::error::ValidationException>() {
                 return error.into();
-567
+            }
             crate::error::InternalServerError {
                 message: error.to_string(),
-570
+            }
             .into()
         })
-573
+    }
-574
+}
-575
 /* RustType.kt:516 */
 #[::pyo3::pyclass(extends = ::pyo3::exceptions::PyException)]
 /* PythonServerStructureGenerator.kt:63 */
 /// :param message str:
 /// :param field_list typing.Optional\[typing.List\[misc.model.ValidationExceptionField\]\]:
 /// :rtype None:
 /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 /// /* StructureGenerator.kt:197 */A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 /* RustType.kt:516 */
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ValidationException {
 pub /* StructureGenerator.kt:201 */ struct ValidationException {
     /* RustType.kt:516 */
     #[pyo3(get, set)]
     /* PythonServerStructureGenerator.kt:80 */
     /// :type str:
     /// A summary of the validation failure.
     /// /* StructureGenerator.kt:231 */A summary of the validation failure.
     pub message: ::std::string::String,
     /* RustType.kt:516 */
     #[pyo3(get, set)]
     /* PythonServerStructureGenerator.kt:80 */
     /// :type typing.Optional\[typing.List\[misc.model.ValidationExceptionField\]\]:
     /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
     /// /* StructureGenerator.kt:231 */A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
     pub field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
     /* StructureGenerator.kt:201 */
-601
+}
 /* StructureGenerator.kt:135 */
 impl ValidationException {
     /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
     /// /* StructureGenerator.kt:231 */A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
     /* StructureGenerator.kt:166 */
     pub fn field_list(&self) -> ::std::option::Option<&[crate::model::ValidationExceptionField]> {
         /* StructureGenerator.kt:169 */
         self.field_list.as_deref()
         /* StructureGenerator.kt:166 */
-610
+    }
     /* StructureGenerator.kt:135 */
-612
+}
 /* RustType.kt:516 */
 #[allow(clippy::new_without_default)]
 /* RustType.kt:516 */
 #[allow(clippy::too_many_arguments)]
 /* RustType.kt:516 */
 #[::pyo3::pymethods]
 /* PythonServerStructureGenerator.kt:88 */
 impl ValidationException {
     #[new]
     pub fn new(
         message: ::std::string::String,
         field_list: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
     ) -> Self {
         Self {
             message,
             field_list,
-629
+        }
-630
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-633
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-636
+    }
-637
+}
 /* ErrorImplGenerator.kt:99 */
 impl ValidationException {
     /* ErrorImplGenerator.kt:128 */
     /// Returns the error message.
     pub fn message(&self) -> &str {
         &self.message
-644
+    }
     /* ErrorImplGenerator.kt:141 */
     #[doc(hidden)]
     /// Returns the error name.
     pub fn name(&self) -> &'static str {
         "ValidationException"
-650
+    }
     /* ErrorImplGenerator.kt:99 */
-652
+}
 /* ErrorImplGenerator.kt:153 */
 impl ::std::fmt::Display for ValidationException {
     /* ErrorImplGenerator.kt:154 */
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         /* ErrorImplGenerator.kt:161 */
         ::std::write!(f, "ValidationException")?;
         /* ErrorImplGenerator.kt:166 */
-660
+        {
             /* ErrorImplGenerator.kt:167 */
             ::std::write!(f, ": {}", &self.message)?;
             /* ErrorImplGenerator.kt:166 */
-664
+        }
         /* ErrorImplGenerator.kt:171 */
         Ok(())
         /* ErrorImplGenerator.kt:154 */
-668
+    }
     /* ErrorImplGenerator.kt:153 */
-670
+}
 /* ErrorImplGenerator.kt:175 */
 impl ::std::error::Error for ValidationException {}
 /* ServerCodegenVisitor.kt:370 */
 impl ValidationException {
     /// Creates a new builder-style object to manufacture [`ValidationException`](crate::error::ValidationException).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:211 */Creates a new builder-style object to manufacture [`ValidationException`](crate::error::ValidationException).
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
     pub fn builder() -> crate::error::validation_exception::Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:213 */
         crate::error::validation_exception::Builder::default()
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
-681
+    }
     /* ServerCodegenVisitor.kt:370 */
-683
+}
-684
 /* ServerOperationErrorGenerator.kt:63 */
 /// Error type for the `RequiredInnerShapeOperation` operation.
 /* ServerOperationErrorGenerator.kt:64 */
 /// Each variant represents an error that can occur for the `RequiredInnerShapeOperation` operation.
 /* RustType.kt:516 */
 #[derive(::std::fmt::Debug)]
 pub enum RequiredInnerShapeOperationError {
     /// A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
 pub /* ServerOperationErrorGenerator.kt:66 */ enum RequiredInnerShapeOperationError {
     /// /* ServerOperationErrorGenerator.kt:68 */A standard error for input validation failures. This should be thrown by services when a member of the input structure falls outside of the modeled or documented constraints.
     /* ServerOperationErrorGenerator.kt:71 */
     ValidationException(crate::error::ValidationException),
     /* ServerOperationErrorGenerator.kt:68 */
     #[allow(missing_docs)] // documentation missing in model
     /* ServerOperationErrorGenerator.kt:71 */
     InternalServerError(crate::error::InternalServerError),
     /* ServerOperationErrorGenerator.kt:66 */
-700
+}
 /* ServerOperationErrorGenerator.kt:75 */
 impl ::std::fmt::Display for RequiredInnerShapeOperationError {
     /* ServerOperationErrorGenerator.kt:76 */
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             RequiredInnerShapeOperationError::ValidationException(_inner) => _inner.fmt(f),
             RequiredInnerShapeOperationError::InternalServerError(_inner) => _inner.fmt(f),
             /* ServerOperationErrorGenerator.kt:142 */
             RequiredInnerShapeOperationError::ValidationException(_inner) =>
             /* ServerOperationErrorGenerator.kt:78 */
-+
+            {
                 _inner.fmt(f)
-712
+            }
-+
+            ,
             /* ServerOperationErrorGenerator.kt:142 */
             RequiredInnerShapeOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:78 */
-+
+            {
                 _inner.fmt(f)
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-721
+        }
         /* ServerOperationErrorGenerator.kt:76 */
-+
+    }
     /* ServerOperationErrorGenerator.kt:75 */
-725
+}
 /* ServerOperationErrorGenerator.kt:83 */
 impl RequiredInnerShapeOperationError {
     /* ServerOperationErrorGenerator.kt:87 */
     /// Returns `true` if the error kind is `RequiredInnerShapeOperationError::ValidationException`.
     /* ServerOperationErrorGenerator.kt:88 */
     pub fn is_validation_exception(&self) -> bool {
         /* ServerOperationErrorGenerator.kt:89 */
         matches!(
             &self,
             RequiredInnerShapeOperationError::ValidationException(_)
-736
+        )
         /* ServerOperationErrorGenerator.kt:88 */
-738
+    }
     /* ServerOperationErrorGenerator.kt:87 */
     /// Returns `true` if the error kind is `RequiredInnerShapeOperationError::InternalServerError`.
     /* ServerOperationErrorGenerator.kt:88 */
     pub fn is_internal_server_error(&self) -> bool {
         /* ServerOperationErrorGenerator.kt:89 */
         matches!(
             &self,
             RequiredInnerShapeOperationError::InternalServerError(_)
-747
+        )
         /* ServerOperationErrorGenerator.kt:88 */
-749
+    }
     /* ServerOperationErrorGenerator.kt:92 */
     /// Returns the error name string by matching the correct variant.
     /* ServerOperationErrorGenerator.kt:93 */
     pub fn name(&self) -> &'static str {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             RequiredInnerShapeOperationError::ValidationException(_inner) => _inner.name(),
             RequiredInnerShapeOperationError::InternalServerError(_inner) => _inner.name(),
             /* ServerOperationErrorGenerator.kt:142 */
             RequiredInnerShapeOperationError::ValidationException(_inner) =>
             /* ServerOperationErrorGenerator.kt:95 */
-+
+            {
                 _inner.name()
-761
+            }
-+
+            ,
             /* ServerOperationErrorGenerator.kt:142 */
             RequiredInnerShapeOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:95 */
-+
+            {
                 _inner.name()
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-770
+        }
         /* ServerOperationErrorGenerator.kt:93 */
-+
+    }
     /* ServerOperationErrorGenerator.kt:83 */
-774
+}
 /* ServerOperationErrorGenerator.kt:100 */
 impl ::std::error::Error for RequiredInnerShapeOperationError {
     /* ServerOperationErrorGenerator.kt:101 */
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             RequiredInnerShapeOperationError::ValidationException(_inner) => Some(_inner),
             RequiredInnerShapeOperationError::InternalServerError(_inner) => Some(_inner),
             /* ServerOperationErrorGenerator.kt:142 */
             RequiredInnerShapeOperationError::ValidationException(_inner) =>
             /* ServerOperationErrorGenerator.kt:103 */
-+
+            {
                 Some(_inner)
-786
+            }
-+
+            ,
             /* ServerOperationErrorGenerator.kt:142 */
             RequiredInnerShapeOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:103 */
-+
+            {
                 Some(_inner)
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-795
+        }
         /* ServerOperationErrorGenerator.kt:101 */
-+
+    }
     /* ServerOperationErrorGenerator.kt:100 */
-799
+}
 /* ServerOperationErrorGenerator.kt:110 */
 impl ::std::convert::From<crate::error::ValidationException>
     for crate::error::RequiredInnerShapeOperationError
-803
+{
     /* ServerOperationErrorGenerator.kt:111 */
     fn from(
         variant: crate::error::ValidationException,
     ) -> crate::error::RequiredInnerShapeOperationError {
         /* ServerOperationErrorGenerator.kt:112 */
         Self::ValidationException(variant)
         /* ServerOperationErrorGenerator.kt:111 */
-811
+    }
     /* ServerOperationErrorGenerator.kt:110 */
-813
+}
 /* ServerOperationErrorGenerator.kt:110 */
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::RequiredInnerShapeOperationError
-817
+{
     /* ServerOperationErrorGenerator.kt:111 */
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::RequiredInnerShapeOperationError {
         /* ServerOperationErrorGenerator.kt:112 */
         Self::InternalServerError(variant)
         /* ServerOperationErrorGenerator.kt:111 */
-825
+    }
     /* ServerOperationErrorGenerator.kt:110 */
-827
+}
-828
 /* PythonServerOperationErrorGenerator.kt:38 */
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::RequiredInnerShapeOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::RequiredInnerShapeOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
             if let Ok(error) = error.extract::<crate::error::ValidationException>() {
                 return error.into();
-836
+            }
             crate::error::InternalServerError {
                 message: error.to_string(),
-839
+            }
             .into()
         })
-842
+    }
-843
+}
-844
 /* ServerOperationErrorGenerator.kt:63 */
 /// Error type for the `TypeComplexityOperation` operation.
 /* ServerOperationErrorGenerator.kt:64 */
 /// Each variant represents an error that can occur for the `TypeComplexityOperation` operation.
 /* RustType.kt:516 */
 #[derive(::std::fmt::Debug)]
 pub enum TypeComplexityOperationError {
 pub /* ServerOperationErrorGenerator.kt:66 */ enum TypeComplexityOperationError {
     /* ServerOperationErrorGenerator.kt:68 */
     #[allow(missing_docs)] // documentation missing in model
     /* ServerOperationErrorGenerator.kt:71 */
     InternalServerError(crate::error::InternalServerError),
     /* ServerOperationErrorGenerator.kt:66 */
-857
+}
 /* ServerOperationErrorGenerator.kt:75 */
 impl ::std::fmt::Display for TypeComplexityOperationError {
     /* ServerOperationErrorGenerator.kt:76 */
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             TypeComplexityOperationError::InternalServerError(_inner) => _inner.fmt(f),
             /* ServerOperationErrorGenerator.kt:142 */
             TypeComplexityOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:78 */
-+
+            {
                 _inner.fmt(f)
-869
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-871
+        }
         /* ServerOperationErrorGenerator.kt:76 */
-+
+    }
     /* ServerOperationErrorGenerator.kt:75 */
-875
+}
 /* ServerOperationErrorGenerator.kt:83 */
 impl TypeComplexityOperationError {
     /* ServerOperationErrorGenerator.kt:87 */
     /// Returns `true` if the error kind is `TypeComplexityOperationError::InternalServerError`.
     /* ServerOperationErrorGenerator.kt:88 */
     pub fn is_internal_server_error(&self) -> bool {
         /* ServerOperationErrorGenerator.kt:89 */
         matches!(&self, TypeComplexityOperationError::InternalServerError(_))
         /* ServerOperationErrorGenerator.kt:88 */
-885
+    }
     /* ServerOperationErrorGenerator.kt:92 */
     /// Returns the error name string by matching the correct variant.
     /* ServerOperationErrorGenerator.kt:93 */
     pub fn name(&self) -> &'static str {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             TypeComplexityOperationError::InternalServerError(_inner) => _inner.name(),
             /* ServerOperationErrorGenerator.kt:142 */
             TypeComplexityOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:95 */
-+
+            {
                 _inner.name()
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-899
+        }
         /* ServerOperationErrorGenerator.kt:93 */
-901
+    }
     /* ServerOperationErrorGenerator.kt:83 */
-903
+}
 /* ServerOperationErrorGenerator.kt:100 */
 impl ::std::error::Error for TypeComplexityOperationError {
     /* ServerOperationErrorGenerator.kt:101 */
     fn source(&self) -> std::option::Option<&(dyn ::std::error::Error + 'static)> {
         /* ServerOperationErrorGenerator.kt:139 */
         match &self {
             TypeComplexityOperationError::InternalServerError(_inner) => Some(_inner),
             /* ServerOperationErrorGenerator.kt:142 */
             TypeComplexityOperationError::InternalServerError(_inner) =>
             /* ServerOperationErrorGenerator.kt:103 */
-+
+            {
                 Some(_inner)
-+
+            }
             /* ServerOperationErrorGenerator.kt:139 */
-917
+        }
         /* ServerOperationErrorGenerator.kt:101 */
-919
+    }
     /* ServerOperationErrorGenerator.kt:100 */
-921
+}
 /* ServerOperationErrorGenerator.kt:110 */
 impl ::std::convert::From<crate::error::InternalServerError>
     for crate::error::TypeComplexityOperationError
-925
+{
     /* ServerOperationErrorGenerator.kt:111 */
     fn from(
         variant: crate::error::InternalServerError,
     ) -> crate::error::TypeComplexityOperationError {
         /* ServerOperationErrorGenerator.kt:112 */
         Self::InternalServerError(variant)
         /* ServerOperationErrorGenerator.kt:111 */
-933
+    }
     /* ServerOperationErrorGenerator.kt:110 */
-935
+}
-936
 /* PythonServerOperationErrorGenerator.kt:38 */
 impl ::std::convert::From<::pyo3::PyErr> for crate::error::TypeComplexityOperationError {
     fn from(variant: ::pyo3::PyErr) -> crate::error::TypeComplexityOperationError {
         ::pyo3::Python::with_gil(|py| {
             let error = variant.value(py);
-942
             crate::error::InternalServerError {
                 message: error.to_string(),
-945
+            }
             .into()
         })
-948
+    }
-949
+}
 /// See [`InternalServerError`](crate::error::InternalServerError).
 /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:110 */See [`InternalServerError`](crate::error::InternalServerError).
 pub mod internal_server_error {
-952
     /* RustType.kt:516 */
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     /// /* ServerBuilderConstraintViolations.kt:72 */Holds one variant for each of the ways the builder can fail.
     /* ServerBuilderConstraintViolations.kt:75 */
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `message` was not provided but it is required when building `InternalServerError`.
         /// /* ServerBuilderConstraintViolations.kt:138 */`message` was not provided but it is required when building `InternalServerError`.
         /* ServerBuilderConstraintViolations.kt:143 */
         MissingMessage,
         /* ServerBuilderConstraintViolations.kt:75 */
-963
+    }
     /* ServerBuilderConstraintViolations.kt:117 */
     impl ::std::fmt::Display for ConstraintViolation {
         /* ServerBuilderConstraintViolations.kt:118 */
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             /* ServerBuilderConstraintViolations.kt:119 */
             match self {
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `InternalServerError`"),
--
+            }
                 /* ServerBuilderConstraintViolations.kt:127 */ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `InternalServerError`"),
             /* ServerBuilderConstraintViolations.kt:119 */}
             /* ServerBuilderConstraintViolations.kt:118 */
-973
+        }
         /* ServerBuilderConstraintViolations.kt:117 */
-975
+    }
     /* ServerBuilderConstraintViolations.kt:84 */
     impl ::std::error::Error for ConstraintViolation {}
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:254 */
     impl ::std::convert::TryFrom<Builder> for crate::error::InternalServerError {
         type Error = ConstraintViolation;
-981
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-984
+        }
-985
+    }
     /// A builder for [`InternalServerError`](crate::error::InternalServerError).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:130 */A builder for [`InternalServerError`](crate::error::InternalServerError).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
     pub struct Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:225 */
         pub(crate) message: ::std::option::Option<::std::string::String>,
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
-994
+    }
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
     impl Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:241 */
         #[allow(missing_docs)] // documentation missing in model
                                /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
         pub fn message(mut self, input: ::std::string::String) -> Self {
             self.message = Some(input);
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */
             self.message =
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:246 */Some(
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:247 */input
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:246 */)
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */;
             self
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
-1009
+        }
         /// Consumes the builder and constructs a [`InternalServerError`](crate::error::InternalServerError).
         ///
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:150 */Consumes the builder and constructs a [`InternalServerError`](crate::error::InternalServerError).
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:152 */
         /// The builder fails to construct a [`InternalServerError`](crate::error::InternalServerError) if you do not provide a value for all non-`Option`al members.
         ///
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:159 */
         pub fn build(self) -> Result<crate::error::InternalServerError, ConstraintViolation> {
             self.build_enforcing_required_and_enum_traits()
-1017
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::error::InternalServerError, ConstraintViolation> {
             Ok(crate::error::InternalServerError {
                 message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
             })
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:175 */
             Ok(
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
                 crate::error::InternalServerError {
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:186 */
                     message: self
                         .message
                         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:202 */
                         .ok_or(ConstraintViolation::MissingMessage)?,
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
                 }, /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:175 */
-+
+            )
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
-1035
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
-1037
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-1040
+}
 /// See [`ValidationException`](crate::error::ValidationException).
 /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:110 */See [`ValidationException`](crate::error::ValidationException).
 pub mod validation_exception {
-1043
     /* RustType.kt:516 */
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     /// /* ServerBuilderConstraintViolations.kt:72 */Holds one variant for each of the ways the builder can fail.
     /* ServerBuilderConstraintViolations.kt:75 */
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `message` was not provided but it is required when building `ValidationException`.
         /// /* ServerBuilderConstraintViolations.kt:138 */`message` was not provided but it is required when building `ValidationException`.
         /* ServerBuilderConstraintViolations.kt:143 */
         MissingMessage,
         /* ServerBuilderConstraintViolations.kt:75 */
-1054
+    }
     /* ServerBuilderConstraintViolations.kt:117 */
     impl ::std::fmt::Display for ConstraintViolation {
         /* ServerBuilderConstraintViolations.kt:118 */
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             /* ServerBuilderConstraintViolations.kt:119 */
             match self {
                 ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `ValidationException`"),
--
+            }
                 /* ServerBuilderConstraintViolations.kt:127 */ConstraintViolation::MissingMessage => write!(f, "`message` was not provided but it is required when building `ValidationException`"),
             /* ServerBuilderConstraintViolations.kt:119 */}
             /* ServerBuilderConstraintViolations.kt:118 */
-1064
+        }
         /* ServerBuilderConstraintViolations.kt:117 */
-1066
+    }
     /* ServerBuilderConstraintViolations.kt:84 */
     impl ::std::error::Error for ConstraintViolation {}
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:254 */
     impl ::std::convert::TryFrom<Builder> for crate::error::ValidationException {
         type Error = ConstraintViolation;
-1072
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1075
+        }
-1076
+    }
     /// A builder for [`ValidationException`](crate::error::ValidationException).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:130 */A builder for [`ValidationException`](crate::error::ValidationException).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
     pub struct Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:225 */
         pub(crate) message: ::std::option::Option<::std::string::String>,
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:225 */
         pub(crate) field_list:
             ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
-1088
+    }
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
     impl Builder {
         /// A summary of the validation failure.
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:241 */A summary of the validation failure.
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
         pub fn message(mut self, input: ::std::string::String) -> Self {
             self.message = Some(input);
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */
             self.message =
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:246 */Some(
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:247 */input
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:246 */)
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */;
             self
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
-1102
+        }
         /// A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:241 */A list of specific failures encountered while validating the input. A member can appear in this list more than once if it failed to satisfy multiple constraints.
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
         pub fn field_list(
             mut self,
             input: ::std::option::Option<::std::vec::Vec<crate::model::ValidationExceptionField>>,
         ) -> Self {
             self.field_list = input;
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */
             self.field_list =
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:247 */input
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */;
             self
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
-1115
+        }
         /// Consumes the builder and constructs a [`ValidationException`](crate::error::ValidationException).
         ///
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:150 */Consumes the builder and constructs a [`ValidationException`](crate::error::ValidationException).
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:152 */
         /// The builder fails to construct a [`ValidationException`](crate::error::ValidationException) if you do not provide a value for all non-`Option`al members.
         ///
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:159 */
         pub fn build(self) -> Result<crate::error::ValidationException, ConstraintViolation> {
             self.build_enforcing_required_and_enum_traits()
-1123
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::error::ValidationException, ConstraintViolation> {
             Ok(crate::error::ValidationException {
                 message: self.message.ok_or(ConstraintViolation::MissingMessage)?,
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:175 */
             Ok(
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
                 crate::error::ValidationException {
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:186 */
                     message: self
                         .message
                         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:202 */
                         .ok_or(ConstraintViolation::MissingMessage)?,
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:186 */
                     field_list: self.field_list,
             })
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
                 }, /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:175 */
-+
+            )
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
-1143
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
-1145
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-1148
+}

tmp-codegen-diff/codegen-server-test-python/misc/rust-server-codegen-python/src/input.rs

@@ -1,1 +956,1359 @@

 // Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
 /* RustType.kt:516 */
 #[::pyo3::pyclass]
 /* PythonServerStructureGenerator.kt:63 */
 /// :rtype None:
 /* StructureGenerator.kt:197 */
 #[allow(missing_docs)] // documentation missing in model
 /* RustType.kt:516 */
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ResponseCodeDefaultOperationInput {}
 pub /* StructureGenerator.kt:201 */ struct ResponseCodeDefaultOperationInput {/* StructureGenerator.kt:201 */}
 /* RustType.kt:516 */
 #[allow(clippy::new_without_default)]
 /* RustType.kt:516 */
 #[allow(clippy::too_many_arguments)]
 /* RustType.kt:516 */
 #[::pyo3::pymethods]
 /* PythonServerStructureGenerator.kt:88 */
 impl ResponseCodeDefaultOperationInput {
     #[new]
     pub fn new() -> Self {
         Self {}
-24
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-27
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-30
+    }
-31
+}
 /* PythonServerStructureGenerator.kt:111 */
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<ResponseCodeDefaultOperationInput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<ResponseCodeDefaultOperationInput>()
             .map(Box::new)
-37
+    }
-38
+}
-39
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<ResponseCodeDefaultOperationInput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-43
+    }
-44
+}
 /* ServerStructureConstrainedTraitImpl.kt:21 */
 impl crate::constrained::Constrained for crate::input::ResponseCodeDefaultOperationInput {
     type Unconstrained = crate::input::response_code_default_operation_input_internal::Builder;
-48
+}
 /* ServerCodegenVisitor.kt:370 */
 impl ResponseCodeDefaultOperationInput {
     /// Creates a new builder-style object to manufacture [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:211 */Creates a new builder-style object to manufacture [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
     pub fn builder() -> crate::input::response_code_default_operation_input::Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:213 */
         crate::input::response_code_default_operation_input::Builder::default()
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
-57
+    }
     /* ServerCodegenVisitor.kt:370 */
-59
+}
-60
 /* RustType.kt:516 */
 #[::pyo3::pyclass]
 /* PythonServerStructureGenerator.kt:63 */
 /// :rtype None:
 /* StructureGenerator.kt:197 */
 #[allow(missing_docs)] // documentation missing in model
 /* RustType.kt:516 */
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ResponseCodeHttpFallbackOperationInput {}
 pub /* StructureGenerator.kt:201 */ struct ResponseCodeHttpFallbackOperationInput {/* StructureGenerator.kt:201 */}
 /* RustType.kt:516 */
 #[allow(clippy::new_without_default)]
 /* RustType.kt:516 */
 #[allow(clippy::too_many_arguments)]
 /* RustType.kt:516 */
 #[::pyo3::pymethods]
 /* PythonServerStructureGenerator.kt:88 */
 impl ResponseCodeHttpFallbackOperationInput {
     #[new]
     pub fn new() -> Self {
         Self {}
-83
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-86
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-89
+    }
-90
+}
 /* PythonServerStructureGenerator.kt:111 */
 impl<'source> ::pyo3::FromPyObject<'source>
     for std::boxed::Box<ResponseCodeHttpFallbackOperationInput>
-94
+{
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<ResponseCodeHttpFallbackOperationInput>()
             .map(Box::new)
-98
+    }
-99
+}
-100
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<ResponseCodeHttpFallbackOperationInput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-104
+    }
-105
+}
 /* ServerStructureConstrainedTraitImpl.kt:21 */
 impl crate::constrained::Constrained for crate::input::ResponseCodeHttpFallbackOperationInput {
     type Unconstrained =
         crate::input::response_code_http_fallback_operation_input_internal::Builder;
-110
+}
 /* ServerCodegenVisitor.kt:370 */
 impl ResponseCodeHttpFallbackOperationInput {
     /// Creates a new builder-style object to manufacture [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:211 */Creates a new builder-style object to manufacture [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
     pub fn builder() -> crate::input::response_code_http_fallback_operation_input::Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:213 */
         crate::input::response_code_http_fallback_operation_input::Builder::default()
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
-119
+    }
     /* ServerCodegenVisitor.kt:370 */
-121
+}
-122
 /* RustType.kt:516 */
 #[::pyo3::pyclass]
 /* PythonServerStructureGenerator.kt:63 */
 /// :rtype None:
 /* StructureGenerator.kt:197 */
 #[allow(missing_docs)] // documentation missing in model
 /* RustType.kt:516 */
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct ResponseCodeRequiredOperationInput {}
 pub /* StructureGenerator.kt:201 */ struct ResponseCodeRequiredOperationInput {/* StructureGenerator.kt:201 */}
 /* RustType.kt:516 */
 #[allow(clippy::new_without_default)]
 /* RustType.kt:516 */
 #[allow(clippy::too_many_arguments)]
 /* RustType.kt:516 */
 #[::pyo3::pymethods]
 /* PythonServerStructureGenerator.kt:88 */
 impl ResponseCodeRequiredOperationInput {
     #[new]
     pub fn new() -> Self {
         Self {}
-145
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-148
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-151
+    }
-152
+}
 /* PythonServerStructureGenerator.kt:111 */
 impl<'source> ::pyo3::FromPyObject<'source>
     for std::boxed::Box<ResponseCodeRequiredOperationInput>
-156
+{
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<ResponseCodeRequiredOperationInput>()
             .map(Box::new)
-160
+    }
-161
+}
-162
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<ResponseCodeRequiredOperationInput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-166
+    }
-167
+}
 /* ServerStructureConstrainedTraitImpl.kt:21 */
 impl crate::constrained::Constrained for crate::input::ResponseCodeRequiredOperationInput {
     type Unconstrained = crate::input::response_code_required_operation_input_internal::Builder;
-171
+}
 /* ServerCodegenVisitor.kt:370 */
 impl ResponseCodeRequiredOperationInput {
     /// Creates a new builder-style object to manufacture [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:211 */Creates a new builder-style object to manufacture [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
     pub fn builder() -> crate::input::response_code_required_operation_input::Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:213 */
         crate::input::response_code_required_operation_input::Builder::default()
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
-180
+    }
     /* ServerCodegenVisitor.kt:370 */
-182
+}
-183
 /* RustType.kt:516 */
 #[::pyo3::pyclass]
 /* PythonServerStructureGenerator.kt:63 */
 /// :param required_header_list typing.List\[str\]:
 /// :param required_header_set typing.List\[str\]:
 /// :rtype None:
 /* StructureGenerator.kt:197 */
 #[allow(missing_docs)] // documentation missing in model
 /* RustType.kt:516 */
 #[derive(
     ::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug, ::std::hash::Hash,
 )]
 pub struct RequiredHeaderCollectionOperationInput {
 pub /* StructureGenerator.kt:201 */ struct RequiredHeaderCollectionOperationInput {
     /* RustType.kt:516 */
     #[pyo3(get, set)]
     /* PythonServerStructureGenerator.kt:80 */
     /// :type typing.List\[str\]:
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
     pub required_header_list: ::std::vec::Vec<::std::string::String>,
     /* RustType.kt:516 */
     #[pyo3(get, set)]
     /* PythonServerStructureGenerator.kt:80 */
     /// :type typing.List\[str\]:
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
     pub required_header_set: ::std::vec::Vec<::std::string::String>,
     /* StructureGenerator.kt:201 */
-212
+}
 /* StructureGenerator.kt:135 */
 impl RequiredHeaderCollectionOperationInput {
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
                            /* StructureGenerator.kt:166 */
     pub fn required_header_list(&self) -> &[::std::string::String] {
         /* StructureGenerator.kt:171 */
         use std::ops::Deref;
         self.required_header_list.deref()
         /* StructureGenerator.kt:166 */
-223
+    }
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
                            /* StructureGenerator.kt:166 */
     pub fn required_header_set(&self) -> &[::std::string::String] {
         /* StructureGenerator.kt:171 */
         use std::ops::Deref;
         self.required_header_set.deref()
         /* StructureGenerator.kt:166 */
-232
+    }
     /* StructureGenerator.kt:135 */
-234
+}
 /* RustType.kt:516 */
 #[allow(clippy::new_without_default)]
 /* RustType.kt:516 */
 #[allow(clippy::too_many_arguments)]
 /* RustType.kt:516 */
 #[::pyo3::pymethods]
 /* PythonServerStructureGenerator.kt:88 */
 impl RequiredHeaderCollectionOperationInput {
     #[new]
     pub fn new(
         required_header_list: ::std::vec::Vec<::std::string::String>,
         required_header_set: ::std::vec::Vec<::std::string::String>,
     ) -> Self {
         Self {
             required_header_list,
             required_header_set,
-251
+        }
-252
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-255
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-258
+    }
-259
+}
 /* PythonServerStructureGenerator.kt:111 */
 impl<'source> ::pyo3::FromPyObject<'source>
     for std::boxed::Box<RequiredHeaderCollectionOperationInput>
-263
+{
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<RequiredHeaderCollectionOperationInput>()
             .map(Box::new)
-267
+    }
-268
+}
-269
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<RequiredHeaderCollectionOperationInput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-273
+    }
-274
+}
 /* ServerStructureConstrainedTraitImpl.kt:21 */
 impl crate::constrained::Constrained for crate::input::RequiredHeaderCollectionOperationInput {
     type Unconstrained = crate::input::required_header_collection_operation_input_internal::Builder;
-278
+}
 /* ServerCodegenVisitor.kt:370 */
 impl RequiredHeaderCollectionOperationInput {
     /// Creates a new builder-style object to manufacture [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:211 */Creates a new builder-style object to manufacture [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
     pub fn builder() -> crate::input::required_header_collection_operation_input::Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:213 */
         crate::input::required_header_collection_operation_input::Builder::default()
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
-287
+    }
     /* ServerCodegenVisitor.kt:370 */
-289
+}
-290
 /* RustType.kt:516 */
 #[::pyo3::pyclass]
 /* PythonServerStructureGenerator.kt:63 */
 /// :param inner typing.Optional\[misc.model.InnerShape\]:
 /// :rtype None:
 /* StructureGenerator.kt:197 */
 #[allow(missing_docs)] // documentation missing in model
 /* RustType.kt:516 */
 #[derive(::std::clone::Clone, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct RequiredInnerShapeOperationInput {
 pub /* StructureGenerator.kt:201 */ struct RequiredInnerShapeOperationInput {
     /* RustType.kt:516 */
     #[pyo3(get, set)]
     /* PythonServerStructureGenerator.kt:80 */
     /// :type typing.Optional\[misc.model.InnerShape\]:
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
     pub inner: ::std::option::Option<crate::model::InnerShape>,
     /* StructureGenerator.kt:201 */
-309
+}
 /* StructureGenerator.kt:135 */
 impl RequiredInnerShapeOperationInput {
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
                            /* StructureGenerator.kt:166 */
     pub fn inner(&self) -> ::std::option::Option<&crate::model::InnerShape> {
         /* StructureGenerator.kt:170 */
         self.inner.as_ref()
         /* StructureGenerator.kt:166 */
-319
+    }
     /* StructureGenerator.kt:135 */
-321
+}
 /* RustType.kt:516 */
 #[allow(clippy::new_without_default)]
 /* RustType.kt:516 */
 #[allow(clippy::too_many_arguments)]
 /* RustType.kt:516 */
 #[::pyo3::pymethods]
 /* PythonServerStructureGenerator.kt:88 */
 impl RequiredInnerShapeOperationInput {
     #[new]
     pub fn new(inner: ::std::option::Option<crate::model::InnerShape>) -> Self {
         Self { inner }
-333
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-336
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-339
+    }
-340
+}
 /* PythonServerStructureGenerator.kt:111 */
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<RequiredInnerShapeOperationInput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<RequiredInnerShapeOperationInput>()
             .map(Box::new)
-346
+    }
-347
+}
-348
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<RequiredInnerShapeOperationInput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-352
+    }
-353
+}
 /* ServerStructureConstrainedTraitImpl.kt:21 */
 impl crate::constrained::Constrained for crate::input::RequiredInnerShapeOperationInput {
     type Unconstrained = crate::input::required_inner_shape_operation_input_internal::Builder;
-357
+}
 /* ServerCodegenVisitor.kt:370 */
 impl RequiredInnerShapeOperationInput {
     /// Creates a new builder-style object to manufacture [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:211 */Creates a new builder-style object to manufacture [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
     pub fn builder() -> crate::input::required_inner_shape_operation_input::Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:213 */
         crate::input::required_inner_shape_operation_input::Builder::default()
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
-366
+    }
     /* ServerCodegenVisitor.kt:370 */
-368
+}
-369
 /* RustType.kt:516 */
 #[::pyo3::pyclass]
 /* PythonServerStructureGenerator.kt:63 */
 /// :param list typing.Optional\[typing.List\[typing.List\[typing.List\[typing.Dict\[str, misc.model.EmptyStructure\]\]\]\]\]:
 /// :rtype None:
 /* StructureGenerator.kt:197 */
 #[allow(missing_docs)] // documentation missing in model
 /* RustType.kt:516 */
 #[derive(::std::clone::Clone, ::std::cmp::Eq, ::std::cmp::PartialEq, ::std::fmt::Debug)]
 pub struct TypeComplexityOperationInput {
 pub /* StructureGenerator.kt:201 */ struct TypeComplexityOperationInput {
     /* RustType.kt:516 */
     #[pyo3(get, set)]
     /* PythonServerStructureGenerator.kt:80 */
     /// :type typing.Optional\[typing.List\[typing.List\[typing.List\[typing.Dict\[str, misc.model.EmptyStructure\]\]\]\]\]:
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
     pub list: ::std::option::Option<
         ::std::vec::Vec<
             ::std::vec::Vec<
                 ::std::vec::Vec<
                     ::std::collections::HashMap<
                         ::std::string::String,
                         crate::model::EmptyStructure,
                     >,
                 >,
             >,
         >,
     >,
     /* StructureGenerator.kt:201 */
-399
+}
 /* StructureGenerator.kt:135 */
 impl TypeComplexityOperationInput {
     /* StructureGenerator.kt:231 */
     #[allow(missing_docs)] // documentation missing in model
                            /* StructureGenerator.kt:166 */
     pub fn list(
         &self,
     ) -> ::std::option::Option<
         &[::std::vec::Vec<
             ::std::vec::Vec<
                 ::std::collections::HashMap<::std::string::String, crate::model::EmptyStructure>,
             >,
         >],
     > {
         /* StructureGenerator.kt:169 */
         self.list.as_deref()
         /* StructureGenerator.kt:166 */
-417
+    }
     /* StructureGenerator.kt:135 */
-419
+}
 /* RustType.kt:516 */
 #[allow(clippy::new_without_default)]
 /* RustType.kt:516 */
 #[allow(clippy::too_many_arguments)]
 /* RustType.kt:516 */
 #[::pyo3::pymethods]
 /* PythonServerStructureGenerator.kt:88 */
 impl TypeComplexityOperationInput {
     #[new]
     pub fn new(
         list: ::std::option::Option<
             ::std::vec::Vec<
                 ::std::vec::Vec<
                     ::std::vec::Vec<
                         ::std::collections::HashMap<
                             ::std::string::String,
                             crate::model::EmptyStructure,
                         >,
                     >,
                 >,
             >,
         >,
     ) -> Self {
         Self { list }
-444
+    }
     fn __repr__(&self) -> String {
         format!("{self:?}")
-447
+    }
     fn __str__(&self) -> String {
         format!("{self:?}")
-450
+    }
-451
+}
 /* PythonServerStructureGenerator.kt:111 */
 impl<'source> ::pyo3::FromPyObject<'source> for std::boxed::Box<TypeComplexityOperationInput> {
     fn extract(ob: &'source ::pyo3::PyAny) -> ::pyo3::PyResult<Self> {
         ob.extract::<TypeComplexityOperationInput>().map(Box::new)
-456
+    }
-457
+}
-458
 impl ::pyo3::IntoPy<::pyo3::PyObject> for std::boxed::Box<TypeComplexityOperationInput> {
     fn into_py(self, py: ::pyo3::Python<'_>) -> ::pyo3::PyObject {
         (*self).into_py(py)
-462
+    }
-463
+}
 /* ServerStructureConstrainedTraitImpl.kt:21 */
 impl crate::constrained::Constrained for crate::input::TypeComplexityOperationInput {
     type Unconstrained = crate::input::type_complexity_operation_input_internal::Builder;
-467
+}
 /* ServerCodegenVisitor.kt:370 */
 impl TypeComplexityOperationInput {
     /// Creates a new builder-style object to manufacture [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:211 */Creates a new builder-style object to manufacture [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
     pub fn builder() -> crate::input::type_complexity_operation_input::Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:213 */
         crate::input::type_complexity_operation_input::Builder::default()
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:212 */
-476
+    }
     /* ServerCodegenVisitor.kt:370 */
-478
+}
 /// See [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
 /// /* ServerBuilderGenerator.kt:171 */See [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
 pub(crate) mod response_code_default_operation_input_internal {
-481
     /* ServerBuilderGenerator.kt:461 */
     impl ::std::convert::From<Builder> for crate::input::ResponseCodeDefaultOperationInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-486
+        }
-487
+    }
     /// A builder for [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
     /// /* ServerBuilderGenerator.kt:201 */A builder for [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub(crate) struct Builder {}
     /* ServerBuilderGenerator.kt:211 */
     pub(crate) struct Builder {/* ServerBuilderGenerator.kt:211 */}
     /* ServerBuilderGenerator.kt:215 */
     impl Builder {
         /// Consumes the builder and constructs a [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
         /// /* ServerBuilderGenerator.kt:258 */Consumes the builder and constructs a [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
         /* ServerBuilderGenerator.kt:271 */
         pub fn build(self) -> crate::input::ResponseCodeDefaultOperationInput {
             self.build_enforcing_all_constraints()
-499
+        }
         /* ServerBuilderGenerator.kt:283 */
         fn build_enforcing_all_constraints(
             self,
         ) -> crate::input::ResponseCodeDefaultOperationInput {
             crate::input::ResponseCodeDefaultOperationInput {}
             /* ServerBuilderGenerator.kt:542 */
             crate::input::ResponseCodeDefaultOperationInput {
             /* ServerBuilderGenerator.kt:542 */}
             /* ServerBuilderGenerator.kt:283 */
-508
+        }
         /* ServerBuilderGenerator.kt:215 */
-510
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-513
+}
 /// See [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
 /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:110 */See [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
 pub mod response_code_default_operation_input {
-516
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:269 */
     impl ::std::convert::From<Builder> for crate::input::ResponseCodeDefaultOperationInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-521
+        }
-522
+    }
     /// A builder for [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:130 */A builder for [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
     pub struct Builder {/* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */}
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
     impl Builder {
         /// Consumes the builder and constructs a [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:150 */Consumes the builder and constructs a [`ResponseCodeDefaultOperationInput`](crate::input::ResponseCodeDefaultOperationInput).
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:159 */
         pub fn build(self) -> crate::input::ResponseCodeDefaultOperationInput {
             self.build_enforcing_required_and_enum_traits()
-534
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::input::ResponseCodeDefaultOperationInput {
             crate::input::ResponseCodeDefaultOperationInput {}
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
             crate::input::ResponseCodeDefaultOperationInput {
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */}
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
-543
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
-545
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-548
+}
 /// See [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
 /// /* ServerBuilderGenerator.kt:171 */See [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
 pub(crate) mod response_code_http_fallback_operation_input_internal {
-551
     /* ServerBuilderGenerator.kt:461 */
     impl ::std::convert::From<Builder> for crate::input::ResponseCodeHttpFallbackOperationInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-556
+        }
-557
+    }
     /// A builder for [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
     /// /* ServerBuilderGenerator.kt:201 */A builder for [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub(crate) struct Builder {}
     /* ServerBuilderGenerator.kt:211 */
     pub(crate) struct Builder {/* ServerBuilderGenerator.kt:211 */}
     /* ServerBuilderGenerator.kt:215 */
     impl Builder {
         /// Consumes the builder and constructs a [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
         /// /* ServerBuilderGenerator.kt:258 */Consumes the builder and constructs a [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
         /* ServerBuilderGenerator.kt:271 */
         pub fn build(self) -> crate::input::ResponseCodeHttpFallbackOperationInput {
             self.build_enforcing_all_constraints()
-569
+        }
         /* ServerBuilderGenerator.kt:283 */
         fn build_enforcing_all_constraints(
             self,
         ) -> crate::input::ResponseCodeHttpFallbackOperationInput {
             crate::input::ResponseCodeHttpFallbackOperationInput {}
             /* ServerBuilderGenerator.kt:542 */
             crate::input::ResponseCodeHttpFallbackOperationInput {
             /* ServerBuilderGenerator.kt:542 */}
             /* ServerBuilderGenerator.kt:283 */
-578
+        }
         /* ServerBuilderGenerator.kt:215 */
-580
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-583
+}
 /// See [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
 /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:110 */See [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
 pub mod response_code_http_fallback_operation_input {
-586
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:269 */
     impl ::std::convert::From<Builder> for crate::input::ResponseCodeHttpFallbackOperationInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-591
+        }
-592
+    }
     /// A builder for [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:130 */A builder for [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
     pub struct Builder {/* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */}
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
     impl Builder {
         /// Consumes the builder and constructs a [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:150 */Consumes the builder and constructs a [`ResponseCodeHttpFallbackOperationInput`](crate::input::ResponseCodeHttpFallbackOperationInput).
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:159 */
         pub fn build(self) -> crate::input::ResponseCodeHttpFallbackOperationInput {
             self.build_enforcing_required_and_enum_traits()
-604
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::input::ResponseCodeHttpFallbackOperationInput {
             crate::input::ResponseCodeHttpFallbackOperationInput {}
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
             crate::input::ResponseCodeHttpFallbackOperationInput {
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */}
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
-613
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
-615
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-618
+}
 /// See [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
 /// /* ServerBuilderGenerator.kt:171 */See [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
 pub(crate) mod response_code_required_operation_input_internal {
-621
     /* ServerBuilderGenerator.kt:461 */
     impl ::std::convert::From<Builder> for crate::input::ResponseCodeRequiredOperationInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-626
+        }
-627
+    }
     /// A builder for [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
     /// /* ServerBuilderGenerator.kt:201 */A builder for [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub(crate) struct Builder {}
     /* ServerBuilderGenerator.kt:211 */
     pub(crate) struct Builder {/* ServerBuilderGenerator.kt:211 */}
     /* ServerBuilderGenerator.kt:215 */
     impl Builder {
         /// Consumes the builder and constructs a [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
         /// /* ServerBuilderGenerator.kt:258 */Consumes the builder and constructs a [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
         /* ServerBuilderGenerator.kt:271 */
         pub fn build(self) -> crate::input::ResponseCodeRequiredOperationInput {
             self.build_enforcing_all_constraints()
-639
+        }
         /* ServerBuilderGenerator.kt:283 */
         fn build_enforcing_all_constraints(
             self,
         ) -> crate::input::ResponseCodeRequiredOperationInput {
             crate::input::ResponseCodeRequiredOperationInput {}
             /* ServerBuilderGenerator.kt:542 */
             crate::input::ResponseCodeRequiredOperationInput {
             /* ServerBuilderGenerator.kt:542 */}
             /* ServerBuilderGenerator.kt:283 */
-648
+        }
         /* ServerBuilderGenerator.kt:215 */
-650
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-653
+}
 /// See [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
 /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:110 */See [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
 pub mod response_code_required_operation_input {
-656
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:269 */
     impl ::std::convert::From<Builder> for crate::input::ResponseCodeRequiredOperationInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-661
+        }
-662
+    }
     /// A builder for [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:130 */A builder for [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     pub struct Builder {}
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
     pub struct Builder {/* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */}
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
     impl Builder {
         /// Consumes the builder and constructs a [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:150 */Consumes the builder and constructs a [`ResponseCodeRequiredOperationInput`](crate::input::ResponseCodeRequiredOperationInput).
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:159 */
         pub fn build(self) -> crate::input::ResponseCodeRequiredOperationInput {
             self.build_enforcing_required_and_enum_traits()
-674
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::input::ResponseCodeRequiredOperationInput {
             crate::input::ResponseCodeRequiredOperationInput {}
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
             crate::input::ResponseCodeRequiredOperationInput {
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */}
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
-683
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
-685
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-688
+}
 /// See [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
 /// /* ServerBuilderGenerator.kt:171 */See [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
 pub(crate) mod required_header_collection_operation_input_internal {
-691
     /* RustType.kt:516 */
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     /// /* ServerBuilderConstraintViolations.kt:72 */Holds one variant for each of the ways the builder can fail.
     /* RustType.kt:516 */
     #[non_exhaustive]
     /* ServerBuilderConstraintViolations.kt:75 */
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// `required_header_list` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`.
         /// /* ServerBuilderConstraintViolations.kt:138 */`required_header_list` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`.
         /* ServerBuilderConstraintViolations.kt:143 */
         MissingRequiredHeaderList,
         /// `required_header_set` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`.
         /// /* ServerBuilderConstraintViolations.kt:138 */`required_header_set` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`.
         /* ServerBuilderConstraintViolations.kt:143 */
         MissingRequiredHeaderSet,
         /// Constraint violation occurred building member `required_header_set` when building `RequiredHeaderCollectionOperationInput`.
         /// /* ServerBuilderConstraintViolations.kt:158 */Constraint violation occurred building member `required_header_set` when building `RequiredHeaderCollectionOperationInput`.
         /* RustType.kt:516 */
         #[doc(hidden)]
         /* ServerBuilderConstraintViolations.kt:164 */
         RequiredHeaderSet(crate::model::header_set_internal::ConstraintViolation),
         /* ServerBuilderConstraintViolations.kt:75 */
-712
+    }
     /* ServerBuilderConstraintViolations.kt:117 */
     impl ::std::fmt::Display for ConstraintViolation {
         /* ServerBuilderConstraintViolations.kt:118 */
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             /* ServerBuilderConstraintViolations.kt:119 */
             match self {
                 ConstraintViolation::MissingRequiredHeaderList => write!(f, "`required_header_list` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`"),
                 ConstraintViolation::MissingRequiredHeaderSet => write!(f, "`required_header_set` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`"),
                 ConstraintViolation::RequiredHeaderSet(_) => write!(f, "constraint violation occurred building member `required_header_set` when building `RequiredHeaderCollectionOperationInput`"),
--
+            }
                 /* ServerBuilderConstraintViolations.kt:127 */ConstraintViolation::MissingRequiredHeaderList => write!(f, "`required_header_list` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`"),
                 /* ServerBuilderConstraintViolations.kt:127 */ConstraintViolation::MissingRequiredHeaderSet => write!(f, "`required_header_set` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`"),
                 /* ServerBuilderConstraintViolations.kt:127 */ConstraintViolation::RequiredHeaderSet(_) => write!(f, "constraint violation occurred building member `required_header_set` when building `RequiredHeaderCollectionOperationInput`"),
             /* ServerBuilderConstraintViolations.kt:119 */}
             /* ServerBuilderConstraintViolations.kt:118 */
-724
+        }
         /* ServerBuilderConstraintViolations.kt:117 */
-726
+    }
     /* ServerBuilderConstraintViolations.kt:84 */
     impl ::std::error::Error for ConstraintViolation {}
     /* ServerBuilderConstraintViolations.kt:171 */
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
             ConstraintViolation::MissingRequiredHeaderList => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/requiredHeaderList' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/requiredHeaderList",
                                             },
             ConstraintViolation::MissingRequiredHeaderSet => crate::model::ValidationExceptionField {
                                                 message: format!("Value at '{}/requiredHeaderSet' failed to satisfy constraint: Member must not be null", path),
                                                 path: path + "/requiredHeaderSet",
                                             },
             ConstraintViolation::RequiredHeaderSet(inner) => inner.as_validation_exception_field(path + "/requiredHeaderSet"),
-745
+        }
-746
+        }
-747
+    }
     /* ServerBuilderGenerator.kt:234 */
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
-751
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),
             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-765
+                            )
-766
+        }
-767
+    }
     /* ServerBuilderGenerator.kt:244 */
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<
             crate::input::RequiredHeaderCollectionOperationInput,
-772
+        >
-773
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-776
+        }
-777
+    }
     /* ServerBuilderGenerator.kt:446 */
     impl ::std::convert::TryFrom<Builder> for crate::input::RequiredHeaderCollectionOperationInput {
         type Error = ConstraintViolation;
-781
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-784
+        }
-785
+    }
     /// A builder for [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
     /// /* ServerBuilderGenerator.kt:201 */A builder for [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     /* ServerBuilderGenerator.kt:211 */
     pub(crate) struct Builder {
         /* ServerBuilderGenerator.kt:308 */
         pub(crate) required_header_list:
             ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         /* ServerBuilderGenerator.kt:308 */
         pub(crate) required_header_set:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::HeaderSet>>,
         /* ServerBuilderGenerator.kt:211 */
-798
+    }
     /* ServerBuilderGenerator.kt:215 */
     impl Builder {
         /* ServerBuilderGenerator.kt:426 */
         #[allow(missing_docs)] // documentation missing in model
                                /* ServerBuilderGenerator.kt:428 */
         pub(crate) fn set_required_header_list(
             mut self,
             input: impl ::std::convert::Into<::std::vec::Vec<::std::string::String>>,
         ) -> Self {
             /* ServerBuilderGenerator.kt:429 */
             self.required_header_list = Some(input.into());
             self
             /* ServerBuilderGenerator.kt:428 */
-812
+        }
         /* ServerBuilderGenerator.kt:426 */
         #[allow(missing_docs)] // documentation missing in model
                                /* ServerBuilderGenerator.kt:428 */
         pub(crate) fn set_required_header_set(
             mut self,
             input: impl ::std::convert::Into<
                 crate::constrained::MaybeConstrained<crate::model::HeaderSet>,
             >,
         ) -> Self {
             /* ServerBuilderGenerator.kt:429 */
             self.required_header_set = Some(input.into());
             self
             /* ServerBuilderGenerator.kt:428 */
-826
+        }
         /// Consumes the builder and constructs a [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
         ///
         /// /* ServerBuilderGenerator.kt:258 */Consumes the builder and constructs a [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
         /// /* ServerBuilderGenerator.kt:260 */
         /// The builder fails to construct a [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput) if a [`ConstraintViolation`] occurs.
         ///
         /// If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
         /// /* ServerBuilderGenerator.kt:268 */If the builder fails, it will return the _first_ encountered [`ConstraintViolation`].
         /* ServerBuilderGenerator.kt:271 */
         pub fn build(
             self,
         ) -> Result<crate::input::RequiredHeaderCollectionOperationInput, ConstraintViolation>
-836
+        {
             self.build_enforcing_all_constraints()
-838
+        }
         /* ServerBuilderGenerator.kt:283 */
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::RequiredHeaderCollectionOperationInput, ConstraintViolation>
-843
+        {
             Ok(crate::input::RequiredHeaderCollectionOperationInput {
             /* ServerBuilderGenerator.kt:287 */
             Ok(
                 /* ServerBuilderGenerator.kt:542 */
                 crate::input::RequiredHeaderCollectionOperationInput {
                     /* ServerBuilderGenerator.kt:546 */
                     required_header_list: self
                         .required_header_list
                         /* ServerBuilderGenerator.kt:569 */
                         .ok_or(ConstraintViolation::MissingRequiredHeaderList)?,
                     /* ServerBuilderGenerator.kt:546 */
                     required_header_set: self
                         .required_header_set
                         /* ServerBuilderGenerator.kt:602 */
                         .map(|v| match v {
                             crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                             crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                         })
                         /* ServerBuilderGenerator.kt:614 */
                         .map(|res| res.map_err(ConstraintViolation::RequiredHeaderSet))
                         .transpose()?
                         /* ServerBuilderGenerator.kt:630 */
                         .map(|v: crate::model::HeaderSet| v.into())
                         /* ServerBuilderGenerator.kt:569 */
                         .ok_or(ConstraintViolation::MissingRequiredHeaderSet)?,
             })
                     /* ServerBuilderGenerator.kt:542 */
                 }, /* ServerBuilderGenerator.kt:287 */
-+
+            )
             /* ServerBuilderGenerator.kt:283 */
-872
+        }
         /* ServerBuilderGenerator.kt:215 */
-874
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-877
+}
 /// See [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
 /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:110 */See [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
 pub mod required_header_collection_operation_input {
-880
     /* RustType.kt:516 */
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
--
     /// /* ServerBuilderConstraintViolations.kt:72 */Holds one variant for each of the ways the builder can fail.
     /* ServerBuilderConstraintViolations.kt:75 */
     #[allow(clippy::enum_variant_names)]
     pub enum ConstraintViolation {
         /// `required_header_list` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`.
         /// /* ServerBuilderConstraintViolations.kt:138 */`required_header_list` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`.
         /* ServerBuilderConstraintViolations.kt:143 */
         MissingRequiredHeaderList,
         /// `required_header_set` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`.
         /// /* ServerBuilderConstraintViolations.kt:138 */`required_header_set` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`.
         /* ServerBuilderConstraintViolations.kt:143 */
         MissingRequiredHeaderSet,
         /* ServerBuilderConstraintViolations.kt:75 */
-894
+    }
     /* ServerBuilderConstraintViolations.kt:117 */
     impl ::std::fmt::Display for ConstraintViolation {
         /* ServerBuilderConstraintViolations.kt:118 */
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             /* ServerBuilderConstraintViolations.kt:119 */
             match self {
                 ConstraintViolation::MissingRequiredHeaderList => write!(f, "`required_header_list` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`"),
                 ConstraintViolation::MissingRequiredHeaderSet => write!(f, "`required_header_set` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`"),
--
+            }
                 /* ServerBuilderConstraintViolations.kt:127 */ConstraintViolation::MissingRequiredHeaderList => write!(f, "`required_header_list` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`"),
                 /* ServerBuilderConstraintViolations.kt:127 */ConstraintViolation::MissingRequiredHeaderSet => write!(f, "`required_header_set` was not provided but it is required when building `RequiredHeaderCollectionOperationInput`"),
             /* ServerBuilderConstraintViolations.kt:119 */}
             /* ServerBuilderConstraintViolations.kt:118 */
-905
+        }
         /* ServerBuilderConstraintViolations.kt:117 */
-907
+    }
     /* ServerBuilderConstraintViolations.kt:84 */
     impl ::std::error::Error for ConstraintViolation {}
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:254 */
     impl ::std::convert::TryFrom<Builder> for crate::input::RequiredHeaderCollectionOperationInput {
         type Error = ConstraintViolation;
-913
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-916
+        }
-917
+    }
     /// A builder for [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:130 */A builder for [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
     pub struct Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:225 */
         pub(crate) required_header_list:
             ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:225 */
         pub(crate) required_header_set:
             ::std::option::Option<::std::vec::Vec<::std::string::String>>,
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
-930
+    }
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
     impl Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:241 */
         #[allow(missing_docs)] // documentation missing in model
                                /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
         pub fn required_header_list(
             mut self,
             input: ::std::vec::Vec<::std::string::String>,
         ) -> Self {
             self.required_header_list = Some(input);
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */
             self.required_header_list =
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:246 */Some(
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:247 */input
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:246 */)
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */;
             self
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
-948
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:241 */
         #[allow(missing_docs)] // documentation missing in model
                                /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
         pub fn required_header_set(
             mut self,
             input: ::std::vec::Vec<::std::string::String>,
         ) -> Self {
             self.required_header_set = Some(input);
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */
             self.required_header_set =
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:246 */Some(
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:247 */input
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:246 */)
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */;
             self
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
-964
+        }
         /// Consumes the builder and constructs a [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
         ///
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:150 */Consumes the builder and constructs a [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput).
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:152 */
         /// The builder fails to construct a [`RequiredHeaderCollectionOperationInput`](crate::input::RequiredHeaderCollectionOperationInput) if you do not provide a value for all non-`Option`al members.
         ///
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:159 */
         pub fn build(
             self,
         ) -> Result<crate::input::RequiredHeaderCollectionOperationInput, ConstraintViolation>
-973
+        {
             self.build_enforcing_required_and_enum_traits()
-975
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> Result<crate::input::RequiredHeaderCollectionOperationInput, ConstraintViolation>
-980
+        {
             Ok(crate::input::RequiredHeaderCollectionOperationInput {
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:175 */
             Ok(
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
                 crate::input::RequiredHeaderCollectionOperationInput {
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:186 */
                     required_header_list: self
                         .required_header_list
                         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:202 */
                         .ok_or(ConstraintViolation::MissingRequiredHeaderList)?,
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:186 */
                     required_header_set: self
                         .required_header_set
                         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:202 */
                         .ok_or(ConstraintViolation::MissingRequiredHeaderSet)?,
             })
                     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
                 }, /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:175 */
-+
+            )
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
-999
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
-1001
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-1004
+}
 /// See [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
 /// /* ServerBuilderGenerator.kt:171 */See [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
 pub(crate) mod required_inner_shape_operation_input_internal {
-1007
     /* RustType.kt:516 */
     #[derive(::std::cmp::PartialEq, ::std::fmt::Debug)]
     /// Holds one variant for each of the ways the builder can fail.
     /// /* ServerBuilderConstraintViolations.kt:72 */Holds one variant for each of the ways the builder can fail.
     /* RustType.kt:516 */
     #[non_exhaustive]
     /* ServerBuilderConstraintViolations.kt:75 */
     #[allow(clippy::enum_variant_names)]
     pub(crate) enum ConstraintViolation {
         /// Constraint violation occurred building member `inner` when building `RequiredInnerShapeOperationInput`.
         /// /* ServerBuilderConstraintViolations.kt:158 */Constraint violation occurred building member `inner` when building `RequiredInnerShapeOperationInput`.
         /* RustType.kt:516 */
         #[doc(hidden)]
         /* ServerBuilderConstraintViolations.kt:164 */
         Inner(crate::model::inner_shape_internal::ConstraintViolation),
         /* ServerBuilderConstraintViolations.kt:75 */
-1022
+    }
     /* ServerBuilderConstraintViolations.kt:117 */
     impl ::std::fmt::Display for ConstraintViolation {
         /* ServerBuilderConstraintViolations.kt:118 */
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             /* ServerBuilderConstraintViolations.kt:119 */
             match self {
                 ConstraintViolation::Inner(_) => write!(f, "constraint violation occurred building member `inner` when building `RequiredInnerShapeOperationInput`"),
--
+            }
                 /* ServerBuilderConstraintViolations.kt:127 */ConstraintViolation::Inner(_) => write!(f, "constraint violation occurred building member `inner` when building `RequiredInnerShapeOperationInput`"),
             /* ServerBuilderConstraintViolations.kt:119 */}
             /* ServerBuilderConstraintViolations.kt:118 */
-1032
+        }
         /* ServerBuilderConstraintViolations.kt:117 */
-1034
+    }
     /* ServerBuilderConstraintViolations.kt:84 */
     impl ::std::error::Error for ConstraintViolation {}
     /* ServerBuilderConstraintViolations.kt:171 */
     impl ConstraintViolation {
         pub(crate) fn as_validation_exception_field(
             self,
             path: ::std::string::String,
         ) -> crate::model::ValidationExceptionField {
             match self {
                 ConstraintViolation::Inner(inner) => {
                     inner.as_validation_exception_field(path + "/inner")
-1046
+                }
-1047
+            }
-1048
+        }
-1049
+    }
     /* ServerBuilderGenerator.kt:234 */
     impl ::std::convert::From<ConstraintViolation>
         for ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection
-1053
+    {
         fn from(constraint_violation: ConstraintViolation) -> Self {
             let first_validation_exception_field =
                 constraint_violation.as_validation_exception_field("".to_owned());
             let validation_exception = crate::error::ValidationException {
                 message: format!(
                     "1 validation error detected. {}",
                     &first_validation_exception_field.message
                 ),
                 field_list: Some(vec![first_validation_exception_field]),
             };
             Self::ConstraintViolation(
                                 crate::protocol_serde::shape_validation_exception::ser_validation_exception_error(&validation_exception)
                                     .expect("validation exceptions should never fail to serialize; please file a bug report under https://github.com/smithy-lang/smithy-rs/issues")
-1067
+                            )
-1068
+        }
-1069
+    }
     /* ServerBuilderGenerator.kt:244 */
     impl ::std::convert::From<Builder>
         for crate::constrained::MaybeConstrained<crate::input::RequiredInnerShapeOperationInput>
-1073
+    {
         fn from(builder: Builder) -> Self {
             Self::Unconstrained(builder)
-1076
+        }
-1077
+    }
     /* ServerBuilderGenerator.kt:446 */
     impl ::std::convert::TryFrom<Builder> for crate::input::RequiredInnerShapeOperationInput {
         type Error = ConstraintViolation;
-1081
         fn try_from(builder: Builder) -> ::std::result::Result<Self, Self::Error> {
             builder.build()
-1084
+        }
-1085
+    }
     /// A builder for [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
     /// /* ServerBuilderGenerator.kt:201 */A builder for [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     /* ServerBuilderGenerator.kt:211 */
     pub(crate) struct Builder {
         /* ServerBuilderGenerator.kt:308 */
         pub(crate) inner:
             ::std::option::Option<crate::constrained::MaybeConstrained<crate::model::InnerShape>>,
         /* ServerBuilderGenerator.kt:211 */
-1095
+    }
     /* ServerBuilderGenerator.kt:215 */
     impl Builder {
         /* ServerBuilderGenerator.kt:426 */
         #[allow(missing_docs)] // documentation missing in model
                                /* ServerBuilderGenerator.kt:428 */
         pub(crate) fn set_inner(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     crate::constrained::MaybeConstrained<crate::model::InnerShape>,
                 >,
             >,
         ) -> Self {
             /* ServerBuilderGenerator.kt:429 */
             self.inner = input.map(|v| v.into());
             self
             /* ServerBuilderGenerator.kt:428 */
-1113
+        }
         /// Consumes the builder and constructs a [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
         ///
         /// /* ServerBuilderGenerator.kt:258 */Consumes the builder and constructs a [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
         /// /* ServerBuilderGenerator.kt:260 */
         /// The builder fails to construct a [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput) if a [`ConstraintViolation`] occurs.
         ///
         /* ServerBuilderGenerator.kt:271 */
         pub fn build(
             self,
         ) -> Result<crate::input::RequiredInnerShapeOperationInput, ConstraintViolation> {
             self.build_enforcing_all_constraints()
-1123
+        }
         /* ServerBuilderGenerator.kt:283 */
         fn build_enforcing_all_constraints(
             self,
         ) -> Result<crate::input::RequiredInnerShapeOperationInput, ConstraintViolation> {
             Ok(crate::input::RequiredInnerShapeOperationInput {
             /* ServerBuilderGenerator.kt:287 */
             Ok(
                 /* ServerBuilderGenerator.kt:542 */
                 crate::input::RequiredInnerShapeOperationInput {
                     /* ServerBuilderGenerator.kt:546 */
                     inner: self
                         .inner
                         /* ServerBuilderGenerator.kt:602 */
                         .map(|v| match v {
                             crate::constrained::MaybeConstrained::Constrained(x) => Ok(x),
                             crate::constrained::MaybeConstrained::Unconstrained(x) => x.try_into(),
                         })
                         /* ServerBuilderGenerator.kt:614 */
                         .map(|res| res.map_err(ConstraintViolation::Inner))
                         .transpose()?,
             })
                     /* ServerBuilderGenerator.kt:542 */
                 }, /* ServerBuilderGenerator.kt:287 */
-+
+            )
             /* ServerBuilderGenerator.kt:283 */
-1147
+        }
         /* ServerBuilderGenerator.kt:215 */
-1149
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-1152
+}
 /// See [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
 /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:110 */See [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
 pub mod required_inner_shape_operation_input {
-1155
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:269 */
     impl ::std::convert::From<Builder> for crate::input::RequiredInnerShapeOperationInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-1160
+        }
-1161
+    }
     /// A builder for [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:130 */A builder for [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
     pub struct Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:225 */
         pub(crate) inner: ::std::option::Option<crate::model::InnerShape>,
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
-1170
+    }
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
     impl Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:241 */
         #[allow(missing_docs)] // documentation missing in model
                                /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
         pub fn inner(mut self, input: ::std::option::Option<crate::model::InnerShape>) -> Self {
             self.inner = input;
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */
             self.inner =
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:247 */input
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */;
             self
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
-1183
+        }
         /// Consumes the builder and constructs a [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:150 */Consumes the builder and constructs a [`RequiredInnerShapeOperationInput`](crate::input::RequiredInnerShapeOperationInput).
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:159 */
         pub fn build(self) -> crate::input::RequiredInnerShapeOperationInput {
             self.build_enforcing_required_and_enum_traits()
-1188
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::input::RequiredInnerShapeOperationInput {
             crate::input::RequiredInnerShapeOperationInput { inner: self.inner }
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
             crate::input::RequiredInnerShapeOperationInput {
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:186 */
                 inner: self.inner,
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
-+
+            }
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
-1200
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
-1202
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-1205
+}
 /// See [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
 /// /* ServerBuilderGenerator.kt:171 */See [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
 pub(crate) mod type_complexity_operation_input_internal {
-1208
     /* ServerBuilderGenerator.kt:461 */
     impl ::std::convert::From<Builder> for crate::input::TypeComplexityOperationInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-1213
+        }
-1214
+    }
     /// A builder for [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
     /// /* ServerBuilderGenerator.kt:201 */A builder for [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     /* ServerBuilderGenerator.kt:211 */
     pub(crate) struct Builder {
         /* ServerBuilderGenerator.kt:308 */
         pub(crate) list: ::std::option::Option<
             ::std::vec::Vec<
                 ::std::vec::Vec<
                     ::std::vec::Vec<
                         ::std::collections::HashMap<
                             ::std::string::String,
                             crate::model::EmptyStructure,
                         >,
                     >,
                 >,
             >,
         >,
         /* ServerBuilderGenerator.kt:211 */
-1234
+    }
     /* ServerBuilderGenerator.kt:215 */
     impl Builder {
         /* ServerBuilderGenerator.kt:426 */
         #[allow(missing_docs)] // documentation missing in model
                                /* ServerBuilderGenerator.kt:428 */
         pub(crate) fn set_list(
             mut self,
             input: Option<
                 impl ::std::convert::Into<
                     ::std::vec::Vec<
                         ::std::vec::Vec<
                             ::std::vec::Vec<
                                 ::std::collections::HashMap<
                                     ::std::string::String,
                                     crate::model::EmptyStructure,
                                 >,
                             >,
                         >,
                     >,
                 >,
             >,
         ) -> Self {
             /* ServerBuilderGenerator.kt:429 */
             self.list = input.map(|v| v.into());
             self
             /* ServerBuilderGenerator.kt:428 */
-1261
+        }
         /// Consumes the builder and constructs a [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
         /// /* ServerBuilderGenerator.kt:258 */Consumes the builder and constructs a [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
         /* ServerBuilderGenerator.kt:271 */
         pub fn build(self) -> crate::input::TypeComplexityOperationInput {
             self.build_enforcing_all_constraints()
-1266
+        }
         /* ServerBuilderGenerator.kt:283 */
         fn build_enforcing_all_constraints(self) -> crate::input::TypeComplexityOperationInput {
             crate::input::TypeComplexityOperationInput { list: self.list }
             /* ServerBuilderGenerator.kt:542 */
             crate::input::TypeComplexityOperationInput {
                 /* ServerBuilderGenerator.kt:546 */
                 list: self.list,
                 /* ServerBuilderGenerator.kt:542 */
-+
+            }
             /* ServerBuilderGenerator.kt:283 */
-1276
+        }
         /* ServerBuilderGenerator.kt:215 */
-1278
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-1281
+}
 /// See [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
 /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:110 */See [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
 pub mod type_complexity_operation_input {
-1284
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:269 */
     impl ::std::convert::From<Builder> for crate::input::TypeComplexityOperationInput {
         fn from(builder: Builder) -> Self {
             builder.build()
-1289
+        }
-1290
+    }
     /// A builder for [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
     /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:130 */A builder for [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
     /* RustType.kt:516 */
     #[derive(::std::clone::Clone, ::std::default::Default, ::std::fmt::Debug)]
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
     pub struct Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:225 */
         pub(crate) list: ::std::option::Option<
             ::std::vec::Vec<
                 ::std::vec::Vec<
                     ::std::vec::Vec<
                         ::std::collections::HashMap<
                             ::std::string::String,
                             crate::model::EmptyStructure,
                         >,
                     >,
                 >,
             >,
         >,
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:137 */
-1310
+    }
     /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
     impl Builder {
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:241 */
         #[allow(missing_docs)] // documentation missing in model
                                /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
         pub fn list(
             mut self,
             input: ::std::option::Option<
                 ::std::vec::Vec<
                     ::std::vec::Vec<
                         ::std::vec::Vec<
                             ::std::collections::HashMap<
                                 ::std::string::String,
                                 crate::model::EmptyStructure,
                             >,
                         >,
                     >,
                 >,
             >,
         ) -> Self {
             self.list = input;
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */
             self.list =
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:247 */input
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:245 */;
             self
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:244 */
-1337
+        }
         /// Consumes the builder and constructs a [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
         /// /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:150 */Consumes the builder and constructs a [`TypeComplexityOperationInput`](crate::input::TypeComplexityOperationInput).
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:159 */
         pub fn build(self) -> crate::input::TypeComplexityOperationInput {
             self.build_enforcing_required_and_enum_traits()
-1342
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
         fn build_enforcing_required_and_enum_traits(
             self,
         ) -> crate::input::TypeComplexityOperationInput {
             crate::input::TypeComplexityOperationInput { list: self.list }
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
             crate::input::TypeComplexityOperationInput {
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:186 */
                 list: self.list,
                 /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:182 */
-+
+            }
             /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:171 */
-1354
+        }
         /* ServerBuilderGeneratorWithoutPublicConstrainedTypes.kt:141 */
-1356
+    }
-+
     /* RustCrateInlineModuleComposingWriter.kt:299 */
-1359
+}

Pages: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89

1 1	`import misc.model`
2 2	`import typing`