json_blueprint

-module(json@blueprint@schema).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([new_schema/2, type_constraint/1, string_constraint/4, number_constraint/5, map_ref/2, to_json/1, to_json_string/1, hash_schema_definition/1]).
-export_type([schema/0, schema_definition/0, schema_type/0, string_format/0]).

-type schema() :: {schema,
        schema_definition(),
        gleam@option:option(list(binary())),
        gleam@option:option(binary()),
        gleam@option:option(binary()),
        gleam@option:option(list({binary(), schema_definition()}))}.

-type schema_definition() :: {type, schema_type()} |
    {enum, list(gleam@json:json()), gleam@option:option(schema_type())} |
    {const, gleam@json:json()} |
    {nullable, schema_definition()} |
    {optional, schema_definition()} |
    {number,
        gleam@option:option(float()),
        gleam@option:option(float()),
        gleam@option:option(float()),
        gleam@option:option(float()),
        gleam@option:option(float())} |
    {string,
        gleam@option:option(integer()),
        gleam@option:option(integer()),
        gleam@option:option(binary()),
        gleam@option:option(string_format())} |
    {array, gleam@option:option(schema_definition())} |
    {detailed_array,
        gleam@option:option(schema_definition()),
        gleam@option:option(list(schema_definition())),
        gleam@option:option(integer()),
        gleam@option:option(integer()),
        gleam@option:option(boolean()),
        gleam@option:option(schema_definition()),
        gleam@option:option(integer()),
        gleam@option:option(integer())} |
    {object,
        list({binary(), schema_definition()}),
        gleam@option:option(boolean()),
        gleam@option:option(list(binary()))} |
    {detailed_object,
        gleam@option:option(list({binary(), schema_definition()})),
        gleam@option:option(list({binary(), schema_definition()})),
        gleam@option:option(schema_definition()),
        gleam@option:option(list(binary())),
        gleam@option:option(schema_definition()),
        gleam@option:option(integer()),
        gleam@option:option(integer())} |
    {all_of, list(schema_definition())} |
    {any_of, list(schema_definition())} |
    {one_of, list(schema_definition())} |
    {'not', schema_definition()} |
    {ref, binary()} |
    true_value |
    false_value.

-type schema_type() :: null |
    boolean_type |
    object_type |
    array_type |
    number_type |
    string_type |
    integer_type |
    {multiple, list(schema_type())}.

-type string_format() :: date_time |
    date |
    time |
    duration |
    email |
    idn_email |
    hostname |
    idn_hostname |
    ipv4 |
    ipv6 |
    uri |
    uri_reference |
    iri |
    iri_reference |
    uri_template |
    json_pointer |
    relative_json_pointer |
    regex.

-file("/code/edgar/json_blueprint/src/json/blueprint/schema.gleam", 136).
-spec new_schema(
    schema_definition(),
    gleam@option:option(list({binary(), schema_definition()}))
) -> schema().
new_schema(Definition, References) ->
    {schema, Definition, none, none, none, References}.

-file("/code/edgar/json_blueprint/src/json/blueprint/schema.gleam", 150).
-spec type_constraint(schema_type()) -> schema_definition().
type_constraint(Type_) ->
    {type, Type_}.

-file("/code/edgar/json_blueprint/src/json/blueprint/schema.gleam", 155).
-spec string_constraint(
    gleam@option:option(integer()),
    gleam@option:option(integer()),
    gleam@option:option(binary()),
    gleam@option:option(string_format())
) -> schema_definition().
string_constraint(Min_length, Max_length, Pattern, Format) ->
    {string, Min_length, Max_length, Pattern, Format}.

-file("/code/edgar/json_blueprint/src/json/blueprint/schema.gleam", 170).
-spec number_constraint(
    gleam@option:option(float()),
    gleam@option:option(float()),
    gleam@option:option(float()),
    gleam@option:option(float()),
    gleam@option:option(float())
) -> schema_definition().
number_constraint(
    Minimum,
    Maximum,
    Exclusive_minimum,
    Exclusive_maximum,
    Multiple_of
) ->
    {number,
        Minimum,
        Maximum,
        Exclusive_minimum,
        Exclusive_maximum,
        Multiple_of}.

-file("/code/edgar/json_blueprint/src/json/blueprint/schema.gleam", 225).
-spec map_ref(schema_definition(), fun((binary()) -> binary())) -> schema_definition().
map_ref(Def, F) ->
    case Def of
        {ref, Ref} ->
            {ref, F(Ref)};

        {array, Items} ->
            {array, gleam@option:map(Items, fun(I) -> map_ref(I, F) end)};

        {detailed_array,
            Items@1,
            Prefix_items,
            Min_items,
            Max_items,
            Unique_items,
            Contains,
            Min_contains,
            Max_contains} ->
            {detailed_array,
                gleam@option:map(Items@1, fun(I@1) -> map_ref(I@1, F) end),
                gleam@option:map(
                    Prefix_items,
                    fun(Items@2) ->
                        gleam@list:map(Items@2, fun(I@2) -> map_ref(I@2, F) end)
                    end
                ),
                Min_items,
                Max_items,
                Unique_items,
                gleam@option:map(Contains, fun(C) -> map_ref(C, F) end),
                Min_contains,
                Max_contains};

        {object, Properties, Additional_properties, Required} ->
            {object,
                gleam@list:map(
                    Properties,
                    fun(Prop) ->
                        {erlang:element(1, Prop),
                            map_ref(erlang:element(2, Prop), F)}
                    end
                ),
                Additional_properties,
                Required};

        {detailed_object,
            Properties@1,
            Pattern_properties,
            Additional_properties@1,
            Required@1,
            Property_names,
            Min_properties,
            Max_properties} ->
            {detailed_object,
                gleam@option:map(
                    Properties@1,
                    fun(Props) ->
                        gleam@list:map(
                            Props,
                            fun(Prop@1) ->
                                {erlang:element(1, Prop@1),
                                    map_ref(erlang:element(2, Prop@1), F)}
                            end
                        )
                    end
                ),
                gleam@option:map(
                    Pattern_properties,
                    fun(Patterns) ->
                        gleam@list:map(
                            Patterns,
                            fun(Pattern) ->
                                {erlang:element(1, Pattern),
                                    map_ref(erlang:element(2, Pattern), F)}
                            end
                        )
                    end
                ),
                gleam@option:map(
                    Additional_properties@1,
                    fun(Props@1) -> map_ref(Props@1, F) end
                ),
                Required@1,
                gleam@option:map(
                    Property_names,
                    fun(Names) -> map_ref(Names, F) end
                ),
                Min_properties,
                Max_properties};

        {all_of, Schemas} ->
            {all_of, gleam@list:map(Schemas, fun(S) -> map_ref(S, F) end)};

        {any_of, Schemas@1} ->
            {any_of, gleam@list:map(Schemas@1, fun(S@1) -> map_ref(S@1, F) end)};

        {one_of, Schemas@2} ->
            {one_of, gleam@list:map(Schemas@2, fun(S@2) -> map_ref(S@2, F) end)};

        {'not', Schema} ->
            {'not', map_ref(Schema, F)};

        {nullable, Schema@1} ->
            {nullable, map_ref(Schema@1, F)};

        {optional, Schema@2} ->
            {optional, map_ref(Schema@2, F)};

        _ ->
            Def
    end.

-file("/code/edgar/json_blueprint/src/json/blueprint/schema.gleam", 297).
-spec prepend_option(
    list({binary(), gleam@json:json()}),
    gleam@option:option(GAQ),
    binary(),
    fun((GAQ) -> gleam@json:json())
) -> list({binary(), gleam@json:json()}).
prepend_option(List, Maybe, Name, To_json) ->
    case Maybe of
        {some, Value} ->
            gleam@list:prepend(List, {Name, To_json(Value)});

        none ->
            List
    end.

-file("/code/edgar/json_blueprint/src/json/blueprint/schema.gleam", 473).
-spec schema_type_to_json(schema_type()) -> gleam@json:json().
schema_type_to_json(Type_) ->
    case Type_ of
        null ->
            gleam@json:string(<<"null"/utf8>>);

        boolean_type ->
            gleam@json:string(<<"boolean"/utf8>>);

        object_type ->
            gleam@json:string(<<"object"/utf8>>);

        array_type ->
            gleam@json:string(<<"array"/utf8>>);

        number_type ->
            gleam@json:string(<<"number"/utf8>>);

        string_type ->
            gleam@json:string(<<"string"/utf8>>);

        integer_type ->
            gleam@json:string(<<"integer"/utf8>>);

        {multiple, Types} ->
            gleam@json:array(Types, fun(T) -> schema_type_to_json(T) end)
    end.

-file("/code/edgar/json_blueprint/src/json/blueprint/schema.gleam", 487).
-spec string_format_to_string(string_format()) -> binary().
string_format_to_string(Format) ->
    case Format of
        date_time ->
            <<"date-time"/utf8>>;

        date ->
            <<"date"/utf8>>;

        time ->
            <<"time"/utf8>>;

        duration ->
            <<"duration"/utf8>>;

        email ->
            <<"email"/utf8>>;

        idn_email ->
            <<"idn-email"/utf8>>;

        hostname ->
            <<"hostname"/utf8>>;

        idn_hostname ->
            <<"idn-hostname"/utf8>>;

        ipv4 ->
            <<"ipv4"/utf8>>;

        ipv6 ->
            <<"ipv6"/utf8>>;

        uri ->
            <<"uri"/utf8>>;

        uri_reference ->
            <<"uri-reference"/utf8>>;

        iri ->
            <<"iri"/utf8>>;

        iri_reference ->
            <<"iri-reference"/utf8>>;

        uri_template ->
            <<"uri-template"/utf8>>;

        json_pointer ->
            <<"json-pointer"/utf8>>;

        relative_json_pointer ->
            <<"relative-json-pointer"/utf8>>;

        regex ->
            <<"regex"/utf8>>
    end.

-file("/code/edgar/json_blueprint/src/json/blueprint/schema.gleam", 312).
-spec schema_definition_to_json_fields(schema_definition(), boolean()) -> list({binary(),
    gleam@json:json()}).
schema_definition_to_json_fields(Def, Make_type_nullable) ->
    With_nullable_type = fun(Type_) -> case Make_type_nullable of
            false ->
                schema_type_to_json(Type_);

            true ->
                schema_type_to_json({multiple, [Type_, null]})
        end end,
    case Def of
        {type, Type_@1} ->
            [{<<"type"/utf8>>, With_nullable_type(Type_@1)}];

        {enum, Values, Schema} ->
            _pipe = [{<<"enum"/utf8>>, gleam@json:preprocessed_array(Values)}],
            prepend_option(_pipe, Schema, <<"type"/utf8>>, With_nullable_type);

        {const, Value} ->
            [{<<"const"/utf8>>, Value}];

        {nullable, Schema@1} ->
            schema_definition_to_json_fields(Schema@1, true);

        {optional, Schema@2} ->
            schema_definition_to_json_fields(Schema@2, Make_type_nullable);

        {number,
            Minimum,
            Maximum,
            Exclusive_minimum,
            Exclusive_maximum,
            Multiple_of} ->
            _pipe@1 = [{<<"type"/utf8>>, With_nullable_type(number_type)}],
            _pipe@2 = prepend_option(
                _pipe@1,
                Minimum,
                <<"minimum"/utf8>>,
                fun gleam@json:float/1
            ),
            _pipe@3 = prepend_option(
                _pipe@2,
                Maximum,
                <<"maximum"/utf8>>,
                fun gleam@json:float/1
            ),
            _pipe@4 = prepend_option(
                _pipe@3,
                Exclusive_minimum,
                <<"exclusiveMinimum"/utf8>>,
                fun gleam@json:float/1
            ),
            _pipe@5 = prepend_option(
                _pipe@4,
                Exclusive_maximum,
                <<"exclusiveMaximum"/utf8>>,
                fun gleam@json:float/1
            ),
            prepend_option(
                _pipe@5,
                Multiple_of,
                <<"multipleOf"/utf8>>,
                fun gleam@json:float/1
            );

        {string, Min_length, Max_length, Pattern, Format} ->
            _pipe@6 = [{<<"type"/utf8>>, With_nullable_type(string_type)}],
            _pipe@7 = prepend_option(
                _pipe@6,
                Min_length,
                <<"minLength"/utf8>>,
                fun gleam@json:int/1
            ),
            _pipe@8 = prepend_option(
                _pipe@7,
                Max_length,
                <<"maxLength"/utf8>>,
                fun gleam@json:int/1
            ),
            _pipe@9 = prepend_option(
                _pipe@8,
                Pattern,
                <<"pattern"/utf8>>,
                fun gleam@json:string/1
            ),
            prepend_option(
                _pipe@9,
                Format,
                <<"format"/utf8>>,
                fun(F) -> gleam@json:string(string_format_to_string(F)) end
            );

        {array, Items} ->
            _pipe@10 = [{<<"type"/utf8>>, With_nullable_type(array_type)}],
            prepend_option(
                _pipe@10,
                Items,
                <<"items"/utf8>>,
                fun(Schema@3) -> schema_definition_to_json(Schema@3) end
            );

        {object, Properties, Additional_properties, Required} ->
            _pipe@11 = [{<<"type"/utf8>>, With_nullable_type(object_type)},
                {<<"properties"/utf8>>,
                    gleam@json:object(
                        gleam@list:map(
                            Properties,
                            fun(Prop) ->
                                {erlang:element(1, Prop),
                                    schema_definition_to_json(
                                        erlang:element(2, Prop)
                                    )}
                            end
                        )
                    )}],
            _pipe@12 = prepend_option(
                _pipe@11,
                Additional_properties,
                <<"additionalProperties"/utf8>>,
                fun gleam@json:bool/1
            ),
            prepend_option(
                _pipe@12,
                Required,
                <<"required"/utf8>>,
                fun(_capture) ->
                    gleam@json:array(_capture, fun gleam@json:string/1)
                end
            );

        {detailed_array,
            Items@1,
            Prefix_items,
            Min_items,
            Max_items,
            Unique_items,
            Contains,
            Min_contains,
            Max_contains} ->
            _pipe@13 = [{<<"type"/utf8>>, With_nullable_type(array_type)}],
            _pipe@14 = prepend_option(
                _pipe@13,
                Items@1,
                <<"items"/utf8>>,
                fun(Schema@4) -> schema_definition_to_json(Schema@4) end
            ),
            _pipe@15 = prepend_option(
                _pipe@14,
                Prefix_items,
                <<"prefixItems"/utf8>>,
                fun(Schemas) ->
                    gleam@json:array(Schemas, fun schema_definition_to_json/1)
                end
            ),
            _pipe@16 = prepend_option(
                _pipe@15,
                Min_items,
                <<"minItems"/utf8>>,
                fun gleam@json:int/1
            ),
            _pipe@17 = prepend_option(
                _pipe@16,
                Max_items,
                <<"maxItems"/utf8>>,
                fun gleam@json:int/1
            ),
            _pipe@18 = prepend_option(
                _pipe@17,
                Unique_items,
                <<"uniqueItems"/utf8>>,
                fun gleam@json:bool/1
            ),
            _pipe@19 = prepend_option(
                _pipe@18,
                Contains,
                <<"contains"/utf8>>,
                fun(Schema@5) -> schema_definition_to_json(Schema@5) end
            ),
            _pipe@20 = prepend_option(
                _pipe@19,
                Min_contains,
                <<"minContains"/utf8>>,
                fun gleam@json:int/1
            ),
            prepend_option(
                _pipe@20,
                Max_contains,
                <<"maxContains"/utf8>>,
                fun gleam@json:int/1
            );

        {detailed_object,
            Properties@1,
            Pattern_properties,
            Additional_properties@1,
            Required@1,
            Property_names,
            Min_properties,
            Max_properties} ->
            _pipe@21 = [{<<"type"/utf8>>, With_nullable_type(object_type)}],
            _pipe@22 = prepend_option(
                _pipe@21,
                Properties@1,
                <<"properties"/utf8>>,
                fun(Props) ->
                    gleam@json:object(
                        gleam@list:map(
                            Props,
                            fun(Prop@1) ->
                                {erlang:element(1, Prop@1),
                                    schema_definition_to_json(
                                        erlang:element(2, Prop@1)
                                    )}
                            end
                        )
                    )
                end
            ),
            _pipe@23 = prepend_option(
                _pipe@22,
                Pattern_properties,
                <<"patternProperties"/utf8>>,
                fun(Patterns) ->
                    gleam@json:object(
                        gleam@list:map(
                            Patterns,
                            fun(Pattern@1) ->
                                {erlang:element(1, Pattern@1),
                                    schema_definition_to_json(
                                        erlang:element(2, Pattern@1)
                                    )}
                            end
                        )
                    )
                end
            ),
            _pipe@24 = prepend_option(
                _pipe@23,
                Additional_properties@1,
                <<"additionalProperties"/utf8>>,
                fun(Schema@6) -> schema_definition_to_json(Schema@6) end
            ),
            _pipe@25 = prepend_option(
                _pipe@24,
                Required@1,
                <<"required"/utf8>>,
                fun(Reqs) -> gleam@json:array(Reqs, fun gleam@json:string/1) end
            ),
            _pipe@26 = prepend_option(
                _pipe@25,
                Property_names,
                <<"propertyNames"/utf8>>,
                fun(Schema@7) -> schema_definition_to_json(Schema@7) end
            ),
            _pipe@27 = prepend_option(
                _pipe@26,
                Min_properties,
                <<"minProperties"/utf8>>,
                fun gleam@json:int/1
            ),
            prepend_option(
                _pipe@27,
                Max_properties,
                <<"maxProperties"/utf8>>,
                fun gleam@json:int/1
            );

        {all_of, Schemas@1} ->
            [{<<"allOf"/utf8>>,
                    gleam@json:array(Schemas@1, fun schema_definition_to_json/1)}];

        {any_of, Schemas@2} ->
            [{<<"anyOf"/utf8>>,
                    gleam@json:array(Schemas@2, fun schema_definition_to_json/1)}];

        {one_of, Schemas@3} ->
            [{<<"oneOf"/utf8>>,
                    gleam@json:array(Schemas@3, fun schema_definition_to_json/1)}];

        {'not', Schema@8} ->
            [{<<"not"/utf8>>, schema_definition_to_json(Schema@8)}];

        {ref, Ref} ->
            case Make_type_nullable of
                false ->
                    [{<<"$ref"/utf8>>, gleam@json:string(Ref)}];

                true ->
                    schema_definition_to_json_fields(
                        {any_of, [{ref, Ref}, {type, null}]},
                        false
                    )
            end;

        true_value ->
            [{<<"type"/utf8>>, gleam@json:bool(true)}];

        false_value ->
            [{<<"type"/utf8>>, gleam@json:bool(false)}]
    end.

-file("/code/edgar/json_blueprint/src/json/blueprint/schema.gleam", 293).
-spec schema_definition_to_json(schema_definition()) -> gleam@json:json().
schema_definition_to_json(Def) ->
    gleam@json:object(schema_definition_to_json_fields(Def, false)).

-file("/code/edgar/json_blueprint/src/json/blueprint/schema.gleam", 194).
-spec to_json(schema()) -> gleam@json:json().
to_json(Schema) ->
    Fields = begin
        _pipe = [{<<"$schema"/utf8>>,
                gleam@json:string(
                    <<"http://json-schema.org/draft-07/schema#"/utf8>>
                )}],
        _pipe@1 = prepend_option(
            _pipe,
            erlang:element(3, Schema),
            <<"$vocabulary"/utf8>>,
            fun(Vocab) -> gleam@json:array(Vocab, fun gleam@json:string/1) end
        ),
        _pipe@2 = prepend_option(
            _pipe@1,
            erlang:element(4, Schema),
            <<"$id"/utf8>>,
            fun gleam@json:string/1
        ),
        _pipe@3 = prepend_option(
            _pipe@2,
            erlang:element(5, Schema),
            <<"$comment"/utf8>>,
            fun gleam@json:string/1
        ),
        prepend_option(
            _pipe@3,
            erlang:element(6, Schema),
            <<"$defs"/utf8>>,
            fun(Defs) ->
                gleam@json:object(
                    gleam@list:map(
                        Defs,
                        fun(Def) ->
                            {erlang:element(1, Def),
                                schema_definition_to_json(
                                    erlang:element(2, Def)
                                )}
                        end
                    )
                )
            end
        )
    end,
    Schema_fields = schema_definition_to_json_fields(
        erlang:element(2, Schema),
        false
    ),
    Fields@1 = lists:append(Fields, Schema_fields),
    gleam@json:object(Fields@1).

-file("/code/edgar/json_blueprint/src/json/blueprint/schema.gleam", 187).
-spec to_json_string(schema()) -> binary().
to_json_string(Schema) ->
    _pipe = Schema,
    _pipe@1 = to_json(_pipe),
    gleam@json:to_string(_pipe@1).

-file("/code/edgar/json_blueprint/src/json/blueprint/schema.gleam", 216).
-spec hash_schema_definition(schema_definition()) -> binary().
hash_schema_definition(Def) ->
    _pipe = Def,
    _pipe@1 = schema_definition_to_json(_pipe),
    _pipe@2 = gleam@json:to_string(_pipe@1),
    _pipe@3 = gleam_stdlib:identity(_pipe@2),
    _pipe@4 = gleam@crypto:hash(sha1, _pipe@3),
    gleam_stdlib:base16_encode(_pipe@4).