Server Test

Server Test

rev. dfb5149b65b7bcc09edd15b8e071ad43b5ac5943 (ignoring whitespace)

Files changed:

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_sparse_list.rs

@@ -1,1 +47,72 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonParserGenerator.kt:398 */
    2      3   
pub(crate) fn de_sparse_list<'a, I>(
    3      4   
    tokens: &mut ::std::iter::Peekable<I>,
    4      5   
) -> ::std::result::Result<
    5      6   
    Option<crate::unconstrained::sparse_list_unconstrained::SparseListUnconstrained>,
    6      7   
    ::aws_smithy_json::deserialize::error::DeserializeError,
    7      8   
>
    8      9   
where
    9     10   
    I: Iterator<
   10     11   
        Item = Result<
   11     12   
            ::aws_smithy_json::deserialize::Token<'a>,
   12     13   
            ::aws_smithy_json::deserialize::error::DeserializeError,
   13     14   
        >,
   14     15   
    >,
   15     16   
{
          17  +
    /* JsonParserGenerator.kt:712 */
   16     18   
    match tokens.next().transpose()? {
          19  +
        /* JsonParserGenerator.kt:713 */
   17     20   
        Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
   18     21   
        Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
          22  +
            /* JsonParserGenerator.kt:407 */
   19     23   
            let mut items = Vec::new();
          24  +
            /* JsonParserGenerator.kt:408 */
   20     25   
            loop {
          26  +
                /* JsonParserGenerator.kt:409 */
   21     27   
                match tokens.peek() {
          28  +
                    /* JsonParserGenerator.kt:410 */
   22     29   
                    Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
          30  +
                        /* JsonParserGenerator.kt:411 */
   23     31   
                        tokens.next().transpose().unwrap();
   24     32   
                        break;
          33  +
                        /* JsonParserGenerator.kt:410 */
   25     34   
                    }
          35  +
                    /* JsonParserGenerator.kt:413 */
   26     36   
                    _ => {
          37  +
                        /* JsonParserGenerator.kt:415 */
   27     38   
                        items.push(
          39  +
                            /* JsonParserGenerator.kt:354 */
   28     40   
                            ::aws_smithy_json::deserialize::token::expect_string_or_null(
   29     41   
                                tokens.next(),
   30     42   
                            )?
   31         -
                            .map(|s| s.to_unescaped().map(|u| u.into_owned()))
   32         -
                            .transpose()?,
          43  +
                            .map(|s|
          44  +
                                /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
          45  +
                                    /* JsonParserGenerator.kt:348 */u.into_owned()
          46  +
                                /* JsonParserGenerator.kt:339 */) /* JsonParserGenerator.kt:354 */)
          47  +
                            .transpose()?, /* JsonParserGenerator.kt:415 */
   33     48   
                        );
          49  +
                        /* JsonParserGenerator.kt:413 */
          50  +
                    } /* JsonParserGenerator.kt:409 */
   34     51   
                }
          52  +
                /* JsonParserGenerator.kt:408 */
   35     53   
            }
   36         -
            }
          54  +
            /* JsonParserGenerator.kt:444 */
   37     55   
            Ok(Some(
   38     56   
                crate::unconstrained::sparse_list_unconstrained::SparseListUnconstrained(items),
   39     57   
            ))
          58  +
            /* JsonParserGenerator.kt:713 */
   40     59   
        }
   41         -
        _ => Err(
          60  +
        /* JsonParserGenerator.kt:722 */
          61  +
        _ => {
          62  +
            /* JsonParserGenerator.kt:723 */
          63  +
            Err(
   42     64   
                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   43     65   
                    "expected start array or null",
   44     66   
                ),
   45         -
        ),
          67  +
            )
          68  +
            /* JsonParserGenerator.kt:722 */
          69  +
        } /* JsonParserGenerator.kt:712 */
   46     70   
    }
          71  +
    /* JsonParserGenerator.kt:398 */
   47     72   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_sparse_map.rs

@@ -1,1 +50,74 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonParserGenerator.kt:460 */
    2      3   
pub(crate) fn de_sparse_map<'a, I>(
    3      4   
    tokens: &mut ::std::iter::Peekable<I>,
    4      5   
) -> ::std::result::Result<
    5      6   
    Option<crate::unconstrained::sparse_map_unconstrained::SparseMapUnconstrained>,
    6      7   
    ::aws_smithy_json::deserialize::error::DeserializeError,
    7      8   
>
    8      9   
where
    9     10   
    I: Iterator<
   10     11   
        Item = Result<
   11     12   
            ::aws_smithy_json::deserialize::Token<'a>,
   12     13   
            ::aws_smithy_json::deserialize::error::DeserializeError,
   13     14   
        >,
   14     15   
    >,
   15     16   
{
          17  +
    /* JsonParserGenerator.kt:712 */
   16     18   
    match tokens.next().transpose()? {
          19  +
        /* JsonParserGenerator.kt:713 */
   17     20   
        Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
   18     21   
        Some(::aws_smithy_json::deserialize::Token::StartObject { .. }) => {
          22  +
            /* JsonParserGenerator.kt:469 */
   19     23   
            let mut map = ::std::collections::HashMap::new();
          24  +
            /* JsonParserGenerator.kt:684 */
   20     25   
            loop {
          26  +
                /* JsonParserGenerator.kt:685 */
   21     27   
                match tokens.next().transpose()? {
          28  +
                    /* JsonParserGenerator.kt:686 */
   22     29   
                    Some(::aws_smithy_json::deserialize::Token::EndObject { .. }) => break,
   23     30   
                    Some(::aws_smithy_json::deserialize::Token::ObjectKey { key, .. }) => {
   24         -
                        let key = key.to_unescaped().map(|u| u.into_owned())?;
          31  +
                        /* JsonParserGenerator.kt:471 */
          32  +
                        let key =
          33  +
                            /* JsonParserGenerator.kt:339 */key.to_unescaped().map(|u|
          34  +
                                /* JsonParserGenerator.kt:348 */u.into_owned()
          35  +
                            /* JsonParserGenerator.kt:339 */)
          36  +
                        /* JsonParserGenerator.kt:471 */?;
          37  +
                        /* JsonParserGenerator.kt:474 */
   25     38   
                        let value =
   26         -
                            crate::protocol_serde::shape_unique_items_list::de_unique_items_list(
   27         -
                                tokens,
   28         -
                            )?;
          39  +
                            /* JsonParserGenerator.kt:451 */crate::protocol_serde::shape_unique_items_list::de_unique_items_list(tokens)?
          40  +
                        /* JsonParserGenerator.kt:474 */;
          41  +
                        /* JsonParserGenerator.kt:478 */
   29     42   
                        map.insert(key, value);
          43  +
                        /* JsonParserGenerator.kt:686 */
   30     44   
                    }
          45  +
                    /* JsonParserGenerator.kt:695 */
   31     46   
                    other => {
   32     47   
                        return Err(
   33     48   
                            ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   34     49   
                                format!("expected object key or end object, found: {:?}", other),
   35     50   
                            ),
   36     51   
                        )
          52  +
                    } /* JsonParserGenerator.kt:685 */
   37     53   
                }
          54  +
                /* JsonParserGenerator.kt:684 */
   38     55   
            }
   39         -
            }
          56  +
            /* JsonParserGenerator.kt:502 */
   40     57   
            Ok(Some(
   41     58   
                crate::unconstrained::sparse_map_unconstrained::SparseMapUnconstrained(map),
   42     59   
            ))
          60  +
            /* JsonParserGenerator.kt:713 */
   43     61   
        }
   44         -
        _ => Err(
          62  +
        /* JsonParserGenerator.kt:722 */
          63  +
        _ => {
          64  +
            /* JsonParserGenerator.kt:723 */
          65  +
            Err(
   45     66   
                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   46     67   
                    "expected start object or null",
   47     68   
                ),
   48         -
        ),
          69  +
            )
          70  +
            /* JsonParserGenerator.kt:722 */
          71  +
        } /* JsonParserGenerator.kt:712 */
   49     72   
    }
          73  +
    /* JsonParserGenerator.kt:460 */
   50     74   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_streaming_blob_operation.rs

@@ -1,1 +56,78 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* RustType.kt:516 */
    2      3   
#[allow(clippy::unnecessary_wraps)]
           4  +
/* ServerHttpBoundProtocolGenerator.kt:383 */
    3      5   
pub async fn de_streaming_blob_operation_http_request<B>(
    4      6   
    #[allow(unused_variables)] request: ::http::Request<B>,
    5      7   
) -> std::result::Result<
    6      8   
    crate::input::StreamingBlobOperationInput,
    7      9   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection,
    8     10   
>
    9     11   
where
   10     12   
    B: ::aws_smithy_http_server::body::HttpBody + Send,
   11     13   
    B: Into<::aws_smithy_types::byte_stream::ByteStream>,
   12     14   
    B::Data: Send,
   13     15   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::RequestRejection:
   14     16   
        From<<B as ::aws_smithy_http_server::body::HttpBody>::Error>,
   15     17   
{
          18  +
    /* ServerHttpBoundProtocolGenerator.kt:399 */
   16     19   
    Ok({
          20  +
        /* RustType.kt:516 */
   17     21   
        #[allow(unused_mut)]
          22  +
        /* ServerHttpBoundProtocolGenerator.kt:723 */
   18     23   
        let mut input = crate::input::streaming_blob_operation_input::Builder::default();
          24  +
        /* RustType.kt:516 */
   19     25   
        #[allow(unused_variables)]
          26  +
        /* ServerHttpBoundProtocolGenerator.kt:728 */
   20     27   
        let ::aws_smithy_runtime_api::http::RequestParts {
   21     28   
            uri, headers, body, ..
   22     29   
        } = ::aws_smithy_runtime_api::http::Request::try_from(request)?.into_parts();
          30  +
        /* ServerHttpBoundProtocolGenerator.kt:794 */
   23     31   
        if let Some(value) = {
   24     32   
            Some(crate::protocol_serde::shape_streaming_blob_operation_input::de_streaming_blob_payload(&mut body.into().into_inner())?)
   25     33   
        } {
   26     34   
            input = input.set_streaming_blob(value)
   27     35   
        }
          36  +
        /* ServerHttpBoundProtocolGenerator.kt:834 */
   28     37   
        input.build()
          38  +
        /* ServerHttpBoundProtocolGenerator.kt:399 */
   29     39   
    })
          40  +
    /* ServerHttpBoundProtocolGenerator.kt:383 */
   30     41   
}
   31     42   
          43  +
/* RustType.kt:516 */
   32     44   
#[allow(clippy::unnecessary_wraps)]
          45  +
/* ServerHttpBoundProtocolGenerator.kt:421 */
   33     46   
pub fn ser_streaming_blob_operation_http_response(
   34     47   
    #[allow(unused_variables)] output: crate::output::StreamingBlobOperationOutput,
   35     48   
) -> std::result::Result<
   36     49   
    ::aws_smithy_http_server::response::Response,
   37     50   
    ::aws_smithy_http_server::protocol::rest_json_1::rejection::ResponseRejection,
   38     51   
> {
          52  +
    /* ServerHttpBoundProtocolGenerator.kt:433 */
   39     53   
    Ok({
          54  +
        /* RustType.kt:516 */
   40     55   
        #[allow(unused_mut)]
          56  +
        /* ServerHttpBoundProtocolGenerator.kt:523 */
   41     57   
        let mut builder = ::http::Response::builder();
          58  +
        /* ServerHttpBoundProtocolGenerator.kt:597 */
   42     59   
        builder = ::aws_smithy_http::header::set_response_header_if_absent(
   43     60   
            builder,
   44     61   
            ::http::header::CONTENT_TYPE,
   45     62   
            "application/octet-stream",
   46     63   
        );
          64  +
        /* ServerHttpBoundProtocolGenerator.kt:682 */
   47     65   
        let http_status: u16 = 200;
   48     66   
        builder = builder.status(http_status);
          67  +
        /* ServerHttpBoundProtocolGenerator.kt:543 */
   49     68   
        let body = ::aws_smithy_http_server::body::boxed(::aws_smithy_http_server::body::Body::wrap_stream(
   50         -
            ::aws_smithy_http::futures_stream_adapter::FuturesStreamCompatByteStream::new(
   51         -
                crate::protocol_serde::shape_streaming_blob_operation_output::ser_streaming_blob_http_payload( output.streaming_blob)?
   52         -
            )
   53         -
        ));
          69  +
            /* ServerProtocolLoader.kt:36 */::aws_smithy_http::futures_stream_adapter::FuturesStreamCompatByteStream::new(
          70  +
                /* HttpBoundProtocolPayloadGenerator.kt:350 */crate::protocol_serde::shape_streaming_blob_operation_output::ser_streaming_blob_http_payload( output.streaming_blob)?
          71  +
            /* ServerProtocolLoader.kt:36 */)
          72  +
        /* ServerHttpBoundProtocolGenerator.kt:543 */));
          73  +
        /* ServerHttpBoundProtocolGenerator.kt:575 */
   54     74   
        builder.body(body)?
          75  +
        /* ServerHttpBoundProtocolGenerator.kt:433 */
   55     76   
    })
          77  +
    /* ServerHttpBoundProtocolGenerator.kt:421 */
   56     78   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_streaming_blob_operation_input.rs

@@ -1,1 +11,13 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* HttpBindingGenerator.kt:230 */
    2      3   
pub fn de_streaming_blob_payload(
    3      4   
    body: &mut ::aws_smithy_types::body::SdkBody,
    4      5   
) -> std::result::Result<
    5      6   
    ::aws_smithy_types::byte_stream::ByteStream,
    6      7   
    ::aws_smithy_json::deserialize::error::DeserializeError,
    7      8   
> {
    8         -
    // replace the body with an empty body
           9  +
    /* HttpBindingGenerator.kt:299 */// replace the body with an empty body
    9     10   
    let body = std::mem::replace(body, ::aws_smithy_types::body::SdkBody::taken());
   10     11   
    Ok(::aws_smithy_types::byte_stream::ByteStream::new(body))
          12  +
    /* HttpBindingGenerator.kt:230 */
   11     13   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_streaming_blob_operation_output.rs

@@ -1,1 +9,15 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* HttpBoundProtocolPayloadGenerator.kt:311 */
    2      3   
pub fn ser_streaming_blob_http_payload(
    3      4   
    payload: ::aws_smithy_types::byte_stream::ByteStream,
    4      5   
) -> ::std::result::Result<
    5      6   
    ::aws_smithy_types::byte_stream::ByteStream,
    6      7   
    ::aws_smithy_types::error::operation::BuildError,
    7      8   
> {
    8         -
    Ok(payload)
           9  +
    /* HttpBoundProtocolPayloadGenerator.kt:345 */
          10  +
    Ok(
          11  +
        /* HttpBoundProtocolPayloadGenerator.kt:374 */
          12  +
        payload, /* HttpBoundProtocolPayloadGenerator.kt:345 */
          13  +
    )
          14  +
    /* HttpBoundProtocolPayloadGenerator.kt:311 */
    9     15   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_transitively_constrained_structure_in_output.rs

@@ -1,1 +10,16 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonSerializerGenerator.kt:358 */
    2      3   
pub fn ser_transitively_constrained_structure_in_output(
    3      4   
    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
    4      5   
    input: &crate::model::TransitivelyConstrainedStructureInOutput,
    5      6   
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
           7  +
    /* JsonSerializerGenerator.kt:382 */
    6      8   
    if let Some(var_1) = &input.length_string {
           9  +
        /* JsonSerializerGenerator.kt:423 */
    7     10   
        object.key("lengthString").string(var_1.as_str());
          11  +
        /* JsonSerializerGenerator.kt:382 */
    8     12   
    }
          13  +
    /* JsonSerializerGenerator.kt:372 */
    9     14   
    Ok(())
          15  +
    /* JsonSerializerGenerator.kt:358 */
   10     16   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_unique_items_list.rs

@@ -1,1 +56,82 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonParserGenerator.kt:398 */
    2      3   
pub(crate) fn de_unique_items_list<'a, I>(
    3      4   
    tokens: &mut ::std::iter::Peekable<I>,
    4      5   
) -> ::std::result::Result<
    5      6   
    Option<crate::unconstrained::unique_items_list_unconstrained::UniqueItemsListUnconstrained>,
    6      7   
    ::aws_smithy_json::deserialize::error::DeserializeError,
    7      8   
>
    8      9   
where
    9     10   
    I: Iterator<
   10     11   
        Item = Result<
   11     12   
            ::aws_smithy_json::deserialize::Token<'a>,
   12     13   
            ::aws_smithy_json::deserialize::error::DeserializeError,
   13     14   
        >,
   14     15   
    >,
   15     16   
{
          17  +
    /* JsonParserGenerator.kt:712 */
   16     18   
    match tokens.next().transpose()? {
          19  +
        /* JsonParserGenerator.kt:713 */
   17     20   
        Some(::aws_smithy_json::deserialize::Token::ValueNull { .. }) => Ok(None),
   18     21   
        Some(::aws_smithy_json::deserialize::Token::StartArray { .. }) => {
          22  +
            /* JsonParserGenerator.kt:407 */
   19     23   
            let mut items = Vec::new();
          24  +
            /* JsonParserGenerator.kt:408 */
   20     25   
            loop {
          26  +
                /* JsonParserGenerator.kt:409 */
   21     27   
                match tokens.peek() {
          28  +
                    /* JsonParserGenerator.kt:410 */
   22     29   
                    Some(Ok(::aws_smithy_json::deserialize::Token::EndArray { .. })) => {
          30  +
                        /* JsonParserGenerator.kt:411 */
   23     31   
                        tokens.next().transpose().unwrap();
   24     32   
                        break;
          33  +
                        /* JsonParserGenerator.kt:410 */
   25     34   
                    }
          35  +
                    /* JsonParserGenerator.kt:413 */
   26     36   
                    _ => {
   27         -
                        let value = ::aws_smithy_json::deserialize::token::expect_string_or_null(
   28         -
                            tokens.next(),
   29         -
                        )?
   30         -
                        .map(|s| s.to_unescaped().map(|u| u.into_owned()))
   31         -
                        .transpose()?;
          37  +
                        /* JsonParserGenerator.kt:419 */
          38  +
                        let value =
          39  +
                            /* JsonParserGenerator.kt:354 */::aws_smithy_json::deserialize::token::expect_string_or_null(tokens.next())?.map(|s|
          40  +
                                /* JsonParserGenerator.kt:339 */s.to_unescaped().map(|u|
          41  +
                                    /* JsonParserGenerator.kt:348 */u.into_owned()
          42  +
                                /* JsonParserGenerator.kt:339 */)
          43  +
                            /* JsonParserGenerator.kt:354 */).transpose()?
          44  +
                        /* JsonParserGenerator.kt:419 */;
          45  +
                        /* JsonParserGenerator.kt:422 */
   32     46   
                        if let Some(value) = value {
   33     47   
                            items.push(value);
   34         -
                        } else {
          48  +
                        }
          49  +
                        /* JsonParserGenerator.kt:430 */
          50  +
                        else {
   35     51   
                            return Err(
   36     52   
                                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   37     53   
                                    "dense list cannot contain null values",
   38     54   
                                ),
   39     55   
                            );
   40     56   
                        }
          57  +
                        /* JsonParserGenerator.kt:413 */
          58  +
                    } /* JsonParserGenerator.kt:409 */
   41     59   
                }
          60  +
                /* JsonParserGenerator.kt:408 */
   42     61   
            }
   43         -
            }
          62  +
            /* JsonParserGenerator.kt:444 */
   44     63   
            Ok(Some(
   45     64   
                crate::unconstrained::unique_items_list_unconstrained::UniqueItemsListUnconstrained(
   46     65   
                    items,
   47     66   
                ),
   48     67   
            ))
          68  +
            /* JsonParserGenerator.kt:713 */
   49     69   
        }
   50         -
        _ => Err(
          70  +
        /* JsonParserGenerator.kt:722 */
          71  +
        _ => {
          72  +
            /* JsonParserGenerator.kt:723 */
          73  +
            Err(
   51     74   
                ::aws_smithy_json::deserialize::error::DeserializeError::custom(
   52     75   
                    "expected start array or null",
   53     76   
                ),
   54         -
        ),
          77  +
            )
          78  +
            /* JsonParserGenerator.kt:722 */
          79  +
        } /* JsonParserGenerator.kt:712 */
   55     80   
    }
          81  +
    /* JsonParserGenerator.kt:398 */
   56     82   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_validation_exception.rs

@@ -1,1 +35,58 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonSerializerGenerator.kt:213 */
    2      3   
pub fn ser_validation_exception_error(
    3      4   
    value: &crate::error::ValidationException,
    4      5   
) -> ::std::result::Result<String, ::aws_smithy_types::error::operation::SerializationError> {
           6  +
    /* JsonSerializerGenerator.kt:218 */
    5      7   
    let mut out = ::std::string::String::new();
    6      8   
    let mut object = ::aws_smithy_json::serialize::JsonObjectWriter::new(&mut out);
           9  +
    /* JsonSerializerGenerator.kt:375 */
    7     10   
    crate::protocol_serde::shape_validation_exception::ser_validation_exception(
    8     11   
        &mut object,
    9     12   
        value,
   10     13   
    )?;
          14  +
    /* JsonSerializerGenerator.kt:227 */
   11     15   
    object.finish();
   12     16   
    Ok(out)
          17  +
    /* JsonSerializerGenerator.kt:213 */
   13     18   
}
   14     19   
          20  +
/* JsonSerializerGenerator.kt:358 */
   15     21   
pub fn ser_validation_exception(
   16     22   
    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
   17     23   
    input: &crate::error::ValidationException,
   18     24   
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
          25  +
    /* JsonSerializerGenerator.kt:382 */
   19     26   
    if let Some(var_1) = &input.field_list {
          27  +
        /* JsonSerializerGenerator.kt:484 */
   20     28   
        let mut array_2 = object.key("fieldList").start_array();
          29  +
        /* JsonSerializerGenerator.kt:524 */
   21     30   
        for item_3 in var_1 {
          31  +
            /* SerializerUtil.kt:42 */
   22     32   
            {
          33  +
                /* JsonSerializerGenerator.kt:495 */
   23     34   
                #[allow(unused_mut)]
          35  +
                /* JsonSerializerGenerator.kt:496 */
   24     36   
                let mut object_4 = array_2.value().start_object();
          37  +
                /* JsonSerializerGenerator.kt:375 */
   25     38   
                crate::protocol_serde::shape_validation_exception_field::ser_validation_exception_field(&mut object_4, item_3)?;
          39  +
                /* JsonSerializerGenerator.kt:515 */
   26     40   
                object_4.finish();
          41  +
                /* SerializerUtil.kt:42 */
   27     42   
            }
          43  +
            /* JsonSerializerGenerator.kt:524 */
   28     44   
        }
          45  +
        /* JsonSerializerGenerator.kt:486 */
   29     46   
        array_2.finish();
          47  +
        /* JsonSerializerGenerator.kt:382 */
   30     48   
    }
          49  +
    /* SerializerUtil.kt:42 */
   31     50   
    {
          51  +
        /* JsonSerializerGenerator.kt:423 */
   32     52   
        object.key("message").string(input.message.as_str());
          53  +
        /* SerializerUtil.kt:42 */
   33     54   
    }
          55  +
    /* JsonSerializerGenerator.kt:372 */
   34     56   
    Ok(())
          57  +
    /* JsonSerializerGenerator.kt:358 */
   35     58   
}

tmp-codegen-diff/codegen-server-test/constraints/rust-server-codegen/src/protocol_serde/shape_validation_exception_field.rs

@@ -1,1 +13,22 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* JsonSerializerGenerator.kt:358 */
    2      3   
pub fn ser_validation_exception_field(
    3      4   
    object: &mut ::aws_smithy_json::serialize::JsonObjectWriter,
    4      5   
    input: &crate::model::ValidationExceptionField,
    5      6   
) -> ::std::result::Result<(), ::aws_smithy_types::error::operation::SerializationError> {
           7  +
    /* SerializerUtil.kt:42 */
    6      8   
    {
           9  +
        /* JsonSerializerGenerator.kt:423 */
    7     10   
        object.key("path").string(input.path.as_str());
          11  +
        /* SerializerUtil.kt:42 */
    8     12   
    }
          13  +
    /* SerializerUtil.kt:42 */
    9     14   
    {
          15  +
        /* JsonSerializerGenerator.kt:423 */
   10     16   
        object.key("message").string(input.message.as_str());
          17  +
        /* SerializerUtil.kt:42 */
   11     18   
    }
          19  +
    /* JsonSerializerGenerator.kt:372 */
   12     20   
    Ok(())
          21  +
    /* JsonSerializerGenerator.kt:358 */
   13     22   
}

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

@@ -1,1 +31,32 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* ServerServiceGenerator.kt:795 */
    2      3   
/// The service builder for [`ConstraintsService`].
    3      4   
///
    4      5   
/// Constructed via [`ConstraintsService::builder`].
    5      6   
pub struct ConstraintsServiceBuilder<Body, L, HttpPl, ModelPl> {
    6      7   
    constrained_http_bound_shapes_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
    7      8   
    constrained_http_payload_bound_shape_operation:
    8      9   
        Option<::aws_smithy_http_server::routing::Route<Body>>,
    9     10   
    constrained_recursive_shapes_operation: Option<::aws_smithy_http_server::routing::Route<Body>>,
   10     11   
    constrained_shapes_only_in_output_operation:
   11     12   
        Option<::aws_smithy_http_server::routing::Route<Body>>,
@@ -4219,4220 +4278,4280 @@
 4239   4240   
            "com.amazonaws.constraints",
 4240   4241   
            "ConstraintsService",
 4241   4242   
        );
 4242   4243   
 4243   4244   
    const VERSION: Option<&'static str> = Some("");
 4244   4245   
 4245   4246   
    type Protocol = ::aws_smithy_http_server::protocol::rest_json_1::RestJson1;
 4246   4247   
 4247   4248   
    type Operations = Operation;
 4248   4249   
}
        4250  +
/* ServiceConfigGenerator.kt:178 */
 4249   4251   
/// Configuration for the [`ConstraintsService`]. This is the central place where to register and
 4250   4252   
/// configure [`::tower::Layer`]s, HTTP plugins, and model plugins.
 4251   4253   
///
 4252   4254   
/// ```rust,no_run
 4253   4255   
/// # use constraints::ConstraintsServiceConfig;
 4254   4256   
/// # use ::aws_smithy_http_server::plugin::IdentityPlugin;
 4255   4257   
/// # use ::tower::layer::util::Identity;
 4256   4258   
/// # let authentication_plugin = IdentityPlugin;
 4257   4259   
/// # let authorization_plugin = IdentityPlugin;
 4258   4260   
/// # let server_request_id_provider_layer = Identity::new();
@@ -4340,4342 +4399,4402 @@
 4360   4362   
 4361   4363   
    /// Build the configuration.
 4362   4364   
    pub fn build(self) -> super::ConstraintsServiceConfig<L, H, M> {
 4363   4365   
        super::ConstraintsServiceConfig {
 4364   4366   
            layers: self.layers,
 4365   4367   
            http_plugins: self.http_plugins,
 4366   4368   
            model_plugins: self.model_plugins,
 4367   4369   
        }
 4368   4370   
    }
 4369   4371   
}
        4372  +
/* ScopeMacroGenerator.kt:81 */
 4370   4373   
/// A macro to help with scoping [plugins](crate::server::plugin) to a subset of all operations.
 4371   4374   
///
 4372   4375   
/// In contrast to [`crate::server::scope`](crate::server::scope), this macro has knowledge
 4373   4376   
/// of the service and any operations _not_ specified will be placed in the opposing group.
 4374   4377   
///
 4375   4378   
/// # Example
 4376   4379   
///
 4377   4380   
/// ```rust
 4378   4381   
/// scope! {
 4379   4382   
///     /// Includes [`ConstrainedHttpBoundShapesOperation`], excluding all other operations.

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

@@ -1,1 +0,15 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
           2  +
/* SmithyTypesPubUseExtra.kt:66 */
    2      3   
pub use ::aws_smithy_types::body::SdkBody;
    3      4   
pub use ::aws_smithy_types::byte_stream::error::Error as ByteStreamError;
    4      5   
pub use ::aws_smithy_types::byte_stream::AggregatedBytes;
    5         -
pub use ::aws_smithy_types::byte_stream::ByteStream;
           6  +
/* SmithyTypesPubUseExtra.kt:86 */ pub use ::aws_smithy_types::byte_stream::ByteStream;
    6      7   
#[cfg(feature = "rt-tokio")]
    7      8   
pub use ::aws_smithy_types::byte_stream::FsBuilder;
    8      9   
#[cfg(feature = "rt-tokio")]
    9     10   
pub use ::aws_smithy_types::byte_stream::Length;
   10     11   
pub use ::aws_smithy_types::date_time::Format as DateTimeFormat;
          12  +
/* ServerRequiredCustomizations.kt:69 */
   11     13   
pub use ::aws_smithy_types::error::display::DisplayErrorContext;
   12     14   
pub use ::aws_smithy_types::Blob;
   13         -
pub use ::aws_smithy_types::DateTime;
          15  +
/* SmithyTypesPubUseExtra.kt:69 */ pub use ::aws_smithy_types::DateTime;

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

@@ -1,1 +1823,2264 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
           3  +
/* UnconstrainedUnionGenerator.kt:121 */
    3      4   
impl crate::constrained::Constrained for crate::model::ConstrainedUnion {
    4      5   
    type Unconstrained =
    5      6   
        crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained;
    6      7   
}
    7      8   
    8      9   
impl From<crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained>
    9     10   
    for crate::constrained::MaybeConstrained<crate::model::ConstrainedUnion>
   10     11   
{
   11     12   
    fn from(
   12     13   
        value: crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained,
   13     14   
    ) -> Self {
   14     15   
        Self::Unconstrained(value)
   15     16   
    }
   16     17   
}
   17     18   
   18     19   
pub(crate) mod map_of_enum_string_unconstrained {
   19     20   
          21  +
    /* UnconstrainedMapGenerator.kt:79 */
   20     22   
    #[derive(Debug, Clone)]
   21     23   
    pub(crate) struct MapOfEnumStringUnconstrained(
   22     24   
        pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
   23     25   
    );
   24     26   
   25     27   
    impl From<MapOfEnumStringUnconstrained>
   26     28   
        for crate::constrained::MaybeConstrained<
   27     29   
            crate::constrained::map_of_enum_string_constrained::MapOfEnumStringConstrained,
   28     30   
        >
   29     31   
    {
   30     32   
        fn from(value: MapOfEnumStringUnconstrained) -> Self {
   31     33   
            Self::Unconstrained(value)
   32     34   
        }
   33     35   
    }
          36  +
    /* UnconstrainedMapGenerator.kt:101 */
   34     37   
    impl std::convert::TryFrom<MapOfEnumStringUnconstrained>
   35     38   
        for crate::constrained::map_of_enum_string_constrained::MapOfEnumStringConstrained
   36     39   
    {
          40  +
        /* UnconstrainedMapGenerator.kt:102 */
   37     41   
        type Error = crate::model::map_of_enum_string::ConstraintViolation;
          42  +
        /* UnconstrainedMapGenerator.kt:104 */
   38     43   
        fn try_from(value: MapOfEnumStringUnconstrained) -> std::result::Result<Self, Self::Error> {
          44  +
            /* UnconstrainedMapGenerator.kt:186 */
   39     45   
            let res: ::std::result::Result<
   40     46   
                ::std::collections::HashMap<crate::model::EnumString, crate::model::EnumString>,
   41     47   
                Self::Error,
   42     48   
            > = value
   43     49   
                .0
   44     50   
                .into_iter()
   45     51   
                .map(|(k, v)| {
   46     52   
                    let k: crate::model::EnumString = k.try_into().map_err(Self::Error::Key)?;
   47     53   
   48     54   
                    match crate::model::EnumString::try_from(v) {
   49     55   
                        Ok(v) => Ok((k, v)),
   50     56   
                        Err(inner_constraint_violation) => {
   51     57   
                            Err(Self::Error::Value(k, inner_constraint_violation))
   52     58   
                        }
   53     59   
                    }
   54     60   
                })
   55     61   
                .collect();
   56     62   
            let hm = res?;
          63  +
            /* UnconstrainedMapGenerator.kt:247 */
   57     64   
            Ok(Self(hm))
          65  +
            /* UnconstrainedMapGenerator.kt:104 */
   58     66   
        }
          67  +
        /* UnconstrainedMapGenerator.kt:101 */
   59     68   
    }
          69  +
          70  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
   60     71   
}
   61     72   
pub(crate) mod con_b_map_unconstrained {
   62     73   
          74  +
    /* UnconstrainedMapGenerator.kt:79 */
   63     75   
    #[derive(Debug, Clone)]
   64     76   
    pub(crate) struct ConBMapUnconstrained(
   65     77   
        pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
   66     78   
    );
   67     79   
   68     80   
    impl From<ConBMapUnconstrained> for crate::constrained::MaybeConstrained<crate::model::ConBMap> {
   69     81   
        fn from(value: ConBMapUnconstrained) -> Self {
   70     82   
            Self::Unconstrained(value)
   71     83   
        }
   72     84   
    }
          85  +
    /* UnconstrainedMapGenerator.kt:101 */
   73     86   
    impl std::convert::TryFrom<ConBMapUnconstrained> for crate::model::ConBMap {
          87  +
        /* UnconstrainedMapGenerator.kt:102 */
   74     88   
        type Error = crate::model::con_b_map::ConstraintViolation;
          89  +
        /* UnconstrainedMapGenerator.kt:104 */
   75     90   
        fn try_from(value: ConBMapUnconstrained) -> std::result::Result<Self, Self::Error> {
          91  +
            /* UnconstrainedMapGenerator.kt:186 */
   76     92   
            let res: ::std::result::Result<
   77     93   
                ::std::collections::HashMap<::std::string::String, crate::model::LengthString>,
   78     94   
                Self::Error,
   79     95   
            > = value
   80     96   
                .0
   81     97   
                .into_iter()
   82     98   
                .map(|(k, v)| match crate::model::LengthString::try_from(v) {
   83     99   
                    Ok(v) => Ok((k, v)),
   84    100   
                    Err(inner_constraint_violation) => {
   85    101   
                        Err(Self::Error::Value(k, inner_constraint_violation))
   86    102   
                    }
   87    103   
                })
   88    104   
                .collect();
   89    105   
            let hm = res?;
         106  +
            /* UnconstrainedMapGenerator.kt:245 */
   90    107   
            Self::try_from(hm)
         108  +
            /* UnconstrainedMapGenerator.kt:104 */
   91    109   
        }
         110  +
        /* UnconstrainedMapGenerator.kt:101 */
   92    111   
    }
         112  +
         113  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
   93    114   
}
   94    115   
pub(crate) mod map_of_list_of_length_pattern_string_unconstrained {
   95    116   
         117  +
    /* UnconstrainedMapGenerator.kt:79 */
   96    118   
    #[derive(Debug, Clone)]
   97    119   
    pub(crate) struct MapOfListOfLengthPatternStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::list_of_length_pattern_string_unconstrained::ListOfLengthPatternStringUnconstrained>);
   98    120   
   99    121   
    impl From<MapOfListOfLengthPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_length_pattern_string_constrained::MapOfListOfLengthPatternStringConstrained> {
  100    122   
                        fn from(value: MapOfListOfLengthPatternStringUnconstrained) -> Self {
  101    123   
                            Self::Unconstrained(value)
  102    124   
                        }
  103    125   
                    }
         126  +
    /* UnconstrainedMapGenerator.kt:101 */
  104    127   
    impl std::convert::TryFrom<MapOfListOfLengthPatternStringUnconstrained> for crate::constrained::map_of_list_of_length_pattern_string_constrained::MapOfListOfLengthPatternStringConstrained {
  105         -
        type Error = crate::model::map_of_list_of_length_pattern_string::ConstraintViolation;
  106         -
        fn try_from(value: MapOfListOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
  107         -
            let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthPatternString, crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained>, Self::Error> = value.0
         128  +
        /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_list_of_length_pattern_string::ConstraintViolation;
         129  +
        /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfListOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
         130  +
            /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthPatternString, crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained>, Self::Error> = value.0
  108    131   
                                        .into_iter()
  109    132   
                                        .map(|(k, v)| {
  110    133   
                                            let k: crate::model::LengthPatternString = k.try_into().map_err(Self::Error::Key)?;
  111    134   
            
  112    135   
            match crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained::try_from(v) {
  113    136   
                                                    Ok(v) => Ok((k, v)),
  114    137   
                                                    Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
  115    138   
                                                }
  116    139   
                                        })
  117    140   
                                        .collect();
  118    141   
                                    let hm = res?;
  119         -
            Ok(Self(hm))
  120         -
        }
  121         -
    }
         142  +
            /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
         143  +
        /* UnconstrainedMapGenerator.kt:104 */}
         144  +
    /* UnconstrainedMapGenerator.kt:101 */}
         145  +
         146  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  122    147   
}
  123    148   
pub(crate) mod list_of_length_pattern_string_unconstrained {
  124    149   
         150  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  125    151   
    #[derive(Debug, Clone)]
  126    152   
    pub(crate) struct ListOfLengthPatternStringUnconstrained(
  127    153   
        pub(crate) std::vec::Vec<::std::string::String>,
  128    154   
    );
  129    155   
  130    156   
    impl From<ListOfLengthPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained> {
  131    157   
                        fn from(value: ListOfLengthPatternStringUnconstrained) -> Self {
  132    158   
                            Self::Unconstrained(value)
  133    159   
                        }
  134    160   
                    }
         161  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  135    162   
    impl std::convert::TryFrom<ListOfLengthPatternStringUnconstrained> for crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained {
  136         -
        type Error = crate::model::list_of_length_pattern_string::ConstraintViolation;
  137         -
        fn try_from(value: ListOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
  138         -
            let res: ::std::result::Result<::std::vec::Vec<crate::model::LengthPatternString>, (usize, crate::model::length_pattern_string::ConstraintViolation) > = value
         163  +
        /* UnconstrainedCollectionGenerator.kt:98 */type Error = crate::model::list_of_length_pattern_string::ConstraintViolation;
         164  +
        /* UnconstrainedCollectionGenerator.kt:100 */fn try_from(value: ListOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
         165  +
            /* UnconstrainedCollectionGenerator.kt:127 */let res: ::std::result::Result<::std::vec::Vec<crate::model::LengthPatternString>, (usize, crate::model::length_pattern_string::ConstraintViolation) > = value
  139    166   
                                        .0
  140    167   
                                        .into_iter()
  141    168   
                                        .enumerate()
  142    169   
                                        .map(|(idx, inner)| {
  143    170   
                                            inner.try_into().map_err(|inner_violation| (idx, inner_violation))
  144    171   
                                        })
  145    172   
                                        .collect();
  146    173   
                                    let inner = res
  147    174   
                                        
  148    175   
                                        .map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
  149         -
            Ok(Self(inner))
  150         -
        }
  151         -
    }
         176  +
            /* UnconstrainedCollectionGenerator.kt:191 */Ok(Self(inner))
         177  +
        /* UnconstrainedCollectionGenerator.kt:100 */}
         178  +
    /* UnconstrainedCollectionGenerator.kt:97 */}
         179  +
         180  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  152    181   
}
  153    182   
pub(crate) mod map_of_length_pattern_string_unconstrained {
  154    183   
         184  +
    /* UnconstrainedMapGenerator.kt:79 */
  155    185   
    #[derive(Debug, Clone)]
  156    186   
    pub(crate) struct MapOfLengthPatternStringUnconstrained(
  157    187   
        pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
  158    188   
    );
  159    189   
  160    190   
    impl From<MapOfLengthPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_length_pattern_string_constrained::MapOfLengthPatternStringConstrained> {
  161    191   
                        fn from(value: MapOfLengthPatternStringUnconstrained) -> Self {
  162    192   
                            Self::Unconstrained(value)
  163    193   
                        }
  164    194   
                    }
         195  +
    /* UnconstrainedMapGenerator.kt:101 */
  165    196   
    impl std::convert::TryFrom<MapOfLengthPatternStringUnconstrained> for crate::constrained::map_of_length_pattern_string_constrained::MapOfLengthPatternStringConstrained {
  166         -
        type Error = crate::model::map_of_length_pattern_string::ConstraintViolation;
  167         -
        fn try_from(value: MapOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
  168         -
            let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthPatternString, crate::model::LengthPatternString>, Self::Error> = value.0
         197  +
        /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_length_pattern_string::ConstraintViolation;
         198  +
        /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfLengthPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
         199  +
            /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthPatternString, crate::model::LengthPatternString>, Self::Error> = value.0
  169    200   
                                        .into_iter()
  170    201   
                                        .map(|(k, v)| {
  171    202   
                                            let k: crate::model::LengthPatternString = k.try_into().map_err(Self::Error::Key)?;
  172    203   
            
  173    204   
            match crate::model::LengthPatternString::try_from(v) {
  174    205   
                                                    Ok(v) => Ok((k, v)),
  175    206   
                                                    Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
  176    207   
                                                }
  177    208   
                                        })
  178    209   
                                        .collect();
  179    210   
                                    let hm = res?;
  180         -
            Ok(Self(hm))
  181         -
        }
  182         -
    }
         211  +
            /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
         212  +
        /* UnconstrainedMapGenerator.kt:104 */}
         213  +
    /* UnconstrainedMapGenerator.kt:101 */}
         214  +
         215  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  183    216   
}
  184    217   
pub(crate) mod map_of_list_of_pattern_string_unconstrained {
  185    218   
         219  +
    /* UnconstrainedMapGenerator.kt:79 */
  186    220   
    #[derive(Debug, Clone)]
  187    221   
    pub(crate) struct MapOfListOfPatternStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::list_of_pattern_string_unconstrained::ListOfPatternStringUnconstrained>);
  188    222   
  189    223   
    impl From<MapOfListOfPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_pattern_string_constrained::MapOfListOfPatternStringConstrained> {
  190    224   
                        fn from(value: MapOfListOfPatternStringUnconstrained) -> Self {
  191    225   
                            Self::Unconstrained(value)
  192    226   
                        }
  193    227   
                    }
         228  +
    /* UnconstrainedMapGenerator.kt:101 */
  194    229   
    impl std::convert::TryFrom<MapOfListOfPatternStringUnconstrained> for crate::constrained::map_of_list_of_pattern_string_constrained::MapOfListOfPatternStringConstrained {
  195         -
        type Error = crate::model::map_of_list_of_pattern_string::ConstraintViolation;
  196         -
        fn try_from(value: MapOfListOfPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
  197         -
            let res: ::std::result::Result<::std::collections::HashMap<crate::model::PatternString, crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained>, Self::Error> = value.0
         230  +
        /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_list_of_pattern_string::ConstraintViolation;
         231  +
        /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfListOfPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
         232  +
            /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<crate::model::PatternString, crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained>, Self::Error> = value.0
  198    233   
                                        .into_iter()
  199    234   
                                        .map(|(k, v)| {
  200    235   
                                            let k: crate::model::PatternString = k.try_into().map_err(Self::Error::Key)?;
  201    236   
            
  202    237   
            match crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained::try_from(v) {
  203    238   
                                                    Ok(v) => Ok((k, v)),
  204    239   
                                                    Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
  205    240   
                                                }
  206    241   
                                        })
  207    242   
                                        .collect();
  208    243   
                                    let hm = res?;
  209         -
            Ok(Self(hm))
  210         -
        }
  211         -
    }
         244  +
            /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
         245  +
        /* UnconstrainedMapGenerator.kt:104 */}
         246  +
    /* UnconstrainedMapGenerator.kt:101 */}
         247  +
         248  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  212    249   
}
  213    250   
pub(crate) mod list_of_pattern_string_unconstrained {
  214    251   
         252  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  215    253   
    #[derive(Debug, Clone)]
  216    254   
    pub(crate) struct ListOfPatternStringUnconstrained(
  217    255   
        pub(crate) std::vec::Vec<::std::string::String>,
  218    256   
    );
  219    257   
  220    258   
    impl From<ListOfPatternStringUnconstrained>
  221    259   
        for crate::constrained::MaybeConstrained<
  222    260   
            crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained,
  223    261   
        >
  224    262   
    {
  225    263   
        fn from(value: ListOfPatternStringUnconstrained) -> Self {
  226    264   
            Self::Unconstrained(value)
  227    265   
        }
  228    266   
    }
         267  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  229    268   
    impl std::convert::TryFrom<ListOfPatternStringUnconstrained>
  230    269   
        for crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained
  231    270   
    {
         271  +
        /* UnconstrainedCollectionGenerator.kt:98 */
  232    272   
        type Error = crate::model::list_of_pattern_string::ConstraintViolation;
         273  +
        /* UnconstrainedCollectionGenerator.kt:100 */
  233    274   
        fn try_from(
  234    275   
            value: ListOfPatternStringUnconstrained,
  235    276   
        ) -> std::result::Result<Self, Self::Error> {
         277  +
            /* UnconstrainedCollectionGenerator.kt:127 */
  236    278   
            let res: ::std::result::Result<
  237    279   
                ::std::vec::Vec<crate::model::PatternString>,
  238    280   
                (usize, crate::model::pattern_string::ConstraintViolation),
  239    281   
            > = value
  240    282   
                .0
  241    283   
                .into_iter()
  242    284   
                .enumerate()
  243    285   
                .map(|(idx, inner)| {
  244    286   
                    inner
  245    287   
                        .try_into()
  246    288   
                        .map_err(|inner_violation| (idx, inner_violation))
  247    289   
                })
  248    290   
                .collect();
  249    291   
            let inner =
  250    292   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
         293  +
            /* UnconstrainedCollectionGenerator.kt:191 */
  251    294   
            Ok(Self(inner))
         295  +
            /* UnconstrainedCollectionGenerator.kt:100 */
  252    296   
        }
         297  +
        /* UnconstrainedCollectionGenerator.kt:97 */
  253    298   
    }
         299  +
         300  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  254    301   
}
  255    302   
pub(crate) mod map_of_pattern_string_unconstrained {
  256    303   
         304  +
    /* UnconstrainedMapGenerator.kt:79 */
  257    305   
    #[derive(Debug, Clone)]
  258    306   
    pub(crate) struct MapOfPatternStringUnconstrained(
  259    307   
        pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
  260    308   
    );
  261    309   
  262    310   
    impl From<MapOfPatternStringUnconstrained>
  263    311   
        for crate::constrained::MaybeConstrained<
  264    312   
            crate::constrained::map_of_pattern_string_constrained::MapOfPatternStringConstrained,
  265    313   
        >
  266    314   
    {
  267    315   
        fn from(value: MapOfPatternStringUnconstrained) -> Self {
  268    316   
            Self::Unconstrained(value)
  269    317   
        }
  270    318   
    }
         319  +
    /* UnconstrainedMapGenerator.kt:101 */
  271    320   
    impl std::convert::TryFrom<MapOfPatternStringUnconstrained>
  272    321   
        for crate::constrained::map_of_pattern_string_constrained::MapOfPatternStringConstrained
  273    322   
    {
         323  +
        /* UnconstrainedMapGenerator.kt:102 */
  274    324   
        type Error = crate::model::map_of_pattern_string::ConstraintViolation;
         325  +
        /* UnconstrainedMapGenerator.kt:104 */
  275    326   
        fn try_from(
  276    327   
            value: MapOfPatternStringUnconstrained,
  277    328   
        ) -> std::result::Result<Self, Self::Error> {
         329  +
            /* UnconstrainedMapGenerator.kt:186 */
  278    330   
            let res: ::std::result::Result<
  279    331   
                ::std::collections::HashMap<
  280    332   
                    crate::model::PatternString,
  281    333   
                    crate::model::PatternString,
  282    334   
                >,
  283    335   
                Self::Error,
  284    336   
            > = value
  285    337   
                .0
  286    338   
                .into_iter()
  287    339   
                .map(|(k, v)| {
  288    340   
                    let k: crate::model::PatternString = k.try_into().map_err(Self::Error::Key)?;
  289    341   
  290    342   
                    match crate::model::PatternString::try_from(v) {
  291    343   
                        Ok(v) => Ok((k, v)),
  292    344   
                        Err(inner_constraint_violation) => {
  293    345   
                            Err(Self::Error::Value(k, inner_constraint_violation))
  294    346   
                        }
  295    347   
                    }
  296    348   
                })
  297    349   
                .collect();
  298    350   
            let hm = res?;
         351  +
            /* UnconstrainedMapGenerator.kt:247 */
  299    352   
            Ok(Self(hm))
         353  +
            /* UnconstrainedMapGenerator.kt:104 */
  300    354   
        }
         355  +
        /* UnconstrainedMapGenerator.kt:101 */
  301    356   
    }
         357  +
         358  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  302    359   
}
  303    360   
pub(crate) mod map_of_list_of_enum_string_unconstrained {
  304    361   
         362  +
    /* UnconstrainedMapGenerator.kt:79 */
  305    363   
    #[derive(Debug, Clone)]
  306    364   
    pub(crate) struct MapOfListOfEnumStringUnconstrained(
  307    365   
        pub(crate)  std::collections::HashMap<
  308    366   
            ::std::string::String,
  309    367   
            crate::unconstrained::list_of_enum_string_unconstrained::ListOfEnumStringUnconstrained,
  310    368   
        >,
  311    369   
    );
  312    370   
  313    371   
    impl From<MapOfListOfEnumStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_enum_string_constrained::MapOfListOfEnumStringConstrained> {
  314    372   
                        fn from(value: MapOfListOfEnumStringUnconstrained) -> Self {
  315    373   
                            Self::Unconstrained(value)
  316    374   
                        }
  317    375   
                    }
         376  +
    /* UnconstrainedMapGenerator.kt:101 */
  318    377   
    impl std::convert::TryFrom<MapOfListOfEnumStringUnconstrained> for crate::constrained::map_of_list_of_enum_string_constrained::MapOfListOfEnumStringConstrained {
  319         -
        type Error = crate::model::map_of_list_of_enum_string::ConstraintViolation;
  320         -
        fn try_from(value: MapOfListOfEnumStringUnconstrained) -> std::result::Result<Self, Self::Error> {
  321         -
            let res: ::std::result::Result<::std::collections::HashMap<crate::model::EnumString, crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained>, Self::Error> = value.0
         378  +
        /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_list_of_enum_string::ConstraintViolation;
         379  +
        /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfListOfEnumStringUnconstrained) -> std::result::Result<Self, Self::Error> {
         380  +
            /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<crate::model::EnumString, crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained>, Self::Error> = value.0
  322    381   
                                        .into_iter()
  323    382   
                                        .map(|(k, v)| {
  324    383   
                                            let k: crate::model::EnumString = k.try_into().map_err(Self::Error::Key)?;
  325    384   
            
  326    385   
            match crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained::try_from(v) {
  327    386   
                                                    Ok(v) => Ok((k, v)),
  328    387   
                                                    Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
  329    388   
                                                }
  330    389   
                                        })
  331    390   
                                        .collect();
  332    391   
                                    let hm = res?;
  333         -
            Ok(Self(hm))
  334         -
        }
  335         -
    }
         392  +
            /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
         393  +
        /* UnconstrainedMapGenerator.kt:104 */}
         394  +
    /* UnconstrainedMapGenerator.kt:101 */}
         395  +
         396  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  336    397   
}
  337    398   
pub(crate) mod list_of_enum_string_unconstrained {
  338    399   
         400  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  339    401   
    #[derive(Debug, Clone)]
  340    402   
    pub(crate) struct ListOfEnumStringUnconstrained(
  341    403   
        pub(crate) std::vec::Vec<::std::string::String>,
  342    404   
    );
  343    405   
  344    406   
    impl From<ListOfEnumStringUnconstrained>
  345    407   
        for crate::constrained::MaybeConstrained<
  346    408   
            crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained,
  347    409   
        >
  348    410   
    {
  349    411   
        fn from(value: ListOfEnumStringUnconstrained) -> Self {
  350    412   
            Self::Unconstrained(value)
  351    413   
        }
  352    414   
    }
         415  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  353    416   
    impl std::convert::TryFrom<ListOfEnumStringUnconstrained>
  354    417   
        for crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained
  355    418   
    {
         419  +
        /* UnconstrainedCollectionGenerator.kt:98 */
  356    420   
        type Error = crate::model::list_of_enum_string::ConstraintViolation;
         421  +
        /* UnconstrainedCollectionGenerator.kt:100 */
  357    422   
        fn try_from(
  358    423   
            value: ListOfEnumStringUnconstrained,
  359    424   
        ) -> std::result::Result<Self, Self::Error> {
         425  +
            /* UnconstrainedCollectionGenerator.kt:127 */
  360    426   
            let res: ::std::result::Result<
  361    427   
                ::std::vec::Vec<crate::model::EnumString>,
  362    428   
                (usize, crate::model::enum_string::ConstraintViolation),
  363    429   
            > = value
  364    430   
                .0
  365    431   
                .into_iter()
  366    432   
                .enumerate()
  367    433   
                .map(|(idx, inner)| {
  368    434   
                    inner
  369    435   
                        .try_into()
  370    436   
                        .map_err(|inner_violation| (idx, inner_violation))
  371    437   
                })
  372    438   
                .collect();
  373    439   
            let inner =
  374    440   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
         441  +
            /* UnconstrainedCollectionGenerator.kt:191 */
  375    442   
            Ok(Self(inner))
         443  +
            /* UnconstrainedCollectionGenerator.kt:100 */
  376    444   
        }
         445  +
        /* UnconstrainedCollectionGenerator.kt:97 */
  377    446   
    }
         447  +
         448  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  378    449   
}
  379    450   
pub(crate) mod map_of_length_list_of_pattern_string_unconstrained {
  380    451   
         452  +
    /* UnconstrainedMapGenerator.kt:79 */
  381    453   
    #[derive(Debug, Clone)]
  382    454   
    pub(crate) struct MapOfLengthListOfPatternStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::length_list_of_pattern_string_unconstrained::LengthListOfPatternStringUnconstrained>);
  383    455   
  384    456   
    impl From<MapOfLengthListOfPatternStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_length_list_of_pattern_string_constrained::MapOfLengthListOfPatternStringConstrained> {
  385    457   
                        fn from(value: MapOfLengthListOfPatternStringUnconstrained) -> Self {
  386    458   
                            Self::Unconstrained(value)
  387    459   
                        }
  388    460   
                    }
         461  +
    /* UnconstrainedMapGenerator.kt:101 */
  389    462   
    impl std::convert::TryFrom<MapOfLengthListOfPatternStringUnconstrained> for crate::constrained::map_of_length_list_of_pattern_string_constrained::MapOfLengthListOfPatternStringConstrained {
  390         -
        type Error = crate::model::map_of_length_list_of_pattern_string::ConstraintViolation;
  391         -
        fn try_from(value: MapOfLengthListOfPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
  392         -
            let res: ::std::result::Result<::std::collections::HashMap<crate::model::PatternString, crate::model::LengthListOfPatternString>, Self::Error> = value.0
         463  +
        /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_length_list_of_pattern_string::ConstraintViolation;
         464  +
        /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfLengthListOfPatternStringUnconstrained) -> std::result::Result<Self, Self::Error> {
         465  +
            /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<crate::model::PatternString, crate::model::LengthListOfPatternString>, Self::Error> = value.0
  393    466   
                                        .into_iter()
  394    467   
                                        .map(|(k, v)| {
  395    468   
                                            let k: crate::model::PatternString = k.try_into().map_err(Self::Error::Key)?;
  396    469   
            
  397    470   
            match crate::model::LengthListOfPatternString::try_from(v) {
  398    471   
                                                    Ok(v) => Ok((k, v)),
  399    472   
                                                    Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
  400    473   
                                                }
  401    474   
                                        })
  402    475   
                                        .collect();
  403    476   
                                    let hm = res?;
  404         -
            Ok(Self(hm))
  405         -
        }
  406         -
    }
         477  +
            /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
         478  +
        /* UnconstrainedMapGenerator.kt:104 */}
         479  +
    /* UnconstrainedMapGenerator.kt:101 */}
         480  +
         481  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  407    482   
}
  408    483   
pub(crate) mod length_list_of_pattern_string_unconstrained {
  409    484   
         485  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  410    486   
    #[derive(Debug, Clone)]
  411    487   
    pub(crate) struct LengthListOfPatternStringUnconstrained(
  412    488   
        pub(crate) std::vec::Vec<::std::string::String>,
  413    489   
    );
  414    490   
  415    491   
    impl From<LengthListOfPatternStringUnconstrained>
  416    492   
        for crate::constrained::MaybeConstrained<crate::model::LengthListOfPatternString>
  417    493   
    {
  418    494   
        fn from(value: LengthListOfPatternStringUnconstrained) -> Self {
  419    495   
            Self::Unconstrained(value)
  420    496   
        }
  421    497   
    }
         498  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  422    499   
    impl std::convert::TryFrom<LengthListOfPatternStringUnconstrained>
  423    500   
        for crate::model::LengthListOfPatternString
  424    501   
    {
         502  +
        /* UnconstrainedCollectionGenerator.kt:98 */
  425    503   
        type Error = crate::model::length_list_of_pattern_string::ConstraintViolation;
         504  +
        /* UnconstrainedCollectionGenerator.kt:100 */
  426    505   
        fn try_from(
  427    506   
            value: LengthListOfPatternStringUnconstrained,
  428    507   
        ) -> std::result::Result<Self, Self::Error> {
         508  +
            /* UnconstrainedCollectionGenerator.kt:127 */
  429    509   
            let res: ::std::result::Result<
  430    510   
                ::std::vec::Vec<crate::model::PatternString>,
  431    511   
                (usize, crate::model::pattern_string::ConstraintViolation),
  432    512   
            > = value
  433    513   
                .0
  434    514   
                .into_iter()
  435    515   
                .enumerate()
  436    516   
                .map(|(idx, inner)| {
  437    517   
                    inner
  438    518   
                        .try_into()
  439    519   
                        .map_err(|inner_violation| (idx, inner_violation))
  440    520   
                })
  441    521   
                .collect();
  442    522   
            let inner =
  443    523   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
         524  +
            /* UnconstrainedCollectionGenerator.kt:189 */
  444    525   
            Self::try_from(inner)
         526  +
            /* UnconstrainedCollectionGenerator.kt:100 */
  445    527   
        }
         528  +
        /* UnconstrainedCollectionGenerator.kt:97 */
  446    529   
    }
         530  +
         531  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  447    532   
}
  448    533   
pub(crate) mod map_of_set_of_length_string_unconstrained {
  449    534   
         535  +
    /* UnconstrainedMapGenerator.kt:79 */
  450    536   
    #[derive(Debug, Clone)]
  451    537   
    pub(crate) struct MapOfSetOfLengthStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::set_of_length_string_unconstrained::SetOfLengthStringUnconstrained>);
  452    538   
  453    539   
    impl From<MapOfSetOfLengthStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_set_of_length_string_constrained::MapOfSetOfLengthStringConstrained> {
  454    540   
                        fn from(value: MapOfSetOfLengthStringUnconstrained) -> Self {
  455    541   
                            Self::Unconstrained(value)
  456    542   
                        }
  457    543   
                    }
         544  +
    /* UnconstrainedMapGenerator.kt:101 */
  458    545   
    impl std::convert::TryFrom<MapOfSetOfLengthStringUnconstrained> for crate::constrained::map_of_set_of_length_string_constrained::MapOfSetOfLengthStringConstrained {
  459         -
        type Error = crate::model::map_of_set_of_length_string::ConstraintViolation;
  460         -
        fn try_from(value: MapOfSetOfLengthStringUnconstrained) -> std::result::Result<Self, Self::Error> {
  461         -
            let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthString, crate::model::SetOfLengthString>, Self::Error> = value.0
         546  +
        /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_set_of_length_string::ConstraintViolation;
         547  +
        /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfSetOfLengthStringUnconstrained) -> std::result::Result<Self, Self::Error> {
         548  +
            /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthString, crate::model::SetOfLengthString>, Self::Error> = value.0
  462    549   
                                        .into_iter()
  463    550   
                                        .map(|(k, v)| {
  464    551   
                                            let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
  465    552   
            
  466    553   
            match crate::model::SetOfLengthString::try_from(v) {
  467    554   
                                                    Ok(v) => Ok((k, v)),
  468    555   
                                                    Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
  469    556   
                                                }
  470    557   
                                        })
  471    558   
                                        .collect();
  472    559   
                                    let hm = res?;
  473         -
            Ok(Self(hm))
  474         -
        }
  475         -
    }
         560  +
            /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
         561  +
        /* UnconstrainedMapGenerator.kt:104 */}
         562  +
    /* UnconstrainedMapGenerator.kt:101 */}
         563  +
         564  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  476    565   
}
  477    566   
pub(crate) mod set_of_length_string_unconstrained {
  478    567   
         568  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  479    569   
    #[derive(Debug, Clone)]
  480    570   
    pub(crate) struct SetOfLengthStringUnconstrained(
  481    571   
        pub(crate) std::vec::Vec<::std::string::String>,
  482    572   
    );
  483    573   
  484    574   
    impl From<SetOfLengthStringUnconstrained>
  485    575   
        for crate::constrained::MaybeConstrained<crate::model::SetOfLengthString>
  486    576   
    {
  487    577   
        fn from(value: SetOfLengthStringUnconstrained) -> Self {
  488    578   
            Self::Unconstrained(value)
  489    579   
        }
  490    580   
    }
         581  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  491    582   
    impl std::convert::TryFrom<SetOfLengthStringUnconstrained> for crate::model::SetOfLengthString {
         583  +
        /* UnconstrainedCollectionGenerator.kt:98 */
  492    584   
        type Error = crate::model::set_of_length_string::ConstraintViolation;
         585  +
        /* UnconstrainedCollectionGenerator.kt:100 */
  493    586   
        fn try_from(
  494    587   
            value: SetOfLengthStringUnconstrained,
  495    588   
        ) -> std::result::Result<Self, Self::Error> {
         589  +
            /* UnconstrainedCollectionGenerator.kt:127 */
  496    590   
            let res: ::std::result::Result<
  497    591   
                ::std::vec::Vec<crate::model::LengthString>,
  498    592   
                (usize, crate::model::length_string::ConstraintViolation),
  499    593   
            > = value
  500    594   
                .0
  501    595   
                .into_iter()
  502    596   
                .enumerate()
  503    597   
                .map(|(idx, inner)| {
  504    598   
                    inner
  505    599   
                        .try_into()
  506    600   
                        .map_err(|inner_violation| (idx, inner_violation))
  507    601   
                })
  508    602   
                .collect();
  509    603   
            let inner =
  510    604   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
         605  +
            /* UnconstrainedCollectionGenerator.kt:189 */
  511    606   
            Self::try_from(inner)
         607  +
            /* UnconstrainedCollectionGenerator.kt:100 */
  512    608   
        }
         609  +
        /* UnconstrainedCollectionGenerator.kt:97 */
  513    610   
    }
         611  +
         612  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  514    613   
}
  515    614   
pub(crate) mod map_of_list_of_length_string_unconstrained {
  516    615   
         616  +
    /* UnconstrainedMapGenerator.kt:79 */
  517    617   
    #[derive(Debug, Clone)]
  518    618   
    pub(crate) struct MapOfListOfLengthStringUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::list_of_length_string_unconstrained::ListOfLengthStringUnconstrained>);
  519    619   
  520    620   
    impl From<MapOfListOfLengthStringUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_length_string_constrained::MapOfListOfLengthStringConstrained> {
  521    621   
                        fn from(value: MapOfListOfLengthStringUnconstrained) -> Self {
  522    622   
                            Self::Unconstrained(value)
  523    623   
                        }
  524    624   
                    }
         625  +
    /* UnconstrainedMapGenerator.kt:101 */
  525    626   
    impl std::convert::TryFrom<MapOfListOfLengthStringUnconstrained> for crate::constrained::map_of_list_of_length_string_constrained::MapOfListOfLengthStringConstrained {
  526         -
        type Error = crate::model::map_of_list_of_length_string::ConstraintViolation;
  527         -
        fn try_from(value: MapOfListOfLengthStringUnconstrained) -> std::result::Result<Self, Self::Error> {
  528         -
            let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthString, crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained>, Self::Error> = value.0
         627  +
        /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_list_of_length_string::ConstraintViolation;
         628  +
        /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfListOfLengthStringUnconstrained) -> std::result::Result<Self, Self::Error> {
         629  +
            /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<crate::model::LengthString, crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained>, Self::Error> = value.0
  529    630   
                                        .into_iter()
  530    631   
                                        .map(|(k, v)| {
  531    632   
                                            let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
  532    633   
            
  533    634   
            match crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained::try_from(v) {
  534    635   
                                                    Ok(v) => Ok((k, v)),
  535    636   
                                                    Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
  536    637   
                                                }
  537    638   
                                        })
  538    639   
                                        .collect();
  539    640   
                                    let hm = res?;
  540         -
            Ok(Self(hm))
  541         -
        }
  542         -
    }
         641  +
            /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
         642  +
        /* UnconstrainedMapGenerator.kt:104 */}
         643  +
    /* UnconstrainedMapGenerator.kt:101 */}
         644  +
         645  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  543    646   
}
  544    647   
pub(crate) mod list_of_length_string_unconstrained {
  545    648   
         649  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  546    650   
    #[derive(Debug, Clone)]
  547    651   
    pub(crate) struct ListOfLengthStringUnconstrained(
  548    652   
        pub(crate) std::vec::Vec<::std::string::String>,
  549    653   
    );
  550    654   
  551    655   
    impl From<ListOfLengthStringUnconstrained>
  552    656   
        for crate::constrained::MaybeConstrained<
  553    657   
            crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained,
  554    658   
        >
  555    659   
    {
  556    660   
        fn from(value: ListOfLengthStringUnconstrained) -> Self {
  557    661   
            Self::Unconstrained(value)
  558    662   
        }
  559    663   
    }
         664  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  560    665   
    impl std::convert::TryFrom<ListOfLengthStringUnconstrained>
  561    666   
        for crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained
  562    667   
    {
         668  +
        /* UnconstrainedCollectionGenerator.kt:98 */
  563    669   
        type Error = crate::model::list_of_length_string::ConstraintViolation;
         670  +
        /* UnconstrainedCollectionGenerator.kt:100 */
  564    671   
        fn try_from(
  565    672   
            value: ListOfLengthStringUnconstrained,
  566    673   
        ) -> std::result::Result<Self, Self::Error> {
         674  +
            /* UnconstrainedCollectionGenerator.kt:127 */
  567    675   
            let res: ::std::result::Result<
  568    676   
                ::std::vec::Vec<crate::model::LengthString>,
  569    677   
                (usize, crate::model::length_string::ConstraintViolation),
  570    678   
            > = value
  571    679   
                .0
  572    680   
                .into_iter()
  573    681   
                .enumerate()
  574    682   
                .map(|(idx, inner)| {
  575    683   
                    inner
  576    684   
                        .try_into()
  577    685   
                        .map_err(|inner_violation| (idx, inner_violation))
  578    686   
                })
  579    687   
                .collect();
  580    688   
            let inner =
  581    689   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
         690  +
            /* UnconstrainedCollectionGenerator.kt:191 */
  582    691   
            Ok(Self(inner))
         692  +
            /* UnconstrainedCollectionGenerator.kt:100 */
  583    693   
        }
         694  +
        /* UnconstrainedCollectionGenerator.kt:97 */
  584    695   
    }
         696  +
         697  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  585    698   
}
  586    699   
pub(crate) mod map_of_length_string_unconstrained {
  587    700   
         701  +
    /* UnconstrainedMapGenerator.kt:79 */
  588    702   
    #[derive(Debug, Clone)]
  589    703   
    pub(crate) struct MapOfLengthStringUnconstrained(
  590    704   
        pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
  591    705   
    );
  592    706   
  593    707   
    impl From<MapOfLengthStringUnconstrained>
  594    708   
        for crate::constrained::MaybeConstrained<
  595    709   
            crate::constrained::map_of_length_string_constrained::MapOfLengthStringConstrained,
  596    710   
        >
  597    711   
    {
  598    712   
        fn from(value: MapOfLengthStringUnconstrained) -> Self {
  599    713   
            Self::Unconstrained(value)
  600    714   
        }
  601    715   
    }
         716  +
    /* UnconstrainedMapGenerator.kt:101 */
  602    717   
    impl std::convert::TryFrom<MapOfLengthStringUnconstrained>
  603    718   
        for crate::constrained::map_of_length_string_constrained::MapOfLengthStringConstrained
  604    719   
    {
         720  +
        /* UnconstrainedMapGenerator.kt:102 */
  605    721   
        type Error = crate::model::map_of_length_string::ConstraintViolation;
         722  +
        /* UnconstrainedMapGenerator.kt:104 */
  606    723   
        fn try_from(
  607    724   
            value: MapOfLengthStringUnconstrained,
  608    725   
        ) -> std::result::Result<Self, Self::Error> {
         726  +
            /* UnconstrainedMapGenerator.kt:186 */
  609    727   
            let res: ::std::result::Result<
  610    728   
                ::std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
  611    729   
                Self::Error,
  612    730   
            > = value
  613    731   
                .0
  614    732   
                .into_iter()
  615    733   
                .map(|(k, v)| {
  616    734   
                    let k: crate::model::LengthString = k.try_into().map_err(Self::Error::Key)?;
  617    735   
  618    736   
                    match crate::model::LengthString::try_from(v) {
  619    737   
                        Ok(v) => Ok((k, v)),
  620    738   
                        Err(inner_constraint_violation) => {
  621    739   
                            Err(Self::Error::Value(k, inner_constraint_violation))
  622    740   
                        }
  623    741   
                    }
  624    742   
                })
  625    743   
                .collect();
  626    744   
            let hm = res?;
         745  +
            /* UnconstrainedMapGenerator.kt:247 */
  627    746   
            Ok(Self(hm))
         747  +
            /* UnconstrainedMapGenerator.kt:104 */
  628    748   
        }
         749  +
        /* UnconstrainedMapGenerator.kt:101 */
  629    750   
    }
         751  +
         752  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  630    753   
}
  631    754   
pub(crate) mod recursive_list_unconstrained {
  632    755   
         756  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  633    757   
    #[derive(Debug, Clone)]
  634    758   
    pub(crate) struct RecursiveListUnconstrained(
  635    759   
        pub(crate) std::vec::Vec<crate::model::recursive_shapes_input_output_nested1::Builder>,
  636    760   
    );
  637    761   
  638    762   
    impl From<RecursiveListUnconstrained>
  639    763   
        for crate::constrained::MaybeConstrained<
  640    764   
            crate::constrained::recursive_list_constrained::RecursiveListConstrained,
  641    765   
        >
  642    766   
    {
  643    767   
        fn from(value: RecursiveListUnconstrained) -> Self {
  644    768   
            Self::Unconstrained(value)
  645    769   
        }
  646    770   
    }
         771  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  647    772   
    impl std::convert::TryFrom<RecursiveListUnconstrained>
  648    773   
        for crate::constrained::recursive_list_constrained::RecursiveListConstrained
  649    774   
    {
         775  +
        /* UnconstrainedCollectionGenerator.kt:98 */
  650    776   
        type Error = crate::model::recursive_list::ConstraintViolation;
         777  +
        /* UnconstrainedCollectionGenerator.kt:100 */
  651    778   
        fn try_from(value: RecursiveListUnconstrained) -> std::result::Result<Self, Self::Error> {
         779  +
            /* UnconstrainedCollectionGenerator.kt:127 */
  652    780   
            let res: ::std::result::Result<
  653    781   
                ::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>,
  654    782   
                (
  655    783   
                    usize,
  656    784   
                    crate::model::recursive_shapes_input_output_nested1::ConstraintViolation,
  657    785   
                ),
  658    786   
            > = value
  659    787   
                .0
  660    788   
                .into_iter()
  661    789   
                .enumerate()
  662    790   
                .map(|(idx, inner)| {
  663    791   
                    inner
  664    792   
                        .try_into()
  665    793   
                        .map_err(|inner_violation| (idx, inner_violation))
  666    794   
                })
  667    795   
                .collect();
  668    796   
            let inner =
  669    797   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
         798  +
            /* UnconstrainedCollectionGenerator.kt:191 */
  670    799   
            Ok(Self(inner))
         800  +
            /* UnconstrainedCollectionGenerator.kt:100 */
  671    801   
        }
         802  +
        /* UnconstrainedCollectionGenerator.kt:97 */
  672    803   
    }
         804  +
         805  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  673    806   
}
  674    807   
pub(crate) mod length_set_of_pattern_string_unconstrained {
  675    808   
         809  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  676    810   
    #[derive(Debug, Clone)]
  677    811   
    pub(crate) struct LengthSetOfPatternStringUnconstrained(
  678    812   
        pub(crate) std::vec::Vec<::std::string::String>,
  679    813   
    );
  680    814   
  681    815   
    impl From<LengthSetOfPatternStringUnconstrained>
  682    816   
        for crate::constrained::MaybeConstrained<crate::model::LengthSetOfPatternString>
  683    817   
    {
  684    818   
        fn from(value: LengthSetOfPatternStringUnconstrained) -> Self {
  685    819   
            Self::Unconstrained(value)
  686    820   
        }
  687    821   
    }
         822  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  688    823   
    impl std::convert::TryFrom<LengthSetOfPatternStringUnconstrained>
  689    824   
        for crate::model::LengthSetOfPatternString
  690    825   
    {
         826  +
        /* UnconstrainedCollectionGenerator.kt:98 */
  691    827   
        type Error = crate::model::length_set_of_pattern_string::ConstraintViolation;
         828  +
        /* UnconstrainedCollectionGenerator.kt:100 */
  692    829   
        fn try_from(
  693    830   
            value: LengthSetOfPatternStringUnconstrained,
  694    831   
        ) -> std::result::Result<Self, Self::Error> {
         832  +
            /* UnconstrainedCollectionGenerator.kt:127 */
  695    833   
            let res: ::std::result::Result<
  696    834   
                ::std::vec::Vec<crate::model::PatternString>,
  697    835   
                (usize, crate::model::pattern_string::ConstraintViolation),
  698    836   
            > = value
  699    837   
                .0
  700    838   
                .into_iter()
  701    839   
                .enumerate()
  702    840   
                .map(|(idx, inner)| {
  703    841   
                    inner
  704    842   
                        .try_into()
  705    843   
                        .map_err(|inner_violation| (idx, inner_violation))
  706    844   
                })
  707    845   
                .collect();
  708    846   
            let inner =
  709    847   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
         848  +
            /* UnconstrainedCollectionGenerator.kt:189 */
  710    849   
            Self::try_from(inner)
         850  +
            /* UnconstrainedCollectionGenerator.kt:100 */
  711    851   
        }
         852  +
        /* UnconstrainedCollectionGenerator.kt:97 */
  712    853   
    }
         854  +
         855  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  713    856   
}
  714    857   
pub(crate) mod set_of_length_pattern_string_unconstrained {
  715    858   
         859  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  716    860   
    #[derive(Debug, Clone)]
  717    861   
    pub(crate) struct SetOfLengthPatternStringUnconstrained(
  718    862   
        pub(crate) std::vec::Vec<::std::string::String>,
  719    863   
    );
  720    864   
  721    865   
    impl From<SetOfLengthPatternStringUnconstrained>
  722    866   
        for crate::constrained::MaybeConstrained<crate::model::SetOfLengthPatternString>
  723    867   
    {
  724    868   
        fn from(value: SetOfLengthPatternStringUnconstrained) -> Self {
  725    869   
            Self::Unconstrained(value)
  726    870   
        }
  727    871   
    }
         872  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  728    873   
    impl std::convert::TryFrom<SetOfLengthPatternStringUnconstrained>
  729    874   
        for crate::model::SetOfLengthPatternString
  730    875   
    {
         876  +
        /* UnconstrainedCollectionGenerator.kt:98 */
  731    877   
        type Error = crate::model::set_of_length_pattern_string::ConstraintViolation;
         878  +
        /* UnconstrainedCollectionGenerator.kt:100 */
  732    879   
        fn try_from(
  733    880   
            value: SetOfLengthPatternStringUnconstrained,
  734    881   
        ) -> std::result::Result<Self, Self::Error> {
         882  +
            /* UnconstrainedCollectionGenerator.kt:127 */
  735    883   
            let res: ::std::result::Result<
  736    884   
                ::std::vec::Vec<crate::model::LengthPatternString>,
  737    885   
                (
  738    886   
                    usize,
  739    887   
                    crate::model::length_pattern_string::ConstraintViolation,
  740    888   
                ),
  741    889   
            > = value
  742    890   
                .0
  743    891   
                .into_iter()
  744    892   
                .enumerate()
  745    893   
                .map(|(idx, inner)| {
  746    894   
                    inner
  747    895   
                        .try_into()
  748    896   
                        .map_err(|inner_violation| (idx, inner_violation))
  749    897   
                })
  750    898   
                .collect();
  751    899   
            let inner =
  752    900   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
         901  +
            /* UnconstrainedCollectionGenerator.kt:189 */
  753    902   
            Self::try_from(inner)
         903  +
            /* UnconstrainedCollectionGenerator.kt:100 */
  754    904   
        }
         905  +
        /* UnconstrainedCollectionGenerator.kt:97 */
  755    906   
    }
         907  +
         908  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  756    909   
}
  757    910   
pub(crate) mod set_of_pattern_string_unconstrained {
  758    911   
         912  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  759    913   
    #[derive(Debug, Clone)]
  760    914   
    pub(crate) struct SetOfPatternStringUnconstrained(
  761    915   
        pub(crate) std::vec::Vec<::std::string::String>,
  762    916   
    );
  763    917   
  764    918   
    impl From<SetOfPatternStringUnconstrained>
  765    919   
        for crate::constrained::MaybeConstrained<crate::model::SetOfPatternString>
  766    920   
    {
  767    921   
        fn from(value: SetOfPatternStringUnconstrained) -> Self {
  768    922   
            Self::Unconstrained(value)
  769    923   
        }
  770    924   
    }
         925  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  771    926   
    impl std::convert::TryFrom<SetOfPatternStringUnconstrained> for crate::model::SetOfPatternString {
         927  +
        /* UnconstrainedCollectionGenerator.kt:98 */
  772    928   
        type Error = crate::model::set_of_pattern_string::ConstraintViolation;
         929  +
        /* UnconstrainedCollectionGenerator.kt:100 */
  773    930   
        fn try_from(
  774    931   
            value: SetOfPatternStringUnconstrained,
  775    932   
        ) -> std::result::Result<Self, Self::Error> {
         933  +
            /* UnconstrainedCollectionGenerator.kt:127 */
  776    934   
            let res: ::std::result::Result<
  777    935   
                ::std::vec::Vec<crate::model::PatternString>,
  778    936   
                (usize, crate::model::pattern_string::ConstraintViolation),
  779    937   
            > = value
  780    938   
                .0
  781    939   
                .into_iter()
  782    940   
                .enumerate()
  783    941   
                .map(|(idx, inner)| {
  784    942   
                    inner
  785    943   
                        .try_into()
  786    944   
                        .map_err(|inner_violation| (idx, inner_violation))
  787    945   
                })
  788    946   
                .collect();
  789    947   
            let inner =
  790    948   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
         949  +
            /* UnconstrainedCollectionGenerator.kt:189 */
  791    950   
            Self::try_from(inner)
         951  +
            /* UnconstrainedCollectionGenerator.kt:100 */
  792    952   
        }
         953  +
        /* UnconstrainedCollectionGenerator.kt:97 */
  793    954   
    }
         955  +
         956  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  794    957   
}
  795    958   
pub(crate) mod map_of_range_byte_unconstrained {
  796    959   
         960  +
    /* UnconstrainedMapGenerator.kt:79 */
  797    961   
    #[derive(Debug, Clone)]
  798    962   
    pub(crate) struct MapOfRangeByteUnconstrained(
  799    963   
        pub(crate) std::collections::HashMap<::std::string::String, i8>,
  800    964   
    );
  801    965   
  802    966   
    impl From<MapOfRangeByteUnconstrained>
  803    967   
        for crate::constrained::MaybeConstrained<
  804    968   
            crate::constrained::map_of_range_byte_constrained::MapOfRangeByteConstrained,
  805    969   
        >
  806    970   
    {
  807    971   
        fn from(value: MapOfRangeByteUnconstrained) -> Self {
  808    972   
            Self::Unconstrained(value)
  809    973   
        }
  810    974   
    }
         975  +
    /* UnconstrainedMapGenerator.kt:101 */
  811    976   
    impl std::convert::TryFrom<MapOfRangeByteUnconstrained>
  812    977   
        for crate::constrained::map_of_range_byte_constrained::MapOfRangeByteConstrained
  813    978   
    {
         979  +
        /* UnconstrainedMapGenerator.kt:102 */
  814    980   
        type Error = crate::model::map_of_range_byte::ConstraintViolation;
         981  +
        /* UnconstrainedMapGenerator.kt:104 */
  815    982   
        fn try_from(value: MapOfRangeByteUnconstrained) -> std::result::Result<Self, Self::Error> {
         983  +
            /* UnconstrainedMapGenerator.kt:186 */
  816    984   
            let res: ::std::result::Result<
  817    985   
                ::std::collections::HashMap<::std::string::String, crate::model::RangeByte>,
  818    986   
                Self::Error,
  819    987   
            > = value
  820    988   
                .0
  821    989   
                .into_iter()
  822    990   
                .map(|(k, v)| match crate::model::RangeByte::try_from(v) {
  823    991   
                    Ok(v) => Ok((k, v)),
  824    992   
                    Err(inner_constraint_violation) => {
  825    993   
                        Err(Self::Error::Value(k, inner_constraint_violation))
  826    994   
                    }
  827    995   
                })
  828    996   
                .collect();
  829    997   
            let hm = res?;
         998  +
            /* UnconstrainedMapGenerator.kt:247 */
  830    999   
            Ok(Self(hm))
        1000  +
            /* UnconstrainedMapGenerator.kt:104 */
  831   1001   
        }
        1002  +
        /* UnconstrainedMapGenerator.kt:101 */
  832   1003   
    }
        1004  +
        1005  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  833   1006   
}
  834   1007   
pub(crate) mod set_of_range_byte_unconstrained {
  835   1008   
        1009  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  836   1010   
    #[derive(Debug, Clone)]
  837   1011   
    pub(crate) struct SetOfRangeByteUnconstrained(pub(crate) std::vec::Vec<i8>);
  838   1012   
  839   1013   
    impl From<SetOfRangeByteUnconstrained>
  840   1014   
        for crate::constrained::MaybeConstrained<crate::model::SetOfRangeByte>
  841   1015   
    {
  842   1016   
        fn from(value: SetOfRangeByteUnconstrained) -> Self {
  843   1017   
            Self::Unconstrained(value)
  844   1018   
        }
  845   1019   
    }
        1020  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  846   1021   
    impl std::convert::TryFrom<SetOfRangeByteUnconstrained> for crate::model::SetOfRangeByte {
        1022  +
        /* UnconstrainedCollectionGenerator.kt:98 */
  847   1023   
        type Error = crate::model::set_of_range_byte::ConstraintViolation;
        1024  +
        /* UnconstrainedCollectionGenerator.kt:100 */
  848   1025   
        fn try_from(value: SetOfRangeByteUnconstrained) -> std::result::Result<Self, Self::Error> {
        1026  +
            /* UnconstrainedCollectionGenerator.kt:127 */
  849   1027   
            let res: ::std::result::Result<
  850   1028   
                ::std::vec::Vec<crate::model::RangeByte>,
  851   1029   
                (usize, crate::model::range_byte::ConstraintViolation),
  852   1030   
            > = value
  853   1031   
                .0
  854   1032   
                .into_iter()
  855   1033   
                .enumerate()
  856   1034   
                .map(|(idx, inner)| {
  857   1035   
                    inner
  858   1036   
                        .try_into()
  859   1037   
                        .map_err(|inner_violation| (idx, inner_violation))
  860   1038   
                })
  861   1039   
                .collect();
  862   1040   
            let inner =
  863   1041   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
        1042  +
            /* UnconstrainedCollectionGenerator.kt:189 */
  864   1043   
            Self::try_from(inner)
        1044  +
            /* UnconstrainedCollectionGenerator.kt:100 */
  865   1045   
        }
        1046  +
        /* UnconstrainedCollectionGenerator.kt:97 */
  866   1047   
    }
        1048  +
        1049  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  867   1050   
}
  868   1051   
pub(crate) mod list_of_range_byte_unconstrained {
  869   1052   
        1053  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  870   1054   
    #[derive(Debug, Clone)]
  871   1055   
    pub(crate) struct ListOfRangeByteUnconstrained(pub(crate) std::vec::Vec<i8>);
  872   1056   
  873   1057   
    impl From<ListOfRangeByteUnconstrained>
  874   1058   
        for crate::constrained::MaybeConstrained<
  875   1059   
            crate::constrained::list_of_range_byte_constrained::ListOfRangeByteConstrained,
  876   1060   
        >
  877   1061   
    {
  878   1062   
        fn from(value: ListOfRangeByteUnconstrained) -> Self {
  879   1063   
            Self::Unconstrained(value)
  880   1064   
        }
  881   1065   
    }
        1066  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  882   1067   
    impl std::convert::TryFrom<ListOfRangeByteUnconstrained>
  883   1068   
        for crate::constrained::list_of_range_byte_constrained::ListOfRangeByteConstrained
  884   1069   
    {
        1070  +
        /* UnconstrainedCollectionGenerator.kt:98 */
  885   1071   
        type Error = crate::model::list_of_range_byte::ConstraintViolation;
        1072  +
        /* UnconstrainedCollectionGenerator.kt:100 */
  886   1073   
        fn try_from(value: ListOfRangeByteUnconstrained) -> std::result::Result<Self, Self::Error> {
        1074  +
            /* UnconstrainedCollectionGenerator.kt:127 */
  887   1075   
            let res: ::std::result::Result<
  888   1076   
                ::std::vec::Vec<crate::model::RangeByte>,
  889   1077   
                (usize, crate::model::range_byte::ConstraintViolation),
  890   1078   
            > = value
  891   1079   
                .0
  892   1080   
                .into_iter()
  893   1081   
                .enumerate()
  894   1082   
                .map(|(idx, inner)| {
  895   1083   
                    inner
  896   1084   
                        .try_into()
  897   1085   
                        .map_err(|inner_violation| (idx, inner_violation))
  898   1086   
                })
  899   1087   
                .collect();
  900   1088   
            let inner =
  901   1089   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
        1090  +
            /* UnconstrainedCollectionGenerator.kt:191 */
  902   1091   
            Ok(Self(inner))
        1092  +
            /* UnconstrainedCollectionGenerator.kt:100 */
  903   1093   
        }
        1094  +
        /* UnconstrainedCollectionGenerator.kt:97 */
  904   1095   
    }
        1096  +
        1097  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  905   1098   
}
  906   1099   
pub(crate) mod map_of_range_long_unconstrained {
  907   1100   
        1101  +
    /* UnconstrainedMapGenerator.kt:79 */
  908   1102   
    #[derive(Debug, Clone)]
  909   1103   
    pub(crate) struct MapOfRangeLongUnconstrained(
  910   1104   
        pub(crate) std::collections::HashMap<::std::string::String, i64>,
  911   1105   
    );
  912   1106   
  913   1107   
    impl From<MapOfRangeLongUnconstrained>
  914   1108   
        for crate::constrained::MaybeConstrained<
  915   1109   
            crate::constrained::map_of_range_long_constrained::MapOfRangeLongConstrained,
  916   1110   
        >
  917   1111   
    {
  918   1112   
        fn from(value: MapOfRangeLongUnconstrained) -> Self {
  919   1113   
            Self::Unconstrained(value)
  920   1114   
        }
  921   1115   
    }
        1116  +
    /* UnconstrainedMapGenerator.kt:101 */
  922   1117   
    impl std::convert::TryFrom<MapOfRangeLongUnconstrained>
  923   1118   
        for crate::constrained::map_of_range_long_constrained::MapOfRangeLongConstrained
  924   1119   
    {
        1120  +
        /* UnconstrainedMapGenerator.kt:102 */
  925   1121   
        type Error = crate::model::map_of_range_long::ConstraintViolation;
        1122  +
        /* UnconstrainedMapGenerator.kt:104 */
  926   1123   
        fn try_from(value: MapOfRangeLongUnconstrained) -> std::result::Result<Self, Self::Error> {
        1124  +
            /* UnconstrainedMapGenerator.kt:186 */
  927   1125   
            let res: ::std::result::Result<
  928   1126   
                ::std::collections::HashMap<::std::string::String, crate::model::RangeLong>,
  929   1127   
                Self::Error,
  930   1128   
            > = value
  931   1129   
                .0
  932   1130   
                .into_iter()
  933   1131   
                .map(|(k, v)| match crate::model::RangeLong::try_from(v) {
  934   1132   
                    Ok(v) => Ok((k, v)),
  935   1133   
                    Err(inner_constraint_violation) => {
  936   1134   
                        Err(Self::Error::Value(k, inner_constraint_violation))
  937   1135   
                    }
  938   1136   
                })
  939   1137   
                .collect();
  940   1138   
            let hm = res?;
        1139  +
            /* UnconstrainedMapGenerator.kt:247 */
  941   1140   
            Ok(Self(hm))
        1141  +
            /* UnconstrainedMapGenerator.kt:104 */
  942   1142   
        }
        1143  +
        /* UnconstrainedMapGenerator.kt:101 */
  943   1144   
    }
        1145  +
        1146  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  944   1147   
}
  945   1148   
pub(crate) mod set_of_range_long_unconstrained {
  946   1149   
        1150  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  947   1151   
    #[derive(Debug, Clone)]
  948   1152   
    pub(crate) struct SetOfRangeLongUnconstrained(pub(crate) std::vec::Vec<i64>);
  949   1153   
  950   1154   
    impl From<SetOfRangeLongUnconstrained>
  951   1155   
        for crate::constrained::MaybeConstrained<crate::model::SetOfRangeLong>
  952   1156   
    {
  953   1157   
        fn from(value: SetOfRangeLongUnconstrained) -> Self {
  954   1158   
            Self::Unconstrained(value)
  955   1159   
        }
  956   1160   
    }
        1161  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  957   1162   
    impl std::convert::TryFrom<SetOfRangeLongUnconstrained> for crate::model::SetOfRangeLong {
        1163  +
        /* UnconstrainedCollectionGenerator.kt:98 */
  958   1164   
        type Error = crate::model::set_of_range_long::ConstraintViolation;
        1165  +
        /* UnconstrainedCollectionGenerator.kt:100 */
  959   1166   
        fn try_from(value: SetOfRangeLongUnconstrained) -> std::result::Result<Self, Self::Error> {
        1167  +
            /* UnconstrainedCollectionGenerator.kt:127 */
  960   1168   
            let res: ::std::result::Result<
  961   1169   
                ::std::vec::Vec<crate::model::RangeLong>,
  962   1170   
                (usize, crate::model::range_long::ConstraintViolation),
  963   1171   
            > = value
  964   1172   
                .0
  965   1173   
                .into_iter()
  966   1174   
                .enumerate()
  967   1175   
                .map(|(idx, inner)| {
  968   1176   
                    inner
  969   1177   
                        .try_into()
  970   1178   
                        .map_err(|inner_violation| (idx, inner_violation))
  971   1179   
                })
  972   1180   
                .collect();
  973   1181   
            let inner =
  974   1182   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
        1183  +
            /* UnconstrainedCollectionGenerator.kt:189 */
  975   1184   
            Self::try_from(inner)
        1185  +
            /* UnconstrainedCollectionGenerator.kt:100 */
  976   1186   
        }
        1187  +
        /* UnconstrainedCollectionGenerator.kt:97 */
  977   1188   
    }
        1189  +
        1190  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  978   1191   
}
  979   1192   
pub(crate) mod list_of_range_long_unconstrained {
  980   1193   
        1194  +
    /* UnconstrainedCollectionGenerator.kt:77 */
  981   1195   
    #[derive(Debug, Clone)]
  982   1196   
    pub(crate) struct ListOfRangeLongUnconstrained(pub(crate) std::vec::Vec<i64>);
  983   1197   
  984   1198   
    impl From<ListOfRangeLongUnconstrained>
  985   1199   
        for crate::constrained::MaybeConstrained<
  986   1200   
            crate::constrained::list_of_range_long_constrained::ListOfRangeLongConstrained,
  987   1201   
        >
  988   1202   
    {
  989   1203   
        fn from(value: ListOfRangeLongUnconstrained) -> Self {
  990   1204   
            Self::Unconstrained(value)
  991   1205   
        }
  992   1206   
    }
        1207  +
    /* UnconstrainedCollectionGenerator.kt:97 */
  993   1208   
    impl std::convert::TryFrom<ListOfRangeLongUnconstrained>
  994   1209   
        for crate::constrained::list_of_range_long_constrained::ListOfRangeLongConstrained
  995   1210   
    {
        1211  +
        /* UnconstrainedCollectionGenerator.kt:98 */
  996   1212   
        type Error = crate::model::list_of_range_long::ConstraintViolation;
        1213  +
        /* UnconstrainedCollectionGenerator.kt:100 */
  997   1214   
        fn try_from(value: ListOfRangeLongUnconstrained) -> std::result::Result<Self, Self::Error> {
        1215  +
            /* UnconstrainedCollectionGenerator.kt:127 */
  998   1216   
            let res: ::std::result::Result<
  999   1217   
                ::std::vec::Vec<crate::model::RangeLong>,
 1000   1218   
                (usize, crate::model::range_long::ConstraintViolation),
 1001   1219   
            > = value
 1002   1220   
                .0
 1003   1221   
                .into_iter()
 1004   1222   
                .enumerate()
 1005   1223   
                .map(|(idx, inner)| {
 1006   1224   
                    inner
 1007   1225   
                        .try_into()
 1008   1226   
                        .map_err(|inner_violation| (idx, inner_violation))
 1009   1227   
                })
 1010   1228   
                .collect();
 1011   1229   
            let inner =
 1012   1230   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
        1231  +
            /* UnconstrainedCollectionGenerator.kt:191 */
 1013   1232   
            Ok(Self(inner))
        1233  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1014   1234   
        }
        1235  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1015   1236   
    }
        1237  +
        1238  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1016   1239   
}
 1017   1240   
pub(crate) mod map_of_range_short_unconstrained {
 1018   1241   
        1242  +
    /* UnconstrainedMapGenerator.kt:79 */
 1019   1243   
    #[derive(Debug, Clone)]
 1020   1244   
    pub(crate) struct MapOfRangeShortUnconstrained(
 1021   1245   
        pub(crate) std::collections::HashMap<::std::string::String, i16>,
 1022   1246   
    );
 1023   1247   
 1024   1248   
    impl From<MapOfRangeShortUnconstrained>
 1025   1249   
        for crate::constrained::MaybeConstrained<
 1026   1250   
            crate::constrained::map_of_range_short_constrained::MapOfRangeShortConstrained,
 1027   1251   
        >
 1028   1252   
    {
 1029   1253   
        fn from(value: MapOfRangeShortUnconstrained) -> Self {
 1030   1254   
            Self::Unconstrained(value)
 1031   1255   
        }
 1032   1256   
    }
        1257  +
    /* UnconstrainedMapGenerator.kt:101 */
 1033   1258   
    impl std::convert::TryFrom<MapOfRangeShortUnconstrained>
 1034   1259   
        for crate::constrained::map_of_range_short_constrained::MapOfRangeShortConstrained
 1035   1260   
    {
        1261  +
        /* UnconstrainedMapGenerator.kt:102 */
 1036   1262   
        type Error = crate::model::map_of_range_short::ConstraintViolation;
        1263  +
        /* UnconstrainedMapGenerator.kt:104 */
 1037   1264   
        fn try_from(value: MapOfRangeShortUnconstrained) -> std::result::Result<Self, Self::Error> {
        1265  +
            /* UnconstrainedMapGenerator.kt:186 */
 1038   1266   
            let res: ::std::result::Result<
 1039   1267   
                ::std::collections::HashMap<::std::string::String, crate::model::RangeShort>,
 1040   1268   
                Self::Error,
 1041   1269   
            > = value
 1042   1270   
                .0
 1043   1271   
                .into_iter()
 1044   1272   
                .map(|(k, v)| match crate::model::RangeShort::try_from(v) {
 1045   1273   
                    Ok(v) => Ok((k, v)),
 1046   1274   
                    Err(inner_constraint_violation) => {
 1047   1275   
                        Err(Self::Error::Value(k, inner_constraint_violation))
 1048   1276   
                    }
 1049   1277   
                })
 1050   1278   
                .collect();
 1051   1279   
            let hm = res?;
        1280  +
            /* UnconstrainedMapGenerator.kt:247 */
 1052   1281   
            Ok(Self(hm))
        1282  +
            /* UnconstrainedMapGenerator.kt:104 */
 1053   1283   
        }
        1284  +
        /* UnconstrainedMapGenerator.kt:101 */
 1054   1285   
    }
        1286  +
        1287  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1055   1288   
}
 1056   1289   
pub(crate) mod set_of_range_short_unconstrained {
 1057   1290   
        1291  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1058   1292   
    #[derive(Debug, Clone)]
 1059   1293   
    pub(crate) struct SetOfRangeShortUnconstrained(pub(crate) std::vec::Vec<i16>);
 1060   1294   
 1061   1295   
    impl From<SetOfRangeShortUnconstrained>
 1062   1296   
        for crate::constrained::MaybeConstrained<crate::model::SetOfRangeShort>
 1063   1297   
    {
 1064   1298   
        fn from(value: SetOfRangeShortUnconstrained) -> Self {
 1065   1299   
            Self::Unconstrained(value)
 1066   1300   
        }
 1067   1301   
    }
        1302  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1068   1303   
    impl std::convert::TryFrom<SetOfRangeShortUnconstrained> for crate::model::SetOfRangeShort {
        1304  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1069   1305   
        type Error = crate::model::set_of_range_short::ConstraintViolation;
        1306  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1070   1307   
        fn try_from(value: SetOfRangeShortUnconstrained) -> std::result::Result<Self, Self::Error> {
        1308  +
            /* UnconstrainedCollectionGenerator.kt:127 */
 1071   1309   
            let res: ::std::result::Result<
 1072   1310   
                ::std::vec::Vec<crate::model::RangeShort>,
 1073   1311   
                (usize, crate::model::range_short::ConstraintViolation),
 1074   1312   
            > = value
 1075   1313   
                .0
 1076   1314   
                .into_iter()
 1077   1315   
                .enumerate()
 1078   1316   
                .map(|(idx, inner)| {
 1079   1317   
                    inner
 1080   1318   
                        .try_into()
 1081   1319   
                        .map_err(|inner_violation| (idx, inner_violation))
 1082   1320   
                })
 1083   1321   
                .collect();
 1084   1322   
            let inner =
 1085   1323   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
        1324  +
            /* UnconstrainedCollectionGenerator.kt:189 */
 1086   1325   
            Self::try_from(inner)
        1326  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1087   1327   
        }
        1328  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1088   1329   
    }
        1330  +
        1331  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1089   1332   
}
 1090   1333   
pub(crate) mod list_of_range_short_unconstrained {
 1091   1334   
        1335  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1092   1336   
    #[derive(Debug, Clone)]
 1093   1337   
    pub(crate) struct ListOfRangeShortUnconstrained(pub(crate) std::vec::Vec<i16>);
 1094   1338   
 1095   1339   
    impl From<ListOfRangeShortUnconstrained>
 1096   1340   
        for crate::constrained::MaybeConstrained<
 1097   1341   
            crate::constrained::list_of_range_short_constrained::ListOfRangeShortConstrained,
 1098   1342   
        >
 1099   1343   
    {
 1100   1344   
        fn from(value: ListOfRangeShortUnconstrained) -> Self {
 1101   1345   
            Self::Unconstrained(value)
 1102   1346   
        }
 1103   1347   
    }
        1348  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1104   1349   
    impl std::convert::TryFrom<ListOfRangeShortUnconstrained>
 1105   1350   
        for crate::constrained::list_of_range_short_constrained::ListOfRangeShortConstrained
 1106   1351   
    {
        1352  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1107   1353   
        type Error = crate::model::list_of_range_short::ConstraintViolation;
        1354  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1108   1355   
        fn try_from(
 1109   1356   
            value: ListOfRangeShortUnconstrained,
 1110   1357   
        ) -> std::result::Result<Self, Self::Error> {
        1358  +
            /* UnconstrainedCollectionGenerator.kt:127 */
 1111   1359   
            let res: ::std::result::Result<
 1112   1360   
                ::std::vec::Vec<crate::model::RangeShort>,
 1113   1361   
                (usize, crate::model::range_short::ConstraintViolation),
 1114   1362   
            > = value
 1115   1363   
                .0
 1116   1364   
                .into_iter()
 1117   1365   
                .enumerate()
 1118   1366   
                .map(|(idx, inner)| {
 1119   1367   
                    inner
 1120   1368   
                        .try_into()
 1121   1369   
                        .map_err(|inner_violation| (idx, inner_violation))
 1122   1370   
                })
 1123   1371   
                .collect();
 1124   1372   
            let inner =
 1125   1373   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
        1374  +
            /* UnconstrainedCollectionGenerator.kt:191 */
 1126   1375   
            Ok(Self(inner))
        1376  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1127   1377   
        }
        1378  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1128   1379   
    }
        1380  +
        1381  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1129   1382   
}
 1130   1383   
pub(crate) mod map_of_range_integer_unconstrained {
 1131   1384   
        1385  +
    /* UnconstrainedMapGenerator.kt:79 */
 1132   1386   
    #[derive(Debug, Clone)]
 1133   1387   
    pub(crate) struct MapOfRangeIntegerUnconstrained(
 1134   1388   
        pub(crate) std::collections::HashMap<::std::string::String, i32>,
 1135   1389   
    );
 1136   1390   
 1137   1391   
    impl From<MapOfRangeIntegerUnconstrained>
 1138   1392   
        for crate::constrained::MaybeConstrained<
 1139   1393   
            crate::constrained::map_of_range_integer_constrained::MapOfRangeIntegerConstrained,
 1140   1394   
        >
 1141   1395   
    {
 1142   1396   
        fn from(value: MapOfRangeIntegerUnconstrained) -> Self {
 1143   1397   
            Self::Unconstrained(value)
 1144   1398   
        }
 1145   1399   
    }
        1400  +
    /* UnconstrainedMapGenerator.kt:101 */
 1146   1401   
    impl std::convert::TryFrom<MapOfRangeIntegerUnconstrained>
 1147   1402   
        for crate::constrained::map_of_range_integer_constrained::MapOfRangeIntegerConstrained
 1148   1403   
    {
        1404  +
        /* UnconstrainedMapGenerator.kt:102 */
 1149   1405   
        type Error = crate::model::map_of_range_integer::ConstraintViolation;
        1406  +
        /* UnconstrainedMapGenerator.kt:104 */
 1150   1407   
        fn try_from(
 1151   1408   
            value: MapOfRangeIntegerUnconstrained,
 1152   1409   
        ) -> std::result::Result<Self, Self::Error> {
        1410  +
            /* UnconstrainedMapGenerator.kt:186 */
 1153   1411   
            let res: ::std::result::Result<
 1154   1412   
                ::std::collections::HashMap<::std::string::String, crate::model::RangeInteger>,
 1155   1413   
                Self::Error,
 1156   1414   
            > = value
 1157   1415   
                .0
 1158   1416   
                .into_iter()
 1159   1417   
                .map(|(k, v)| match crate::model::RangeInteger::try_from(v) {
 1160   1418   
                    Ok(v) => Ok((k, v)),
 1161   1419   
                    Err(inner_constraint_violation) => {
 1162   1420   
                        Err(Self::Error::Value(k, inner_constraint_violation))
 1163   1421   
                    }
 1164   1422   
                })
 1165   1423   
                .collect();
 1166   1424   
            let hm = res?;
        1425  +
            /* UnconstrainedMapGenerator.kt:247 */
 1167   1426   
            Ok(Self(hm))
        1427  +
            /* UnconstrainedMapGenerator.kt:104 */
 1168   1428   
        }
        1429  +
        /* UnconstrainedMapGenerator.kt:101 */
 1169   1430   
    }
        1431  +
        1432  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1170   1433   
}
 1171   1434   
pub(crate) mod set_of_range_integer_unconstrained {
 1172   1435   
        1436  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1173   1437   
    #[derive(Debug, Clone)]
 1174   1438   
    pub(crate) struct SetOfRangeIntegerUnconstrained(pub(crate) std::vec::Vec<i32>);
 1175   1439   
 1176   1440   
    impl From<SetOfRangeIntegerUnconstrained>
 1177   1441   
        for crate::constrained::MaybeConstrained<crate::model::SetOfRangeInteger>
 1178   1442   
    {
 1179   1443   
        fn from(value: SetOfRangeIntegerUnconstrained) -> Self {
 1180   1444   
            Self::Unconstrained(value)
 1181   1445   
        }
 1182   1446   
    }
        1447  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1183   1448   
    impl std::convert::TryFrom<SetOfRangeIntegerUnconstrained> for crate::model::SetOfRangeInteger {
        1449  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1184   1450   
        type Error = crate::model::set_of_range_integer::ConstraintViolation;
        1451  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1185   1452   
        fn try_from(
 1186   1453   
            value: SetOfRangeIntegerUnconstrained,
 1187   1454   
        ) -> std::result::Result<Self, Self::Error> {
        1455  +
            /* UnconstrainedCollectionGenerator.kt:127 */
 1188   1456   
            let res: ::std::result::Result<
 1189   1457   
                ::std::vec::Vec<crate::model::RangeInteger>,
 1190   1458   
                (usize, crate::model::range_integer::ConstraintViolation),
 1191   1459   
            > = value
 1192   1460   
                .0
 1193   1461   
                .into_iter()
 1194   1462   
                .enumerate()
 1195   1463   
                .map(|(idx, inner)| {
 1196   1464   
                    inner
 1197   1465   
                        .try_into()
 1198   1466   
                        .map_err(|inner_violation| (idx, inner_violation))
 1199   1467   
                })
 1200   1468   
                .collect();
 1201   1469   
            let inner =
 1202   1470   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
        1471  +
            /* UnconstrainedCollectionGenerator.kt:189 */
 1203   1472   
            Self::try_from(inner)
        1473  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1204   1474   
        }
        1475  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1205   1476   
    }
        1477  +
        1478  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1206   1479   
}
 1207   1480   
pub(crate) mod list_of_range_integer_unconstrained {
 1208   1481   
        1482  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1209   1483   
    #[derive(Debug, Clone)]
 1210   1484   
    pub(crate) struct ListOfRangeIntegerUnconstrained(pub(crate) std::vec::Vec<i32>);
 1211   1485   
 1212   1486   
    impl From<ListOfRangeIntegerUnconstrained>
 1213   1487   
        for crate::constrained::MaybeConstrained<
 1214   1488   
            crate::constrained::list_of_range_integer_constrained::ListOfRangeIntegerConstrained,
 1215   1489   
        >
 1216   1490   
    {
 1217   1491   
        fn from(value: ListOfRangeIntegerUnconstrained) -> Self {
 1218   1492   
            Self::Unconstrained(value)
 1219   1493   
        }
 1220   1494   
    }
        1495  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1221   1496   
    impl std::convert::TryFrom<ListOfRangeIntegerUnconstrained>
 1222   1497   
        for crate::constrained::list_of_range_integer_constrained::ListOfRangeIntegerConstrained
 1223   1498   
    {
        1499  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1224   1500   
        type Error = crate::model::list_of_range_integer::ConstraintViolation;
        1501  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1225   1502   
        fn try_from(
 1226   1503   
            value: ListOfRangeIntegerUnconstrained,
 1227   1504   
        ) -> std::result::Result<Self, Self::Error> {
        1505  +
            /* UnconstrainedCollectionGenerator.kt:127 */
 1228   1506   
            let res: ::std::result::Result<
 1229   1507   
                ::std::vec::Vec<crate::model::RangeInteger>,
 1230   1508   
                (usize, crate::model::range_integer::ConstraintViolation),
 1231   1509   
            > = value
 1232   1510   
                .0
 1233   1511   
                .into_iter()
 1234   1512   
                .enumerate()
 1235   1513   
                .map(|(idx, inner)| {
 1236   1514   
                    inner
 1237   1515   
                        .try_into()
 1238   1516   
                        .map_err(|inner_violation| (idx, inner_violation))
 1239   1517   
                })
 1240   1518   
                .collect();
 1241   1519   
            let inner =
 1242   1520   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
        1521  +
            /* UnconstrainedCollectionGenerator.kt:191 */
 1243   1522   
            Ok(Self(inner))
        1523  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1244   1524   
        }
        1525  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1245   1526   
    }
        1527  +
        1528  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1246   1529   
}
 1247   1530   
pub(crate) mod map_of_length_blob_unconstrained {
 1248   1531   
        1532  +
    /* UnconstrainedMapGenerator.kt:79 */
 1249   1533   
    #[derive(Debug, Clone)]
 1250   1534   
    pub(crate) struct MapOfLengthBlobUnconstrained(
 1251   1535   
        pub(crate) std::collections::HashMap<::std::string::String, ::aws_smithy_types::Blob>,
 1252   1536   
    );
 1253   1537   
 1254   1538   
    impl From<MapOfLengthBlobUnconstrained>
 1255   1539   
        for crate::constrained::MaybeConstrained<
 1256   1540   
            crate::constrained::map_of_length_blob_constrained::MapOfLengthBlobConstrained,
 1257   1541   
        >
 1258   1542   
    {
 1259   1543   
        fn from(value: MapOfLengthBlobUnconstrained) -> Self {
 1260   1544   
            Self::Unconstrained(value)
 1261   1545   
        }
 1262   1546   
    }
        1547  +
    /* UnconstrainedMapGenerator.kt:101 */
 1263   1548   
    impl std::convert::TryFrom<MapOfLengthBlobUnconstrained>
 1264   1549   
        for crate::constrained::map_of_length_blob_constrained::MapOfLengthBlobConstrained
 1265   1550   
    {
        1551  +
        /* UnconstrainedMapGenerator.kt:102 */
 1266   1552   
        type Error = crate::model::map_of_length_blob::ConstraintViolation;
        1553  +
        /* UnconstrainedMapGenerator.kt:104 */
 1267   1554   
        fn try_from(value: MapOfLengthBlobUnconstrained) -> std::result::Result<Self, Self::Error> {
        1555  +
            /* UnconstrainedMapGenerator.kt:186 */
 1268   1556   
            let res: ::std::result::Result<
 1269   1557   
                ::std::collections::HashMap<::std::string::String, crate::model::LengthBlob>,
 1270   1558   
                Self::Error,
 1271   1559   
            > = value
 1272   1560   
                .0
 1273   1561   
                .into_iter()
 1274   1562   
                .map(|(k, v)| match crate::model::LengthBlob::try_from(v) {
 1275   1563   
                    Ok(v) => Ok((k, v)),
 1276   1564   
                    Err(inner_constraint_violation) => {
 1277   1565   
                        Err(Self::Error::Value(k, inner_constraint_violation))
 1278   1566   
                    }
 1279   1567   
                })
 1280   1568   
                .collect();
 1281   1569   
            let hm = res?;
        1570  +
            /* UnconstrainedMapGenerator.kt:247 */
 1282   1571   
            Ok(Self(hm))
        1572  +
            /* UnconstrainedMapGenerator.kt:104 */
 1283   1573   
        }
        1574  +
        /* UnconstrainedMapGenerator.kt:101 */
 1284   1575   
    }
        1576  +
        1577  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1285   1578   
}
 1286   1579   
pub(crate) mod list_of_length_blob_unconstrained {
 1287   1580   
        1581  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1288   1582   
    #[derive(Debug, Clone)]
 1289   1583   
    pub(crate) struct ListOfLengthBlobUnconstrained(
 1290   1584   
        pub(crate) std::vec::Vec<::aws_smithy_types::Blob>,
 1291   1585   
    );
 1292   1586   
 1293   1587   
    impl From<ListOfLengthBlobUnconstrained>
 1294   1588   
        for crate::constrained::MaybeConstrained<
 1295   1589   
            crate::constrained::list_of_length_blob_constrained::ListOfLengthBlobConstrained,
 1296   1590   
        >
 1297   1591   
    {
 1298   1592   
        fn from(value: ListOfLengthBlobUnconstrained) -> Self {
 1299   1593   
            Self::Unconstrained(value)
 1300   1594   
        }
 1301   1595   
    }
        1596  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1302   1597   
    impl std::convert::TryFrom<ListOfLengthBlobUnconstrained>
 1303   1598   
        for crate::constrained::list_of_length_blob_constrained::ListOfLengthBlobConstrained
 1304   1599   
    {
        1600  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1305   1601   
        type Error = crate::model::list_of_length_blob::ConstraintViolation;
        1602  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1306   1603   
        fn try_from(
 1307   1604   
            value: ListOfLengthBlobUnconstrained,
 1308   1605   
        ) -> std::result::Result<Self, Self::Error> {
        1606  +
            /* UnconstrainedCollectionGenerator.kt:127 */
 1309   1607   
            let res: ::std::result::Result<
 1310   1608   
                ::std::vec::Vec<crate::model::LengthBlob>,
 1311   1609   
                (usize, crate::model::length_blob::ConstraintViolation),
 1312   1610   
            > = value
 1313   1611   
                .0
 1314   1612   
                .into_iter()
 1315   1613   
                .enumerate()
 1316   1614   
                .map(|(idx, inner)| {
 1317   1615   
                    inner
 1318   1616   
                        .try_into()
 1319   1617   
                        .map_err(|inner_violation| (idx, inner_violation))
 1320   1618   
                })
 1321   1619   
                .collect();
 1322   1620   
            let inner =
 1323   1621   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
        1622  +
            /* UnconstrainedCollectionGenerator.kt:191 */
 1324   1623   
            Ok(Self(inner))
        1624  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1325   1625   
        }
        1626  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1326   1627   
    }
        1628  +
        1629  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1327   1630   
}
 1328   1631   
pub(crate) mod constrained_union_unconstrained {
 1329   1632   
        1633  +
    /* UnconstrainedUnionGenerator.kt:82 */
 1330   1634   
    #[allow(clippy::enum_variant_names)]
 1331   1635   
    #[derive(Debug, Clone)]
 1332   1636   
    pub(crate) enum ConstrainedUnionUnconstrained {
        1637  +
        /* UnconstrainedUnionGenerator.kt:95 */
 1333   1638   
        ConBList(crate::unconstrained::con_b_list_unconstrained::ConBListUnconstrained),
        1639  +
        /* UnconstrainedUnionGenerator.kt:95 */
 1334   1640   
        ConBMap(crate::unconstrained::con_b_map_unconstrained::ConBMapUnconstrained),
        1641  +
        /* UnconstrainedUnionGenerator.kt:95 */
 1335   1642   
        ConBSet(crate::unconstrained::con_b_set_unconstrained::ConBSetUnconstrained),
        1643  +
        /* UnconstrainedUnionGenerator.kt:95 */
 1336   1644   
        ConstrainedStructure(crate::model::con_b::Builder),
 1337         -
        EnumString(::std::string::String),
        1645  +
        /* UnconstrainedUnionGenerator.kt:95 */ EnumString(::std::string::String),
        1646  +
        /* UnconstrainedUnionGenerator.kt:95 */
 1338   1647   
        LengthString(::std::string::String),
        1648  +
        /* UnconstrainedUnionGenerator.kt:82 */
 1339   1649   
    }
        1650  +
    /* UnconstrainedUnionGenerator.kt:103 */
 1340   1651   
    impl ::std::convert::TryFrom<ConstrainedUnionUnconstrained> for crate::model::ConstrainedUnion {
 1341   1652   
        type Error = crate::model::constrained_union::ConstraintViolation;
 1342   1653   
 1343   1654   
        fn try_from(
 1344   1655   
            value: ConstrainedUnionUnconstrained,
 1345   1656   
        ) -> ::std::result::Result<Self, Self::Error> {
 1346   1657   
            Ok(
 1347   1658   
        match value {
 1348   1659   
            crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConBList(unconstrained) => Self::ConBList(
 1349   1660   
                {
 1350   1661   
                                        let constrained: crate::constrained::con_b_list_constrained::ConBListConstrained = unconstrained
 1351   1662   
                                            .try_into()
 1352   1663   
                                            .map_err(Self::Error::ConBList)?;
 1353   1664   
                                        constrained.into()
 1354   1665   
                                    }
 1355   1666   
            ),
 1356   1667   
            crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConBMap(unconstrained) => Self::ConBMap(
 1357   1668   
                unconstrained
 1358   1669   
                                        .try_into()
 1359   1670   
                                        
 1360   1671   
                                        
 1361   1672   
                                        .map_err(Self::Error::ConBMap)?
 1362   1673   
            ),
 1363   1674   
            crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConBSet(unconstrained) => Self::ConBSet(
 1364   1675   
                unconstrained
 1365   1676   
                                        .try_into()
 1366   1677   
                                        
 1367   1678   
                                        
 1368   1679   
                                        .map_err(Self::Error::ConBSet)?
 1369   1680   
            ),
 1370   1681   
            crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::ConstrainedStructure(unconstrained) => Self::ConstrainedStructure(
 1371   1682   
                unconstrained
 1372   1683   
                                        .try_into()
 1373   1684   
                                        
 1374   1685   
                                        
 1375   1686   
                                        .map_err(Self::Error::ConstrainedStructure)?
 1376   1687   
            ),
 1377   1688   
            crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::EnumString(unconstrained) => Self::EnumString(
 1378   1689   
                unconstrained
 1379   1690   
                                        .try_into()
 1380   1691   
                                        
 1381   1692   
                                        
 1382   1693   
                                        .map_err(Self::Error::EnumString)?
 1383   1694   
            ),
 1384   1695   
            crate::unconstrained::constrained_union_unconstrained::ConstrainedUnionUnconstrained::LengthString(unconstrained) => Self::LengthString(
 1385   1696   
                unconstrained
 1386   1697   
                                        .try_into()
 1387   1698   
                                        
 1388   1699   
                                        
 1389   1700   
                                        .map_err(Self::Error::LengthString)?
 1390   1701   
            ),
 1391   1702   
        }
 1392   1703   
    )
 1393   1704   
        }
 1394   1705   
    }
        1706  +
        1707  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1395   1708   
}
 1396   1709   
pub(crate) mod con_b_set_unconstrained {
 1397   1710   
        1711  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1398   1712   
    #[derive(Debug, Clone)]
 1399   1713   
    pub(crate) struct ConBSetUnconstrained(
 1400   1714   
        pub(crate)  std::vec::Vec<
 1401   1715   
            crate::unconstrained::con_b_set_inner_unconstrained::ConBSetInnerUnconstrained,
 1402   1716   
        >,
 1403   1717   
    );
 1404   1718   
 1405   1719   
    impl From<ConBSetUnconstrained> for crate::constrained::MaybeConstrained<crate::model::ConBSet> {
 1406   1720   
        fn from(value: ConBSetUnconstrained) -> Self {
 1407   1721   
            Self::Unconstrained(value)
 1408   1722   
        }
 1409   1723   
    }
        1724  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1410   1725   
    impl std::convert::TryFrom<ConBSetUnconstrained> for crate::model::ConBSet {
        1726  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1411   1727   
        type Error = crate::model::con_b_set::ConstraintViolation;
        1728  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1412   1729   
        fn try_from(value: ConBSetUnconstrained) -> std::result::Result<Self, Self::Error> {
        1730  +
            /* UnconstrainedCollectionGenerator.kt:127 */
 1413   1731   
            let res: ::std::result::Result<
 1414   1732   
                ::std::vec::Vec<crate::model::ConBSetInner>,
 1415   1733   
                (usize, crate::model::con_b_set_inner::ConstraintViolation),
 1416   1734   
            > = value
 1417   1735   
                .0
 1418   1736   
                .into_iter()
 1419   1737   
                .enumerate()
 1420   1738   
                .map(|(idx, inner)| {
 1421   1739   
                    inner
 1422   1740   
                        .try_into()
 1423   1741   
                        .map_err(|inner_violation| (idx, inner_violation))
 1424   1742   
                })
 1425   1743   
                .collect();
 1426   1744   
            let inner =
 1427   1745   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
        1746  +
            /* UnconstrainedCollectionGenerator.kt:189 */
 1428   1747   
            Self::try_from(inner)
        1748  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1429   1749   
        }
        1750  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1430   1751   
    }
        1752  +
        1753  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1431   1754   
}
 1432   1755   
pub(crate) mod con_b_set_inner_unconstrained {
 1433   1756   
        1757  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1434   1758   
    #[derive(Debug, Clone)]
 1435   1759   
    pub(crate) struct ConBSetInnerUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
 1436   1760   
 1437   1761   
    impl From<ConBSetInnerUnconstrained>
 1438   1762   
        for crate::constrained::MaybeConstrained<crate::model::ConBSetInner>
 1439   1763   
    {
 1440   1764   
        fn from(value: ConBSetInnerUnconstrained) -> Self {
 1441   1765   
            Self::Unconstrained(value)
 1442   1766   
        }
 1443   1767   
    }
        1768  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1444   1769   
    impl std::convert::TryFrom<ConBSetInnerUnconstrained> for crate::model::ConBSetInner {
        1770  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1445   1771   
        type Error = crate::model::con_b_set_inner::ConstraintViolation;
        1772  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1446   1773   
        fn try_from(value: ConBSetInnerUnconstrained) -> std::result::Result<Self, Self::Error> {
        1774  +
            /* UnconstrainedCollectionGenerator.kt:185 */
 1447   1775   
            let inner = value.0;
        1776  +
            /* UnconstrainedCollectionGenerator.kt:189 */
 1448   1777   
            Self::try_from(inner)
        1778  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1449   1779   
        }
        1780  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1450   1781   
    }
        1782  +
        1783  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1451   1784   
}
 1452   1785   
pub(crate) mod con_b_list_unconstrained {
 1453   1786   
        1787  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1454   1788   
    #[derive(Debug, Clone)]
 1455   1789   
    pub(crate) struct ConBListUnconstrained(
 1456   1790   
        pub(crate)  std::vec::Vec<
 1457   1791   
            crate::unconstrained::con_b_list_inner_unconstrained::ConBListInnerUnconstrained,
 1458   1792   
        >,
 1459   1793   
    );
 1460   1794   
 1461   1795   
    impl From<ConBListUnconstrained>
 1462   1796   
        for crate::constrained::MaybeConstrained<
 1463   1797   
            crate::constrained::con_b_list_constrained::ConBListConstrained,
 1464   1798   
        >
 1465   1799   
    {
 1466   1800   
        fn from(value: ConBListUnconstrained) -> Self {
 1467   1801   
            Self::Unconstrained(value)
 1468   1802   
        }
 1469   1803   
    }
        1804  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1470   1805   
    impl std::convert::TryFrom<ConBListUnconstrained>
 1471   1806   
        for crate::constrained::con_b_list_constrained::ConBListConstrained
 1472   1807   
    {
        1808  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1473   1809   
        type Error = crate::model::con_b_list::ConstraintViolation;
        1810  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1474   1811   
        fn try_from(value: ConBListUnconstrained) -> std::result::Result<Self, Self::Error> {
        1812  +
            /* UnconstrainedCollectionGenerator.kt:127 */
 1475   1813   
            let res: ::std::result::Result<
 1476   1814   
                ::std::vec::Vec<
 1477   1815   
                    crate::constrained::con_b_list_inner_constrained::ConBListInnerConstrained,
 1478   1816   
                >,
 1479   1817   
                (usize, crate::model::con_b_list_inner::ConstraintViolation),
 1480   1818   
            > = value
 1481   1819   
                .0
 1482   1820   
                .into_iter()
 1483   1821   
                .enumerate()
 1484   1822   
                .map(|(idx, inner)| {
 1485   1823   
                    inner
 1486   1824   
                        .try_into()
 1487   1825   
                        .map_err(|inner_violation| (idx, inner_violation))
 1488   1826   
                })
 1489   1827   
                .collect();
 1490   1828   
            let inner =
 1491   1829   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
        1830  +
            /* UnconstrainedCollectionGenerator.kt:191 */
 1492   1831   
            Ok(Self(inner))
        1832  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1493   1833   
        }
        1834  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1494   1835   
    }
        1836  +
        1837  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1495   1838   
}
 1496   1839   
pub(crate) mod con_b_list_inner_unconstrained {
 1497   1840   
        1841  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1498   1842   
    #[derive(Debug, Clone)]
 1499   1843   
    pub(crate) struct ConBListInnerUnconstrained(
 1500   1844   
        pub(crate) std::vec::Vec<crate::model::con_b::Builder>,
 1501   1845   
    );
 1502   1846   
 1503   1847   
    impl From<ConBListInnerUnconstrained>
 1504   1848   
        for crate::constrained::MaybeConstrained<
 1505   1849   
            crate::constrained::con_b_list_inner_constrained::ConBListInnerConstrained,
 1506   1850   
        >
 1507   1851   
    {
 1508   1852   
        fn from(value: ConBListInnerUnconstrained) -> Self {
 1509   1853   
            Self::Unconstrained(value)
 1510   1854   
        }
 1511   1855   
    }
        1856  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1512   1857   
    impl std::convert::TryFrom<ConBListInnerUnconstrained>
 1513   1858   
        for crate::constrained::con_b_list_inner_constrained::ConBListInnerConstrained
 1514   1859   
    {
        1860  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1515   1861   
        type Error = crate::model::con_b_list_inner::ConstraintViolation;
        1862  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1516   1863   
        fn try_from(value: ConBListInnerUnconstrained) -> std::result::Result<Self, Self::Error> {
        1864  +
            /* UnconstrainedCollectionGenerator.kt:127 */
 1517   1865   
            let res: ::std::result::Result<
 1518   1866   
                ::std::vec::Vec<crate::model::ConB>,
 1519   1867   
                (usize, crate::model::con_b::ConstraintViolation),
 1520   1868   
            > = value
 1521   1869   
                .0
 1522   1870   
                .into_iter()
 1523   1871   
                .enumerate()
 1524   1872   
                .map(|(idx, inner)| {
 1525   1873   
                    inner
 1526   1874   
                        .try_into()
 1527   1875   
                        .map_err(|inner_violation| (idx, inner_violation))
 1528   1876   
                })
 1529   1877   
                .collect();
 1530   1878   
            let inner =
 1531   1879   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
        1880  +
            /* UnconstrainedCollectionGenerator.kt:191 */
 1532   1881   
            Ok(Self(inner))
        1882  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1533   1883   
        }
        1884  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1534   1885   
    }
        1886  +
        1887  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1535   1888   
}
 1536   1889   
pub(crate) mod sparse_length_list_unconstrained {
 1537   1890   
        1891  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1538   1892   
    #[derive(Debug, Clone)]
 1539   1893   
    pub(crate) struct SparseLengthListUnconstrained(
 1540   1894   
        pub(crate) std::vec::Vec<::std::option::Option<::std::string::String>>,
 1541   1895   
    );
 1542   1896   
 1543   1897   
    impl From<SparseLengthListUnconstrained>
 1544   1898   
        for crate::constrained::MaybeConstrained<crate::model::SparseLengthList>
 1545   1899   
    {
 1546   1900   
        fn from(value: SparseLengthListUnconstrained) -> Self {
 1547   1901   
            Self::Unconstrained(value)
 1548   1902   
        }
 1549   1903   
    }
        1904  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1550   1905   
    impl std::convert::TryFrom<SparseLengthListUnconstrained> for crate::model::SparseLengthList {
        1906  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1551   1907   
        type Error = crate::model::sparse_length_list::ConstraintViolation;
        1908  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1552   1909   
        fn try_from(
 1553   1910   
            value: SparseLengthListUnconstrained,
 1554   1911   
        ) -> std::result::Result<Self, Self::Error> {
        1912  +
            /* UnconstrainedCollectionGenerator.kt:185 */
 1555   1913   
            let inner = value.0;
        1914  +
            /* UnconstrainedCollectionGenerator.kt:189 */
 1556   1915   
            Self::try_from(inner)
        1916  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1557   1917   
        }
        1918  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1558   1919   
    }
        1920  +
        1921  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1559   1922   
}
 1560   1923   
pub(crate) mod sparse_length_map_unconstrained {
 1561   1924   
        1925  +
    /* UnconstrainedMapGenerator.kt:79 */
 1562   1926   
    #[derive(Debug, Clone)]
 1563   1927   
    pub(crate) struct SparseLengthMapUnconstrained(
 1564   1928   
        pub(crate)  std::collections::HashMap<
 1565   1929   
            ::std::string::String,
 1566   1930   
            ::std::option::Option<::std::string::String>,
 1567   1931   
        >,
 1568   1932   
    );
 1569   1933   
 1570   1934   
    impl From<SparseLengthMapUnconstrained>
 1571   1935   
        for crate::constrained::MaybeConstrained<crate::model::SparseLengthMap>
 1572   1936   
    {
 1573   1937   
        fn from(value: SparseLengthMapUnconstrained) -> Self {
 1574   1938   
            Self::Unconstrained(value)
 1575   1939   
        }
 1576   1940   
    }
        1941  +
    /* UnconstrainedMapGenerator.kt:101 */
 1577   1942   
    impl std::convert::TryFrom<SparseLengthMapUnconstrained> for crate::model::SparseLengthMap {
        1943  +
        /* UnconstrainedMapGenerator.kt:102 */
 1578   1944   
        type Error = crate::model::sparse_length_map::ConstraintViolation;
        1945  +
        /* UnconstrainedMapGenerator.kt:104 */
 1579   1946   
        fn try_from(value: SparseLengthMapUnconstrained) -> std::result::Result<Self, Self::Error> {
        1947  +
            /* UnconstrainedMapGenerator.kt:241 */
 1580   1948   
            let hm = value.0;
        1949  +
            /* UnconstrainedMapGenerator.kt:245 */
 1581   1950   
            Self::try_from(hm)
        1951  +
            /* UnconstrainedMapGenerator.kt:104 */
 1582   1952   
        }
        1953  +
        /* UnconstrainedMapGenerator.kt:101 */
 1583   1954   
    }
        1955  +
        1956  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1584   1957   
}
 1585   1958   
pub(crate) mod sparse_list_unconstrained {
 1586   1959   
        1960  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1587   1961   
    #[derive(Debug, Clone)]
 1588   1962   
    pub(crate) struct SparseListUnconstrained(
 1589   1963   
        pub(crate) std::vec::Vec<::std::option::Option<::std::string::String>>,
 1590   1964   
    );
 1591   1965   
 1592   1966   
    impl From<SparseListUnconstrained>
 1593   1967   
        for crate::constrained::MaybeConstrained<
 1594   1968   
            crate::constrained::sparse_list_constrained::SparseListConstrained,
 1595   1969   
        >
 1596   1970   
    {
 1597   1971   
        fn from(value: SparseListUnconstrained) -> Self {
 1598   1972   
            Self::Unconstrained(value)
 1599   1973   
        }
 1600   1974   
    }
        1975  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1601   1976   
    impl std::convert::TryFrom<SparseListUnconstrained>
 1602   1977   
        for crate::constrained::sparse_list_constrained::SparseListConstrained
 1603   1978   
    {
        1979  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1604   1980   
        type Error = crate::model::sparse_list::ConstraintViolation;
        1981  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1605   1982   
        fn try_from(value: SparseListUnconstrained) -> std::result::Result<Self, Self::Error> {
        1983  +
            /* UnconstrainedCollectionGenerator.kt:127 */
 1606   1984   
            let res: ::std::result::Result<
 1607   1985   
                ::std::vec::Vec<::std::option::Option<crate::model::LengthString>>,
 1608   1986   
                (usize, crate::model::length_string::ConstraintViolation),
 1609   1987   
            > = value
 1610   1988   
                .0
 1611   1989   
                .into_iter()
 1612   1990   
                .enumerate()
 1613   1991   
                .map(|(idx, inner)| {
 1614   1992   
                    inner
 1615   1993   
                        .map(|inner| {
 1616   1994   
                            inner
 1617   1995   
                                .try_into()
 1618   1996   
                                .map_err(|inner_violation| (idx, inner_violation))
 1619   1997   
                        })
 1620   1998   
                        .transpose()
 1621   1999   
                })
 1622   2000   
                .collect();
 1623   2001   
            let inner =
 1624   2002   
                res.map_err(|(idx, inner_violation)| Self::Error::Member(idx, inner_violation))?;
        2003  +
            /* UnconstrainedCollectionGenerator.kt:191 */
 1625   2004   
            Ok(Self(inner))
        2005  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1626   2006   
        }
        2007  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1627   2008   
    }
        2009  +
        2010  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1628   2011   
}
 1629   2012   
pub(crate) mod sparse_map_unconstrained {
 1630   2013   
        2014  +
    /* UnconstrainedMapGenerator.kt:79 */
 1631   2015   
    #[derive(Debug, Clone)]
 1632   2016   
    pub(crate) struct SparseMapUnconstrained(
 1633   2017   
        pub(crate)  std::collections::HashMap<
 1634   2018   
            ::std::string::String,
 1635   2019   
            ::std::option::Option<
 1636   2020   
                crate::unconstrained::unique_items_list_unconstrained::UniqueItemsListUnconstrained,
 1637   2021   
            >,
 1638   2022   
        >,
 1639   2023   
    );
 1640   2024   
 1641   2025   
    impl From<SparseMapUnconstrained>
 1642   2026   
        for crate::constrained::MaybeConstrained<
 1643   2027   
            crate::constrained::sparse_map_constrained::SparseMapConstrained,
 1644   2028   
        >
 1645   2029   
    {
 1646   2030   
        fn from(value: SparseMapUnconstrained) -> Self {
 1647   2031   
            Self::Unconstrained(value)
 1648   2032   
        }
 1649   2033   
    }
        2034  +
    /* UnconstrainedMapGenerator.kt:101 */
 1650   2035   
    impl std::convert::TryFrom<SparseMapUnconstrained>
 1651   2036   
        for crate::constrained::sparse_map_constrained::SparseMapConstrained
 1652   2037   
    {
        2038  +
        /* UnconstrainedMapGenerator.kt:102 */
 1653   2039   
        type Error = crate::model::sparse_map::ConstraintViolation;
        2040  +
        /* UnconstrainedMapGenerator.kt:104 */
 1654   2041   
        fn try_from(value: SparseMapUnconstrained) -> std::result::Result<Self, Self::Error> {
        2042  +
            /* UnconstrainedMapGenerator.kt:186 */
 1655   2043   
            let res: ::std::result::Result<
 1656   2044   
                ::std::collections::HashMap<
 1657   2045   
                    ::std::string::String,
 1658   2046   
                    ::std::option::Option<crate::model::UniqueItemsList>,
 1659   2047   
                >,
 1660   2048   
                Self::Error,
 1661   2049   
            > = value
 1662   2050   
                .0
 1663   2051   
                .into_iter()
 1664   2052   
                .map(|(k, v)| match v {
 1665   2053   
                    None => Ok((k, None)),
 1666   2054   
                    Some(v) => match crate::model::UniqueItemsList::try_from(v) {
 1667   2055   
                        Ok(v) => Ok((k, Some(v))),
 1668   2056   
                        Err(inner_constraint_violation) => {
 1669   2057   
                            Err(Self::Error::Value(k, inner_constraint_violation))
 1670   2058   
                        }
 1671   2059   
                    },
 1672   2060   
                })
 1673   2061   
                .collect();
 1674   2062   
            let hm = res?;
        2063  +
            /* UnconstrainedMapGenerator.kt:247 */
 1675   2064   
            Ok(Self(hm))
        2065  +
            /* UnconstrainedMapGenerator.kt:104 */
 1676   2066   
        }
        2067  +
        /* UnconstrainedMapGenerator.kt:101 */
 1677   2068   
    }
        2069  +
        2070  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1678   2071   
}
 1679   2072   
pub(crate) mod unique_items_list_unconstrained {
 1680   2073   
        2074  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1681   2075   
    #[derive(Debug, Clone)]
 1682   2076   
    pub(crate) struct UniqueItemsListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
 1683   2077   
 1684   2078   
    impl From<UniqueItemsListUnconstrained>
 1685   2079   
        for crate::constrained::MaybeConstrained<crate::model::UniqueItemsList>
 1686   2080   
    {
 1687   2081   
        fn from(value: UniqueItemsListUnconstrained) -> Self {
 1688   2082   
            Self::Unconstrained(value)
 1689   2083   
        }
 1690   2084   
    }
        2085  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1691   2086   
    impl std::convert::TryFrom<UniqueItemsListUnconstrained> for crate::model::UniqueItemsList {
        2087  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1692   2088   
        type Error = crate::model::unique_items_list::ConstraintViolation;
        2089  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1693   2090   
        fn try_from(value: UniqueItemsListUnconstrained) -> std::result::Result<Self, Self::Error> {
        2091  +
            /* UnconstrainedCollectionGenerator.kt:185 */
 1694   2092   
            let inner = value.0;
        2093  +
            /* UnconstrainedCollectionGenerator.kt:189 */
 1695   2094   
            Self::try_from(inner)
        2095  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1696   2096   
        }
        2097  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1697   2098   
    }
        2099  +
        2100  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1698   2101   
}
 1699   2102   
pub(crate) mod map_of_map_of_list_of_list_of_con_b_unconstrained {
 1700   2103   
        2104  +
    /* UnconstrainedMapGenerator.kt:79 */
 1701   2105   
    #[derive(Debug, Clone)]
 1702   2106   
    pub(crate) struct MapOfMapOfListOfListOfConBUnconstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::unconstrained::map_of_list_of_list_of_con_b_unconstrained::MapOfListOfListOfConBUnconstrained>);
 1703   2107   
 1704   2108   
    impl From<MapOfMapOfListOfListOfConBUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_map_of_list_of_list_of_con_b_constrained::MapOfMapOfListOfListOfConBConstrained> {
 1705   2109   
                        fn from(value: MapOfMapOfListOfListOfConBUnconstrained) -> Self {
 1706   2110   
                            Self::Unconstrained(value)
 1707   2111   
                        }
 1708   2112   
                    }
        2113  +
    /* UnconstrainedMapGenerator.kt:101 */
 1709   2114   
    impl std::convert::TryFrom<MapOfMapOfListOfListOfConBUnconstrained> for crate::constrained::map_of_map_of_list_of_list_of_con_b_constrained::MapOfMapOfListOfListOfConBConstrained {
 1710         -
        type Error = crate::model::map_of_map_of_list_of_list_of_con_b::ConstraintViolation;
 1711         -
        fn try_from(value: MapOfMapOfListOfListOfConBUnconstrained) -> std::result::Result<Self, Self::Error> {
 1712         -
            let res: ::std::result::Result<::std::collections::HashMap<::std::string::String, crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained>, Self::Error> = value.0
        2115  +
        /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_map_of_list_of_list_of_con_b::ConstraintViolation;
        2116  +
        /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfMapOfListOfListOfConBUnconstrained) -> std::result::Result<Self, Self::Error> {
        2117  +
            /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<::std::string::String, crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained>, Self::Error> = value.0
 1713   2118   
                                        .into_iter()
 1714   2119   
                                        .map(|(k, v)| {
 1715   2120   
                                            match crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained::try_from(v) {
 1716   2121   
                                                    Ok(v) => Ok((k, v)),
 1717   2122   
                                                    Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
 1718   2123   
                                                }
 1719   2124   
                                        })
 1720   2125   
                                        .collect();
 1721   2126   
                                    let hm = res?;
 1722         -
            Ok(Self(hm))
 1723         -
        }
 1724         -
    }
        2127  +
            /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
        2128  +
        /* UnconstrainedMapGenerator.kt:104 */}
        2129  +
    /* UnconstrainedMapGenerator.kt:101 */}
        2130  +
        2131  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1725   2132   
}
 1726   2133   
pub(crate) mod map_of_list_of_list_of_con_b_unconstrained {
 1727   2134   
        2135  +
    /* UnconstrainedMapGenerator.kt:79 */
 1728   2136   
    #[derive(Debug, Clone)]
 1729   2137   
    pub(crate) struct MapOfListOfListOfConBUnconstrained(
 1730   2138   
        pub(crate)  std::collections::HashMap<
 1731   2139   
            ::std::string::String,
 1732   2140   
            crate::unconstrained::con_b_list_unconstrained::ConBListUnconstrained,
 1733   2141   
        >,
 1734   2142   
    );
 1735   2143   
 1736   2144   
    impl From<MapOfListOfListOfConBUnconstrained> for crate::constrained::MaybeConstrained<crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained> {
 1737   2145   
                        fn from(value: MapOfListOfListOfConBUnconstrained) -> Self {
 1738   2146   
                            Self::Unconstrained(value)
 1739   2147   
                        }
 1740   2148   
                    }
        2149  +
    /* UnconstrainedMapGenerator.kt:101 */
 1741   2150   
    impl std::convert::TryFrom<MapOfListOfListOfConBUnconstrained> for crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained {
 1742         -
        type Error = crate::model::map_of_list_of_list_of_con_b::ConstraintViolation;
 1743         -
        fn try_from(value: MapOfListOfListOfConBUnconstrained) -> std::result::Result<Self, Self::Error> {
 1744         -
            let res: ::std::result::Result<::std::collections::HashMap<::std::string::String, crate::constrained::con_b_list_constrained::ConBListConstrained>, Self::Error> = value.0
        2151  +
        /* UnconstrainedMapGenerator.kt:102 */type Error = crate::model::map_of_list_of_list_of_con_b::ConstraintViolation;
        2152  +
        /* UnconstrainedMapGenerator.kt:104 */fn try_from(value: MapOfListOfListOfConBUnconstrained) -> std::result::Result<Self, Self::Error> {
        2153  +
            /* UnconstrainedMapGenerator.kt:186 */let res: ::std::result::Result<::std::collections::HashMap<::std::string::String, crate::constrained::con_b_list_constrained::ConBListConstrained>, Self::Error> = value.0
 1745   2154   
                                        .into_iter()
 1746   2155   
                                        .map(|(k, v)| {
 1747   2156   
                                            match crate::constrained::con_b_list_constrained::ConBListConstrained::try_from(v) {
 1748   2157   
                                                    Ok(v) => Ok((k, v)),
 1749   2158   
                                                    Err(inner_constraint_violation) => Err(Self::Error::Value(k, inner_constraint_violation)),
 1750   2159   
                                                }
 1751   2160   
                                        })
 1752   2161   
                                        .collect();
 1753   2162   
                                    let hm = res?;
 1754         -
            Ok(Self(hm))
 1755         -
        }
 1756         -
    }
        2163  +
            /* UnconstrainedMapGenerator.kt:247 */Ok(Self(hm))
        2164  +
        /* UnconstrainedMapGenerator.kt:104 */}
        2165  +
    /* UnconstrainedMapGenerator.kt:101 */}
        2166  +
        2167  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1757   2168   
}
 1758   2169   
pub(crate) mod length_map_unconstrained {
 1759   2170   
        2171  +
    /* UnconstrainedMapGenerator.kt:79 */
 1760   2172   
    #[derive(Debug, Clone)]
 1761   2173   
    pub(crate) struct LengthMapUnconstrained(
 1762   2174   
        pub(crate) std::collections::HashMap<::std::string::String, ::std::string::String>,
 1763   2175   
    );
 1764   2176   
 1765   2177   
    impl From<LengthMapUnconstrained>
 1766   2178   
        for crate::constrained::MaybeConstrained<crate::model::LengthMap>
 1767   2179   
    {
 1768   2180   
        fn from(value: LengthMapUnconstrained) -> Self {
 1769   2181   
            Self::Unconstrained(value)
 1770   2182   
        }
 1771   2183   
    }
        2184  +
    /* UnconstrainedMapGenerator.kt:101 */
 1772   2185   
    impl std::convert::TryFrom<LengthMapUnconstrained> for crate::model::LengthMap {
        2186  +
        /* UnconstrainedMapGenerator.kt:102 */
 1773   2187   
        type Error = crate::model::length_map::ConstraintViolation;
        2188  +
        /* UnconstrainedMapGenerator.kt:104 */
 1774   2189   
        fn try_from(value: LengthMapUnconstrained) -> std::result::Result<Self, Self::Error> {
        2190  +
            /* UnconstrainedMapGenerator.kt:241 */
 1775   2191   
            let hm = value.0;
        2192  +
            /* UnconstrainedMapGenerator.kt:245 */
 1776   2193   
            Self::try_from(hm)
        2194  +
            /* UnconstrainedMapGenerator.kt:104 */
 1777   2195   
        }
        2196  +
        /* UnconstrainedMapGenerator.kt:101 */
 1778   2197   
    }
        2198  +
        2199  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1779   2200   
}
 1780   2201   
pub(crate) mod sensitive_length_list_unconstrained {
 1781   2202   
        2203  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1782   2204   
    #[derive(Debug, Clone)]
 1783   2205   
    pub(crate) struct SensitiveLengthListUnconstrained(
 1784   2206   
        pub(crate) std::vec::Vec<crate::model::SensitiveStructure>,
 1785   2207   
    );
 1786   2208   
 1787   2209   
    impl From<SensitiveLengthListUnconstrained>
 1788   2210   
        for crate::constrained::MaybeConstrained<crate::model::SensitiveLengthList>
 1789   2211   
    {
 1790   2212   
        fn from(value: SensitiveLengthListUnconstrained) -> Self {
 1791   2213   
            Self::Unconstrained(value)
 1792   2214   
        }
 1793   2215   
    }
        2216  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1794   2217   
    impl std::convert::TryFrom<SensitiveLengthListUnconstrained> for crate::model::SensitiveLengthList {
        2218  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1795   2219   
        type Error = crate::model::sensitive_length_list::ConstraintViolation;
        2220  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1796   2221   
        fn try_from(
 1797   2222   
            value: SensitiveLengthListUnconstrained,
 1798   2223   
        ) -> std::result::Result<Self, Self::Error> {
        2224  +
            /* UnconstrainedCollectionGenerator.kt:185 */
 1799   2225   
            let inner = value.0;
        2226  +
            /* UnconstrainedCollectionGenerator.kt:189 */
 1800   2227   
            Self::try_from(inner)
        2228  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1801   2229   
        }
        2230  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1802   2231   
    }
        2232  +
        2233  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1803   2234   
}
 1804   2235   
pub(crate) mod length_list_unconstrained {
 1805   2236   
        2237  +
    /* UnconstrainedCollectionGenerator.kt:77 */
 1806   2238   
    #[derive(Debug, Clone)]
 1807   2239   
    pub(crate) struct LengthListUnconstrained(pub(crate) std::vec::Vec<::std::string::String>);
 1808   2240   
 1809   2241   
    impl From<LengthListUnconstrained>
 1810   2242   
        for crate::constrained::MaybeConstrained<crate::model::LengthList>
 1811   2243   
    {
 1812   2244   
        fn from(value: LengthListUnconstrained) -> Self {
 1813   2245   
            Self::Unconstrained(value)
 1814   2246   
        }
 1815   2247   
    }
        2248  +
    /* UnconstrainedCollectionGenerator.kt:97 */
 1816   2249   
    impl std::convert::TryFrom<LengthListUnconstrained> for crate::model::LengthList {
        2250  +
        /* UnconstrainedCollectionGenerator.kt:98 */
 1817   2251   
        type Error = crate::model::length_list::ConstraintViolation;
        2252  +
        /* UnconstrainedCollectionGenerator.kt:100 */
 1818   2253   
        fn try_from(value: LengthListUnconstrained) -> std::result::Result<Self, Self::Error> {
        2254  +
            /* UnconstrainedCollectionGenerator.kt:185 */
 1819   2255   
            let inner = value.0;
        2256  +
            /* UnconstrainedCollectionGenerator.kt:189 */
 1820   2257   
            Self::try_from(inner)
        2258  +
            /* UnconstrainedCollectionGenerator.kt:100 */
 1821   2259   
        }
        2260  +
        /* UnconstrainedCollectionGenerator.kt:97 */
 1822   2261   
    }
        2262  +
        2263  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
 1823   2264   
}

tmp-codegen-diff/codegen-server-test/constraints_without_public_constrained_types/rust-server-codegen/src/constrained.rs

@@ -1,1 +719,1116 @@
    1      1   
// Code generated by software.amazon.smithy.rust.codegen.smithy-rs. DO NOT EDIT.
    2      2   
    3      3   
pub(crate) mod map_of_enum_string_constrained {
    4      4   
           5  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
    5      6   
    #[derive(Debug, Clone)]
    6      7   
    pub(crate) struct MapOfEnumStringConstrained(
    7      8   
        pub(crate) std::collections::HashMap<crate::model::EnumString, crate::model::EnumString>,
    8      9   
    );
    9     10   
   10     11   
    impl crate::constrained::Constrained for MapOfEnumStringConstrained {
   11     12   
        type Unconstrained =
   12     13   
            crate::unconstrained::map_of_enum_string_unconstrained::MapOfEnumStringUnconstrained;
   13     14   
    }
          15  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
   14     16   
    impl ::std::convert::From<MapOfEnumStringConstrained>
   15     17   
        for ::std::collections::HashMap<crate::model::EnumString, crate::model::EnumString>
   16     18   
    {
          19  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
   17     20   
        fn from(v: MapOfEnumStringConstrained) -> Self {
          21  +
            /* PubCrateConstrainedMapGenerator.kt:144 */
   18     22   
            v.0
          23  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
   19     24   
        }
          25  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
   20     26   
    }
          27  +
          28  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
   21     29   
}
   22     30   
pub(crate) mod map_of_list_of_length_pattern_string_constrained {
   23     31   
          32  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
   24     33   
    #[derive(Debug, Clone)]
   25     34   
    pub(crate) struct MapOfListOfLengthPatternStringConstrained(pub(crate) std::collections::HashMap<crate::model::LengthPatternString, crate::constrained::list_of_length_pattern_string_constrained::ListOfLengthPatternStringConstrained>);
   26     35   
   27     36   
    impl crate::constrained::Constrained for MapOfListOfLengthPatternStringConstrained {
   28     37   
        type Unconstrained = crate::unconstrained::map_of_list_of_length_pattern_string_unconstrained::MapOfListOfLengthPatternStringUnconstrained;
   29     38   
    }
          39  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
   30     40   
    impl ::std::convert::From<MapOfListOfLengthPatternStringConstrained>
   31     41   
        for ::std::collections::HashMap<
   32     42   
            ::std::string::String,
   33     43   
            ::std::vec::Vec<::std::string::String>,
   34     44   
        >
   35     45   
    {
          46  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
   36     47   
        fn from(v: MapOfListOfLengthPatternStringConstrained) -> Self {
          48  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
   37     49   
            v.0.into_iter()
   38     50   
                .map(|(k, v)| {
          51  +
                    /* PubCrateConstrainedMapGenerator.kt:132 */
   39     52   
                    let k = k.into();
   40         -
                    let v = { v.into() };
          53  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
          54  +
                    let v = {
          55  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
          56  +
                        v.into()
          57  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
          58  +
                    };
          59  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
   41     60   
                    (k, v)
          61  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
   42     62   
                })
   43     63   
                .collect()
          64  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
   44     65   
        }
          66  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
   45     67   
    }
          68  +
          69  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
   46     70   
}
   47     71   
pub(crate) mod list_of_length_pattern_string_constrained {
   48     72   
          73  +
    /* PubCrateConstrainedCollectionGenerator.kt:79 */
   49     74   
    #[derive(Debug, Clone)]
   50     75   
    pub(crate) struct ListOfLengthPatternStringConstrained(
   51     76   
        pub(crate) std::vec::Vec<crate::model::LengthPatternString>,
   52     77   
    );
   53     78   
   54     79   
    impl crate::constrained::Constrained for ListOfLengthPatternStringConstrained {
   55     80   
        type Unconstrained = crate::unconstrained::list_of_length_pattern_string_unconstrained::ListOfLengthPatternStringUnconstrained;
   56     81   
    }
          82  +
    /* PubCrateConstrainedCollectionGenerator.kt:140 */
   57     83   
    impl ::std::convert::From<ListOfLengthPatternStringConstrained>
   58     84   
        for ::std::vec::Vec<::std::string::String>
   59     85   
    {
          86  +
        /* PubCrateConstrainedCollectionGenerator.kt:141 */
   60     87   
        fn from(v: ListOfLengthPatternStringConstrained) -> Self {
   61         -
            v.0.into_iter().map(|item| item.into()).collect()
          88  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */
          89  +
            v.0.into_iter().map(|item|
          90  +
                /* PubCrateConstrainedCollectionGenerator.kt:145 */item.into()
          91  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */).collect()
          92  +
            /* PubCrateConstrainedCollectionGenerator.kt:141 */
   62     93   
        }
          94  +
        /* PubCrateConstrainedCollectionGenerator.kt:140 */
   63     95   
    }
          96  +
          97  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
   64     98   
}
   65     99   
pub(crate) mod map_of_length_pattern_string_constrained {
   66    100   
         101  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
   67    102   
    #[derive(Debug, Clone)]
   68    103   
    pub(crate) struct MapOfLengthPatternStringConstrained(
   69    104   
        pub(crate)  std::collections::HashMap<
   70    105   
            crate::model::LengthPatternString,
   71    106   
            crate::model::LengthPatternString,
   72    107   
        >,
   73    108   
    );
   74    109   
   75    110   
    impl crate::constrained::Constrained for MapOfLengthPatternStringConstrained {
   76    111   
        type Unconstrained = crate::unconstrained::map_of_length_pattern_string_unconstrained::MapOfLengthPatternStringUnconstrained;
   77    112   
    }
         113  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
   78    114   
    impl ::std::convert::From<MapOfLengthPatternStringConstrained>
   79    115   
        for ::std::collections::HashMap<::std::string::String, ::std::string::String>
   80    116   
    {
         117  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
   81    118   
        fn from(v: MapOfLengthPatternStringConstrained) -> Self {
         119  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
   82    120   
            v.0.into_iter()
   83    121   
                .map(|(k, v)| {
         122  +
                    /* PubCrateConstrainedMapGenerator.kt:132 */
   84    123   
                    let k = k.into();
   85         -
                    let v = { v.into() };
         124  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         125  +
                    let v = {
         126  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
         127  +
                        v.into()
         128  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
         129  +
                    };
         130  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
   86    131   
                    (k, v)
         132  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
   87    133   
                })
   88    134   
                .collect()
         135  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
   89    136   
        }
         137  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
   90    138   
    }
         139  +
         140  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
   91    141   
}
   92    142   
pub(crate) mod map_of_list_of_pattern_string_constrained {
   93    143   
         144  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
   94    145   
    #[derive(Debug, Clone)]
   95    146   
    pub(crate) struct MapOfListOfPatternStringConstrained(
   96    147   
        pub(crate)  std::collections::HashMap<
   97    148   
            crate::model::PatternString,
   98    149   
            crate::constrained::list_of_pattern_string_constrained::ListOfPatternStringConstrained,
   99    150   
        >,
  100    151   
    );
  101    152   
  102    153   
    impl crate::constrained::Constrained for MapOfListOfPatternStringConstrained {
  103    154   
        type Unconstrained = crate::unconstrained::map_of_list_of_pattern_string_unconstrained::MapOfListOfPatternStringUnconstrained;
  104    155   
    }
         156  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  105    157   
    impl ::std::convert::From<MapOfListOfPatternStringConstrained>
  106    158   
        for ::std::collections::HashMap<
  107    159   
            ::std::string::String,
  108    160   
            ::std::vec::Vec<::std::string::String>,
  109    161   
        >
  110    162   
    {
         163  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  111    164   
        fn from(v: MapOfListOfPatternStringConstrained) -> Self {
         165  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  112    166   
            v.0.into_iter()
  113    167   
                .map(|(k, v)| {
         168  +
                    /* PubCrateConstrainedMapGenerator.kt:132 */
  114    169   
                    let k = k.into();
  115         -
                    let v = { v.into() };
         170  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         171  +
                    let v = {
         172  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
         173  +
                        v.into()
         174  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
         175  +
                    };
         176  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  116    177   
                    (k, v)
         178  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  117    179   
                })
  118    180   
                .collect()
         181  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  119    182   
        }
         183  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  120    184   
    }
         185  +
         186  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  121    187   
}
  122    188   
pub(crate) mod list_of_pattern_string_constrained {
  123    189   
         190  +
    /* PubCrateConstrainedCollectionGenerator.kt:79 */
  124    191   
    #[derive(Debug, Clone)]
  125    192   
    pub(crate) struct ListOfPatternStringConstrained(
  126    193   
        pub(crate) std::vec::Vec<crate::model::PatternString>,
  127    194   
    );
  128    195   
  129    196   
    impl crate::constrained::Constrained for ListOfPatternStringConstrained {
  130    197   
        type Unconstrained = crate::unconstrained::list_of_pattern_string_unconstrained::ListOfPatternStringUnconstrained;
  131    198   
    }
         199  +
    /* PubCrateConstrainedCollectionGenerator.kt:140 */
  132    200   
    impl ::std::convert::From<ListOfPatternStringConstrained>
  133    201   
        for ::std::vec::Vec<::std::string::String>
  134    202   
    {
         203  +
        /* PubCrateConstrainedCollectionGenerator.kt:141 */
  135    204   
        fn from(v: ListOfPatternStringConstrained) -> Self {
  136         -
            v.0.into_iter().map(|item| item.into()).collect()
         205  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */
         206  +
            v.0.into_iter().map(|item|
         207  +
                /* PubCrateConstrainedCollectionGenerator.kt:145 */item.into()
         208  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */).collect()
         209  +
            /* PubCrateConstrainedCollectionGenerator.kt:141 */
  137    210   
        }
         211  +
        /* PubCrateConstrainedCollectionGenerator.kt:140 */
  138    212   
    }
         213  +
         214  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  139    215   
}
  140    216   
pub(crate) mod map_of_pattern_string_constrained {
  141    217   
         218  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  142    219   
    #[derive(Debug, Clone)]
  143    220   
    pub(crate) struct MapOfPatternStringConstrained(
  144    221   
        pub(crate) 
  145    222   
            std::collections::HashMap<crate::model::PatternString, crate::model::PatternString>,
  146    223   
    );
  147    224   
  148    225   
    impl crate::constrained::Constrained for MapOfPatternStringConstrained {
  149    226   
        type Unconstrained = crate::unconstrained::map_of_pattern_string_unconstrained::MapOfPatternStringUnconstrained;
  150    227   
    }
         228  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  151    229   
    impl ::std::convert::From<MapOfPatternStringConstrained>
  152    230   
        for ::std::collections::HashMap<::std::string::String, ::std::string::String>
  153    231   
    {
         232  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  154    233   
        fn from(v: MapOfPatternStringConstrained) -> Self {
         234  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  155    235   
            v.0.into_iter()
  156    236   
                .map(|(k, v)| {
         237  +
                    /* PubCrateConstrainedMapGenerator.kt:132 */
  157    238   
                    let k = k.into();
  158         -
                    let v = { v.into() };
         239  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         240  +
                    let v = {
         241  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
         242  +
                        v.into()
         243  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
         244  +
                    };
         245  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  159    246   
                    (k, v)
         247  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  160    248   
                })
  161    249   
                .collect()
         250  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  162    251   
        }
         252  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  163    253   
    }
         254  +
         255  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  164    256   
}
  165    257   
pub(crate) mod map_of_list_of_enum_string_constrained {
  166    258   
         259  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  167    260   
    #[derive(Debug, Clone)]
  168    261   
    pub(crate) struct MapOfListOfEnumStringConstrained(
  169    262   
        pub(crate)  std::collections::HashMap<
  170    263   
            crate::model::EnumString,
  171    264   
            crate::constrained::list_of_enum_string_constrained::ListOfEnumStringConstrained,
  172    265   
        >,
  173    266   
    );
  174    267   
  175    268   
    impl crate::constrained::Constrained for MapOfListOfEnumStringConstrained {
  176    269   
        type Unconstrained = crate::unconstrained::map_of_list_of_enum_string_unconstrained::MapOfListOfEnumStringUnconstrained;
  177    270   
    }
         271  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  178    272   
    impl ::std::convert::From<MapOfListOfEnumStringConstrained>
  179    273   
        for ::std::collections::HashMap<
  180    274   
            crate::model::EnumString,
  181    275   
            ::std::vec::Vec<crate::model::EnumString>,
  182    276   
        >
  183    277   
    {
         278  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  184    279   
        fn from(v: MapOfListOfEnumStringConstrained) -> Self {
         280  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  185    281   
            v.0.into_iter()
  186    282   
                .map(|(k, v)| {
  187         -
                    let v = { v.into() };
         283  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         284  +
                    let v = {
         285  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
         286  +
                        v.into()
         287  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
         288  +
                    };
         289  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  188    290   
                    (k, v)
         291  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  189    292   
                })
  190    293   
                .collect()
         294  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  191    295   
        }
         296  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  192    297   
    }
         298  +
         299  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  193    300   
}
  194    301   
pub(crate) mod list_of_enum_string_constrained {
  195    302   
         303  +
    /* PubCrateConstrainedCollectionGenerator.kt:79 */
  196    304   
    #[derive(Debug, Clone)]
  197    305   
    pub(crate) struct ListOfEnumStringConstrained(
  198    306   
        pub(crate) std::vec::Vec<crate::model::EnumString>,
  199    307   
    );
  200    308   
  201    309   
    impl crate::constrained::Constrained for ListOfEnumStringConstrained {
  202    310   
        type Unconstrained =
  203    311   
            crate::unconstrained::list_of_enum_string_unconstrained::ListOfEnumStringUnconstrained;
  204    312   
    }
         313  +
    /* PubCrateConstrainedCollectionGenerator.kt:140 */
  205    314   
    impl ::std::convert::From<ListOfEnumStringConstrained>
  206    315   
        for ::std::vec::Vec<crate::model::EnumString>
  207    316   
    {
         317  +
        /* PubCrateConstrainedCollectionGenerator.kt:141 */
  208    318   
        fn from(v: ListOfEnumStringConstrained) -> Self {
         319  +
            /* PubCrateConstrainedCollectionGenerator.kt:149 */
  209    320   
            v.0
         321  +
            /* PubCrateConstrainedCollectionGenerator.kt:141 */
  210    322   
        }
         323  +
        /* PubCrateConstrainedCollectionGenerator.kt:140 */
  211    324   
    }
         325  +
         326  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  212    327   
}
  213    328   
pub(crate) mod map_of_length_list_of_pattern_string_constrained {
  214    329   
         330  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  215    331   
    #[derive(Debug, Clone)]
  216    332   
    pub(crate) struct MapOfLengthListOfPatternStringConstrained(
  217    333   
        pub(crate)  std::collections::HashMap<
  218    334   
            crate::model::PatternString,
  219    335   
            crate::model::LengthListOfPatternString,
  220    336   
        >,
  221    337   
    );
  222    338   
  223    339   
    impl crate::constrained::Constrained for MapOfLengthListOfPatternStringConstrained {
  224    340   
        type Unconstrained = crate::unconstrained::map_of_length_list_of_pattern_string_unconstrained::MapOfLengthListOfPatternStringUnconstrained;
  225    341   
    }
         342  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  226    343   
    impl ::std::convert::From<MapOfLengthListOfPatternStringConstrained>
  227    344   
        for ::std::collections::HashMap<
  228    345   
            ::std::string::String,
  229    346   
            ::std::vec::Vec<::std::string::String>,
  230    347   
        >
  231    348   
    {
         349  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  232    350   
        fn from(v: MapOfLengthListOfPatternStringConstrained) -> Self {
         351  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  233    352   
            v.0.into_iter()
  234    353   
                .map(|(k, v)| {
         354  +
                    /* PubCrateConstrainedMapGenerator.kt:132 */
  235    355   
                    let k = k.into();
  236         -
                    let v = { v.into() };
         356  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         357  +
                    let v = {
         358  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
         359  +
                        v.into()
         360  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
         361  +
                    };
         362  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  237    363   
                    (k, v)
         364  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  238    365   
                })
  239    366   
                .collect()
         367  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  240    368   
        }
         369  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  241    370   
    }
         371  +
         372  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  242    373   
}
  243    374   
pub(crate) mod map_of_set_of_length_string_constrained {
  244    375   
         376  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  245    377   
    #[derive(Debug, Clone)]
  246    378   
    pub(crate) struct MapOfSetOfLengthStringConstrained(
  247    379   
        pub(crate) 
  248    380   
            std::collections::HashMap<crate::model::LengthString, crate::model::SetOfLengthString>,
  249    381   
    );
  250    382   
  251    383   
    impl crate::constrained::Constrained for MapOfSetOfLengthStringConstrained {
  252    384   
        type Unconstrained = crate::unconstrained::map_of_set_of_length_string_unconstrained::MapOfSetOfLengthStringUnconstrained;
  253    385   
    }
         386  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  254    387   
    impl ::std::convert::From<MapOfSetOfLengthStringConstrained>
  255    388   
        for ::std::collections::HashMap<
  256    389   
            ::std::string::String,
  257    390   
            ::std::vec::Vec<::std::string::String>,
  258    391   
        >
  259    392   
    {
         393  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  260    394   
        fn from(v: MapOfSetOfLengthStringConstrained) -> Self {
         395  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  261    396   
            v.0.into_iter()
  262    397   
                .map(|(k, v)| {
         398  +
                    /* PubCrateConstrainedMapGenerator.kt:132 */
  263    399   
                    let k = k.into();
  264         -
                    let v = { v.into() };
         400  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         401  +
                    let v = {
         402  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
         403  +
                        v.into()
         404  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
         405  +
                    };
         406  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  265    407   
                    (k, v)
         408  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  266    409   
                })
  267    410   
                .collect()
         411  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  268    412   
        }
         413  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  269    414   
    }
         415  +
         416  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  270    417   
}
  271    418   
pub(crate) mod map_of_list_of_length_string_constrained {
  272    419   
         420  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  273    421   
    #[derive(Debug, Clone)]
  274    422   
    pub(crate) struct MapOfListOfLengthStringConstrained(
  275    423   
        pub(crate)  std::collections::HashMap<
  276    424   
            crate::model::LengthString,
  277    425   
            crate::constrained::list_of_length_string_constrained::ListOfLengthStringConstrained,
  278    426   
        >,
  279    427   
    );
  280    428   
  281    429   
    impl crate::constrained::Constrained for MapOfListOfLengthStringConstrained {
  282    430   
        type Unconstrained = crate::unconstrained::map_of_list_of_length_string_unconstrained::MapOfListOfLengthStringUnconstrained;
  283    431   
    }
         432  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  284    433   
    impl ::std::convert::From<MapOfListOfLengthStringConstrained>
  285    434   
        for ::std::collections::HashMap<
  286    435   
            ::std::string::String,
  287    436   
            ::std::vec::Vec<::std::string::String>,
  288    437   
        >
  289    438   
    {
         439  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  290    440   
        fn from(v: MapOfListOfLengthStringConstrained) -> Self {
         441  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  291    442   
            v.0.into_iter()
  292    443   
                .map(|(k, v)| {
         444  +
                    /* PubCrateConstrainedMapGenerator.kt:132 */
  293    445   
                    let k = k.into();
  294         -
                    let v = { v.into() };
         446  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         447  +
                    let v = {
         448  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
         449  +
                        v.into()
         450  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
         451  +
                    };
         452  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  295    453   
                    (k, v)
         454  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  296    455   
                })
  297    456   
                .collect()
         457  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  298    458   
        }
         459  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  299    460   
    }
         461  +
         462  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  300    463   
}
  301    464   
pub(crate) mod list_of_length_string_constrained {
  302    465   
         466  +
    /* PubCrateConstrainedCollectionGenerator.kt:79 */
  303    467   
    #[derive(Debug, Clone)]
  304    468   
    pub(crate) struct ListOfLengthStringConstrained(
  305    469   
        pub(crate) std::vec::Vec<crate::model::LengthString>,
  306    470   
    );
  307    471   
  308    472   
    impl crate::constrained::Constrained for ListOfLengthStringConstrained {
  309    473   
        type Unconstrained = crate::unconstrained::list_of_length_string_unconstrained::ListOfLengthStringUnconstrained;
  310    474   
    }
         475  +
    /* PubCrateConstrainedCollectionGenerator.kt:140 */
  311    476   
    impl ::std::convert::From<ListOfLengthStringConstrained>
  312    477   
        for ::std::vec::Vec<::std::string::String>
  313    478   
    {
         479  +
        /* PubCrateConstrainedCollectionGenerator.kt:141 */
  314    480   
        fn from(v: ListOfLengthStringConstrained) -> Self {
  315         -
            v.0.into_iter().map(|item| item.into()).collect()
         481  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */
         482  +
            v.0.into_iter().map(|item|
         483  +
                /* PubCrateConstrainedCollectionGenerator.kt:145 */item.into()
         484  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */).collect()
         485  +
            /* PubCrateConstrainedCollectionGenerator.kt:141 */
  316    486   
        }
         487  +
        /* PubCrateConstrainedCollectionGenerator.kt:140 */
  317    488   
    }
         489  +
         490  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  318    491   
}
  319    492   
pub(crate) mod map_of_length_string_constrained {
  320    493   
         494  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  321    495   
    #[derive(Debug, Clone)]
  322    496   
    pub(crate) struct MapOfLengthStringConstrained(
  323    497   
        pub(crate) std::collections::HashMap<crate::model::LengthString, crate::model::LengthString>,
  324    498   
    );
  325    499   
  326    500   
    impl crate::constrained::Constrained for MapOfLengthStringConstrained {
  327    501   
        type Unconstrained = crate::unconstrained::map_of_length_string_unconstrained::MapOfLengthStringUnconstrained;
  328    502   
    }
         503  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  329    504   
    impl ::std::convert::From<MapOfLengthStringConstrained>
  330    505   
        for ::std::collections::HashMap<::std::string::String, ::std::string::String>
  331    506   
    {
         507  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  332    508   
        fn from(v: MapOfLengthStringConstrained) -> Self {
         509  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  333    510   
            v.0.into_iter()
  334    511   
                .map(|(k, v)| {
         512  +
                    /* PubCrateConstrainedMapGenerator.kt:132 */
  335    513   
                    let k = k.into();
  336         -
                    let v = { v.into() };
         514  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         515  +
                    let v = {
         516  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
         517  +
                        v.into()
         518  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
         519  +
                    };
         520  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  337    521   
                    (k, v)
         522  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  338    523   
                })
  339    524   
                .collect()
         525  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  340    526   
        }
         527  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  341    528   
    }
         529  +
         530  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  342    531   
}
  343    532   
pub(crate) mod recursive_list_constrained {
  344    533   
         534  +
    /* PubCrateConstrainedCollectionGenerator.kt:79 */
  345    535   
    #[derive(Debug, Clone)]
  346    536   
    pub(crate) struct RecursiveListConstrained(
  347    537   
        pub(crate) std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>,
  348    538   
    );
  349    539   
  350    540   
    impl crate::constrained::Constrained for RecursiveListConstrained {
  351    541   
        type Unconstrained =
  352    542   
            crate::unconstrained::recursive_list_unconstrained::RecursiveListUnconstrained;
  353    543   
    }
         544  +
    /* PubCrateConstrainedCollectionGenerator.kt:140 */
  354    545   
    impl ::std::convert::From<RecursiveListConstrained>
  355    546   
        for ::std::vec::Vec<crate::model::RecursiveShapesInputOutputNested1>
  356    547   
    {
         548  +
        /* PubCrateConstrainedCollectionGenerator.kt:141 */
  357    549   
        fn from(v: RecursiveListConstrained) -> Self {
         550  +
            /* PubCrateConstrainedCollectionGenerator.kt:149 */
  358    551   
            v.0
         552  +
            /* PubCrateConstrainedCollectionGenerator.kt:141 */
  359    553   
        }
         554  +
        /* PubCrateConstrainedCollectionGenerator.kt:140 */
  360    555   
    }
         556  +
         557  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  361    558   
}
  362    559   
pub(crate) mod map_of_range_byte_constrained {
  363    560   
         561  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  364    562   
    #[derive(Debug, Clone)]
  365    563   
    pub(crate) struct MapOfRangeByteConstrained(
  366    564   
        pub(crate) std::collections::HashMap<::std::string::String, crate::model::RangeByte>,
  367    565   
    );
  368    566   
  369    567   
    impl crate::constrained::Constrained for MapOfRangeByteConstrained {
  370    568   
        type Unconstrained =
  371    569   
            crate::unconstrained::map_of_range_byte_unconstrained::MapOfRangeByteUnconstrained;
  372    570   
    }
         571  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  373    572   
    impl ::std::convert::From<MapOfRangeByteConstrained>
  374    573   
        for ::std::collections::HashMap<::std::string::String, i8>
  375    574   
    {
         575  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  376    576   
        fn from(v: MapOfRangeByteConstrained) -> Self {
         577  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  377    578   
            v.0.into_iter()
  378    579   
                .map(|(k, v)| {
  379         -
                    let v = { v.into() };
         580  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         581  +
                    let v = {
         582  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
         583  +
                        v.into()
         584  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
         585  +
                    };
         586  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  380    587   
                    (k, v)
         588  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  381    589   
                })
  382    590   
                .collect()
         591  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  383    592   
        }
         593  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  384    594   
    }
         595  +
         596  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  385    597   
}
  386    598   
pub(crate) mod list_of_range_byte_constrained {
  387    599   
         600  +
    /* PubCrateConstrainedCollectionGenerator.kt:79 */
  388    601   
    #[derive(Debug, Clone)]
  389    602   
    pub(crate) struct ListOfRangeByteConstrained(pub(crate) std::vec::Vec<crate::model::RangeByte>);
  390    603   
  391    604   
    impl crate::constrained::Constrained for ListOfRangeByteConstrained {
  392    605   
        type Unconstrained =
  393    606   
            crate::unconstrained::list_of_range_byte_unconstrained::ListOfRangeByteUnconstrained;
  394    607   
    }
         608  +
    /* PubCrateConstrainedCollectionGenerator.kt:140 */
  395    609   
    impl ::std::convert::From<ListOfRangeByteConstrained> for ::std::vec::Vec<i8> {
         610  +
        /* PubCrateConstrainedCollectionGenerator.kt:141 */
  396    611   
        fn from(v: ListOfRangeByteConstrained) -> Self {
  397         -
            v.0.into_iter().map(|item| item.into()).collect()
         612  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */
         613  +
            v.0.into_iter().map(|item|
         614  +
                /* PubCrateConstrainedCollectionGenerator.kt:145 */item.into()
         615  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */).collect()
         616  +
            /* PubCrateConstrainedCollectionGenerator.kt:141 */
  398    617   
        }
         618  +
        /* PubCrateConstrainedCollectionGenerator.kt:140 */
  399    619   
    }
         620  +
         621  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  400    622   
}
  401    623   
pub(crate) mod map_of_range_long_constrained {
  402    624   
         625  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  403    626   
    #[derive(Debug, Clone)]
  404    627   
    pub(crate) struct MapOfRangeLongConstrained(
  405    628   
        pub(crate) std::collections::HashMap<::std::string::String, crate::model::RangeLong>,
  406    629   
    );
  407    630   
  408    631   
    impl crate::constrained::Constrained for MapOfRangeLongConstrained {
  409    632   
        type Unconstrained =
  410    633   
            crate::unconstrained::map_of_range_long_unconstrained::MapOfRangeLongUnconstrained;
  411    634   
    }
         635  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  412    636   
    impl ::std::convert::From<MapOfRangeLongConstrained>
  413    637   
        for ::std::collections::HashMap<::std::string::String, i64>
  414    638   
    {
         639  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  415    640   
        fn from(v: MapOfRangeLongConstrained) -> Self {
         641  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  416    642   
            v.0.into_iter()
  417    643   
                .map(|(k, v)| {
  418         -
                    let v = { v.into() };
         644  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         645  +
                    let v = {
         646  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
         647  +
                        v.into()
         648  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
         649  +
                    };
         650  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  419    651   
                    (k, v)
         652  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  420    653   
                })
  421    654   
                .collect()
         655  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  422    656   
        }
         657  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  423    658   
    }
         659  +
         660  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  424    661   
}
  425    662   
pub(crate) mod list_of_range_long_constrained {
  426    663   
         664  +
    /* PubCrateConstrainedCollectionGenerator.kt:79 */
  427    665   
    #[derive(Debug, Clone)]
  428    666   
    pub(crate) struct ListOfRangeLongConstrained(pub(crate) std::vec::Vec<crate::model::RangeLong>);
  429    667   
  430    668   
    impl crate::constrained::Constrained for ListOfRangeLongConstrained {
  431    669   
        type Unconstrained =
  432    670   
            crate::unconstrained::list_of_range_long_unconstrained::ListOfRangeLongUnconstrained;
  433    671   
    }
         672  +
    /* PubCrateConstrainedCollectionGenerator.kt:140 */
  434    673   
    impl ::std::convert::From<ListOfRangeLongConstrained> for ::std::vec::Vec<i64> {
         674  +
        /* PubCrateConstrainedCollectionGenerator.kt:141 */
  435    675   
        fn from(v: ListOfRangeLongConstrained) -> Self {
  436         -
            v.0.into_iter().map(|item| item.into()).collect()
         676  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */
         677  +
            v.0.into_iter().map(|item|
         678  +
                /* PubCrateConstrainedCollectionGenerator.kt:145 */item.into()
         679  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */).collect()
         680  +
            /* PubCrateConstrainedCollectionGenerator.kt:141 */
  437    681   
        }
         682  +
        /* PubCrateConstrainedCollectionGenerator.kt:140 */
  438    683   
    }
         684  +
         685  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  439    686   
}
  440    687   
pub(crate) mod map_of_range_short_constrained {
  441    688   
         689  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  442    690   
    #[derive(Debug, Clone)]
  443    691   
    pub(crate) struct MapOfRangeShortConstrained(
  444    692   
        pub(crate) std::collections::HashMap<::std::string::String, crate::model::RangeShort>,
  445    693   
    );
  446    694   
  447    695   
    impl crate::constrained::Constrained for MapOfRangeShortConstrained {
  448    696   
        type Unconstrained =
  449    697   
            crate::unconstrained::map_of_range_short_unconstrained::MapOfRangeShortUnconstrained;
  450    698   
    }
         699  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  451    700   
    impl ::std::convert::From<MapOfRangeShortConstrained>
  452    701   
        for ::std::collections::HashMap<::std::string::String, i16>
  453    702   
    {
         703  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  454    704   
        fn from(v: MapOfRangeShortConstrained) -> Self {
         705  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  455    706   
            v.0.into_iter()
  456    707   
                .map(|(k, v)| {
  457         -
                    let v = { v.into() };
         708  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         709  +
                    let v = {
         710  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
         711  +
                        v.into()
         712  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
         713  +
                    };
         714  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  458    715   
                    (k, v)
         716  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  459    717   
                })
  460    718   
                .collect()
         719  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  461    720   
        }
         721  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  462    722   
    }
         723  +
         724  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  463    725   
}
  464    726   
pub(crate) mod list_of_range_short_constrained {
  465    727   
         728  +
    /* PubCrateConstrainedCollectionGenerator.kt:79 */
  466    729   
    #[derive(Debug, Clone)]
  467    730   
    pub(crate) struct ListOfRangeShortConstrained(
  468    731   
        pub(crate) std::vec::Vec<crate::model::RangeShort>,
  469    732   
    );
  470    733   
  471    734   
    impl crate::constrained::Constrained for ListOfRangeShortConstrained {
  472    735   
        type Unconstrained =
  473    736   
            crate::unconstrained::list_of_range_short_unconstrained::ListOfRangeShortUnconstrained;
  474    737   
    }
         738  +
    /* PubCrateConstrainedCollectionGenerator.kt:140 */
  475    739   
    impl ::std::convert::From<ListOfRangeShortConstrained> for ::std::vec::Vec<i16> {
         740  +
        /* PubCrateConstrainedCollectionGenerator.kt:141 */
  476    741   
        fn from(v: ListOfRangeShortConstrained) -> Self {
  477         -
            v.0.into_iter().map(|item| item.into()).collect()
         742  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */
         743  +
            v.0.into_iter().map(|item|
         744  +
                /* PubCrateConstrainedCollectionGenerator.kt:145 */item.into()
         745  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */).collect()
         746  +
            /* PubCrateConstrainedCollectionGenerator.kt:141 */
  478    747   
        }
         748  +
        /* PubCrateConstrainedCollectionGenerator.kt:140 */
  479    749   
    }
         750  +
         751  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  480    752   
}
  481    753   
pub(crate) mod map_of_range_integer_constrained {
  482    754   
         755  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  483    756   
    #[derive(Debug, Clone)]
  484    757   
    pub(crate) struct MapOfRangeIntegerConstrained(
  485    758   
        pub(crate) std::collections::HashMap<::std::string::String, crate::model::RangeInteger>,
  486    759   
    );
  487    760   
  488    761   
    impl crate::constrained::Constrained for MapOfRangeIntegerConstrained {
  489    762   
        type Unconstrained = crate::unconstrained::map_of_range_integer_unconstrained::MapOfRangeIntegerUnconstrained;
  490    763   
    }
         764  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  491    765   
    impl ::std::convert::From<MapOfRangeIntegerConstrained>
  492    766   
        for ::std::collections::HashMap<::std::string::String, i32>
  493    767   
    {
         768  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  494    769   
        fn from(v: MapOfRangeIntegerConstrained) -> Self {
         770  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  495    771   
            v.0.into_iter()
  496    772   
                .map(|(k, v)| {
  497         -
                    let v = { v.into() };
         773  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         774  +
                    let v = {
         775  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
         776  +
                        v.into()
         777  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
         778  +
                    };
         779  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  498    780   
                    (k, v)
         781  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  499    782   
                })
  500    783   
                .collect()
         784  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  501    785   
        }
         786  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  502    787   
    }
         788  +
         789  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  503    790   
}
  504    791   
pub(crate) mod list_of_range_integer_constrained {
  505    792   
         793  +
    /* PubCrateConstrainedCollectionGenerator.kt:79 */
  506    794   
    #[derive(Debug, Clone)]
  507    795   
    pub(crate) struct ListOfRangeIntegerConstrained(
  508    796   
        pub(crate) std::vec::Vec<crate::model::RangeInteger>,
  509    797   
    );
  510    798   
  511    799   
    impl crate::constrained::Constrained for ListOfRangeIntegerConstrained {
  512    800   
        type Unconstrained = crate::unconstrained::list_of_range_integer_unconstrained::ListOfRangeIntegerUnconstrained;
  513    801   
    }
         802  +
    /* PubCrateConstrainedCollectionGenerator.kt:140 */
  514    803   
    impl ::std::convert::From<ListOfRangeIntegerConstrained> for ::std::vec::Vec<i32> {
         804  +
        /* PubCrateConstrainedCollectionGenerator.kt:141 */
  515    805   
        fn from(v: ListOfRangeIntegerConstrained) -> Self {
  516         -
            v.0.into_iter().map(|item| item.into()).collect()
         806  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */
         807  +
            v.0.into_iter().map(|item|
         808  +
                /* PubCrateConstrainedCollectionGenerator.kt:145 */item.into()
         809  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */).collect()
         810  +
            /* PubCrateConstrainedCollectionGenerator.kt:141 */
  517    811   
        }
         812  +
        /* PubCrateConstrainedCollectionGenerator.kt:140 */
  518    813   
    }
         814  +
         815  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  519    816   
}
  520    817   
pub(crate) mod map_of_length_blob_constrained {
  521    818   
         819  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  522    820   
    #[derive(Debug, Clone)]
  523    821   
    pub(crate) struct MapOfLengthBlobConstrained(
  524    822   
        pub(crate) std::collections::HashMap<::std::string::String, crate::model::LengthBlob>,
  525    823   
    );
  526    824   
  527    825   
    impl crate::constrained::Constrained for MapOfLengthBlobConstrained {
  528    826   
        type Unconstrained =
  529    827   
            crate::unconstrained::map_of_length_blob_unconstrained::MapOfLengthBlobUnconstrained;
  530    828   
    }
         829  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  531    830   
    impl ::std::convert::From<MapOfLengthBlobConstrained>
  532    831   
        for ::std::collections::HashMap<::std::string::String, ::aws_smithy_types::Blob>
  533    832   
    {
         833  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  534    834   
        fn from(v: MapOfLengthBlobConstrained) -> Self {
         835  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  535    836   
            v.0.into_iter()
  536    837   
                .map(|(k, v)| {
  537         -
                    let v = { v.into() };
         838  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         839  +
                    let v = {
         840  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
         841  +
                        v.into()
         842  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
         843  +
                    };
         844  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  538    845   
                    (k, v)
         846  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  539    847   
                })
  540    848   
                .collect()
         849  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  541    850   
        }
         851  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  542    852   
    }
         853  +
         854  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  543    855   
}
  544    856   
pub(crate) mod list_of_length_blob_constrained {
  545    857   
         858  +
    /* PubCrateConstrainedCollectionGenerator.kt:79 */
  546    859   
    #[derive(Debug, Clone)]
  547    860   
    pub(crate) struct ListOfLengthBlobConstrained(
  548    861   
        pub(crate) std::vec::Vec<crate::model::LengthBlob>,
  549    862   
    );
  550    863   
  551    864   
    impl crate::constrained::Constrained for ListOfLengthBlobConstrained {
  552    865   
        type Unconstrained =
  553    866   
            crate::unconstrained::list_of_length_blob_unconstrained::ListOfLengthBlobUnconstrained;
  554    867   
    }
         868  +
    /* PubCrateConstrainedCollectionGenerator.kt:140 */
  555    869   
    impl ::std::convert::From<ListOfLengthBlobConstrained>
  556    870   
        for ::std::vec::Vec<::aws_smithy_types::Blob>
  557    871   
    {
         872  +
        /* PubCrateConstrainedCollectionGenerator.kt:141 */
  558    873   
        fn from(v: ListOfLengthBlobConstrained) -> Self {
  559         -
            v.0.into_iter().map(|item| item.into()).collect()
         874  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */
         875  +
            v.0.into_iter().map(|item|
         876  +
                /* PubCrateConstrainedCollectionGenerator.kt:145 */item.into()
         877  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */).collect()
         878  +
            /* PubCrateConstrainedCollectionGenerator.kt:141 */
  560    879   
        }
         880  +
        /* PubCrateConstrainedCollectionGenerator.kt:140 */
  561    881   
    }
         882  +
         883  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  562    884   
}
  563    885   
pub(crate) mod con_b_list_constrained {
  564    886   
         887  +
    /* PubCrateConstrainedCollectionGenerator.kt:79 */
  565    888   
    #[derive(Debug, Clone)]
  566    889   
    pub(crate) struct ConBListConstrained(
  567    890   
        pub(crate)  std::vec::Vec<
  568    891   
            crate::constrained::con_b_list_inner_constrained::ConBListInnerConstrained,
  569    892   
        >,
  570    893   
    );
  571    894   
  572    895   
    impl crate::constrained::Constrained for ConBListConstrained {
  573    896   
        type Unconstrained = crate::unconstrained::con_b_list_unconstrained::ConBListUnconstrained;
  574    897   
    }
         898  +
    /* PubCrateConstrainedCollectionGenerator.kt:140 */
  575    899   
    impl ::std::convert::From<ConBListConstrained>
  576    900   
        for ::std::vec::Vec<::std::vec::Vec<crate::model::ConB>>
  577    901   
    {
         902  +
        /* PubCrateConstrainedCollectionGenerator.kt:141 */
  578    903   
        fn from(v: ConBListConstrained) -> Self {
  579         -
            v.0.into_iter().map(|item| item.into()).collect()
         904  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */
         905  +
            v.0.into_iter().map(|item|
         906  +
                /* PubCrateConstrainedCollectionGenerator.kt:145 */item.into()
         907  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */).collect()
         908  +
            /* PubCrateConstrainedCollectionGenerator.kt:141 */
  580    909   
        }
         910  +
        /* PubCrateConstrainedCollectionGenerator.kt:140 */
  581    911   
    }
         912  +
         913  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  582    914   
}
  583    915   
pub(crate) mod con_b_list_inner_constrained {
  584    916   
         917  +
    /* PubCrateConstrainedCollectionGenerator.kt:79 */
  585    918   
    #[derive(Debug, Clone)]
  586    919   
    pub(crate) struct ConBListInnerConstrained(pub(crate) std::vec::Vec<crate::model::ConB>);
  587    920   
  588    921   
    impl crate::constrained::Constrained for ConBListInnerConstrained {
  589    922   
        type Unconstrained =
  590    923   
            crate::unconstrained::con_b_list_inner_unconstrained::ConBListInnerUnconstrained;
  591    924   
    }
         925  +
    /* PubCrateConstrainedCollectionGenerator.kt:140 */
  592    926   
    impl ::std::convert::From<ConBListInnerConstrained> for ::std::vec::Vec<crate::model::ConB> {
         927  +
        /* PubCrateConstrainedCollectionGenerator.kt:141 */
  593    928   
        fn from(v: ConBListInnerConstrained) -> Self {
         929  +
            /* PubCrateConstrainedCollectionGenerator.kt:149 */
  594    930   
            v.0
         931  +
            /* PubCrateConstrainedCollectionGenerator.kt:141 */
  595    932   
        }
         933  +
        /* PubCrateConstrainedCollectionGenerator.kt:140 */
  596    934   
    }
         935  +
         936  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  597    937   
}
  598    938   
pub(crate) mod sparse_list_constrained {
  599    939   
         940  +
    /* PubCrateConstrainedCollectionGenerator.kt:79 */
  600    941   
    #[derive(Debug, Clone)]
  601    942   
    pub(crate) struct SparseListConstrained(
  602    943   
        pub(crate) std::vec::Vec<::std::option::Option<crate::model::LengthString>>,
  603    944   
    );
  604    945   
  605    946   
    impl crate::constrained::Constrained for SparseListConstrained {
  606    947   
        type Unconstrained =
  607    948   
            crate::unconstrained::sparse_list_unconstrained::SparseListUnconstrained;
  608    949   
    }
         950  +
    /* PubCrateConstrainedCollectionGenerator.kt:140 */
  609    951   
    impl ::std::convert::From<SparseListConstrained>
  610    952   
        for ::std::vec::Vec<::std::option::Option<::std::string::String>>
  611    953   
    {
         954  +
        /* PubCrateConstrainedCollectionGenerator.kt:141 */
  612    955   
        fn from(v: SparseListConstrained) -> Self {
  613         -
            v.0.into_iter()
  614         -
                .map(|item| item.map(|item| item.into()))
  615         -
                .collect()
         956  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */
         957  +
            v.0.into_iter().map(|item|
         958  +
                /* PubCrateConstrainedCollectionGenerator.kt:144 */item.map(|item|
         959  +
                    /* PubCrateConstrainedCollectionGenerator.kt:145 */item.into()
         960  +
                /* PubCrateConstrainedCollectionGenerator.kt:144 */)
         961  +
            /* PubCrateConstrainedCollectionGenerator.kt:143 */).collect()
         962  +
            /* PubCrateConstrainedCollectionGenerator.kt:141 */
  616    963   
        }
         964  +
        /* PubCrateConstrainedCollectionGenerator.kt:140 */
  617    965   
    }
         966  +
         967  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  618    968   
}
  619    969   
pub(crate) mod sparse_map_constrained {
  620    970   
         971  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  621    972   
    #[derive(Debug, Clone)]
  622    973   
    pub(crate) struct SparseMapConstrained(
  623    974   
        pub(crate)  std::collections::HashMap<
  624    975   
            ::std::string::String,
  625    976   
            ::std::option::Option<crate::model::UniqueItemsList>,
  626    977   
        >,
  627    978   
    );
  628    979   
  629    980   
    impl crate::constrained::Constrained for SparseMapConstrained {
  630    981   
        type Unconstrained = crate::unconstrained::sparse_map_unconstrained::SparseMapUnconstrained;
  631    982   
    }
         983  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  632    984   
    impl ::std::convert::From<SparseMapConstrained>
  633    985   
        for ::std::collections::HashMap<
  634    986   
            ::std::string::String,
  635    987   
            ::std::option::Option<::std::vec::Vec<::std::string::String>>,
  636    988   
        >
  637    989   
    {
         990  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  638    991   
        fn from(v: SparseMapConstrained) -> Self {
         992  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  639    993   
            v.0.into_iter()
  640    994   
                .map(|(k, v)| {
  641         -
                    let v = { v.map(|v| v.into()) };
         995  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
         996  +
                    let v = {
         997  +
                        /* PubCrateConstrainedMapGenerator.kt:136 */
         998  +
                        v.map(|v|
         999  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */v.into()
        1000  +
                    /* PubCrateConstrainedMapGenerator.kt:136 */)
        1001  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
        1002  +
                    };
        1003  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  642   1004   
                    (k, v)
        1005  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  643   1006   
                })
  644   1007   
                .collect()
        1008  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  645   1009   
        }
        1010  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  646   1011   
    }
        1012  +
        1013  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  647   1014   
}
  648   1015   
pub(crate) mod map_of_map_of_list_of_list_of_con_b_constrained {
  649   1016   
        1017  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  650   1018   
    #[derive(Debug, Clone)]
  651   1019   
    pub(crate) struct MapOfMapOfListOfListOfConBConstrained(pub(crate) std::collections::HashMap<::std::string::String, crate::constrained::map_of_list_of_list_of_con_b_constrained::MapOfListOfListOfConBConstrained>);
  652   1020   
  653   1021   
    impl crate::constrained::Constrained for MapOfMapOfListOfListOfConBConstrained {
  654   1022   
        type Unconstrained = crate::unconstrained::map_of_map_of_list_of_list_of_con_b_unconstrained::MapOfMapOfListOfListOfConBUnconstrained;
  655   1023   
    }
        1024  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  656   1025   
    impl ::std::convert::From<MapOfMapOfListOfListOfConBConstrained>
  657   1026   
        for ::std::collections::HashMap<
  658   1027   
            ::std::string::String,
  659   1028   
            ::std::collections::HashMap<
  660   1029   
                ::std::string::String,
  661   1030   
                ::std::vec::Vec<::std::vec::Vec<crate::model::ConB>>,
  662   1031   
            >,
  663   1032   
        >
  664   1033   
    {
        1034  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  665   1035   
        fn from(v: MapOfMapOfListOfListOfConBConstrained) -> Self {
        1036  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  666   1037   
            v.0.into_iter()
  667   1038   
                .map(|(k, v)| {
  668         -
                    let v = { v.into() };
        1039  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
        1040  +
                    let v = {
        1041  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
        1042  +
                        v.into()
        1043  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
        1044  +
                    };
        1045  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  669   1046   
                    (k, v)
        1047  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  670   1048   
                })
  671   1049   
                .collect()
        1050  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  672   1051   
        }
        1052  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  673   1053   
    }
        1054  +
        1055  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  674   1056   
}
  675   1057   
pub(crate) mod map_of_list_of_list_of_con_b_constrained {
  676   1058   
        1059  +
    /* PubCrateConstrainedMapGenerator.kt:80 */
  677   1060   
    #[derive(Debug, Clone)]
  678   1061   
    pub(crate) struct MapOfListOfListOfConBConstrained(
  679   1062   
        pub(crate)  std::collections::HashMap<
  680   1063   
            ::std::string::String,
  681   1064   
            crate::constrained::con_b_list_constrained::ConBListConstrained,
  682   1065   
        >,
  683   1066   
    );
  684   1067   
  685   1068   
    impl crate::constrained::Constrained for MapOfListOfListOfConBConstrained {
  686   1069   
        type Unconstrained = crate::unconstrained::map_of_list_of_list_of_con_b_unconstrained::MapOfListOfListOfConBUnconstrained;
  687   1070   
    }
        1071  +
    /* PubCrateConstrainedMapGenerator.kt:127 */
  688   1072   
    impl ::std::convert::From<MapOfListOfListOfConBConstrained>
  689   1073   
        for ::std::collections::HashMap<
  690   1074   
            ::std::string::String,
  691   1075   
            ::std::vec::Vec<::std::vec::Vec<crate::model::ConB>>,
  692   1076   
        >
  693   1077   
    {
        1078  +
        /* PubCrateConstrainedMapGenerator.kt:128 */
  694   1079   
        fn from(v: MapOfListOfListOfConBConstrained) -> Self {
        1080  +
            /* PubCrateConstrainedMapGenerator.kt:130 */
  695   1081   
            v.0.into_iter()
  696   1082   
                .map(|(k, v)| {
  697         -
                    let v = { v.into() };
        1083  +
                    /* PubCrateConstrainedMapGenerator.kt:135 */
        1084  +
                    let v = {
        1085  +
                        /* PubCrateConstrainedMapGenerator.kt:137 */
        1086  +
                        v.into()
        1087  +
                        /* PubCrateConstrainedMapGenerator.kt:135 */
        1088  +
                    };
        1089  +
                    /* PubCrateConstrainedMapGenerator.kt:141 */
  698   1090   
                    (k, v)
        1091  +
                    /* PubCrateConstrainedMapGenerator.kt:130 */
  699   1092   
                })
  700   1093   
                .collect()
        1094  +
            /* PubCrateConstrainedMapGenerator.kt:128 */
  701   1095   
        }
        1096  +
        /* PubCrateConstrainedMapGenerator.kt:127 */
  702   1097   
    }
        1098  +
        1099  +
    /* RustCrateInlineModuleComposingWriter.kt:299 */
  703   1100   
}
  704   1101   
  705   1102   
/*
  706   1103   
 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
  707   1104   
 * SPDX-License-Identifier: Apache-2.0
  708   1105   
 */
  709   1106   
  710   1107   
pub(crate) trait Constrained {
  711   1108   
    type Unconstrained;
  712   1109   
}