-module(sparkleplug).
-compile([no_auto_import, nowarn_unused_vars, nowarn_unused_function, nowarn_nomatch]).

-export([sparkplug_payload_to_json_string/1, metric_to_json_string/1, string_to_metric/1, string_to_sparkplug_payload/1, bit_array_to_sparkplug_payload/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.

-file("src\\sparkleplug.gleam", 245).
-spec datatype_decoder() -> gleam@dynamic@decode:decoder(sparkleplug@sparkplug_b@payload@datatype:data_type()).
datatype_decoder() ->
    _pipe@2 = gleam@dynamic@decode:one_of(
        begin
            _pipe = {decoder, fun gleam@dynamic@decode:decode_int/1},
            gleam@dynamic@decode:map(
                _pipe,
                fun sparkleplug@sparkplug_b@payload@datatype:from_int/1
            )
        end,
        [begin
                _pipe@1 = {decoder, fun gleam@dynamic@decode:decode_string/1},
                gleam@dynamic@decode:map(
                    _pipe@1,
                    fun sparkleplug@sparkplug_b@payload@datatype:from_string/1
                )
            end]
    ),
    gleam@dynamic@decode:map(_pipe@2, fun(Result) -> case Result of
                {ok, Datatype} ->
                    Datatype;

                {error, _} ->
                    bytes
            end end).

-file("src\\sparkleplug.gleam", 324).
-spec data_value_decoder() -> gleam@dynamic@decode:decoder(sparkleplug@sparkplug_b@payload@dataset:value()).
data_value_decoder() ->
    gleam@dynamic@decode:one_of(
        begin
            _pipe = {decoder, fun gleam@dynamic@decode:decode_int/1},
            gleam@dynamic@decode:map(
                _pipe,
                fun(Field@0) -> {int_value, Field@0} end
            )
        end,
        [begin
                _pipe@1 = {decoder, fun gleam@dynamic@decode:decode_float/1},
                gleam@dynamic@decode:map(
                    _pipe@1,
                    fun(Field@0) -> {float_value, Field@0} end
                )
            end,
            begin
                _pipe@2 = {decoder, fun gleam@dynamic@decode:decode_bool/1},
                gleam@dynamic@decode:map(
                    _pipe@2,
                    fun(Field@0) -> {boolean_value, Field@0} end
                )
            end,
            begin
                _pipe@3 = {decoder, fun gleam@dynamic@decode:decode_string/1},
                gleam@dynamic@decode:map(
                    _pipe@3,
                    fun(Field@0) -> {string_value, Field@0} end
                )
            end]
    ).

-file("src\\sparkleplug.gleam", 316).
-spec data_set_value_decoder() -> gleam@dynamic@decode:decoder(sparkleplug@sparkplug_b@payload@dataset:data_set_value()).
data_set_value_decoder() ->
    gleam@dynamic@decode:field(
        <<"value"/utf8>>,
        gleam@dynamic@decode:optional(data_value_decoder()),
        fun(Maybe_data_set_value) ->
            gleam@dynamic@decode:success({data_set_value, Maybe_data_set_value})
        end
    ).

-file("src\\sparkleplug.gleam", 311).
-spec row_decoder() -> gleam@dynamic@decode:decoder(sparkleplug@sparkplug_b@payload@dataset:row()).
row_decoder() ->
    gleam@dynamic@decode:field(
        <<"elements"/utf8>>,
        gleam@dynamic@decode:list(data_set_value_decoder()),
        fun(Row) -> gleam@dynamic@decode:success({row, Row}) end
    ).

-file("src\\sparkleplug.gleam", 300).
-spec data_set_decoder() -> gleam@dynamic@decode:decoder(sparkleplug@sparkplug_b@payload@dataset:data_set()).
data_set_decoder() ->
    gleam@dynamic@decode:field(
        <<"num_of_columns"/utf8>>,
        gleam@dynamic@decode:optional(
            {decoder, fun gleam@dynamic@decode:decode_int/1}
        ),
        fun(Maybe_num_of_columns) ->
            gleam@dynamic@decode:field(
                <<"columns"/utf8>>,
                gleam@dynamic@decode:list(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Columns) ->
                    gleam@dynamic@decode:field(
                        <<"types"/utf8>>,
                        gleam@dynamic@decode:list(
                            {decoder, fun gleam@dynamic@decode:decode_int/1}
                        ),
                        fun(Types) ->
                            gleam@dynamic@decode:field(
                                <<"rows"/utf8>>,
                                gleam@dynamic@decode:list(row_decoder()),
                                fun(Rows) ->
                                    gleam@dynamic@decode:success(
                                        {data_set,
                                            Maybe_num_of_columns,
                                            Columns,
                                            Types,
                                            Rows}
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src\\sparkleplug.gleam", 353).
-spec parameter_decoder() -> gleam@dynamic@decode:decoder(sparkleplug@sparkplug_b@payload@metric:parameter()).
parameter_decoder() ->
    gleam@dynamic@decode:field(
        <<"name"/utf8>>,
        gleam@dynamic@decode:optional(
            {decoder, fun gleam@dynamic@decode:decode_string/1}
        ),
        fun(Maybe_name) ->
            gleam@dynamic@decode:field(
                <<"type"/utf8>>,
                gleam@dynamic@decode:optional(
                    {decoder, fun gleam@dynamic@decode:decode_string/1}
                ),
                fun(Maybe_type) ->
                    gleam@dynamic@decode:field(
                        <<"value"/utf8>>,
                        gleam@dynamic@decode:optional(
                            {decoder, fun gleam@dynamic@decode:decode_string/1}
                        ),
                        fun(Maybe_value) ->
                            gleam@dynamic@decode:success(
                                {parameter, Maybe_name, Maybe_type, Maybe_value}
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src\\sparkleplug.gleam", 366).
-spec property_value_decoder() -> gleam@dynamic@decode:decoder(sparkleplug@sparkplug_b@payload@propertyset:property_value()).
property_value_decoder() ->
    gleam@dynamic@decode:field(
        <<"type"/utf8>>,
        gleam@dynamic@decode:optional(
            {decoder, fun gleam@dynamic@decode:decode_int/1}
        ),
        fun(Maybe_type) ->
            gleam@dynamic@decode:field(
                <<"is_null"/utf8>>,
                gleam@dynamic@decode:optional(
                    {decoder, fun gleam@dynamic@decode:decode_bool/1}
                ),
                fun(Maybe_is_null) ->
                    gleam@dynamic@decode:field(
                        <<"value"/utf8>>,
                        gleam@dynamic@decode:optional(
                            gleam@dynamic@decode:one_of(
                                begin
                                    _pipe = {decoder,
                                        fun gleam@dynamic@decode:decode_int/1},
                                    gleam@dynamic@decode:map(
                                        _pipe,
                                        fun(Field@0) -> {int_value, Field@0} end
                                    )
                                end,
                                [begin
                                        _pipe@1 = {decoder,
                                            fun gleam@dynamic@decode:decode_float/1},
                                        gleam@dynamic@decode:map(
                                            _pipe@1,
                                            fun(Field@0) -> {float_value, Field@0} end
                                        )
                                    end,
                                    begin
                                        _pipe@2 = {decoder,
                                            fun gleam@dynamic@decode:decode_bool/1},
                                        gleam@dynamic@decode:map(
                                            _pipe@2,
                                            fun(Field@0) -> {boolean_value, Field@0} end
                                        )
                                    end,
                                    begin
                                        _pipe@3 = {decoder,
                                            fun gleam@dynamic@decode:decode_string/1},
                                        gleam@dynamic@decode:map(
                                            _pipe@3,
                                            fun(Field@0) -> {string_value, Field@0} end
                                        )
                                    end]
                            )
                        ),
                        fun(Maybe_value) ->
                            gleam@dynamic@decode:success(
                                {property_value,
                                    Maybe_type,
                                    Maybe_is_null,
                                    Maybe_value}
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src\\sparkleplug.gleam", 360).
-spec property_set_decoder() -> gleam@dynamic@decode:decoder(sparkleplug@sparkplug_b@payload@propertyset:property_set()).
property_set_decoder() ->
    gleam@dynamic@decode:field(
        <<"keys"/utf8>>,
        gleam@dynamic@decode:list(
            {decoder, fun gleam@dynamic@decode:decode_string/1}
        ),
        fun(Keys) ->
            gleam@dynamic@decode:field(
                <<"values"/utf8>>,
                gleam@dynamic@decode:list(property_value_decoder()),
                fun(Values) ->
                    gleam@dynamic@decode:success({property_set, Keys, Values})
                end
            )
        end
    ).

-file("src\\sparkleplug.gleam", 386).
-spec property_set_list_decoder() -> gleam@dynamic@decode:decoder(sparkleplug@sparkplug_b@payload@propertyset:property_set_list()).
property_set_list_decoder() ->
    gleam@dynamic@decode:field(
        <<"propertyset"/utf8>>,
        gleam@dynamic@decode:list(property_set_decoder()),
        fun(Property_set_list) ->
            gleam@dynamic@decode:success({property_set_list, Property_set_list})
        end
    ).

-file("src\\sparkleplug.gleam", 415).
-spec encode_data_set_val(sparkleplug@sparkplug_b@payload@dataset:value()) -> gleam@json:json().
encode_data_set_val(Value) ->
    case Value of
        {int_value, Val} ->
            gleam@json:int(Val);

        {long_value, Val@1} ->
            gleam@json:int(Val@1);

        {float_value, Val@2} ->
            gleam@json:float(Val@2);

        {double_value, Val@3} ->
            gleam@json:float(Val@3);

        {boolean_value, Val@4} ->
            gleam@json:bool(Val@4);

        {string_value, Val@5} ->
            gleam@json:string(Val@5);

        {extension_value, Val@5} ->
            gleam@json:string(Val@5)
    end.

-file("src\\sparkleplug.gleam", 409).
-spec encode_data_set_value(
    sparkleplug@sparkplug_b@payload@dataset:data_set_value()
) -> gleam@json:json().
encode_data_set_value(Data_set_value) ->
    gleam@json:object(
        [{<<"value"/utf8>>,
                gleam@json:nullable(
                    erlang:element(2, Data_set_value),
                    fun encode_data_set_val/1
                )}]
    ).

-file("src\\sparkleplug.gleam", 403).
-spec encode_row(sparkleplug@sparkplug_b@payload@dataset:row()) -> gleam@json:json().
encode_row(Row) ->
    gleam@json:object(
        [{<<"elements"/utf8>>,
                gleam@json:array(
                    erlang:element(2, Row),
                    fun encode_data_set_value/1
                )}]
    ).

-file("src\\sparkleplug.gleam", 394).
-spec encode_data_set(sparkleplug@sparkplug_b@payload@dataset:data_set()) -> gleam@json:json().
encode_data_set(Dataset) ->
    gleam@json:object(
        [{<<"num_of_columns"/utf8>>,
                gleam@json:nullable(
                    erlang:element(2, Dataset),
                    fun gleam@json:int/1
                )},
            {<<"columns"/utf8>>,
                gleam@json:array(
                    erlang:element(3, Dataset),
                    fun gleam@json:string/1
                )},
            {<<"types"/utf8>>,
                gleam@json:array(
                    erlang:element(4, Dataset),
                    fun gleam@json:int/1
                )},
            {<<"rows"/utf8>>,
                gleam@json:array(erlang:element(5, Dataset), fun encode_row/1)}]
    ).

-file("src\\sparkleplug.gleam", 436).
-spec encode_parameter(sparkleplug@sparkplug_b@payload@metric:parameter()) -> gleam@json:json().
encode_parameter(Parameter) ->
    gleam@json:object(
        [{<<"name"/utf8>>,
                gleam@json:nullable(
                    erlang:element(2, Parameter),
                    fun gleam@json:string/1
                )},
            {<<"type"/utf8>>,
                gleam@json:nullable(
                    erlang:element(3, Parameter),
                    fun gleam@json:string/1
                )},
            {<<"value"/utf8>>,
                gleam@json:nullable(
                    erlang:element(4, Parameter),
                    fun gleam@json:string/1
                )}]
    ).

-file("src\\sparkleplug.gleam", 444).
-spec encode_extension(
    sparkleplug@sparkplug_b@payload@metric:metric_value_extension()
) -> gleam@json:json().
encode_extension(Extension) ->
    gleam@json:object(
        [{<<"value"/utf8>>, gleam@json:string(erlang:element(2, Extension))}]
    ).

-file("src\\sparkleplug.gleam", 426).
-spec encode_template(sparkleplug@sparkplug_b@payload@metric:template()) -> gleam@json:json().
encode_template(Template) ->
    gleam@json:object(
        [{<<"version"/utf8>>,
                gleam@json:nullable(
                    erlang:element(2, Template),
                    fun gleam@json:string/1
                )},
            {<<"metrics"/utf8>>,
                gleam@json:array(
                    erlang:element(3, Template),
                    fun metric_to_json/1
                )},
            {<<"parameters"/utf8>>,
                gleam@json:array(
                    erlang:element(4, Template),
                    fun encode_parameter/1
                )},
            {<<"template_ref"/utf8>>,
                gleam@json:nullable(
                    erlang:element(5, Template),
                    fun gleam@json:string/1
                )},
            {<<"is_definition"/utf8>>,
                gleam@json:nullable(
                    erlang:element(6, Template),
                    fun gleam@json:bool/1
                )}]
    ).

-file("src\\sparkleplug.gleam", 98).
-spec metric_to_json(sparkleplug@sparkplug_b@payload@metric:metric()) -> gleam@json:json().
metric_to_json(Metric) ->
    Encode_nullable_bool = fun(Nullable_bool_field) ->
        case Nullable_bool_field of
            {some, Val} ->
                gleam@json:bool(Val);

            none ->
                gleam@json:bool(false)
        end
    end,
    Encode_nullable_string = fun(Nullable_bitarray_field) ->
        case Nullable_bitarray_field of
            {some, Val@1} ->
                _pipe = Val@1,
                gleam@json:string(_pipe);

            none ->
                _pipe@1 = <<""/utf8>>,
                gleam@json:string(_pipe@1)
        end
    end,
    gleam@json:object(
        [{<<"name"/utf8>>,
                gleam@json:nullable(
                    erlang:element(2, Metric),
                    fun gleam@json:string/1
                )},
            {<<"alias"/utf8>>,
                gleam@json:nullable(
                    erlang:element(3, Metric),
                    fun gleam@json:int/1
                )},
            {<<"timestamp"/utf8>>,
                gleam@json:nullable(
                    erlang:element(4, Metric),
                    fun gleam@json:int/1
                )},
            {<<"dataType"/utf8>>,
                gleam@json:nullable(
                    erlang:element(5, Metric),
                    fun gleam@json:int/1
                )},
            {<<"is_historical"/utf8>>,
                Encode_nullable_bool(erlang:element(6, Metric))},
            {<<"is_transient"/utf8>>,
                Encode_nullable_bool(erlang:element(7, Metric))},
            {<<"is_null"/utf8>>,
                Encode_nullable_bool(erlang:element(8, Metric))},
            {<<"metadata"/utf8>>,
                Encode_nullable_string(erlang:element(9, Metric))},
            {<<"value"/utf8>>,
                gleam@json:nullable(
                    erlang:element(10, Metric),
                    fun value_to_json/1
                )}]
    ).

-file("src\\sparkleplug.gleam", 133).
-spec value_to_json(sparkleplug@sparkplug_b@payload@metric:value()) -> gleam@json:json().
value_to_json(Value) ->
    case Value of
        {int_value, Val} ->
            gleam@json:int(Val);

        {long_value, Val@1} ->
            gleam@json:int(Val@1);

        {float_value, Val@2} ->
            gleam@json:float(Val@2);

        {double_value, Val@3} ->
            gleam@json:float(Val@3);

        {boolean_value, Val@4} ->
            gleam@json:bool(Val@4);

        {string_value, Val@5} ->
            gleam@json:string(Val@5);

        {bytes_value, Val@6} ->
            _pipe = gleam_stdlib:bit_array_base64_encode(Val@6, true),
            gleam@json:string(_pipe);

        {dataset_value, Val@7} ->
            encode_data_set(Val@7);

        {template_value, Val@8} ->
            encode_template(Val@8);

        {extension_value, Val@9} ->
            encode_extension(Val@9);

        {property_set_value, Val@10} ->
            encode_property_set(Val@10);

        {property_set_list_value, Val@11} ->
            encode_property_set_list(Val@11)
    end.

-file("src\\sparkleplug.gleam", 70).
?DOC(" Serialise a Payload into a JSON string.\n").
-spec sparkplug_payload_to_json_string(
    sparkleplug@sparkplug_b@payload@payload:payload()
) -> binary().
sparkplug_payload_to_json_string(Payload) ->
    Encode_nullable_string = fun(Nullable_bitarray_field) ->
        case Nullable_bitarray_field of
            {some, Val} ->
                _pipe = Val,
                gleam@json:string(_pipe);

            none ->
                _pipe@1 = <<""/utf8>>,
                gleam@json:string(_pipe@1)
        end
    end,
    _pipe@2 = gleam@json:object(
        [{<<"timestamp"/utf8>>,
                gleam@json:nullable(
                    erlang:element(2, Payload),
                    fun gleam@json:int/1
                )},
            {<<"metrics"/utf8>>,
                gleam@json:array(
                    erlang:element(3, Payload),
                    fun metric_to_json/1
                )},
            {<<"seq"/utf8>>,
                gleam@json:nullable(
                    erlang:element(4, Payload),
                    fun gleam@json:int/1
                )},
            {<<"uuid"/utf8>>,
                Encode_nullable_string(erlang:element(5, Payload))},
            {<<"body"/utf8>>,
                Encode_nullable_string(erlang:element(6, Payload))}]
    ),
    gleam@json:to_string(_pipe@2).

-file("src\\sparkleplug.gleam", 93).
?DOC(" Serialise a Metric into a JSON string.\n").
-spec metric_to_json_string(sparkleplug@sparkplug_b@payload@metric:metric()) -> binary().
metric_to_json_string(Metric) ->
    _pipe = metric_to_json(Metric),
    gleam@json:to_string(_pipe).

-file("src\\sparkleplug.gleam", 463).
-spec encode_prop_val(sparkleplug@sparkplug_b@payload@propertyset:value()) -> gleam@json:json().
encode_prop_val(Prop_val) ->
    case Prop_val of
        {int_value, Val} ->
            gleam@json:int(Val);

        {long_value, Val@1} ->
            gleam@json:int(Val@1);

        {float_value, Val@2} ->
            gleam@json:float(Val@2);

        {double_value, Val@3} ->
            gleam@json:float(Val@3);

        {boolean_value, Val@4} ->
            gleam@json:bool(Val@4);

        {string_value, Val@5} ->
            gleam@json:string(Val@5);

        {propertyset_value, Val@6} ->
            encode_property_set(Val@6);

        {propertysets_value, Val@7} ->
            encode_property_set_list(Val@7);

        {extension_value, Val@8} ->
            gleam@json:string(Val@8)
    end.

-file("src\\sparkleplug.gleam", 448).
-spec encode_property_set(
    sparkleplug@sparkplug_b@payload@propertyset:property_set()
) -> gleam@json:json().
encode_property_set(Property_set) ->
    gleam@json:object(
        [{<<"keys"/utf8>>,
                gleam@json:array(
                    erlang:element(2, Property_set),
                    fun gleam@json:string/1
                )},
            {<<"values"/utf8>>,
                gleam@json:array(
                    erlang:element(3, Property_set),
                    fun encode_property_value/1
                )}]
    ).

-file("src\\sparkleplug.gleam", 455).
-spec encode_property_value(
    sparkleplug@sparkplug_b@payload@propertyset:property_value()
) -> gleam@json:json().
encode_property_value(Property_value) ->
    gleam@json:object(
        [{<<"type"/utf8>>,
                gleam@json:nullable(
                    erlang:element(2, Property_value),
                    fun gleam@json:int/1
                )},
            {<<"is_null"/utf8>>,
                gleam@json:nullable(
                    erlang:element(3, Property_value),
                    fun gleam@json:bool/1
                )},
            {<<"value"/utf8>>,
                gleam@json:nullable(
                    erlang:element(4, Property_value),
                    fun encode_prop_val/1
                )}]
    ).

-file("src\\sparkleplug.gleam", 477).
-spec encode_property_set_list(
    sparkleplug@sparkplug_b@payload@propertyset:property_set_list()
) -> gleam@json:json().
encode_property_set_list(Property_set_list) ->
    gleam@json:object(
        [{<<"propertyset"/utf8>>,
                gleam@json:array(
                    erlang:element(2, Property_set_list),
                    fun encode_property_set/1
                )}]
    ).

-file("src\\sparkleplug.gleam", 332).
-spec template_decoder() -> gleam@dynamic@decode:decoder(sparkleplug@sparkplug_b@payload@metric:template()).
template_decoder() ->
    gleam@dynamic@decode:field(
        <<"version"/utf8>>,
        gleam@dynamic@decode:optional(
            {decoder, fun gleam@dynamic@decode:decode_string/1}
        ),
        fun(Maybe_version) ->
            gleam@dynamic@decode:field(
                <<"metrics"/utf8>>,
                gleam@dynamic@decode:list(metric_decoder()),
                fun(Metrics) ->
                    gleam@dynamic@decode:field(
                        <<"parameters"/utf8>>,
                        gleam@dynamic@decode:list(parameter_decoder()),
                        fun(Parameters) ->
                            gleam@dynamic@decode:field(
                                <<"template_ref"/utf8>>,
                                gleam@dynamic@decode:optional(
                                    {decoder,
                                        fun gleam@dynamic@decode:decode_string/1}
                                ),
                                fun(Maybe_template_ref) ->
                                    gleam@dynamic@decode:field(
                                        <<"is_definition"/utf8>>,
                                        gleam@dynamic@decode:optional(
                                            {decoder,
                                                fun gleam@dynamic@decode:decode_bool/1}
                                        ),
                                        fun(Maybe_is_definition) ->
                                            gleam@dynamic@decode:success(
                                                {template,
                                                    Maybe_version,
                                                    Metrics,
                                                    Parameters,
                                                    Maybe_template_ref,
                                                    Maybe_is_definition}
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src\\sparkleplug.gleam", 187).
-spec metric_decoder() -> gleam@dynamic@decode:decoder(sparkleplug@sparkplug_b@payload@metric:metric()).
metric_decoder() ->
    gleam@dynamic@decode:optional_field(
        <<"name"/utf8>>,
        none,
        gleam@dynamic@decode:optional(
            {decoder, fun gleam@dynamic@decode:decode_string/1}
        ),
        fun(Maybe_name) ->
            gleam@dynamic@decode:optional_field(
                <<"alias"/utf8>>,
                none,
                gleam@dynamic@decode:optional(
                    {decoder, fun gleam@dynamic@decode:decode_int/1}
                ),
                fun(Maybe_alias) ->
                    gleam@dynamic@decode:optional_field(
                        <<"timestamp"/utf8>>,
                        none,
                        gleam@dynamic@decode:optional(
                            {decoder, fun gleam@dynamic@decode:decode_int/1}
                        ),
                        fun(Maybe_timestamp) ->
                            gleam@dynamic@decode:optional_field(
                                <<"dataType"/utf8>>,
                                bytes,
                                datatype_decoder(),
                                fun(Datatype) ->
                                    gleam@dynamic@decode:optional_field(
                                        <<"is_historical"/utf8>>,
                                        none,
                                        gleam@dynamic@decode:optional(
                                            {decoder,
                                                fun gleam@dynamic@decode:decode_bool/1}
                                        ),
                                        fun(Maybe_is_historical) ->
                                            gleam@dynamic@decode:optional_field(
                                                <<"is_transient"/utf8>>,
                                                none,
                                                gleam@dynamic@decode:optional(
                                                    {decoder,
                                                        fun gleam@dynamic@decode:decode_bool/1}
                                                ),
                                                fun(Maybe_is_transient) ->
                                                    gleam@dynamic@decode:optional_field(
                                                        <<"is_null"/utf8>>,
                                                        none,
                                                        gleam@dynamic@decode:optional(
                                                            {decoder,
                                                                fun gleam@dynamic@decode:decode_bool/1}
                                                        ),
                                                        fun(Maybe_is_null) ->
                                                            gleam@dynamic@decode:optional_field(
                                                                <<"metadata"/utf8>>,
                                                                none,
                                                                gleam@dynamic@decode:optional(
                                                                    {decoder,
                                                                        fun gleam@dynamic@decode:decode_string/1}
                                                                ),
                                                                fun(
                                                                    Maybe_metadata
                                                                ) ->
                                                                    gleam@dynamic@decode:field(
                                                                        <<"value"/utf8>>,
                                                                        gleam@dynamic@decode:optional(
                                                                            value_decoder(
                                                                                Datatype
                                                                            )
                                                                        ),
                                                                        fun(
                                                                            Maybe_value
                                                                        ) ->
                                                                            gleam@dynamic@decode:success(
                                                                                {metric,
                                                                                    Maybe_name,
                                                                                    Maybe_alias,
                                                                                    Maybe_timestamp,
                                                                                    {some,
                                                                                        begin
                                                                                            _pipe = Datatype,
                                                                                            sparkleplug@sparkplug_b@payload@datatype:to_int(
                                                                                                _pipe
                                                                                            )
                                                                                        end},
                                                                                    Maybe_is_historical,
                                                                                    Maybe_is_transient,
                                                                                    Maybe_is_null,
                                                                                    Maybe_metadata,
                                                                                    Maybe_value}
                                                                            )
                                                                        end
                                                                    )
                                                                end
                                                            )
                                                        end
                                                    )
                                                end
                                            )
                                        end
                                    )
                                end
                            )
                        end
                    )
                end
            )
        end
    ).

-file("src\\sparkleplug.gleam", 257).
-spec value_decoder(sparkleplug@sparkplug_b@payload@datatype:data_type()) -> gleam@dynamic@decode:decoder(sparkleplug@sparkplug_b@payload@metric:value()).
value_decoder(Datatype) ->
    case Datatype of
        unknown ->
            _pipe = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        int8 ->
            _pipe@1 = {decoder, fun gleam@dynamic@decode:decode_int/1},
            gleam@dynamic@decode:map(
                _pipe@1,
                fun(Field@0) -> {int_value, Field@0} end
            );

        int16 ->
            _pipe@1 = {decoder, fun gleam@dynamic@decode:decode_int/1},
            gleam@dynamic@decode:map(
                _pipe@1,
                fun(Field@0) -> {int_value, Field@0} end
            );

        int32 ->
            _pipe@1 = {decoder, fun gleam@dynamic@decode:decode_int/1},
            gleam@dynamic@decode:map(
                _pipe@1,
                fun(Field@0) -> {int_value, Field@0} end
            );

        int64 ->
            _pipe@1 = {decoder, fun gleam@dynamic@decode:decode_int/1},
            gleam@dynamic@decode:map(
                _pipe@1,
                fun(Field@0) -> {int_value, Field@0} end
            );

        u_int8 ->
            _pipe@1 = {decoder, fun gleam@dynamic@decode:decode_int/1},
            gleam@dynamic@decode:map(
                _pipe@1,
                fun(Field@0) -> {int_value, Field@0} end
            );

        u_int16 ->
            _pipe@1 = {decoder, fun gleam@dynamic@decode:decode_int/1},
            gleam@dynamic@decode:map(
                _pipe@1,
                fun(Field@0) -> {int_value, Field@0} end
            );

        u_int32 ->
            _pipe@1 = {decoder, fun gleam@dynamic@decode:decode_int/1},
            gleam@dynamic@decode:map(
                _pipe@1,
                fun(Field@0) -> {int_value, Field@0} end
            );

        u_int64 ->
            _pipe@1 = {decoder, fun gleam@dynamic@decode:decode_int/1},
            gleam@dynamic@decode:map(
                _pipe@1,
                fun(Field@0) -> {int_value, Field@0} end
            );

        float ->
            _pipe@2 = {decoder, fun gleam@dynamic@decode:decode_float/1},
            gleam@dynamic@decode:map(
                _pipe@2,
                fun(Field@0) -> {float_value, Field@0} end
            );

        double ->
            _pipe@2 = {decoder, fun gleam@dynamic@decode:decode_float/1},
            gleam@dynamic@decode:map(
                _pipe@2,
                fun(Field@0) -> {float_value, Field@0} end
            );

        boolean ->
            _pipe@3 = {decoder, fun gleam@dynamic@decode:decode_bool/1},
            gleam@dynamic@decode:map(
                _pipe@3,
                fun(Field@0) -> {boolean_value, Field@0} end
            );

        string ->
            _pipe@4 = {decoder, fun gleam@dynamic@decode:decode_string/1},
            gleam@dynamic@decode:map(
                _pipe@4,
                fun(Field@0) -> {string_value, Field@0} end
            );

        date_time ->
            _pipe@5 = {decoder, fun gleam@dynamic@decode:decode_int/1},
            gleam@dynamic@decode:map(
                _pipe@5,
                fun(Field@0) -> {int_value, Field@0} end
            );

        text ->
            _pipe@6 = {decoder, fun gleam@dynamic@decode:decode_string/1},
            gleam@dynamic@decode:map(
                _pipe@6,
                fun(Field@0) -> {string_value, Field@0} end
            );

        uuid ->
            _pipe@7 = {decoder, fun gleam@dynamic@decode:decode_string/1},
            gleam@dynamic@decode:map(
                _pipe@7,
                fun(Field@0) -> {string_value, Field@0} end
            );

        data_set ->
            _pipe@8 = data_set_decoder(),
            gleam@dynamic@decode:map(
                _pipe@8,
                fun(Field@0) -> {dataset_value, Field@0} end
            );

        bytes ->
            _pipe@9 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@9,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        file ->
            _pipe@9 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@9,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        template ->
            _pipe@10 = template_decoder(),
            gleam@dynamic@decode:map(
                _pipe@10,
                fun(Field@0) -> {template_value, Field@0} end
            );

        property_set ->
            _pipe@11 = property_set_decoder(),
            gleam@dynamic@decode:map(
                _pipe@11,
                fun(Field@0) -> {property_set_value, Field@0} end
            );

        property_set_list ->
            _pipe@12 = property_set_list_decoder(),
            gleam@dynamic@decode:map(
                _pipe@12,
                fun(Field@0) -> {property_set_list_value, Field@0} end
            );

        int8_array ->
            _pipe@13 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@13,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        int16_array ->
            _pipe@13 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@13,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        int32_array ->
            _pipe@13 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@13,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        int64_array ->
            _pipe@13 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@13,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        u_int8_array ->
            _pipe@13 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@13,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        u_int16_array ->
            _pipe@13 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@13,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        u_int32_array ->
            _pipe@13 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@13,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        u_int64_array ->
            _pipe@13 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@13,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        float_array ->
            _pipe@13 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@13,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        double_array ->
            _pipe@13 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@13,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        boolean_array ->
            _pipe@13 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@13,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        string_array ->
            _pipe@13 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@13,
                fun(Field@0) -> {bytes_value, Field@0} end
            );

        date_time_array ->
            _pipe@13 = {decoder, fun gleam@dynamic@decode:decode_bit_array/1},
            gleam@dynamic@decode:map(
                _pipe@13,
                fun(Field@0) -> {bytes_value, Field@0} end
            )
    end.

-file("src\\sparkleplug.gleam", 63).
?DOC(
    " Attempts to convert a string representation of a Sparkplug B metric into a Metric type.\n"
    "\n"
    " Returns an error if the string doesn't hold a valid representation.\n"
).
-spec string_to_metric(binary()) -> {ok,
        sparkleplug@sparkplug_b@payload@metric:metric()} |
    {error, gleam@json:decode_error()}.
string_to_metric(Metric_string) ->
    gleam@json:parse(Metric_string, metric_decoder()).

-file("src\\sparkleplug.gleam", 150).
-spec json_to_sparkplug_payload(binary()) -> {ok,
        sparkleplug@sparkplug_b@payload@payload:payload()} |
    {error, gleam@json:decode_error()}.
json_to_sparkplug_payload(Json_string) ->
    Sparkplug_decoder = begin
        gleam@dynamic@decode:optional_field(
            <<"timestamp"/utf8>>,
            none,
            gleam@dynamic@decode:optional(
                {decoder, fun gleam@dynamic@decode:decode_int/1}
            ),
            fun(Maybe_timestamp) ->
                gleam@dynamic@decode:field(
                    <<"metrics"/utf8>>,
                    gleam@dynamic@decode:list(metric_decoder()),
                    fun(Metrics) ->
                        gleam@dynamic@decode:optional_field(
                            <<"seq"/utf8>>,
                            none,
                            gleam@dynamic@decode:optional(
                                {decoder, fun gleam@dynamic@decode:decode_int/1}
                            ),
                            fun(Maybe_seq) ->
                                gleam@dynamic@decode:optional_field(
                                    <<"uuid"/utf8>>,
                                    none,
                                    gleam@dynamic@decode:optional(
                                        {decoder,
                                            fun gleam@dynamic@decode:decode_string/1}
                                    ),
                                    fun(Maybe_uuid) ->
                                        gleam@dynamic@decode:optional_field(
                                            <<"body"/utf8>>,
                                            none,
                                            gleam@dynamic@decode:optional(
                                                {decoder,
                                                    fun gleam@dynamic@decode:decode_string/1}
                                            ),
                                            fun(Maybe_body) ->
                                                gleam@dynamic@decode:success(
                                                    {payload,
                                                        Maybe_timestamp,
                                                        Metrics,
                                                        Maybe_seq,
                                                        Maybe_uuid,
                                                        Maybe_body}
                                                )
                                            end
                                        )
                                    end
                                )
                            end
                        )
                    end
                )
            end
        )
    end,
    gleam@json:parse(Json_string, Sparkplug_decoder).

-file("src\\sparkleplug.gleam", 27).
?DOC(
    " Attempts to convert a string representation of a Sparkplug B payload into a Payload type.\n"
    "\n"
    " Returns an error if the string doesn't hold a valid representation.\n"
).
-spec string_to_sparkplug_payload(binary()) -> {ok,
        sparkleplug@sparkplug_b@payload@payload:payload()} |
    {error, binary()}.
string_to_sparkplug_payload(Payload_string) ->
    _pipe = json_to_sparkplug_payload(Payload_string),
    gleam@result:map_error(_pipe, fun(Error_val) -> case Error_val of
                unexpected_end_of_input ->
                    <<"Unexpected end of input"/utf8>>;

                {unexpected_byte, Message} ->
                    <<"Unexpected byte: "/utf8, Message/binary>>;

                {unexpected_format, Inner_errors} ->
                    case gleam@list:first(Inner_errors) of
                        {ok, Error} ->
                            <<<<<<"Unexpected format: Expected "/utf8,
                                        (erlang:element(2, Error))/binary>>/binary,
                                    "; found "/utf8>>/binary,
                                (erlang:element(3, Error))/binary>>;

                        {error, _} ->
                            <<"Unexpected format: No inner errors"/utf8>>
                    end;

                {unexpected_sequence, Message@1} ->
                    <<"Unexpected sequence: "/utf8, Message@1/binary>>;

                {unable_to_decode, Inner_errors@1} ->
                    case gleam@list:first(Inner_errors@1) of
                        {ok, Error@1} ->
                            <<<<<<"Unable to decode: Expected "/utf8,
                                        (erlang:element(2, Error@1))/binary>>/binary,
                                    "; found "/utf8>>/binary,
                                (erlang:element(3, Error@1))/binary>>;

                        {error, _} ->
                            <<"Unable to decode. No inner errors"/utf8>>
                    end
            end end).

-file("src\\sparkleplug.gleam", 16).
?DOC(
    " Attempts to convert a bit array representation of a Sparkplug B payload into a Payload type.\n"
    "\n"
    " Returns an error if the bit array doesn't hold a valid representation.\n"
).
-spec bit_array_to_sparkplug_payload(bitstring()) -> {ok,
        sparkleplug@sparkplug_b@payload@payload:payload()} |
    {error, binary()}.
bit_array_to_sparkplug_payload(Payload_bit_array) ->
    _pipe = gleam@bit_array:to_string(Payload_bit_array),
    _pipe@1 = gleam@result:map_error(
        _pipe,
        fun(_) -> <<"Couldn't convert the bit array into a string."/utf8>> end
    ),
    gleam@result:'try'(_pipe@1, fun string_to_sparkplug_payload/1).