-module(sqlode@internal@codegen@models).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/sqlode/internal/codegen/models.gleam").
-export([render/6]).

-if(?OTP_RELEASE >= 27).
-define(MODULEDOC(Str), -moduledoc(Str)).
-define(DOC(Str), -doc(Str)).
-else.
-define(MODULEDOC(Str), -compile([])).
-define(DOC(Str), -compile([])).
-endif.

?MODULEDOC(false).

-file("src/sqlode/internal/codegen/models.gleam", 121).
?DOC(false).
-spec has_mysql_set(sqlode@internal@model:catalog()) -> boolean().
has_mysql_set(Catalog) ->
    gleam@list:any(
        erlang:element(3, Catalog),
        fun(E) -> erlang:element(4, E) =:= my_sql_set end
    ).

-file("src/sqlode/internal/codegen/models.gleam", 125).
?DOC(false).
-spec render_enum_type(sqlode@internal@model:enum_def()) -> binary().
render_enum_type(Enum_def) ->
    Type_name = sqlode@internal@type_mapping:enum_type_name(
        erlang:element(2, Enum_def)
    ),
    To_string_fn = sqlode@internal@type_mapping:enum_to_string_fn(
        erlang:element(2, Enum_def)
    ),
    From_string_fn = sqlode@internal@type_mapping:enum_from_string_fn(
        erlang:element(2, Enum_def)
    ),
    Default_fn = sqlode@internal@type_mapping:enum_default_fn(
        erlang:element(2, Enum_def)
    ),
    First_variant = case erlang:element(3, Enum_def) of
        [First | _] ->
            sqlode@internal@type_mapping:enum_value_name(First);

        [] ->
            Type_name
    end,
    Constructors = begin
        _pipe = sqlode@internal@codegen@builder:lines(
            gleam@list:map(
                erlang:element(3, Enum_def),
                fun sqlode@internal@type_mapping:enum_value_name/1
            )
        ),
        sqlode@internal@codegen@builder:indent(_pipe, 2)
    end,
    To_string_cases = begin
        _pipe@1 = sqlode@internal@codegen@builder:lines(
            gleam@list:map(
                erlang:element(3, Enum_def),
                fun(V) ->
                    <<<<<<(sqlode@internal@type_mapping:enum_value_name(V))/binary,
                                " -> \""/utf8>>/binary,
                            V/binary>>/binary,
                        "\""/utf8>>
                end
            )
        ),
        sqlode@internal@codegen@builder:indent(_pipe@1, 4)
    end,
    From_string_cases = begin
        _pipe@2 = sqlode@internal@codegen@builder:lines(
            gleam@list:map(
                erlang:element(3, Enum_def),
                fun(V@1) ->
                    <<<<<<<<"\""/utf8, V@1/binary>>/binary, "\" -> Ok("/utf8>>/binary,
                            (sqlode@internal@type_mapping:enum_value_name(V@1))/binary>>/binary,
                        ")"/utf8>>
                end
            )
        ),
        sqlode@internal@codegen@builder:indent(_pipe@2, 4)
    end,
    _pipe@3 = sqlode@internal@codegen@builder:concat(
        [sqlode@internal@codegen@builder:line(
                <<<<"pub type "/utf8, Type_name/binary>>/binary, " {"/utf8>>
            ),
            Constructors,
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>),
            sqlode@internal@codegen@builder:blank(),
            sqlode@internal@codegen@builder:line(
                <<<<<<<<"pub fn "/utf8, To_string_fn/binary>>/binary,
                            "(value: "/utf8>>/binary,
                        Type_name/binary>>/binary,
                    ") -> String {"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(<<"  case value {"/utf8>>),
            To_string_cases,
            sqlode@internal@codegen@builder:line(<<"  }"/utf8>>),
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>),
            sqlode@internal@codegen@builder:blank(),
            sqlode@internal@codegen@builder:line(
                <<<<<<<<"pub fn "/utf8, From_string_fn/binary>>/binary,
                            "(value: String) -> Result("/utf8>>/binary,
                        Type_name/binary>>/binary,
                    ", String) {"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(<<"  case value {"/utf8>>),
            From_string_cases,
            sqlode@internal@codegen@builder:line(
                <<<<"    _ -> Error(\"Unknown "/utf8,
                        (erlang:element(2, Enum_def))/binary>>/binary,
                    " value: \" <> value)"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(<<"  }"/utf8>>),
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>),
            sqlode@internal@codegen@builder:blank(),
            sqlode@internal@codegen@builder:line(
                <<<<<<<<"pub fn "/utf8, Default_fn/binary>>/binary,
                            "() -> "/utf8>>/binary,
                        Type_name/binary>>/binary,
                    " {"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(
                <<"  "/utf8, First_variant/binary>>
            ),
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>)]
    ),
    sqlode@internal@codegen@builder:render(_pipe@3).

-file("src/sqlode/internal/codegen/models.gleam", 201).
?DOC(false).
-spec render_set_type(sqlode@internal@model:enum_def()) -> binary().
render_set_type(Enum_def) ->
    Value_type = sqlode@internal@type_mapping:set_value_type_name(
        erlang:element(2, Enum_def)
    ),
    Value_to_string_fn = sqlode@internal@type_mapping:enum_to_string_fn(
        erlang:element(2, Enum_def)
    ),
    Value_from_string_fn = sqlode@internal@type_mapping:enum_from_string_fn(
        erlang:element(2, Enum_def)
    ),
    Set_to_string_fn = sqlode@internal@type_mapping:set_to_string_fn(
        erlang:element(2, Enum_def)
    ),
    Set_from_string_fn = sqlode@internal@type_mapping:set_from_string_fn(
        erlang:element(2, Enum_def)
    ),
    Constructors = begin
        _pipe = sqlode@internal@codegen@builder:lines(
            gleam@list:map(
                erlang:element(3, Enum_def),
                fun sqlode@internal@type_mapping:enum_value_name/1
            )
        ),
        sqlode@internal@codegen@builder:indent(_pipe, 2)
    end,
    To_string_cases = begin
        _pipe@1 = sqlode@internal@codegen@builder:lines(
            gleam@list:map(
                erlang:element(3, Enum_def),
                fun(V) ->
                    <<<<<<(sqlode@internal@type_mapping:enum_value_name(V))/binary,
                                " -> \""/utf8>>/binary,
                            V/binary>>/binary,
                        "\""/utf8>>
                end
            )
        ),
        sqlode@internal@codegen@builder:indent(_pipe@1, 4)
    end,
    From_string_cases = begin
        _pipe@2 = sqlode@internal@codegen@builder:lines(
            gleam@list:map(
                erlang:element(3, Enum_def),
                fun(V@1) ->
                    <<<<<<<<"\""/utf8, V@1/binary>>/binary, "\" -> Ok("/utf8>>/binary,
                            (sqlode@internal@type_mapping:enum_value_name(V@1))/binary>>/binary,
                        ")"/utf8>>
                end
            )
        ),
        sqlode@internal@codegen@builder:indent(_pipe@2, 4)
    end,
    _pipe@3 = sqlode@internal@codegen@builder:concat(
        [sqlode@internal@codegen@builder:line(
                <<<<"pub type "/utf8, Value_type/binary>>/binary, " {"/utf8>>
            ),
            Constructors,
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>),
            sqlode@internal@codegen@builder:blank(),
            sqlode@internal@codegen@builder:line(
                <<<<<<<<"pub fn "/utf8, Value_to_string_fn/binary>>/binary,
                            "(value: "/utf8>>/binary,
                        Value_type/binary>>/binary,
                    ") -> String {"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(<<"  case value {"/utf8>>),
            To_string_cases,
            sqlode@internal@codegen@builder:line(<<"  }"/utf8>>),
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>),
            sqlode@internal@codegen@builder:blank(),
            sqlode@internal@codegen@builder:line(
                <<<<<<<<"pub fn "/utf8, Value_from_string_fn/binary>>/binary,
                            "(value: String) -> Result("/utf8>>/binary,
                        Value_type/binary>>/binary,
                    ", String) {"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(<<"  case value {"/utf8>>),
            From_string_cases,
            sqlode@internal@codegen@builder:line(
                <<<<"    _ -> Error(\"Unknown "/utf8,
                        (erlang:element(2, Enum_def))/binary>>/binary,
                    " value: \" <> value)"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(<<"  }"/utf8>>),
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>),
            sqlode@internal@codegen@builder:blank(),
            sqlode@internal@codegen@builder:line(
                <<<<<<<<"pub fn "/utf8, Set_to_string_fn/binary>>/binary,
                            "(values: List("/utf8>>/binary,
                        Value_type/binary>>/binary,
                    ")) -> String {"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(
                <<<<"  values |> mysql_set_list.map("/utf8,
                        Value_to_string_fn/binary>>/binary,
                    ") |> mysql_set_string.join(\",\")"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>),
            sqlode@internal@codegen@builder:blank(),
            sqlode@internal@codegen@builder:line(
                <<<<<<<<"pub fn "/utf8, Set_from_string_fn/binary>>/binary,
                            "(value: String) -> Result(List("/utf8>>/binary,
                        Value_type/binary>>/binary,
                    "), String) {"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(<<"  case value {"/utf8>>),
            sqlode@internal@codegen@builder:line(<<"    \"\" -> Ok([])"/utf8>>),
            sqlode@internal@codegen@builder:line(
                <<<<"    _ -> value |> mysql_set_string.split(\",\") |> mysql_set_list.try_map("/utf8,
                        Value_from_string_fn/binary>>/binary,
                    ")"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(<<"  }"/utf8>>),
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>)]
    ),
    sqlode@internal@codegen@builder:render(_pipe@3).

-file("src/sqlode/internal/codegen/models.gleam", 114).
?DOC(false).
-spec render_enum_or_set_type(sqlode@internal@model:enum_def()) -> binary().
render_enum_or_set_type(Enum_def) ->
    case erlang:element(4, Enum_def) of
        postgres_enum ->
            render_enum_type(Enum_def);

        my_sql_enum ->
            render_enum_type(Enum_def);

        my_sql_set ->
            render_set_type(Enum_def)
    end.

-file("src/sqlode/internal/codegen/models.gleam", 343).
?DOC(false).
-spec collect_rich_scalar_types(
    sqlode@internal@model:catalog(),
    list(sqlode@internal@model:analyzed_query())
) -> list(sqlode@internal@model:scalar_type()).
collect_rich_scalar_types(Catalog, Queries) ->
    Table_types = begin
        _pipe = erlang:element(2, Catalog),
        gleam@list:flat_map(
            _pipe,
            fun(Table) ->
                gleam@list:filter_map(
                    erlang:element(3, Table),
                    fun(Col) ->
                        case sqlode@internal@type_mapping:is_rich_type(
                            erlang:element(3, Col)
                        ) of
                            true ->
                                {ok, erlang:element(3, Col)};

                            false ->
                                {error, nil}
                        end
                    end
                )
            end
        )
    end,
    Query_types = begin
        _pipe@1 = Queries,
        gleam@list:flat_map(
            _pipe@1,
            fun(Query) ->
                gleam@list:filter_map(
                    erlang:element(4, Query),
                    fun(Item) -> case Item of
                            {scalar_result,
                                {result_column, _, Scalar_type, _, _}} ->
                                case sqlode@internal@type_mapping:is_rich_type(
                                    Scalar_type
                                ) of
                                    true ->
                                        {ok, Scalar_type};

                                    false ->
                                        {error, nil}
                                end;

                            {embedded_result, _} ->
                                {error, nil}
                        end end
                )
            end
        )
    end,
    Param_types = begin
        _pipe@2 = Queries,
        gleam@list:flat_map(
            _pipe@2,
            fun(Query@1) ->
                gleam@list:filter_map(
                    erlang:element(3, Query@1),
                    fun(P) ->
                        case sqlode@internal@type_mapping:is_rich_type(
                            erlang:element(4, P)
                        ) of
                            true ->
                                {ok, erlang:element(4, P)};

                            false ->
                                {error, nil}
                        end
                    end
                )
            end
        )
    end,
    _pipe@3 = lists:append([Table_types, Query_types, Param_types]),
    _pipe@4 = gleam@list:unique(_pipe@3),
    gleam@list:sort(
        _pipe@4,
        fun(A, B) ->
            gleam@string:compare(
                sqlode@internal@type_mapping:scalar_type_to_gleam_type(
                    A,
                    rich_mapping
                ),
                sqlode@internal@type_mapping:scalar_type_to_gleam_type(
                    B,
                    rich_mapping
                )
            )
        end
    ).

-file("src/sqlode/internal/codegen/models.gleam", 294).
?DOC(false).
-spec render_semantic_type_aliases(
    sqlode@internal@model:catalog(),
    list(sqlode@internal@model:analyzed_query())
) -> binary().
render_semantic_type_aliases(Catalog, Queries) ->
    All_types = collect_rich_scalar_types(Catalog, Queries),
    _pipe = All_types,
    _pipe@2 = gleam@list:map(
        _pipe,
        fun(Scalar_type) ->
            Alias_name = sqlode@internal@type_mapping:scalar_type_to_gleam_type(
                Scalar_type,
                rich_mapping
            ),
            _pipe@1 = sqlode@internal@codegen@builder:concat(
                [sqlode@internal@codegen@builder:line(
                        <<<<"pub type "/utf8, Alias_name/binary>>/binary,
                            " ="/utf8>>
                    ),
                    sqlode@internal@codegen@builder:line(<<"  String"/utf8>>)]
            ),
            sqlode@internal@codegen@builder:render(_pipe@1)
        end
    ),
    gleam@string:join(_pipe@2, <<"\n\n"/utf8>>).

-file("src/sqlode/internal/codegen/models.gleam", 313).
?DOC(false).
-spec render_strong_type_wrappers(
    sqlode@internal@model:catalog(),
    list(sqlode@internal@model:analyzed_query())
) -> binary().
render_strong_type_wrappers(Catalog, Queries) ->
    All_types = collect_rich_scalar_types(Catalog, Queries),
    _pipe = All_types,
    _pipe@2 = gleam@list:map(
        _pipe,
        fun(Scalar_type) ->
            Type_name = sqlode@internal@type_mapping:scalar_type_to_gleam_type(
                Scalar_type,
                strong_mapping
            ),
            Unwrap_fn = case sqlode@internal@type_mapping:strong_type_unwrap_fn(
                Scalar_type
            ) of
                {some, Fn_name} ->
                    Fn_name;

                none ->
                    <<Type_name/binary, "_to_string"/utf8>>
            end,
            Body = <<<<"let "/utf8, Type_name/binary>>/binary,
                "(inner) = value\n  inner"/utf8>>,
            _pipe@1 = sqlode@internal@codegen@builder:concat(
                [sqlode@internal@codegen@builder:line(
                        sqlode@internal@codegen@common:gleam_type(
                            Type_name,
                            <<"String"/utf8>>
                        )
                    ),
                    sqlode@internal@codegen@builder:blank(),
                    sqlode@internal@codegen@builder:line(
                        sqlode@internal@codegen@common:gleam_fn(
                            Unwrap_fn,
                            <<"value: "/utf8, Type_name/binary>>,
                            <<"String"/utf8>>,
                            Body
                        )
                    )]
            ),
            sqlode@internal@codegen@builder:render(_pipe@1)
        end
    ),
    gleam@string:join(_pipe@2, <<"\n\n"/utf8>>).

-file("src/sqlode/internal/codegen/models.gleam", 399).
?DOC(false).
-spec needs_option_import_for_results(
    list(sqlode@internal@model:analyzed_query())
) -> boolean().
needs_option_import_for_results(Queries) ->
    gleam@list:any(
        Queries,
        fun(Query) ->
            case sqlode@internal@model:is_result_command(
                erlang:element(4, erlang:element(2, Query))
            ) of
                true ->
                    gleam@list:any(
                        erlang:element(4, Query),
                        fun(Item) -> case Item of
                                {scalar_result, {result_column, _, _, true, _}} ->
                                    true;

                                {scalar_result, _} ->
                                    false;

                                {embedded_result,
                                    {embedded_column, _, _, Columns}} ->
                                    gleam@list:any(
                                        Columns,
                                        fun(C) -> erlang:element(4, C) end
                                    )
                            end end
                    );

                false ->
                    false
            end
        end
    ).

-file("src/sqlode/internal/codegen/models.gleam", 416).
?DOC(false).
-spec needs_option_import_for_tables(sqlode@internal@model:catalog()) -> boolean().
needs_option_import_for_tables(Catalog) ->
    gleam@list:any(
        erlang:element(2, Catalog),
        fun(Table) ->
            gleam@list:any(
                erlang:element(3, Table),
                fun(Col) -> erlang:element(4, Col) end
            )
        end
    ).

-file("src/sqlode/internal/codegen/models.gleam", 422).
?DOC(false).
-spec has_custom_types_in_results(list(sqlode@internal@model:analyzed_query())) -> boolean().
has_custom_types_in_results(Queries) ->
    gleam@list:any(
        Queries,
        fun(Query) ->
            case sqlode@internal@model:is_result_command(
                erlang:element(4, erlang:element(2, Query))
            ) of
                true ->
                    gleam@list:any(
                        erlang:element(4, Query),
                        fun(Item) -> case Item of
                                {scalar_result,
                                    {result_column,
                                        _,
                                        {custom_type, _, _, _},
                                        _,
                                        _}} ->
                                    true;

                                {scalar_result, _} ->
                                    false;

                                {embedded_result,
                                    {embedded_column, _, _, Columns}} ->
                                    gleam@list:any(
                                        Columns,
                                        fun(C) -> case erlang:element(3, C) of
                                                {custom_type, _, _, _} ->
                                                    true;

                                                _ ->
                                                    false
                                            end end
                                    )
                            end end
                    );

                false ->
                    false
            end
        end
    ).

-file("src/sqlode/internal/codegen/models.gleam", 447).
?DOC(false).
-spec render_table_type(
    sqlode@internal@naming:naming_context(),
    sqlode@internal@model:table(),
    sqlode@internal@model:type_mapping(),
    boolean()
) -> binary().
render_table_type(Naming_ctx, Table, Type_mapping, Emit_exact_table_names) ->
    Type_name = sqlode@internal@naming:table_type_name(
        Naming_ctx,
        erlang:element(2, Table),
        Emit_exact_table_names
    ),
    Fields = begin
        _pipe = erlang:element(3, Table),
        _pipe@1 = gleam@list:map(
            _pipe,
            fun(Col) ->
                Gleam_type = case erlang:element(4, Col) of
                    true ->
                        <<<<"Option("/utf8,
                                (sqlode@internal@type_mapping:scalar_type_to_gleam_type(
                                    erlang:element(3, Col),
                                    Type_mapping
                                ))/binary>>/binary,
                            ")"/utf8>>;

                    false ->
                        sqlode@internal@type_mapping:scalar_type_to_gleam_type(
                            erlang:element(3, Col),
                            Type_mapping
                        )
                end,
                <<<<(sqlode@internal@naming:to_snake_case(
                            Naming_ctx,
                            erlang:element(2, Col)
                        ))/binary,
                        ": "/utf8>>/binary,
                    Gleam_type/binary>>
            end
        ),
        gleam@string:join(_pipe@1, <<", "/utf8>>)
    end,
    _pipe@2 = sqlode@internal@codegen@builder:concat(
        [sqlode@internal@codegen@builder:line(
                <<<<"pub type "/utf8, Type_name/binary>>/binary, " {"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(
                <<<<<<<<"  "/utf8, Type_name/binary>>/binary, "("/utf8>>/binary,
                        Fields/binary>>/binary,
                    ")"/utf8>>
            ),
            sqlode@internal@codegen@builder:line(<<"}"/utf8>>)]
    ),
    sqlode@internal@codegen@builder:render(_pipe@2).

-file("src/sqlode/internal/codegen/models.gleam", 504).
?DOC(false).
-spec render_row_type(
    sqlode@internal@naming:naming_context(),
    sqlode@internal@model:analyzed_query(),
    sqlode@internal@model:type_mapping(),
    boolean()
) -> binary().
render_row_type(Naming_ctx, Query, Type_mapping, Emit_exact_table_names) ->
    Type_name = <<(sqlode@internal@naming:to_pascal_case(
            Naming_ctx,
            erlang:element(2, erlang:element(2, Query))
        ))/binary,
        "Row"/utf8>>,
    case erlang:element(4, Query) of
        [] ->
            <<""/utf8>>;

        Columns ->
            Fields = begin
                _pipe = Columns,
                _pipe@1 = gleam@list:map(_pipe, fun(Col) -> case Col of
                            {scalar_result,
                                {result_column, Name, Scalar_type, Nullable, _}} ->
                                Gleam_type = case Nullable of
                                    true ->
                                        <<<<"Option("/utf8,
                                                (sqlode@internal@type_mapping:scalar_type_to_gleam_type(
                                                    Scalar_type,
                                                    Type_mapping
                                                ))/binary>>/binary,
                                            ")"/utf8>>;

                                    false ->
                                        sqlode@internal@type_mapping:scalar_type_to_gleam_type(
                                            Scalar_type,
                                            Type_mapping
                                        )
                                end,
                                <<<<(sqlode@internal@naming:to_snake_case(
                                            Naming_ctx,
                                            Name
                                        ))/binary,
                                        ": "/utf8>>/binary,
                                    Gleam_type/binary>>;

                            {embedded_result,
                                {embedded_column, Name@1, Table_name, _}} ->
                                <<<<(sqlode@internal@naming:to_snake_case(
                                            Naming_ctx,
                                            Name@1
                                        ))/binary,
                                        ": "/utf8>>/binary,
                                    (sqlode@internal@naming:table_type_name(
                                        Naming_ctx,
                                        Table_name,
                                        Emit_exact_table_names
                                    ))/binary>>
                        end end),
                gleam@string:join(_pipe@1, <<", "/utf8>>)
            end,
            _pipe@2 = sqlode@internal@codegen@builder:concat(
                [sqlode@internal@codegen@builder:line(
                        <<<<"pub type "/utf8, Type_name/binary>>/binary,
                            " {"/utf8>>
                    ),
                    sqlode@internal@codegen@builder:line(
                        <<<<<<<<"  "/utf8, Type_name/binary>>/binary, "("/utf8>>/binary,
                                Fields/binary>>/binary,
                            ")"/utf8>>
                    ),
                    sqlode@internal@codegen@builder:line(<<"}"/utf8>>)]
            ),
            sqlode@internal@codegen@builder:render(_pipe@2)
    end.

-file("src/sqlode/internal/codegen/models.gleam", 482).
?DOC(false).
-spec render_row_type_or_alias(
    sqlode@internal@naming:naming_context(),
    sqlode@internal@model:analyzed_query(),
    gleam@dict:dict(binary(), binary()),
    sqlode@internal@model:type_mapping(),
    boolean()
) -> binary().
render_row_type_or_alias(
    Naming_ctx,
    Query,
    Table_matches,
    Type_mapping,
    Emit_exact_table_names
) ->
    Row_type_name = <<(sqlode@internal@naming:to_pascal_case(
            Naming_ctx,
            erlang:element(2, erlang:element(2, Query))
        ))/binary,
        "Row"/utf8>>,
    case gleam_stdlib:map_get(
        Table_matches,
        erlang:element(3, erlang:element(2, Query))
    ) of
        {ok, Table_type_name} ->
            _pipe = sqlode@internal@codegen@builder:concat(
                [sqlode@internal@codegen@builder:line(
                        <<<<"pub type "/utf8, Row_type_name/binary>>/binary,
                            " ="/utf8>>
                    ),
                    sqlode@internal@codegen@builder:line(
                        <<"  "/utf8, Table_type_name/binary>>
                    )]
            ),
            sqlode@internal@codegen@builder:render(_pipe);

        {error, _} ->
            render_row_type(
                Naming_ctx,
                Query,
                Type_mapping,
                Emit_exact_table_names
            )
    end.

-file("src/sqlode/internal/codegen/models.gleam", 11).
?DOC(false).
-spec render(
    sqlode@internal@naming:naming_context(),
    sqlode@internal@model:catalog(),
    list(sqlode@internal@model:analyzed_query()),
    gleam@dict:dict(binary(), binary()),
    sqlode@internal@model:type_mapping(),
    boolean()
) -> binary().
render(
    Naming_ctx,
    Catalog,
    Queries,
    Table_matches,
    Type_mapping,
    Emit_exact_table_names
) ->
    Semantic_aliases = case Type_mapping of
        rich_mapping ->
            render_semantic_type_aliases(Catalog, Queries);

        strong_mapping ->
            render_strong_type_wrappers(Catalog, Queries);

        string_mapping ->
            <<""/utf8>>
    end,
    Table_types = begin
        _pipe = erlang:element(2, Catalog),
        _pipe@1 = gleam@list:map(
            _pipe,
            fun(_capture) ->
                render_table_type(
                    Naming_ctx,
                    _capture,
                    Type_mapping,
                    Emit_exact_table_names
                )
            end
        ),
        gleam@string:join(_pipe@1, <<"\n\n"/utf8>>)
    end,
    Row_types = begin
        _pipe@2 = Queries,
        _pipe@3 = gleam@list:filter(
            _pipe@2,
            fun(Query) ->
                sqlode@internal@model:is_result_command(
                    erlang:element(4, erlang:element(2, Query))
                )
                andalso not gleam@list:is_empty(erlang:element(4, Query))
            end
        ),
        _pipe@4 = gleam@list:map(
            _pipe@3,
            fun(_capture@1) ->
                render_row_type_or_alias(
                    Naming_ctx,
                    _capture@1,
                    Table_matches,
                    Type_mapping,
                    Emit_exact_table_names
                )
            end
        ),
        gleam@string:join(_pipe@4, <<"\n\n"/utf8>>)
    end,
    Option_imports = case needs_option_import_for_results(Queries) orelse needs_option_import_for_tables(
        Catalog
    ) of
        true ->
            [<<"import gleam/option.{type Option}"/utf8>>];

        false ->
            []
    end,
    Custom_imports = begin
        _pipe@5 = lists:append(
            [sqlode@internal@codegen@common:result_scalar_types(Queries),
                sqlode@internal@codegen@common:catalog_scalar_types(Catalog)]
        ),
        sqlode@internal@codegen@common:custom_type_imports(_pipe@5)
    end,
    Set_imports = case has_mysql_set(Catalog) of
        true ->
            [<<"import gleam/list as mysql_set_list"/utf8>>,
                <<"import gleam/string as mysql_set_string"/utf8>>];

        false ->
            []
    end,
    Imports = lists:append([Option_imports, Set_imports, Custom_imports]),
    Custom_type_warning = case has_custom_types_in_results(Queries) of
        true ->
            [<<"// NOTE: This file uses custom type overrides. Custom types must be"/utf8>>,
                <<"// transparent type aliases (e.g., pub type UserId = Int), not opaque types."/utf8>>,
                <<"// Opaque types will cause compile errors because encoding/decoding uses"/utf8>>,
                <<"// the underlying primitive type."/utf8>>];

        false ->
            []
    end,
    Enum_types = begin
        _pipe@6 = erlang:element(3, Catalog),
        _pipe@7 = gleam@list:map(_pipe@6, fun render_enum_or_set_type/1),
        gleam@string:join(_pipe@7, <<"\n\n"/utf8>>)
    end,
    Body_parts = begin
        _pipe@8 = [Enum_types, Semantic_aliases, Table_types, Row_types],
        _pipe@9 = gleam@list:filter(
            _pipe@8,
            fun(S) -> not gleam@string:is_empty(S) end
        ),
        gleam@string:join(_pipe@9, <<"\n\n"/utf8>>)
    end,
    Lines = lists:append(
        [[<<"// Code generated by sqlode. DO NOT EDIT."/utf8>>, <<""/utf8>>],
            Custom_type_warning,
            case Custom_type_warning of
                [] ->
                    [];

                _ ->
                    [<<""/utf8>>]
            end,
            Imports,
            case Imports of
                [] ->
                    [];

                _ ->
                    [<<""/utf8>>]
            end,
            [Body_parts]]
    ),
    gleam@string:join(Lines, <<"\n"/utf8>>).