-module(nori@decoder).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch, inline]).
-define(FILEPATH, "src/nori/decoder.gleam").
-export([document_decoder/0, decode_document/1]).

-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(
    " Decoders for parsing OpenAPI documents from JSON.\n"
    "\n"
    " Uses `gleam/dynamic/decode` for composable decoding.\n"
).

-file("src/nori/decoder.gleam", 103).
?DOC(" Helper to wrap a decoder result in Some.\n").
-spec option_decoder(gleam@dynamic@decode:decoder(NRA)) -> gleam@dynamic@decode:decoder(gleam@option:option(NRA)).
option_decoder(Decoder) ->
    gleam@dynamic@decode:map(Decoder, fun(Field@0) -> {some, Field@0} end).

-file("src/nori/decoder.gleam", 108).
?DOC(" Decoder for OpenAPI version strings.\n").
-spec version_decoder() -> gleam@dynamic@decode:decoder(nori@internal@version:open_api_version()).
version_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Version_str) -> case nori@internal@version:parse(Version_str) of
                {ok, V} ->
                    gleam@dynamic@decode:success(V);

                {error, _} ->
                    gleam@dynamic@decode:failure(
                        v310,
                        <<"OpenAPI version 3.0.x or 3.1.x"/utf8>>
                    )
            end end
    ).

-file("src/nori/decoder.gleam", 501).
?DOC(" Decoder for parameter location.\n").
-spec parameter_location_decoder() -> gleam@dynamic@decode:decoder(nori@parameter:parameter_location()).
parameter_location_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(S) -> case nori@parameter:parse_location(S) of
                {ok, Loc} ->
                    gleam@dynamic@decode:success(Loc);

                {error, _} ->
                    gleam@dynamic@decode:failure(
                        in_query,
                        <<"path, query, header, or cookie"/utf8>>
                    )
            end end
    ).

-file("src/nori/decoder.gleam", 511).
?DOC(" Decoder for parameter style.\n").
-spec parameter_style_decoder() -> gleam@dynamic@decode:decoder(nori@parameter:parameter_style()).
parameter_style_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(S) -> case nori@parameter:parse_style(S) of
                {ok, Style} ->
                    gleam@dynamic@decode:success(Style);

                {error, _} ->
                    gleam@dynamic@decode:failure(
                        style_simple,
                        <<"simple, label, matrix, form, spaceDelimited, pipeDelimited, or deepObject"/utf8>>
                    )
            end end
    ).

-file("src/nori/decoder.gleam", 998).
?DOC(" Decodes a JSON type string.\n").
-spec decode_json_type_string(binary()) -> {ok, nori@schema:json_type()} |
    {error, nil}.
decode_json_type_string(S) ->
    case S of
        <<"null"/utf8>> ->
            {ok, type_null};

        <<"boolean"/utf8>> ->
            {ok, type_boolean};

        <<"integer"/utf8>> ->
            {ok, type_integer};

        <<"number"/utf8>> ->
            {ok, type_number};

        <<"string"/utf8>> ->
            {ok, type_string};

        <<"array"/utf8>> ->
            {ok, json_type_array};

        <<"object"/utf8>> ->
            {ok, type_object};

        _ ->
            {error, nil}
    end.

-file("src/nori/decoder.gleam", 977).
?DOC(" Decoder for schema type.\n").
-spec schema_type_decoder() -> gleam@dynamic@decode:decoder(nori@schema:schema_type()).
schema_type_decoder() ->
    gleam@dynamic@decode:one_of(
        begin
            _pipe = {decoder, fun gleam@dynamic@decode:decode_string/1},
            gleam@dynamic@decode:then(
                _pipe,
                fun(S) -> case decode_json_type_string(S) of
                        {ok, T} ->
                            gleam@dynamic@decode:success({single_type, T});

                        {error, _} ->
                            gleam@dynamic@decode:failure(
                                {single_type, type_string},
                                <<"JSON type"/utf8>>
                            )
                    end end
            )
        end,
        [begin
                _pipe@1 = gleam@dynamic@decode:list(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                gleam@dynamic@decode:then(
                    _pipe@1,
                    fun(Strs) ->
                        Types = gleam@list:filter_map(
                            Strs,
                            fun decode_json_type_string/1
                        ),
                        gleam@dynamic@decode:success({multiple_types, Types})
                    end
                )
            end]
    ).

-file("src/nori/decoder.gleam", 1442).
?DOC(" Decoder for API key location.\n").
-spec api_key_location_decoder() -> gleam@dynamic@decode:decoder(nori@security:api_key_location()).
api_key_location_decoder() ->
    gleam@dynamic@decode:then(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(S) -> case nori@security:parse_api_key_location(S) of
                {ok, Loc} ->
                    gleam@dynamic@decode:success(Loc);

                {error, _} ->
                    gleam@dynamic@decode:failure(
                        in_header,
                        <<"query, header, or cookie"/utf8>>
                    )
            end end
    ).

-file("src/nori/decoder.gleam", 1578).
?DOC(" Decoder for security requirement.\n").
-spec security_requirement_decoder() -> gleam@dynamic@decode:decoder(gleam@dict:dict(binary(), list(binary()))).
security_requirement_decoder() ->
    gleam@dynamic@decode:dict(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        gleam@dynamic@decode:list(
            {decoder, fun gleam@dynamic@decode:decode_string/1}
        )
    ).

-file("src/nori/decoder.gleam", 1616).
?DOC(" Decoder for reference or inline value.\n").
-spec ref_or_value_decoder(gleam@dynamic@decode:decoder(NTR)) -> gleam@dynamic@decode:decoder(nori@reference:ref(NTR)).
ref_or_value_decoder(Value_decoder) ->
    gleam@dynamic@decode:one_of(
        begin
            gleam@dynamic@decode:field(
                <<"$ref"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Ref_str) ->
                    gleam@dynamic@decode:success({reference, Ref_str})
                end
            )
        end,
        [gleam@dynamic@decode:map(
                Value_decoder,
                fun(Field@0) -> {inline, Field@0} end
            )]
    ).

-file("src/nori/decoder.gleam", 1633).
?DOC(" Converts a Dynamic value to a Json value.\n").
-spec dynamic_to_json(gleam@dynamic:dynamic_()) -> gleam@json:json().
dynamic_to_json(Dyn) ->
    case gleam@dynamic@decode:run(
        Dyn,
        {decoder, fun gleam@dynamic@decode:decode_bool/1}
    ) of
        {ok, B} ->
            gleam@json:bool(B);

        {error, _} ->
            case gleam@dynamic@decode:run(
                Dyn,
                {decoder, fun gleam@dynamic@decode:decode_int/1}
            ) of
                {ok, I} ->
                    gleam@json:int(I);

                {error, _} ->
                    case gleam@dynamic@decode:run(
                        Dyn,
                        {decoder, fun gleam@dynamic@decode:decode_float/1}
                    ) of
                        {ok, F} ->
                            gleam@json:float(F);

                        {error, _} ->
                            case gleam@dynamic@decode:run(
                                Dyn,
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1}
                            ) of
                                {ok, S} ->
                                    gleam@json:string(S);

                                {error, _} ->
                                    case gleam@dynamic@decode:run(
                                        Dyn,
                                        gleam@dynamic@decode:list(
                                            {decoder,
                                                fun gleam@dynamic@decode:decode_dynamic/1}
                                        )
                                    ) of
                                        {ok, Items} ->
                                            gleam@json:array(
                                                Items,
                                                fun dynamic_to_json/1
                                            );

                                        {error, _} ->
                                            case gleam@dynamic@decode:run(
                                                Dyn,
                                                gleam@dynamic@decode:dict(
                                                    {decoder,
                                                        fun gleam@dynamic@decode:decode_string/1},
                                                    {decoder,
                                                        fun gleam@dynamic@decode:decode_dynamic/1}
                                                )
                                            ) of
                                                {ok, Pairs} ->
                                                    gleam@json:object(
                                                        begin
                                                            _pipe = maps:to_list(
                                                                Pairs
                                                            ),
                                                            gleam@list:map(
                                                                _pipe,
                                                                fun(Pair) ->
                                                                    {erlang:element(
                                                                            1,
                                                                            Pair
                                                                        ),
                                                                        dynamic_to_json(
                                                                            erlang:element(
                                                                                2,
                                                                                Pair
                                                                            )
                                                                        )}
                                                                end
                                                            )
                                                        end
                                                    );

                                                {error, _} ->
                                                    gleam@json:null()
                                            end
                                    end
                            end
                    end
            end
    end.

-file("src/nori/decoder.gleam", 1627).
?DOC(" Decoder for any JSON value.\n").
-spec json_decoder() -> gleam@dynamic@decode:decoder(gleam@json:json()).
json_decoder() ->
    _pipe = {decoder, fun gleam@dynamic@decode:decode_dynamic/1},
    gleam@dynamic@decode:map(_pipe, fun dynamic_to_json/1).

-file("src/nori/decoder.gleam", 1608).
?DOC(" Decoder that extracts extension fields (keys starting with \"x-\") from an object.\n").
-spec extensions_decoder() -> gleam@dynamic@decode:decoder(gleam@dict:dict(binary(), gleam@json:json())).
extensions_decoder() ->
    _pipe = gleam@dynamic@decode:dict(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        json_decoder()
    ),
    gleam@dynamic@decode:map(
        _pipe,
        fun(All_fields) ->
            gleam@dict:filter(
                All_fields,
                fun(Key, _) ->
                    gleam_stdlib:string_starts_with(Key, <<"x-"/utf8>>)
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 160).
?DOC(" Decoder for Contact objects.\n").
-spec contact_decoder() -> gleam@dynamic@decode:decoder(nori@info:contact()).
contact_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"name"/utf8>>,
        none,
        option_decoder({decoder, fun gleam@dynamic@decode:decode_string/1}),
        fun(Name) ->
            gleam@dynamic@decode:optional_field(
                <<"url"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Url) ->
                    gleam@dynamic@decode:optional_field(
                        <<"email"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Email) ->
                            gleam@dynamic@decode:subfield(
                                [],
                                extensions_decoder(),
                                fun(Extensions) ->
                                    gleam@dynamic@decode:success(
                                        {contact, Name, Url, Email, Extensions}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 179).
?DOC(" Decoder for License objects.\n").
-spec license_decoder() -> gleam@dynamic@decode:decoder(nori@info:license()).
license_decoder() ->
    gleam@dynamic@decode:field(
        <<"name"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Name) ->
            gleam@dynamic@decode:optional_field(
                <<"identifier"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Identifier) ->
                    gleam@dynamic@decode:optional_field(
                        <<"url"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Url) ->
                            gleam@dynamic@decode:subfield(
                                [],
                                extensions_decoder(),
                                fun(Extensions) ->
                                    gleam@dynamic@decode:success(
                                        {license,
                                            Name,
                                            Identifier,
                                            Url,
                                            Extensions}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 117).
?DOC(" Decoder for Info objects.\n").
-spec info_decoder() -> gleam@dynamic@decode:decoder(nori@info:info()).
info_decoder() ->
    gleam@dynamic@decode:field(
        <<"title"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Title) ->
            gleam@dynamic@decode:field(
                <<"version"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Version) ->
                    gleam@dynamic@decode:optional_field(
                        <<"description"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Description) ->
                            gleam@dynamic@decode:optional_field(
                                <<"termsOfService"/utf8>>,
                                none,
                                option_decoder(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_string/1}
                                ),
                                fun(Terms_of_service) ->
                                    gleam@dynamic@decode:optional_field(
                                        <<"contact"/utf8>>,
                                        none,
                                        option_decoder(contact_decoder()),
                                        fun(Contact) ->
                                            gleam@dynamic@decode:optional_field(
                                                <<"license"/utf8>>,
                                                none,
                                                option_decoder(
                                                    license_decoder()
                                                ),
                                                fun(License) ->
                                                    gleam@dynamic@decode:optional_field(
                                                        <<"summary"/utf8>>,
                                                        none,
                                                        option_decoder(
                                                            {decoder,
                                                                fun gleam@dynamic@decode:decode_string/1}
                                                        ),
                                                        fun(Summary) ->
                                                            gleam@dynamic@decode:subfield(
                                                                [],
                                                                extensions_decoder(
                                                                    
                                                                ),
                                                                fun(Extensions) ->
                                                                    gleam@dynamic@decode:success(
                                                                        {info,
                                                                            Title,
                                                                            Description,
                                                                            Terms_of_service,
                                                                            Contact,
                                                                            License,
                                                                            Version,
                                                                            Summary,
                                                                            Extensions}
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 221).
?DOC(" Decoder for ServerVariable objects.\n").
-spec server_variable_decoder() -> gleam@dynamic@decode:decoder(nori@server:server_variable()).
server_variable_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"enum"/utf8>>,
        [],
        gleam@dynamic@decode:list(
            {decoder, fun gleam@dynamic@decode:decode_string/1}
        ),
        fun(Enum_values) ->
            gleam@dynamic@decode:field(
                <<"default"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Default) ->
                    gleam@dynamic@decode:optional_field(
                        <<"description"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Description) ->
                            gleam@dynamic@decode:subfield(
                                [],
                                extensions_decoder(),
                                fun(Extensions) ->
                                    gleam@dynamic@decode:success(
                                        {server_variable,
                                            Enum_values,
                                            Default,
                                            Description,
                                            Extensions}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 198).
?DOC(" Decoder for Server objects.\n").
-spec server_decoder() -> gleam@dynamic@decode:decoder(nori@server:server()).
server_decoder() ->
    gleam@dynamic@decode:field(
        <<"url"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Url) ->
            gleam@dynamic@decode:optional_field(
                <<"description"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Description) ->
                    gleam@dynamic@decode:optional_field(
                        <<"variables"/utf8>>,
                        maps:new(),
                        gleam@dynamic@decode:dict(
                            {decoder, fun gleam@dynamic@decode:decode_string/1},
                            server_variable_decoder()
                        ),
                        fun(Variables) ->
                            gleam@dynamic@decode:subfield(
                                [],
                                extensions_decoder(),
                                fun(Extensions) ->
                                    gleam@dynamic@decode:success(
                                        {server,
                                            Url,
                                            Description,
                                            Variables,
                                            Extensions}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 910).
?DOC(" Decoder for Discriminator objects.\n").
-spec discriminator_decoder() -> gleam@dynamic@decode:decoder(nori@schema:discriminator()).
discriminator_decoder() ->
    gleam@dynamic@decode:field(
        <<"propertyName"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Property_name) ->
            gleam@dynamic@decode:optional_field(
                <<"mapping"/utf8>>,
                none,
                option_decoder(
                    gleam@dynamic@decode:dict(
                        {decoder, fun gleam@dynamic@decode:decode_string/1},
                        {decoder, fun gleam@dynamic@decode:decode_string/1}
                    )
                ),
                fun(Mapping) ->
                    gleam@dynamic@decode:subfield(
                        [],
                        extensions_decoder(),
                        fun(Extensions) ->
                            gleam@dynamic@decode:success(
                                {discriminator,
                                    Property_name,
                                    Mapping,
                                    Extensions}
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 927).
?DOC(" Decoder for ExternalDocumentation objects.\n").
-spec external_documentation_decoder() -> gleam@dynamic@decode:decoder(nori@schema:external_documentation()).
external_documentation_decoder() ->
    gleam@dynamic@decode:field(
        <<"url"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Url) ->
            gleam@dynamic@decode:optional_field(
                <<"description"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Description) ->
                    gleam@dynamic@decode:subfield(
                        [],
                        extensions_decoder(),
                        fun(Extensions) ->
                            gleam@dynamic@decode:success(
                                {external_documentation,
                                    Url,
                                    Description,
                                    Extensions}
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 943).
?DOC(" Decoder for XML metadata.\n").
-spec xml_decoder() -> gleam@dynamic@decode:decoder(nori@schema:xml()).
xml_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"name"/utf8>>,
        none,
        option_decoder({decoder, fun gleam@dynamic@decode:decode_string/1}),
        fun(Name) ->
            gleam@dynamic@decode:optional_field(
                <<"namespace"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Namespace) ->
                    gleam@dynamic@decode:optional_field(
                        <<"prefix"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Prefix) ->
                            gleam@dynamic@decode:optional_field(
                                <<"attribute"/utf8>>,
                                none,
                                option_decoder(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_bool/1}
                                ),
                                fun(Attribute) ->
                                    gleam@dynamic@decode:optional_field(
                                        <<"wrapped"/utf8>>,
                                        none,
                                        option_decoder(
                                            {decoder,
                                                fun gleam@dynamic@decode:decode_bool/1}
                                        ),
                                        fun(Wrapped) ->
                                            gleam@dynamic@decode:subfield(
                                                [],
                                                extensions_decoder(),
                                                fun(Extensions) ->
                                                    gleam@dynamic@decode:success(
                                                        {xml,
                                                            Name,
                                                            Namespace,
                                                            Prefix,
                                                            Attribute,
                                                            Wrapped,
                                                            Extensions}
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1012).
?DOC(" Decoder for ExternalDocumentation objects.\n").
-spec external_docs_decoder() -> gleam@dynamic@decode:decoder(nori@schema:external_documentation()).
external_docs_decoder() ->
    gleam@dynamic@decode:field(
        <<"url"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Url) ->
            gleam@dynamic@decode:optional_field(
                <<"description"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Description) ->
                    gleam@dynamic@decode:subfield(
                        [],
                        extensions_decoder(),
                        fun(Extensions) ->
                            gleam@dynamic@decode:success(
                                {external_documentation,
                                    Url,
                                    Description,
                                    Extensions}
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1099).
?DOC(" Decoder for Example objects.\n").
-spec example_decoder() -> gleam@dynamic@decode:decoder(nori@parameter:example()).
example_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"summary"/utf8>>,
        none,
        option_decoder({decoder, fun gleam@dynamic@decode:decode_string/1}),
        fun(Summary) ->
            gleam@dynamic@decode:optional_field(
                <<"description"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Description) ->
                    gleam@dynamic@decode:optional_field(
                        <<"value"/utf8>>,
                        none,
                        option_decoder(json_decoder()),
                        fun(Value) ->
                            gleam@dynamic@decode:optional_field(
                                <<"externalValue"/utf8>>,
                                none,
                                option_decoder(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_string/1}
                                ),
                                fun(External_value) ->
                                    gleam@dynamic@decode:subfield(
                                        [],
                                        extensions_decoder(),
                                        fun(Extensions) ->
                                            gleam@dynamic@decode:success(
                                                {example,
                                                    Summary,
                                                    Description,
                                                    Value,
                                                    External_value,
                                                    Extensions}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1094).
?DOC(" Decoder for Example or $ref.\n").
-spec example_or_ref_decoder() -> gleam@dynamic@decode:decoder(nori@reference:ref(nori@parameter:example())).
example_or_ref_decoder() ->
    ref_or_value_decoder(example_decoder()).

-file("src/nori/decoder.gleam", 1255).
?DOC(" Decoder for Link objects.\n").
-spec link_decoder() -> gleam@dynamic@decode:decoder(nori@response:link()).
link_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"operationRef"/utf8>>,
        none,
        option_decoder({decoder, fun gleam@dynamic@decode:decode_string/1}),
        fun(Operation_ref) ->
            gleam@dynamic@decode:optional_field(
                <<"operationId"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Operation_id) ->
                    gleam@dynamic@decode:optional_field(
                        <<"description"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Description) ->
                            gleam@dynamic@decode:optional_field(
                                <<"server"/utf8>>,
                                none,
                                option_decoder(server_decoder()),
                                fun(Server) ->
                                    gleam@dynamic@decode:subfield(
                                        [],
                                        extensions_decoder(),
                                        fun(Extensions) ->
                                            gleam@dynamic@decode:success(
                                                {link,
                                                    Operation_ref,
                                                    Operation_id,
                                                    maps:new(),
                                                    none,
                                                    Description,
                                                    Server,
                                                    Extensions}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1250).
?DOC(" Decoder for Link or $ref.\n").
-spec link_or_ref_decoder() -> gleam@dynamic@decode:decoder(nori@reference:ref(nori@response:link())).
link_or_ref_decoder() ->
    ref_or_value_decoder(link_decoder()).

-file("src/nori/decoder.gleam", 1484).
?DOC(" Decoder for implicit OAuth flow.\n").
-spec implicit_flow_decoder() -> gleam@dynamic@decode:decoder(nori@security:implicit_o_auth_flow()).
implicit_flow_decoder() ->
    gleam@dynamic@decode:field(
        <<"authorizationUrl"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Authorization_url) ->
            gleam@dynamic@decode:optional_field(
                <<"refreshUrl"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Refresh_url) ->
                    gleam@dynamic@decode:optional_field(
                        <<"scopes"/utf8>>,
                        maps:new(),
                        gleam@dynamic@decode:dict(
                            {decoder, fun gleam@dynamic@decode:decode_string/1},
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Scopes) ->
                            gleam@dynamic@decode:subfield(
                                [],
                                extensions_decoder(),
                                fun(Extensions) ->
                                    gleam@dynamic@decode:success(
                                        {implicit_o_auth_flow,
                                            Authorization_url,
                                            Refresh_url,
                                            Scopes,
                                            Extensions}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1507).
?DOC(" Decoder for password OAuth flow.\n").
-spec password_flow_decoder() -> gleam@dynamic@decode:decoder(nori@security:password_o_auth_flow()).
password_flow_decoder() ->
    gleam@dynamic@decode:field(
        <<"tokenUrl"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Token_url) ->
            gleam@dynamic@decode:optional_field(
                <<"refreshUrl"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Refresh_url) ->
                    gleam@dynamic@decode:optional_field(
                        <<"scopes"/utf8>>,
                        maps:new(),
                        gleam@dynamic@decode:dict(
                            {decoder, fun gleam@dynamic@decode:decode_string/1},
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Scopes) ->
                            gleam@dynamic@decode:subfield(
                                [],
                                extensions_decoder(),
                                fun(Extensions) ->
                                    gleam@dynamic@decode:success(
                                        {password_o_auth_flow,
                                            Token_url,
                                            Refresh_url,
                                            Scopes,
                                            Extensions}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1530).
?DOC(" Decoder for client credentials OAuth flow.\n").
-spec client_credentials_flow_decoder() -> gleam@dynamic@decode:decoder(nori@security:client_credentials_o_auth_flow()).
client_credentials_flow_decoder() ->
    gleam@dynamic@decode:field(
        <<"tokenUrl"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Token_url) ->
            gleam@dynamic@decode:optional_field(
                <<"refreshUrl"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Refresh_url) ->
                    gleam@dynamic@decode:optional_field(
                        <<"scopes"/utf8>>,
                        maps:new(),
                        gleam@dynamic@decode:dict(
                            {decoder, fun gleam@dynamic@decode:decode_string/1},
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Scopes) ->
                            gleam@dynamic@decode:subfield(
                                [],
                                extensions_decoder(),
                                fun(Extensions) ->
                                    gleam@dynamic@decode:success(
                                        {client_credentials_o_auth_flow,
                                            Token_url,
                                            Refresh_url,
                                            Scopes,
                                            Extensions}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1553).
?DOC(" Decoder for authorization code OAuth flow.\n").
-spec authorization_code_flow_decoder() -> gleam@dynamic@decode:decoder(nori@security:authorization_code_o_auth_flow()).
authorization_code_flow_decoder() ->
    gleam@dynamic@decode:field(
        <<"authorizationUrl"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Authorization_url) ->
            gleam@dynamic@decode:field(
                <<"tokenUrl"/utf8>>,
                {decoder, fun gleam@dynamic@decode:decode_string/1},
                fun(Token_url) ->
                    gleam@dynamic@decode:optional_field(
                        <<"refreshUrl"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Refresh_url) ->
                            gleam@dynamic@decode:optional_field(
                                <<"scopes"/utf8>>,
                                maps:new(),
                                gleam@dynamic@decode:dict(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_string/1},
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_string/1}
                                ),
                                fun(Scopes) ->
                                    gleam@dynamic@decode:subfield(
                                        [],
                                        extensions_decoder(),
                                        fun(Extensions) ->
                                            gleam@dynamic@decode:success(
                                                {authorization_code_o_auth_flow,
                                                    Authorization_url,
                                                    Token_url,
                                                    Refresh_url,
                                                    Scopes,
                                                    Extensions}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1451).
?DOC(" Decoder for OAuth flows.\n").
-spec oauth_flows_decoder() -> gleam@dynamic@decode:decoder(nori@security:o_auth_flows()).
oauth_flows_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"implicit"/utf8>>,
        none,
        option_decoder(implicit_flow_decoder()),
        fun(Implicit) ->
            gleam@dynamic@decode:optional_field(
                <<"password"/utf8>>,
                none,
                option_decoder(password_flow_decoder()),
                fun(Password) ->
                    gleam@dynamic@decode:optional_field(
                        <<"clientCredentials"/utf8>>,
                        none,
                        option_decoder(client_credentials_flow_decoder()),
                        fun(Client_credentials) ->
                            gleam@dynamic@decode:optional_field(
                                <<"authorizationCode"/utf8>>,
                                none,
                                option_decoder(
                                    authorization_code_flow_decoder()
                                ),
                                fun(Authorization_code) ->
                                    gleam@dynamic@decode:subfield(
                                        [],
                                        extensions_decoder(),
                                        fun(Extensions) ->
                                            gleam@dynamic@decode:success(
                                                {o_auth_flows,
                                                    Implicit,
                                                    Password,
                                                    Client_credentials,
                                                    Authorization_code,
                                                    Extensions}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1374).
?DOC(" Decoder for SecurityScheme objects.\n").
-spec security_scheme_decoder() -> gleam@dynamic@decode:decoder(nori@security:security_scheme()).
security_scheme_decoder() ->
    gleam@dynamic@decode:field(
        <<"type"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Type_) ->
            gleam@dynamic@decode:optional_field(
                <<"description"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Description) ->
                    gleam@dynamic@decode:subfield(
                        [],
                        extensions_decoder(),
                        fun(Extensions) -> case Type_ of
                                <<"apiKey"/utf8>> ->
                                    gleam@dynamic@decode:field(
                                        <<"name"/utf8>>,
                                        {decoder,
                                            fun gleam@dynamic@decode:decode_string/1},
                                        fun(Name) ->
                                            gleam@dynamic@decode:field(
                                                <<"in"/utf8>>,
                                                api_key_location_decoder(),
                                                fun(In_) ->
                                                    gleam@dynamic@decode:success(
                                                        {api_key_security_scheme,
                                                            Name,
                                                            In_,
                                                            Description,
                                                            Extensions}
                                                    )
                                                end
                                            )
                                        end
                                    );

                                <<"http"/utf8>> ->
                                    gleam@dynamic@decode:field(
                                        <<"scheme"/utf8>>,
                                        {decoder,
                                            fun gleam@dynamic@decode:decode_string/1},
                                        fun(Scheme) ->
                                            gleam@dynamic@decode:optional_field(
                                                <<"bearerFormat"/utf8>>,
                                                none,
                                                option_decoder(
                                                    {decoder,
                                                        fun gleam@dynamic@decode:decode_string/1}
                                                ),
                                                fun(Bearer_format) ->
                                                    gleam@dynamic@decode:success(
                                                        {http_security_scheme,
                                                            Scheme,
                                                            Bearer_format,
                                                            Description,
                                                            Extensions}
                                                    )
                                                end
                                            )
                                        end
                                    );

                                <<"mutualTLS"/utf8>> ->
                                    gleam@dynamic@decode:success(
                                        {mutual_tls_security_scheme,
                                            Description,
                                            Extensions}
                                    );

                                <<"oauth2"/utf8>> ->
                                    gleam@dynamic@decode:field(
                                        <<"flows"/utf8>>,
                                        oauth_flows_decoder(),
                                        fun(Flows) ->
                                            gleam@dynamic@decode:success(
                                                {o_auth2_security_scheme,
                                                    Flows,
                                                    Description,
                                                    Extensions}
                                            )
                                        end
                                    );

                                <<"openIdConnect"/utf8>> ->
                                    gleam@dynamic@decode:field(
                                        <<"openIdConnectUrl"/utf8>>,
                                        {decoder,
                                            fun gleam@dynamic@decode:decode_string/1},
                                        fun(Open_id_connect_url) ->
                                            gleam@dynamic@decode:success(
                                                {open_id_connect_security_scheme,
                                                    Open_id_connect_url,
                                                    Description,
                                                    Extensions}
                                            )
                                        end
                                    );

                                _ ->
                                    gleam@dynamic@decode:failure(
                                        {mutual_tls_security_scheme,
                                            none,
                                            Extensions},
                                        <<"apiKey, http, mutualTLS, oauth2, or openIdConnect"/utf8>>
                                    )
                            end end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1369).
?DOC(" Decoder for SecurityScheme or $ref.\n").
-spec security_scheme_or_ref_decoder() -> gleam@dynamic@decode:decoder(nori@reference:ref(nori@security:security_scheme())).
security_scheme_or_ref_decoder() ->
    ref_or_value_decoder(security_scheme_decoder()).

-file("src/nori/decoder.gleam", 1583).
?DOC(" Decoder for Tag objects.\n").
-spec tag_decoder() -> gleam@dynamic@decode:decoder(nori@operation:tag()).
tag_decoder() ->
    gleam@dynamic@decode:field(
        <<"name"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Name) ->
            gleam@dynamic@decode:optional_field(
                <<"description"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Description) ->
                    gleam@dynamic@decode:optional_field(
                        <<"externalDocs"/utf8>>,
                        none,
                        option_decoder(external_docs_decoder()),
                        fun(External_docs) ->
                            gleam@dynamic@decode:subfield(
                                [],
                                extensions_decoder(),
                                fun(Extensions) ->
                                    gleam@dynamic@decode:success(
                                        {tag,
                                            Name,
                                            Description,
                                            External_docs,
                                            Extensions}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1295).
?DOC(" Decoder for Callback objects.\n").
-spec callback_decoder() -> gleam@dynamic@decode:decoder(gleam@dict:dict(binary(), nori@reference:ref(nori@operation:path_item()))).
callback_decoder() ->
    gleam@dynamic@decode:dict(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        path_item_or_ref_decoder()
    ).

-file("src/nori/decoder.gleam", 249).
?DOC(" Decoder for PathItem or $ref.\n").
-spec path_item_or_ref_decoder() -> gleam@dynamic@decode:decoder(nori@reference:ref(nori@operation:path_item())).
path_item_or_ref_decoder() ->
    ref_or_value_decoder(path_item_decoder()).

-file("src/nori/decoder.gleam", 254).
?DOC(" Decoder for PathItem objects.\n").
-spec path_item_decoder() -> gleam@dynamic@decode:decoder(nori@operation:path_item()).
path_item_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"$ref"/utf8>>,
        none,
        option_decoder({decoder, fun gleam@dynamic@decode:decode_string/1}),
        fun(Ref) ->
            gleam@dynamic@decode:optional_field(
                <<"summary"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Summary) ->
                    gleam@dynamic@decode:optional_field(
                        <<"description"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Description) ->
                            gleam@dynamic@decode:optional_field(
                                <<"get"/utf8>>,
                                none,
                                option_decoder(operation_decoder()),
                                fun(Get) ->
                                    gleam@dynamic@decode:optional_field(
                                        <<"put"/utf8>>,
                                        none,
                                        option_decoder(operation_decoder()),
                                        fun(Put) ->
                                            gleam@dynamic@decode:optional_field(
                                                <<"post"/utf8>>,
                                                none,
                                                option_decoder(
                                                    operation_decoder()
                                                ),
                                                fun(Post) ->
                                                    gleam@dynamic@decode:optional_field(
                                                        <<"delete"/utf8>>,
                                                        none,
                                                        option_decoder(
                                                            operation_decoder()
                                                        ),
                                                        fun(Delete) ->
                                                            gleam@dynamic@decode:optional_field(
                                                                <<"options"/utf8>>,
                                                                none,
                                                                option_decoder(
                                                                    operation_decoder(
                                                                        
                                                                    )
                                                                ),
                                                                fun(Options) ->
                                                                    gleam@dynamic@decode:optional_field(
                                                                        <<"head"/utf8>>,
                                                                        none,
                                                                        option_decoder(
                                                                            operation_decoder(
                                                                                
                                                                            )
                                                                        ),
                                                                        fun(
                                                                            Head
                                                                        ) ->
                                                                            gleam@dynamic@decode:optional_field(
                                                                                <<"patch"/utf8>>,
                                                                                none,
                                                                                option_decoder(
                                                                                    operation_decoder(
                                                                                        
                                                                                    )
                                                                                ),
                                                                                fun(
                                                                                    Patch
                                                                                ) ->
                                                                                    gleam@dynamic@decode:optional_field(
                                                                                        <<"trace"/utf8>>,
                                                                                        none,
                                                                                        option_decoder(
                                                                                            operation_decoder(
                                                                                                
                                                                                            )
                                                                                        ),
                                                                                        fun(
                                                                                            Trace
                                                                                        ) ->
                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                <<"servers"/utf8>>,
                                                                                                [],
                                                                                                gleam@dynamic@decode:list(
                                                                                                    server_decoder(
                                                                                                        
                                                                                                    )
                                                                                                ),
                                                                                                fun(
                                                                                                    Servers
                                                                                                ) ->
                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                        <<"parameters"/utf8>>,
                                                                                                        [],
                                                                                                        gleam@dynamic@decode:list(
                                                                                                            parameter_or_ref_decoder(
                                                                                                                
                                                                                                            )
                                                                                                        ),
                                                                                                        fun(
                                                                                                            Parameters
                                                                                                        ) ->
                                                                                                            gleam@dynamic@decode:subfield(
                                                                                                                [],
                                                                                                                extensions_decoder(
                                                                                                                    
                                                                                                                ),
                                                                                                                fun(
                                                                                                                    Extensions
                                                                                                                ) ->
                                                                                                                    gleam@dynamic@decode:success(
                                                                                                                        {path_item,
                                                                                                                            Ref,
                                                                                                                            Summary,
                                                                                                                            Description,
                                                                                                                            Get,
                                                                                                                            Put,
                                                                                                                            Post,
                                                                                                                            Delete,
                                                                                                                            Options,
                                                                                                                            Head,
                                                                                                                            Patch,
                                                                                                                            Trace,
                                                                                                                            Servers,
                                                                                                                            Parameters,
                                                                                                                            Extensions}
                                                                                                                    )
                                                                                                                end
                                                                                                            )
                                                                                                        end
                                                                                                    )
                                                                                                end
                                                                                            )
                                                                                        end
                                                                                    )
                                                                                end
                                                                            )
                                                                        end
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 337).
?DOC(" Decoder for Operation objects.\n").
-spec operation_decoder() -> gleam@dynamic@decode:decoder(nori@operation:operation()).
operation_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"tags"/utf8>>,
        [],
        gleam@dynamic@decode:list(
            {decoder, fun gleam@dynamic@decode:decode_string/1}
        ),
        fun(Tags) ->
            gleam@dynamic@decode:optional_field(
                <<"summary"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Summary) ->
                    gleam@dynamic@decode:optional_field(
                        <<"description"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Description) ->
                            gleam@dynamic@decode:optional_field(
                                <<"externalDocs"/utf8>>,
                                none,
                                option_decoder(external_docs_decoder()),
                                fun(External_docs) ->
                                    gleam@dynamic@decode:optional_field(
                                        <<"operationId"/utf8>>,
                                        none,
                                        option_decoder(
                                            {decoder,
                                                fun gleam@dynamic@decode:decode_string/1}
                                        ),
                                        fun(Operation_id) ->
                                            gleam@dynamic@decode:optional_field(
                                                <<"parameters"/utf8>>,
                                                [],
                                                gleam@dynamic@decode:list(
                                                    parameter_or_ref_decoder()
                                                ),
                                                fun(Parameters) ->
                                                    gleam@dynamic@decode:optional_field(
                                                        <<"requestBody"/utf8>>,
                                                        none,
                                                        option_decoder(
                                                            request_body_or_ref_decoder(
                                                                
                                                            )
                                                        ),
                                                        fun(Request_body) ->
                                                            gleam@dynamic@decode:optional_field(
                                                                <<"responses"/utf8>>,
                                                                maps:new(),
                                                                gleam@dynamic@decode:dict(
                                                                    {decoder,
                                                                        fun gleam@dynamic@decode:decode_string/1},
                                                                    response_or_ref_decoder(
                                                                        
                                                                    )
                                                                ),
                                                                fun(Responses) ->
                                                                    gleam@dynamic@decode:optional_field(
                                                                        <<"callbacks"/utf8>>,
                                                                        maps:new(
                                                                            
                                                                        ),
                                                                        gleam@dynamic@decode:dict(
                                                                            {decoder,
                                                                                fun gleam@dynamic@decode:decode_string/1},
                                                                            callback_or_ref_decoder(
                                                                                
                                                                            )
                                                                        ),
                                                                        fun(
                                                                            Callbacks
                                                                        ) ->
                                                                            gleam@dynamic@decode:optional_field(
                                                                                <<"deprecated"/utf8>>,
                                                                                none,
                                                                                option_decoder(
                                                                                    {decoder,
                                                                                        fun gleam@dynamic@decode:decode_bool/1}
                                                                                ),
                                                                                fun(
                                                                                    Deprecated
                                                                                ) ->
                                                                                    gleam@dynamic@decode:optional_field(
                                                                                        <<"security"/utf8>>,
                                                                                        [],
                                                                                        gleam@dynamic@decode:list(
                                                                                            security_requirement_decoder(
                                                                                                
                                                                                            )
                                                                                        ),
                                                                                        fun(
                                                                                            Security
                                                                                        ) ->
                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                <<"servers"/utf8>>,
                                                                                                [],
                                                                                                gleam@dynamic@decode:list(
                                                                                                    server_decoder(
                                                                                                        
                                                                                                    )
                                                                                                ),
                                                                                                fun(
                                                                                                    Servers
                                                                                                ) ->
                                                                                                    gleam@dynamic@decode:subfield(
                                                                                                        [],
                                                                                                        extensions_decoder(
                                                                                                            
                                                                                                        ),
                                                                                                        fun(
                                                                                                            Extensions
                                                                                                        ) ->
                                                                                                            gleam@dynamic@decode:success(
                                                                                                                {operation,
                                                                                                                    Tags,
                                                                                                                    Summary,
                                                                                                                    Description,
                                                                                                                    External_docs,
                                                                                                                    Operation_id,
                                                                                                                    Parameters,
                                                                                                                    Request_body,
                                                                                                                    Responses,
                                                                                                                    Callbacks,
                                                                                                                    Deprecated,
                                                                                                                    case Security of
                                                                                                                        [] ->
                                                                                                                            none;

                                                                                                                        S ->
                                                                                                                            {some,
                                                                                                                                S}
                                                                                                                    end,
                                                                                                                    Servers,
                                                                                                                    Extensions}
                                                                                                            )
                                                                                                        end
                                                                                                    )
                                                                                                end
                                                                                            )
                                                                                        end
                                                                                    )
                                                                                end
                                                                            )
                                                                        end
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1290).
?DOC(" Decoder for Callback or $ref.\n").
-spec callback_or_ref_decoder() -> gleam@dynamic@decode:decoder(nori@reference:ref(gleam@dict:dict(binary(), nori@reference:ref(nori@operation:path_item())))).
callback_or_ref_decoder() ->
    ref_or_value_decoder(callback_decoder()).

-file("src/nori/decoder.gleam", 244).
?DOC(" Decoder for Paths object.\n").
-spec paths_decoder() -> gleam@dynamic@decode:decoder(gleam@dict:dict(binary(), nori@reference:ref(nori@operation:path_item()))).
paths_decoder() ->
    gleam@dynamic@decode:dict(
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        path_item_or_ref_decoder()
    ).

-file("src/nori/decoder.gleam", 524).
?DOC(" Decoder for Schema or $ref.\n").
-spec schema_or_ref_decoder() -> gleam@dynamic@decode:decoder(nori@reference:ref(nori@schema:schema())).
schema_or_ref_decoder() ->
    ref_or_value_decoder(schema_decoder()).

-file("src/nori/decoder.gleam", 529).
?DOC(" Decoder for Schema objects.\n").
-spec schema_decoder() -> gleam@dynamic@decode:decoder(nori@schema:schema()).
schema_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"$schema"/utf8>>,
        none,
        option_decoder({decoder, fun gleam@dynamic@decode:decode_string/1}),
        fun(Schema_uri) ->
            gleam@dynamic@decode:optional_field(
                <<"$vocabulary"/utf8>>,
                none,
                option_decoder(
                    gleam@dynamic@decode:dict(
                        {decoder, fun gleam@dynamic@decode:decode_string/1},
                        {decoder, fun gleam@dynamic@decode:decode_bool/1}
                    )
                ),
                fun(Vocabulary) ->
                    gleam@dynamic@decode:optional_field(
                        <<"$id"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Id) ->
                            gleam@dynamic@decode:optional_field(
                                <<"$anchor"/utf8>>,
                                none,
                                option_decoder(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_string/1}
                                ),
                                fun(Anchor) ->
                                    gleam@dynamic@decode:optional_field(
                                        <<"$dynamicAnchor"/utf8>>,
                                        none,
                                        option_decoder(
                                            {decoder,
                                                fun gleam@dynamic@decode:decode_string/1}
                                        ),
                                        fun(Dynamic_anchor) ->
                                            gleam@dynamic@decode:optional_field(
                                                <<"$ref"/utf8>>,
                                                none,
                                                option_decoder(
                                                    {decoder,
                                                        fun gleam@dynamic@decode:decode_string/1}
                                                ),
                                                fun(Ref) ->
                                                    gleam@dynamic@decode:optional_field(
                                                        <<"$dynamicRef"/utf8>>,
                                                        none,
                                                        option_decoder(
                                                            {decoder,
                                                                fun gleam@dynamic@decode:decode_string/1}
                                                        ),
                                                        fun(Dynamic_ref) ->
                                                            gleam@dynamic@decode:optional_field(
                                                                <<"$defs"/utf8>>,
                                                                none,
                                                                option_decoder(
                                                                    gleam@dynamic@decode:dict(
                                                                        {decoder,
                                                                            fun gleam@dynamic@decode:decode_string/1},
                                                                        schema_decoder(
                                                                            
                                                                        )
                                                                    )
                                                                ),
                                                                fun(Defs) ->
                                                                    gleam@dynamic@decode:optional_field(
                                                                        <<"$comment"/utf8>>,
                                                                        none,
                                                                        option_decoder(
                                                                            {decoder,
                                                                                fun gleam@dynamic@decode:decode_string/1}
                                                                        ),
                                                                        fun(
                                                                            Comment
                                                                        ) ->
                                                                            gleam@dynamic@decode:optional_field(
                                                                                <<"allOf"/utf8>>,
                                                                                [],
                                                                                gleam@dynamic@decode:list(
                                                                                    schema_or_ref_decoder(
                                                                                        
                                                                                    )
                                                                                ),
                                                                                fun(
                                                                                    All_of
                                                                                ) ->
                                                                                    gleam@dynamic@decode:optional_field(
                                                                                        <<"anyOf"/utf8>>,
                                                                                        [],
                                                                                        gleam@dynamic@decode:list(
                                                                                            schema_or_ref_decoder(
                                                                                                
                                                                                            )
                                                                                        ),
                                                                                        fun(
                                                                                            Any_of
                                                                                        ) ->
                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                <<"oneOf"/utf8>>,
                                                                                                [],
                                                                                                gleam@dynamic@decode:list(
                                                                                                    schema_or_ref_decoder(
                                                                                                        
                                                                                                    )
                                                                                                ),
                                                                                                fun(
                                                                                                    One_of
                                                                                                ) ->
                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                        <<"not"/utf8>>,
                                                                                                        none,
                                                                                                        option_decoder(
                                                                                                            schema_or_ref_decoder(
                                                                                                                
                                                                                                            )
                                                                                                        ),
                                                                                                        fun(
                                                                                                            Not
                                                                                                        ) ->
                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                <<"if"/utf8>>,
                                                                                                                none,
                                                                                                                option_decoder(
                                                                                                                    schema_or_ref_decoder(
                                                                                                                        
                                                                                                                    )
                                                                                                                ),
                                                                                                                fun(
                                                                                                                    If_schema
                                                                                                                ) ->
                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                        <<"then"/utf8>>,
                                                                                                                        none,
                                                                                                                        option_decoder(
                                                                                                                            schema_or_ref_decoder(
                                                                                                                                
                                                                                                                            )
                                                                                                                        ),
                                                                                                                        fun(
                                                                                                                            Then_schema
                                                                                                                        ) ->
                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                <<"else"/utf8>>,
                                                                                                                                none,
                                                                                                                                option_decoder(
                                                                                                                                    schema_or_ref_decoder(
                                                                                                                                        
                                                                                                                                    )
                                                                                                                                ),
                                                                                                                                fun(
                                                                                                                                    Else_schema
                                                                                                                                ) ->
                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                        <<"dependentSchemas"/utf8>>,
                                                                                                                                        none,
                                                                                                                                        option_decoder(
                                                                                                                                            gleam@dynamic@decode:dict(
                                                                                                                                                {decoder,
                                                                                                                                                    fun gleam@dynamic@decode:decode_string/1},
                                                                                                                                                schema_or_ref_decoder(
                                                                                                                                                    
                                                                                                                                                )
                                                                                                                                            )
                                                                                                                                        ),
                                                                                                                                        fun(
                                                                                                                                            Dependent_schemas
                                                                                                                                        ) ->
                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                <<"prefixItems"/utf8>>,
                                                                                                                                                [],
                                                                                                                                                gleam@dynamic@decode:list(
                                                                                                                                                    schema_or_ref_decoder(
                                                                                                                                                        
                                                                                                                                                    )
                                                                                                                                                ),
                                                                                                                                                fun(
                                                                                                                                                    Prefix_items
                                                                                                                                                ) ->
                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                        <<"items"/utf8>>,
                                                                                                                                                        none,
                                                                                                                                                        option_decoder(
                                                                                                                                                            schema_or_ref_decoder(
                                                                                                                                                                
                                                                                                                                                            )
                                                                                                                                                        ),
                                                                                                                                                        fun(
                                                                                                                                                            Items
                                                                                                                                                        ) ->
                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                <<"contains"/utf8>>,
                                                                                                                                                                none,
                                                                                                                                                                option_decoder(
                                                                                                                                                                    schema_or_ref_decoder(
                                                                                                                                                                        
                                                                                                                                                                    )
                                                                                                                                                                ),
                                                                                                                                                                fun(
                                                                                                                                                                    Contains
                                                                                                                                                                ) ->
                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                        <<"properties"/utf8>>,
                                                                                                                                                                        maps:new(
                                                                                                                                                                            
                                                                                                                                                                        ),
                                                                                                                                                                        gleam@dynamic@decode:dict(
                                                                                                                                                                            {decoder,
                                                                                                                                                                                fun gleam@dynamic@decode:decode_string/1},
                                                                                                                                                                            schema_or_ref_decoder(
                                                                                                                                                                                
                                                                                                                                                                            )
                                                                                                                                                                        ),
                                                                                                                                                                        fun(
                                                                                                                                                                            Properties
                                                                                                                                                                        ) ->
                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                <<"patternProperties"/utf8>>,
                                                                                                                                                                                none,
                                                                                                                                                                                option_decoder(
                                                                                                                                                                                    gleam@dynamic@decode:dict(
                                                                                                                                                                                        {decoder,
                                                                                                                                                                                            fun gleam@dynamic@decode:decode_string/1},
                                                                                                                                                                                        schema_or_ref_decoder(
                                                                                                                                                                                            
                                                                                                                                                                                        )
                                                                                                                                                                                    )
                                                                                                                                                                                ),
                                                                                                                                                                                fun(
                                                                                                                                                                                    Pattern_properties
                                                                                                                                                                                ) ->
                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                        <<"additionalProperties"/utf8>>,
                                                                                                                                                                                        none,
                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                            additional_properties_decoder(
                                                                                                                                                                                                
                                                                                                                                                                                            )
                                                                                                                                                                                        ),
                                                                                                                                                                                        fun(
                                                                                                                                                                                            Additional_properties
                                                                                                                                                                                        ) ->
                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                <<"propertyNames"/utf8>>,
                                                                                                                                                                                                none,
                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                    schema_or_ref_decoder(
                                                                                                                                                                                                        
                                                                                                                                                                                                    )
                                                                                                                                                                                                ),
                                                                                                                                                                                                fun(
                                                                                                                                                                                                    Property_names
                                                                                                                                                                                                ) ->
                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                        <<"unevaluatedItems"/utf8>>,
                                                                                                                                                                                                        none,
                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                            schema_or_ref_decoder(
                                                                                                                                                                                                                
                                                                                                                                                                                                            )
                                                                                                                                                                                                        ),
                                                                                                                                                                                                        fun(
                                                                                                                                                                                                            Unevaluated_items
                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                <<"unevaluatedProperties"/utf8>>,
                                                                                                                                                                                                                none,
                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                    schema_or_ref_decoder(
                                                                                                                                                                                                                        
                                                                                                                                                                                                                    )
                                                                                                                                                                                                                ),
                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                    Unevaluated_properties
                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                        <<"type"/utf8>>,
                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                            schema_type_decoder(
                                                                                                                                                                                                                                
                                                                                                                                                                                                                            )
                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                            Schema_type
                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                <<"const"/utf8>>,
                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                    json_decoder(
                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                    Const_value
                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                        <<"enum"/utf8>>,
                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                            gleam@dynamic@decode:list(
                                                                                                                                                                                                                                                json_decoder(
                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                )
                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                            Enum_values
                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                <<"multipleOf"/utf8>>,
                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                    {decoder,
                                                                                                                                                                                                                                                        fun gleam@dynamic@decode:decode_float/1}
                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                    Multiple_of
                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                        <<"maximum"/utf8>>,
                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                            {decoder,
                                                                                                                                                                                                                                                                fun gleam@dynamic@decode:decode_float/1}
                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                            Maximum
                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                <<"exclusiveMaximum"/utf8>>,
                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                    {decoder,
                                                                                                                                                                                                                                                                        fun gleam@dynamic@decode:decode_float/1}
                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                    Exclusive_maximum
                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                        <<"minimum"/utf8>>,
                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                            {decoder,
                                                                                                                                                                                                                                                                                fun gleam@dynamic@decode:decode_float/1}
                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                            Minimum
                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                <<"exclusiveMinimum"/utf8>>,
                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                    {decoder,
                                                                                                                                                                                                                                                                                        fun gleam@dynamic@decode:decode_float/1}
                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                    Exclusive_minimum
                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                        <<"maxLength"/utf8>>,
                                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                                            {decoder,
                                                                                                                                                                                                                                                                                                fun gleam@dynamic@decode:decode_int/1}
                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                            Max_length
                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                <<"minLength"/utf8>>,
                                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                                    {decoder,
                                                                                                                                                                                                                                                                                                        fun gleam@dynamic@decode:decode_int/1}
                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                    Min_length
                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                        <<"pattern"/utf8>>,
                                                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                                                            {decoder,
                                                                                                                                                                                                                                                                                                                fun gleam@dynamic@decode:decode_string/1}
                                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                                            Pattern
                                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                <<"maxItems"/utf8>>,
                                                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                                                    {decoder,
                                                                                                                                                                                                                                                                                                                        fun gleam@dynamic@decode:decode_int/1}
                                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                                    Max_items
                                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                        <<"minItems"/utf8>>,
                                                                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                                                                            {decoder,
                                                                                                                                                                                                                                                                                                                                fun gleam@dynamic@decode:decode_int/1}
                                                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                                                            Min_items
                                                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                <<"uniqueItems"/utf8>>,
                                                                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                                                                    {decoder,
                                                                                                                                                                                                                                                                                                                                        fun gleam@dynamic@decode:decode_bool/1}
                                                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                                                    Unique_items
                                                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                        <<"maxContains"/utf8>>,
                                                                                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                                                                                            {decoder,
                                                                                                                                                                                                                                                                                                                                                fun gleam@dynamic@decode:decode_int/1}
                                                                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                                                                            Max_contains
                                                                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                <<"minContains"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                                                                                    {decoder,
                                                                                                                                                                                                                                                                                                                                                        fun gleam@dynamic@decode:decode_int/1}
                                                                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                                                                    Min_contains
                                                                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                        <<"maxProperties"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                                                                                                            {decoder,
                                                                                                                                                                                                                                                                                                                                                                fun gleam@dynamic@decode:decode_int/1}
                                                                                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                                                                                            Max_properties
                                                                                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                <<"minProperties"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                                                                                                    {decoder,
                                                                                                                                                                                                                                                                                                                                                                        fun gleam@dynamic@decode:decode_int/1}
                                                                                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                                                                                    Min_properties
                                                                                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                        <<"required"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                        [],
                                                                                                                                                                                                                                                                                                                                                                        gleam@dynamic@decode:list(
                                                                                                                                                                                                                                                                                                                                                                            {decoder,
                                                                                                                                                                                                                                                                                                                                                                                fun gleam@dynamic@decode:decode_string/1}
                                                                                                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                                                                                                            Required
                                                                                                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                <<"dependentRequired"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:dict(
                                                                                                                                                                                                                                                                                                                                                                                        {decoder,
                                                                                                                                                                                                                                                                                                                                                                                            fun gleam@dynamic@decode:decode_string/1},
                                                                                                                                                                                                                                                                                                                                                                                        gleam@dynamic@decode:list(
                                                                                                                                                                                                                                                                                                                                                                                            {decoder,
                                                                                                                                                                                                                                                                                                                                                                                                fun gleam@dynamic@decode:decode_string/1}
                                                                                                                                                                                                                                                                                                                                                                                        )
                                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                                                                                                    Dependent_required
                                                                                                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                        <<"format"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                            {decoder,
                                                                                                                                                                                                                                                                                                                                                                                                fun gleam@dynamic@decode:decode_string/1}
                                                                                                                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                                                                                                                            Format
                                                                                                                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                <<"contentEncoding"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                    {decoder,
                                                                                                                                                                                                                                                                                                                                                                                                        fun gleam@dynamic@decode:decode_string/1}
                                                                                                                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                                                                                                                    Content_encoding
                                                                                                                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                        <<"contentMediaType"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                            {decoder,
                                                                                                                                                                                                                                                                                                                                                                                                                fun gleam@dynamic@decode:decode_string/1}
                                                                                                                                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                                                                                                                                            Content_media_type
                                                                                                                                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                                <<"contentSchema"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                    schema_or_ref_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                                                                                                                                    Content_schema
                                                                                                                                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                                        <<"title"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                            {decoder,
                                                                                                                                                                                                                                                                                                                                                                                                                                fun gleam@dynamic@decode:decode_string/1}
                                                                                                                                                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                                                                                                                                                            Title
                                                                                                                                                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                                                <<"description"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                    {decoder,
                                                                                                                                                                                                                                                                                                                                                                                                                                        fun gleam@dynamic@decode:decode_string/1}
                                                                                                                                                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                                                                                                                                                    Description
                                                                                                                                                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                                                        <<"default"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                            json_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                                                                                                                                                                            Default
                                                                                                                                                                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                                                                <<"deprecated"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                    {decoder,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        fun gleam@dynamic@decode:decode_bool/1}
                                                                                                                                                                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                                                                                                                                                                    Deprecated
                                                                                                                                                                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                                                                        <<"readOnly"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                            {decoder,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                fun gleam@dynamic@decode:decode_bool/1}
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                                                                                                                                                                                            Read_only
                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                <<"writeOnly"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    {decoder,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fun gleam@dynamic@decode:decode_bool/1}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Write_only
                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <<"examples"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:list(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                json_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Examples
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <<"discriminator"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    discriminator_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Discriminator
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <<"xml"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            xml_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Xml
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                <<"externalDocs"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                none,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    external_documentation_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    External_docs
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        <<"example"/utf8>>,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        none,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        option_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            json_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        fun(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            gleam@dynamic@decode:subfield(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                [],
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                extensions_decoder(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                fun(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Extensions
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                ) ->
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    gleam@dynamic@decode:success(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        {schema,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Schema_uri,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Vocabulary,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Id,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Anchor,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dynamic_anchor,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Ref,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dynamic_ref,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Defs,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Comment,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            All_of,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Any_of,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            One_of,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Not,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            If_schema,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Then_schema,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Else_schema,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dependent_schemas,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Prefix_items,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Items,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Contains,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Properties,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pattern_properties,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Additional_properties,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Property_names,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Unevaluated_items,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Unevaluated_properties,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Schema_type,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Const_value,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Enum_values,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Multiple_of,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Maximum,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Exclusive_maximum,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Minimum,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Exclusive_minimum,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Max_length,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Min_length,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Pattern,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Max_items,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Min_items,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Unique_items,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Max_contains,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Min_contains,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Max_properties,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Min_properties,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Required,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Dependent_required,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Format,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Content_encoding,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Content_media_type,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Content_schema,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Title,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Description,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Default,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Deprecated,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Read_only,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Write_only,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Examples,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Discriminator,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Xml,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            External_docs,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Example,
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Extensions}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                                end
                                                                                                                                                                                                                                            )
                                                                                                                                                                                                                                        end
                                                                                                                                                                                                                                    )
                                                                                                                                                                                                                                end
                                                                                                                                                                                                                            )
                                                                                                                                                                                                                        end
                                                                                                                                                                                                                    )
                                                                                                                                                                                                                end
                                                                                                                                                                                                            )
                                                                                                                                                                                                        end
                                                                                                                                                                                                    )
                                                                                                                                                                                                end
                                                                                                                                                                                            )
                                                                                                                                                                                        end
                                                                                                                                                                                    )
                                                                                                                                                                                end
                                                                                                                                                                            )
                                                                                                                                                                        end
                                                                                                                                                                    )
                                                                                                                                                                end
                                                                                                                                                            )
                                                                                                                                                        end
                                                                                                                                                    )
                                                                                                                                                end
                                                                                                                                            )
                                                                                                                                        end
                                                                                                                                    )
                                                                                                                                end
                                                                                                                            )
                                                                                                                        end
                                                                                                                    )
                                                                                                                end
                                                                                                            )
                                                                                                        end
                                                                                                    )
                                                                                                end
                                                                                            )
                                                                                        end
                                                                                    )
                                                                                end
                                                                            )
                                                                        end
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 903).
?DOC(" Decoder for additional properties (bool or schema).\n").
-spec additional_properties_decoder() -> gleam@dynamic@decode:decoder(nori@schema:additional_properties()).
additional_properties_decoder() ->
    gleam@dynamic@decode:one_of(
        gleam@dynamic@decode:map(
            {decoder, fun gleam@dynamic@decode:decode_bool/1},
            fun(Field@0) -> {additional_properties_bool, Field@0} end
        ),
        [gleam@dynamic@decode:map(
                schema_or_ref_decoder(),
                fun(Field@0) -> {additional_properties_schema, Field@0} end
            )]
    ).

-file("src/nori/decoder.gleam", 1176).
?DOC(" Decoder for Header objects.\n").
-spec header_decoder() -> gleam@dynamic@decode:decoder(nori@parameter:header()).
header_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"description"/utf8>>,
        none,
        option_decoder({decoder, fun gleam@dynamic@decode:decode_string/1}),
        fun(Description) ->
            gleam@dynamic@decode:optional_field(
                <<"required"/utf8>>,
                none,
                option_decoder(
                    {decoder, fun gleam@dynamic@decode:decode_bool/1}
                ),
                fun(Required) ->
                    gleam@dynamic@decode:optional_field(
                        <<"deprecated"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_bool/1}
                        ),
                        fun(Deprecated) ->
                            gleam@dynamic@decode:optional_field(
                                <<"schema"/utf8>>,
                                none,
                                option_decoder(schema_or_ref_decoder()),
                                fun(Schema) ->
                                    gleam@dynamic@decode:subfield(
                                        [],
                                        extensions_decoder(),
                                        fun(Extensions) ->
                                            gleam@dynamic@decode:success(
                                                {header,
                                                    Description,
                                                    Required,
                                                    Deprecated,
                                                    none,
                                                    none,
                                                    none,
                                                    none,
                                                    Schema,
                                                    none,
                                                    none,
                                                    none,
                                                    Extensions}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1171).
?DOC(" Decoder for Header or $ref.\n").
-spec header_or_ref_decoder() -> gleam@dynamic@decode:decoder(nori@reference:ref(nori@parameter:header())).
header_or_ref_decoder() ->
    ref_or_value_decoder(header_decoder()).

-file("src/nori/decoder.gleam", 1132).
?DOC(" Decoder for Encoding objects.\n").
-spec encoding_decoder() -> gleam@dynamic@decode:decoder(nori@parameter:encoding()).
encoding_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"contentType"/utf8>>,
        none,
        option_decoder({decoder, fun gleam@dynamic@decode:decode_string/1}),
        fun(Content_type) ->
            gleam@dynamic@decode:optional_field(
                <<"headers"/utf8>>,
                none,
                option_decoder(
                    gleam@dynamic@decode:dict(
                        {decoder, fun gleam@dynamic@decode:decode_string/1},
                        header_or_ref_decoder()
                    )
                ),
                fun(Headers) ->
                    gleam@dynamic@decode:optional_field(
                        <<"style"/utf8>>,
                        none,
                        option_decoder(parameter_style_decoder()),
                        fun(Style) ->
                            gleam@dynamic@decode:optional_field(
                                <<"explode"/utf8>>,
                                none,
                                option_decoder(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_bool/1}
                                ),
                                fun(Explode) ->
                                    gleam@dynamic@decode:optional_field(
                                        <<"allowReserved"/utf8>>,
                                        none,
                                        option_decoder(
                                            {decoder,
                                                fun gleam@dynamic@decode:decode_bool/1}
                                        ),
                                        fun(Allow_reserved) ->
                                            gleam@dynamic@decode:subfield(
                                                [],
                                                extensions_decoder(),
                                                fun(Extensions) ->
                                                    gleam@dynamic@decode:success(
                                                        {encoding,
                                                            Content_type,
                                                            Headers,
                                                            Style,
                                                            Explode,
                                                            Allow_reserved,
                                                            Extensions}
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1061).
?DOC(" Decoder for MediaType objects.\n").
-spec media_type_decoder() -> gleam@dynamic@decode:decoder(nori@parameter:media_type()).
media_type_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"schema"/utf8>>,
        none,
        option_decoder(schema_or_ref_decoder()),
        fun(Schema) ->
            gleam@dynamic@decode:optional_field(
                <<"example"/utf8>>,
                none,
                option_decoder(json_decoder()),
                fun(Example) ->
                    gleam@dynamic@decode:optional_field(
                        <<"examples"/utf8>>,
                        none,
                        option_decoder(
                            gleam@dynamic@decode:dict(
                                {decoder,
                                    fun gleam@dynamic@decode:decode_string/1},
                                example_or_ref_decoder()
                            )
                        ),
                        fun(Examples) ->
                            gleam@dynamic@decode:optional_field(
                                <<"encoding"/utf8>>,
                                none,
                                option_decoder(
                                    gleam@dynamic@decode:dict(
                                        {decoder,
                                            fun gleam@dynamic@decode:decode_string/1},
                                        encoding_decoder()
                                    )
                                ),
                                fun(Encoding) ->
                                    gleam@dynamic@decode:subfield(
                                        [],
                                        extensions_decoder(),
                                        fun(Extensions) ->
                                            gleam@dynamic@decode:success(
                                                {media_type,
                                                    Schema,
                                                    Example,
                                                    Examples,
                                                    Encoding,
                                                    Extensions}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 422).
?DOC(" Decoder for Parameter objects.\n").
-spec parameter_decoder() -> gleam@dynamic@decode:decoder(nori@parameter:parameter()).
parameter_decoder() ->
    gleam@dynamic@decode:field(
        <<"name"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Name) ->
            gleam@dynamic@decode:field(
                <<"in"/utf8>>,
                parameter_location_decoder(),
                fun(In_) ->
                    gleam@dynamic@decode:optional_field(
                        <<"description"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Description) ->
                            gleam@dynamic@decode:optional_field(
                                <<"required"/utf8>>,
                                none,
                                option_decoder(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_bool/1}
                                ),
                                fun(Required) ->
                                    gleam@dynamic@decode:optional_field(
                                        <<"deprecated"/utf8>>,
                                        none,
                                        option_decoder(
                                            {decoder,
                                                fun gleam@dynamic@decode:decode_bool/1}
                                        ),
                                        fun(Deprecated) ->
                                            gleam@dynamic@decode:optional_field(
                                                <<"allowEmptyValue"/utf8>>,
                                                none,
                                                option_decoder(
                                                    {decoder,
                                                        fun gleam@dynamic@decode:decode_bool/1}
                                                ),
                                                fun(Allow_empty_value) ->
                                                    gleam@dynamic@decode:optional_field(
                                                        <<"style"/utf8>>,
                                                        none,
                                                        option_decoder(
                                                            parameter_style_decoder(
                                                                
                                                            )
                                                        ),
                                                        fun(Style) ->
                                                            gleam@dynamic@decode:optional_field(
                                                                <<"explode"/utf8>>,
                                                                none,
                                                                option_decoder(
                                                                    {decoder,
                                                                        fun gleam@dynamic@decode:decode_bool/1}
                                                                ),
                                                                fun(Explode) ->
                                                                    gleam@dynamic@decode:optional_field(
                                                                        <<"allowReserved"/utf8>>,
                                                                        none,
                                                                        option_decoder(
                                                                            {decoder,
                                                                                fun gleam@dynamic@decode:decode_bool/1}
                                                                        ),
                                                                        fun(
                                                                            Allow_reserved
                                                                        ) ->
                                                                            gleam@dynamic@decode:optional_field(
                                                                                <<"schema"/utf8>>,
                                                                                none,
                                                                                option_decoder(
                                                                                    schema_or_ref_decoder(
                                                                                        
                                                                                    )
                                                                                ),
                                                                                fun(
                                                                                    Schema
                                                                                ) ->
                                                                                    gleam@dynamic@decode:optional_field(
                                                                                        <<"example"/utf8>>,
                                                                                        none,
                                                                                        option_decoder(
                                                                                            json_decoder(
                                                                                                
                                                                                            )
                                                                                        ),
                                                                                        fun(
                                                                                            Example
                                                                                        ) ->
                                                                                            gleam@dynamic@decode:optional_field(
                                                                                                <<"examples"/utf8>>,
                                                                                                none,
                                                                                                option_decoder(
                                                                                                    gleam@dynamic@decode:dict(
                                                                                                        {decoder,
                                                                                                            fun gleam@dynamic@decode:decode_string/1},
                                                                                                        example_or_ref_decoder(
                                                                                                            
                                                                                                        )
                                                                                                    )
                                                                                                ),
                                                                                                fun(
                                                                                                    Examples
                                                                                                ) ->
                                                                                                    gleam@dynamic@decode:optional_field(
                                                                                                        <<"content"/utf8>>,
                                                                                                        none,
                                                                                                        option_decoder(
                                                                                                            gleam@dynamic@decode:dict(
                                                                                                                {decoder,
                                                                                                                    fun gleam@dynamic@decode:decode_string/1},
                                                                                                                media_type_decoder(
                                                                                                                    
                                                                                                                )
                                                                                                            )
                                                                                                        ),
                                                                                                        fun(
                                                                                                            Content
                                                                                                        ) ->
                                                                                                            gleam@dynamic@decode:subfield(
                                                                                                                [],
                                                                                                                extensions_decoder(
                                                                                                                    
                                                                                                                ),
                                                                                                                fun(
                                                                                                                    Extensions
                                                                                                                ) ->
                                                                                                                    gleam@dynamic@decode:success(
                                                                                                                        {parameter,
                                                                                                                            Name,
                                                                                                                            In_,
                                                                                                                            Description,
                                                                                                                            Required,
                                                                                                                            Deprecated,
                                                                                                                            Allow_empty_value,
                                                                                                                            Style,
                                                                                                                            Explode,
                                                                                                                            Allow_reserved,
                                                                                                                            Schema,
                                                                                                                            Example,
                                                                                                                            Examples,
                                                                                                                            Content,
                                                                                                                            Extensions}
                                                                                                                    )
                                                                                                                end
                                                                                                            )
                                                                                                        end
                                                                                                    )
                                                                                                end
                                                                                            )
                                                                                        end
                                                                                    )
                                                                                end
                                                                            )
                                                                        end
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 417).
?DOC(" Decoder for Parameter or $ref.\n").
-spec parameter_or_ref_decoder() -> gleam@dynamic@decode:decoder(nori@reference:ref(nori@parameter:parameter())).
parameter_or_ref_decoder() ->
    ref_or_value_decoder(parameter_decoder()).

-file("src/nori/decoder.gleam", 1034).
?DOC(" Decoder for RequestBody objects.\n").
-spec request_body_decoder() -> gleam@dynamic@decode:decoder(nori@request_body:request_body()).
request_body_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"description"/utf8>>,
        none,
        option_decoder({decoder, fun gleam@dynamic@decode:decode_string/1}),
        fun(Description) ->
            gleam@dynamic@decode:optional_field(
                <<"content"/utf8>>,
                maps:new(),
                gleam@dynamic@decode:dict(
                    {decoder, fun gleam@dynamic@decode:decode_string/1},
                    media_type_decoder()
                ),
                fun(Content) ->
                    gleam@dynamic@decode:optional_field(
                        <<"required"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_bool/1}
                        ),
                        fun(Required) ->
                            gleam@dynamic@decode:subfield(
                                [],
                                extensions_decoder(),
                                fun(Extensions) ->
                                    gleam@dynamic@decode:success(
                                        {request_body,
                                            Description,
                                            Content,
                                            Required,
                                            Extensions}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1029).
?DOC(" Decoder for RequestBody or $ref.\n").
-spec request_body_or_ref_decoder() -> gleam@dynamic@decode:decoder(nori@reference:ref(nori@request_body:request_body())).
request_body_or_ref_decoder() ->
    ref_or_value_decoder(request_body_decoder()).

-file("src/nori/decoder.gleam", 1221).
?DOC(" Decoder for Response objects.\n").
-spec response_decoder() -> gleam@dynamic@decode:decoder(nori@response:response()).
response_decoder() ->
    gleam@dynamic@decode:field(
        <<"description"/utf8>>,
        {decoder, fun gleam@dynamic@decode:decode_string/1},
        fun(Description) ->
            gleam@dynamic@decode:optional_field(
                <<"headers"/utf8>>,
                maps:new(),
                gleam@dynamic@decode:dict(
                    {decoder, fun gleam@dynamic@decode:decode_string/1},
                    header_or_ref_decoder()
                ),
                fun(Headers) ->
                    gleam@dynamic@decode:optional_field(
                        <<"content"/utf8>>,
                        maps:new(),
                        gleam@dynamic@decode:dict(
                            {decoder, fun gleam@dynamic@decode:decode_string/1},
                            media_type_decoder()
                        ),
                        fun(Content) ->
                            gleam@dynamic@decode:optional_field(
                                <<"links"/utf8>>,
                                maps:new(),
                                gleam@dynamic@decode:dict(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_string/1},
                                    link_or_ref_decoder()
                                ),
                                fun(Links) ->
                                    gleam@dynamic@decode:subfield(
                                        [],
                                        extensions_decoder(),
                                        fun(Extensions) ->
                                            gleam@dynamic@decode:success(
                                                {response,
                                                    Description,
                                                    Headers,
                                                    Content,
                                                    Links,
                                                    Extensions}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 1216).
?DOC(" Decoder for Response or $ref.\n").
-spec response_or_ref_decoder() -> gleam@dynamic@decode:decoder(nori@reference:ref(nori@response:response())).
response_or_ref_decoder() ->
    ref_or_value_decoder(response_decoder()).

-file("src/nori/decoder.gleam", 1300).
?DOC(" Decoder for Components objects.\n").
-spec components_decoder() -> gleam@dynamic@decode:decoder(nori@components:components()).
components_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"schemas"/utf8>>,
        maps:new(),
        gleam@dynamic@decode:dict(
            {decoder, fun gleam@dynamic@decode:decode_string/1},
            schema_decoder()
        ),
        fun(Schemas) ->
            gleam@dynamic@decode:optional_field(
                <<"responses"/utf8>>,
                maps:new(),
                gleam@dynamic@decode:dict(
                    {decoder, fun gleam@dynamic@decode:decode_string/1},
                    response_or_ref_decoder()
                ),
                fun(Responses) ->
                    gleam@dynamic@decode:optional_field(
                        <<"parameters"/utf8>>,
                        maps:new(),
                        gleam@dynamic@decode:dict(
                            {decoder, fun gleam@dynamic@decode:decode_string/1},
                            parameter_or_ref_decoder()
                        ),
                        fun(Parameters) ->
                            gleam@dynamic@decode:optional_field(
                                <<"examples"/utf8>>,
                                maps:new(),
                                gleam@dynamic@decode:dict(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_string/1},
                                    example_or_ref_decoder()
                                ),
                                fun(Examples) ->
                                    gleam@dynamic@decode:optional_field(
                                        <<"requestBodies"/utf8>>,
                                        maps:new(),
                                        gleam@dynamic@decode:dict(
                                            {decoder,
                                                fun gleam@dynamic@decode:decode_string/1},
                                            request_body_or_ref_decoder()
                                        ),
                                        fun(Request_bodies) ->
                                            gleam@dynamic@decode:optional_field(
                                                <<"headers"/utf8>>,
                                                maps:new(),
                                                gleam@dynamic@decode:dict(
                                                    {decoder,
                                                        fun gleam@dynamic@decode:decode_string/1},
                                                    header_or_ref_decoder()
                                                ),
                                                fun(Headers) ->
                                                    gleam@dynamic@decode:optional_field(
                                                        <<"securitySchemes"/utf8>>,
                                                        maps:new(),
                                                        gleam@dynamic@decode:dict(
                                                            {decoder,
                                                                fun gleam@dynamic@decode:decode_string/1},
                                                            security_scheme_or_ref_decoder(
                                                                
                                                            )
                                                        ),
                                                        fun(Security_schemes) ->
                                                            gleam@dynamic@decode:optional_field(
                                                                <<"links"/utf8>>,
                                                                maps:new(),
                                                                gleam@dynamic@decode:dict(
                                                                    {decoder,
                                                                        fun gleam@dynamic@decode:decode_string/1},
                                                                    link_or_ref_decoder(
                                                                        
                                                                    )
                                                                ),
                                                                fun(Links) ->
                                                                    gleam@dynamic@decode:optional_field(
                                                                        <<"callbacks"/utf8>>,
                                                                        maps:new(
                                                                            
                                                                        ),
                                                                        gleam@dynamic@decode:dict(
                                                                            {decoder,
                                                                                fun gleam@dynamic@decode:decode_string/1},
                                                                            callback_or_ref_decoder(
                                                                                
                                                                            )
                                                                        ),
                                                                        fun(
                                                                            Callbacks
                                                                        ) ->
                                                                            gleam@dynamic@decode:optional_field(
                                                                                <<"pathItems"/utf8>>,
                                                                                maps:new(
                                                                                    
                                                                                ),
                                                                                gleam@dynamic@decode:dict(
                                                                                    {decoder,
                                                                                        fun gleam@dynamic@decode:decode_string/1},
                                                                                    path_item_or_ref_decoder(
                                                                                        
                                                                                    )
                                                                                ),
                                                                                fun(
                                                                                    Path_items
                                                                                ) ->
                                                                                    gleam@dynamic@decode:subfield(
                                                                                        [],
                                                                                        extensions_decoder(
                                                                                            
                                                                                        ),
                                                                                        fun(
                                                                                            Extensions
                                                                                        ) ->
                                                                                            gleam@dynamic@decode:success(
                                                                                                {components,
                                                                                                    Schemas,
                                                                                                    Responses,
                                                                                                    Parameters,
                                                                                                    Examples,
                                                                                                    Request_bodies,
                                                                                                    Headers,
                                                                                                    Security_schemes,
                                                                                                    Links,
                                                                                                    Callbacks,
                                                                                                    Path_items,
                                                                                                    Extensions}
                                                                                            )
                                                                                        end
                                                                                    )
                                                                                end
                                                                            )
                                                                        end
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 46).
?DOC(" Decoder for OpenAPI documents.\n").
-spec document_decoder() -> gleam@dynamic@decode:decoder(nori@document:document()).
document_decoder() ->
    gleam@dynamic@decode:field(
        <<"openapi"/utf8>>,
        version_decoder(),
        fun(Openapi) ->
            gleam@dynamic@decode:field(
                <<"info"/utf8>>,
                info_decoder(),
                fun(Info) ->
                    gleam@dynamic@decode:optional_field(
                        <<"jsonSchemaDialect"/utf8>>,
                        none,
                        option_decoder(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Json_schema_dialect) ->
                            gleam@dynamic@decode:optional_field(
                                <<"servers"/utf8>>,
                                [],
                                gleam@dynamic@decode:list(server_decoder()),
                                fun(Servers) ->
                                    gleam@dynamic@decode:optional_field(
                                        <<"paths"/utf8>>,
                                        none,
                                        option_decoder(paths_decoder()),
                                        fun(Paths) ->
                                            gleam@dynamic@decode:optional_field(
                                                <<"webhooks"/utf8>>,
                                                maps:new(),
                                                gleam@dynamic@decode:dict(
                                                    {decoder,
                                                        fun gleam@dynamic@decode:decode_string/1},
                                                    path_item_or_ref_decoder()
                                                ),
                                                fun(Webhooks) ->
                                                    gleam@dynamic@decode:optional_field(
                                                        <<"components"/utf8>>,
                                                        none,
                                                        option_decoder(
                                                            components_decoder()
                                                        ),
                                                        fun(Components) ->
                                                            gleam@dynamic@decode:optional_field(
                                                                <<"security"/utf8>>,
                                                                [],
                                                                gleam@dynamic@decode:list(
                                                                    security_requirement_decoder(
                                                                        
                                                                    )
                                                                ),
                                                                fun(Security) ->
                                                                    gleam@dynamic@decode:optional_field(
                                                                        <<"tags"/utf8>>,
                                                                        [],
                                                                        gleam@dynamic@decode:list(
                                                                            tag_decoder(
                                                                                
                                                                            )
                                                                        ),
                                                                        fun(
                                                                            Tags
                                                                        ) ->
                                                                            gleam@dynamic@decode:optional_field(
                                                                                <<"externalDocs"/utf8>>,
                                                                                none,
                                                                                option_decoder(
                                                                                    external_docs_decoder(
                                                                                        
                                                                                    )
                                                                                ),
                                                                                fun(
                                                                                    External_docs
                                                                                ) ->
                                                                                    gleam@dynamic@decode:subfield(
                                                                                        [],
                                                                                        extensions_decoder(
                                                                                            
                                                                                        ),
                                                                                        fun(
                                                                                            Extensions
                                                                                        ) ->
                                                                                            gleam@dynamic@decode:success(
                                                                                                {document,
                                                                                                    Openapi,
                                                                                                    Info,
                                                                                                    Json_schema_dialect,
                                                                                                    Servers,
                                                                                                    Paths,
                                                                                                    Webhooks,
                                                                                                    Components,
                                                                                                    Security,
                                                                                                    Tags,
                                                                                                    External_docs,
                                                                                                    Extensions}
                                                                                            )
                                                                                        end
                                                                                    )
                                                                                end
                                                                            )
                                                                        end
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src/nori/decoder.gleam", 41).
?DOC(" Decodes an OpenAPI document from a Dynamic value.\n").
-spec decode_document(gleam@dynamic:dynamic_()) -> {ok,
        nori@document:document()} |
    {error, list(gleam@dynamic@decode:decode_error())}.
decode_document(Dyn) ->
    gleam@dynamic@decode:run(Dyn, document_decoder()).