[{"name":"Cbor","comment":"\n\n@docs CborItem, Sign\n\n","unions":[{"name":"CborItem","comment":" A generic sum-type for representing any arbitrary CBOR item. See also\n[`Cbor.Decode.any`](https://package.elm-lang.org/packages/elm-toulouse/cbor/latest/Cbor-Decode#any) and [`Cbor.Encode.any`](https://package.elm-lang.org/packages/elm-toulouse/cbor/latest/Cbor-Encode#any)\n","args":[],"cases":[["CborInt",["Basics.Int"]],["CborBytes",["Bytes.Bytes"]],["CborString",["String.String"]],["CborList",["List.List Cbor.CborItem"]],["CborMap",["List.List ( Cbor.CborItem, Cbor.CborItem )"]],["CborTag",["Cbor.Tag.Tag","Cbor.CborItem"]],["CborBool",["Basics.Bool"]],["CborFloat",["Basics.Float"]],["CborNull",[]],["CborUndefined",[]]]},{"name":"Sign","comment":" A sum-type for representing signs of integer numbers. By convention, 0 is\nalways `Positive`.\n","args":[],"cases":[["Positive",[]],["Negative",[]]]}],"aliases":[],"values":[],"binops":[]},{"name":"Cbor.Decode","comment":" The Concise Binary Object Representation (CBOR) is a data format whose design\ngoals include the possibility of extremely small code size, fairly small message\nsize, and extensibility without the need for version negotiation. These design\ngoals make it different from earlier binary serializations such as ASN.1 and\nMessagePack.\n\n\n## Decoder\n\n@docs Decoder, decode, maybe\n\n\n## Primitives\n\n@docs bool, int, bigint, float, string, bytes\n\n\n## Data Structures\n\n@docs list, length, dict, size\n\n\n## Records & Tuples\n\n@docs Step, record, fields, field, optionalField, tuple, elems, elem, optionalElem\n\n\n## Mapping\n\n@docs succeed, fail, andThen, ignoreThen, thenIgnore, map, map2, map3, map4, map5, traverse\n\n\n## Branching\n\n@docs oneOf, keep, ignore\n\n\n## Streaming\n\n@docs beginString, beginBytes, beginList, beginDict, break\n\n\n## Tagging\n\n@docs tag, tagged\n\n\n## Debugging\n\n@docs any, raw\n\n","unions":[{"name":"Decoder","comment":" Describes how to turn a binary CBOR sequence of bytes into any Elm value.\n","args":["a"],"cases":[]},{"name":"Step","comment":" An intermediate (opaque) step in the decoding of a record. See\n[`record`](#record) or [`tuple`](#tuple) for more detail.\n","args":["k","result"],"cases":[]}],"aliases":[],"values":[{"name":"andThen","comment":" Decode something and then use that information to decode something else.\nThis is useful when a ['Decoder'](#Decoder) depends on a value held by another decoder:\n\n    tagged : Tag -> Decoder a -> Decoder a\n    tagged expectedTag decodeA =\n        tag\n            |> andThen\n                (\\decodedTag ->\n                    if decodedTag == expectedTag then\n                        decodeA\n\n                    else\n                        fail\n                )\n\n","type":"(a -> Cbor.Decode.Decoder b) -> Cbor.Decode.Decoder a -> Cbor.Decode.Decoder b"},{"name":"any","comment":" Decode remaining bytes as _any_ [`CborItem`](https://package.elm-lang.org/packages/elm-toulouse/cbor/latest/Cbor#CborItem). This is useful\nfor debugging or to inspect some unknown Cbor data.\n\n    D.decode D.any <| E.encode (E.int 14) == Just (CborInt 14)\n\n","type":"Cbor.Decode.Decoder Cbor.CborItem"},{"name":"beginBytes","comment":" Decode the beginning of an indefinite [`Bytes`](https://package.elm-lang.org/packages/elm/bytes/latest/Bytes#Bytes) sequence.\n\nThis is useful in combination with [`ignoreThen`](#ignoreThen) and\n[`andThen`](#andThen) to manually decode sequences of byte strings.\n\n","type":"Cbor.Decode.Decoder ()"},{"name":"beginDict","comment":" Decode the beginning of an indefinite [`Dict`](https://package.elm-lang.org/packages/elm/core/latest/Dict#Dict).\n\nThis is useful in combination with [`ignoreThen`](#ignoreThen) and\n[`andThen`](#andThen) to manually decode indefinite [`Dict`](https://package.elm-lang.org/packages/elm/core/latest/Dict#Dict).\n\n","type":"Cbor.Decode.Decoder ()"},{"name":"beginList","comment":" Decode the beginning of an indefinite `List`.\n\nThis is useful in combination with [`ignoreThen`](#ignoreThen) and\n[`andThen`](#andThen) to manually decode indefinite `List`.\n\n","type":"Cbor.Decode.Decoder ()"},{"name":"beginString","comment":" Decode the beginning of an indefinite [`String`](https://package.elm-lang.org/packages/elm/core/latest/String#String) sequence.\n\nThis is useful in combination with [`ignoreThen`](#ignoreThen) and\n[`andThen`](#andThen) to manually decode sequences of text strings.\n\n","type":"Cbor.Decode.Decoder ()"},{"name":"bigint","comment":" Decode an unbounded integer as a big-endian bytes sequence. This\nis particularly useful for decoding large integer values which are beyond the\nmax and min safe integer values allowed by Elm.\n\nThis can also be used to decode tagged [`PositiveBigNum`](../Cbor-Tag#Tag) and [`NegativeBigNum`](../Cbor-Tag#Tag)\ninteger values following the tag semantic specified in [RFC-7049](https://www.rfc-editor.org/rfc/rfc7049#appendix-B).\n\n    -- 0\n    D.decode D.bigint Bytes<0x00>\n        == Just (Positive, Bytes<0x00>)\n\n    -- 1337\n    D.decode D.bigint Bytes<0x19, 0x05, 0x39>\n        == Just (Positive, Bytes<0x05, 0x39>)\n\n    -- -14\n    D.decode D.bigint Bytes<0x2D>\n        == Just (Negative, Bytes<0x0E>)\n\n    -- -1536\n    D.decode D.bigint Bytes<0x39, 0x05, 0xFF>\n        == Just <Negative, Bytes<0x06, 0x00>\n\n    -- 2^53\n    D.decode D.bigint Bytes<0x1B, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00>\n        == Just (Positive, Bytes<0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00>)\n\n    -- 2^64\n    D.decode D.bigint Bytes<0xC2, 0x49, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00>\n        == Just (Positive, Bytes<0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00>)\n\n","type":"Cbor.Decode.Decoder ( Cbor.Sign, Bytes.Bytes )"},{"name":"bool","comment":" Decode a boolean.\n\n    D.decode D.bool Bytes<0xF4> == Just False\n\n    D.decode D.bool Bytes<0xF5> == Just True\n\n","type":"Cbor.Decode.Decoder Basics.Bool"},{"name":"break","comment":" Decode a termination of an indefinite structure. See\n[`beginString`](#beginString), [`beginBytes`](#beginBytes),\n[`beginList`](#beginList), [`beginDict`](#beginDict) for detail about usage.\n","type":"Cbor.Decode.Decoder ()"},{"name":"bytes","comment":" Decode a bunch bytes into [`Bytes`](https://package.elm-lang.org/packages/elm/bytes/latest/Bytes#Bytes).\nIn case of streaming, all byte chunks are decoded at once and concatenated as if they were\none single byte string. See also [`Cbor.Encode.beginBytes`](https://package.elm-lang.org/packages/elm-toulouse/cbor/latest/Cbor-Encode#beginBytes).\n","type":"Cbor.Decode.Decoder Bytes.Bytes"},{"name":"decode","comment":" Turn a binary CBOR sequence of bytes into a nice Elm value.\n","type":"Cbor.Decode.Decoder a -> Bytes.Bytes -> Maybe.Maybe a"},{"name":"dict","comment":" Decode an CBOR map of pairs of data-items into an Elm [`Dict`](https://package.elm-lang.org/packages/elm/core/latest/Dict#Dict).\nThe map can be either of definite length or indefinite length.\n\n    D.decode (D.dict D.int D.int) Bytes<0xA1, 0x0E, 0x18, 0x2A>\n        == Dict.fromList [ ( 14, 42 ) ]\n\n    D.decode (D.dict D.string D.int) Bytes<0xBF, 0x61, 0x61, 0x0E, 0x61, 0x62, 0x18, 0x2A, 0xFF>\n        == Dict.fromList [ ( \"a\", 14 ), ( \"b\", 42 ) ]\n\n","type":"Cbor.Decode.Decoder comparable -> Cbor.Decode.Decoder a -> Cbor.Decode.Decoder (Dict.Dict comparable a)"},{"name":"elem","comment":" Decode an element of a record or tuple and step through the decoder.\n\nSee [`tuple`](#tuple) for detail about usage.\n\n","type":"Cbor.Decode.Decoder field -> Cbor.Decode.Decoder (Cbor.Decode.Step Basics.Never (field -> steps)) -> Cbor.Decode.Decoder (Cbor.Decode.Step Basics.Never steps)"},{"name":"elems","comment":" A helper that makes writing record decoders nicer. It is equivalent to\n[`succeed`](#succeed), but let us align decoders to fight compulsory OCDs.\n","type":"Cbor.Decode.Step Basics.Never steps -> Cbor.Decode.Decoder (Cbor.Decode.Step Basics.Never steps)"},{"name":"fail","comment":" A decoder that always fail.\n\n    D.decode D.fail Bytes<0x00> == Nothing\n\nThis is particularly handy when used in combination with [`andThen`](#andThen)\n\n","type":"Cbor.Decode.Decoder a"},{"name":"field","comment":" Decode a field of record and step through the decoder. This ensures that\nthe decoded key matches the expected key. If it doesn't, the entire decoder is failed.\n\nSee [`record`](#record) for detail about usage.\n\n","type":"k -> Cbor.Decode.Decoder field -> Cbor.Decode.Decoder (Cbor.Decode.Step k (field -> steps)) -> Cbor.Decode.Decoder (Cbor.Decode.Step k steps)"},{"name":"fields","comment":" A helper that makes writing record decoders nicer. It is equivalent to\n[`succeed`](#succeed), but let us align decoders to fight compulsory OCDs.\n","type":"Cbor.Decode.Step k steps -> Cbor.Decode.Decoder (Cbor.Decode.Step k steps)"},{"name":"float","comment":" Decode a floating point number, regardless of its precision. Because in Elm,\nthere exists only one 'Float' type, which is encoded in double-precision, we do\ndecode all floats into this double-precision number in Elm which may lead to\nsome precision gain and therefore, different representation than one would\nexpect.\n\n    D.decode D.float <| E.encode (E.float16 1.1) == Just 1.099609375\n\n    D.decode D.float <| E.encode (E.float64 1.1) == Just 1.1\n\n","type":"Cbor.Decode.Decoder Basics.Float"},{"name":"ignore","comment":" Ignore a field when manually decoding a structure. See [`keep`](#keep) for\ndetails\n","type":"Cbor.Decode.Decoder ignore -> Cbor.Decode.Decoder keep -> Cbor.Decode.Decoder keep"},{"name":"ignoreThen","comment":" Decode something and then another thing, but only continue with the second\nresult.\n\n    ignoreThen a ignored =\n        ignored |> andThen (always a)\n\n","type":"Cbor.Decode.Decoder a -> Cbor.Decode.Decoder ignored -> Cbor.Decode.Decoder a"},{"name":"int","comment":" Decode an integer. Note that there's no granular decoders (nor encoders)\nbecause, the CBOR encoding of an integers varies depending on the integer value.\nTherefore, at the CBOR-level, as in Elm, there's no notion of _smaller_ integers.\n\n    D.decode D.int Bytes<0x00> == Just 0\n\n    D.decode D.int Bytes<0x00> == Just 0\n\n    D.decode D.int Bytes<0x1A, 0x00, 0x02, 0x33, 0x56> == Just 1337\n\n    D.decode D.int Bytes<0x2D> == Just -14\n\n","type":"Cbor.Decode.Decoder Basics.Int"},{"name":"keep","comment":" Decode the next value from a structure, and continue decoding.\n\nThis is particularly useful when manually decoding an array-like or map-like\nstructure that materialize multi-variant constructors. For example, imagine the\nfollowing:\n\n    type Hostname\n        = Single Ipv4 TcpPort\n        | Multi AaaRecord TcpPort\n        | Dns SrvRecord\n\nWhich could be encoded as such:\n\n    toCBOR : Hostname -> E.Encoder\n    toCBOR host =\n        case host of\n            Single ip tcpPort ->\n                E.sequence\n                    [ E.length 3\n                    , E.int 0\n                    , Ipv4.toCbor ip\n                    , TcpPort.toCbor tcpPort\n                    ]\n\n            Multi record tcpPort ->\n                E.sequence\n                    [ E.length 3\n                    , E.int 1\n                    , AaaRecord.toCbor record\n                    , TcpPort.toCbor tcpPort\n                    ]\n\n            Dns record ->\n                E.sequence\n                    [ E.length 2\n                    , E.int 2\n                    , SrvRecord.toCbor record\n                    ]\n\nHere, the usual [`tuple`](#tuple) helper would be hopeless since we can't commit\nto a single constructor a priori. Using [`oneOf`](#oneOf) is also unsatisfactory\nas we could branch into the right decoder by just peaking at the first byte.\nUsing `keep` and [`ignore`](#ignore) we can write an efficient decoder as such:\n\n    fromCbor : D.Decoder Hostname\n    fromCbor =\n        D.length\n            |> D.andThen (\\len -> D.map (\\tag -> ( len, tag )) D.int)\n            |> D.andThen\n                (\\( _, tag ) ->\n                    case tag of\n                        0 ->\n                            succeed Single\n                                |> keep Ipv4.fromCbor\n                                |> keep TcpPort.fromCbor\n\n                        1 ->\n                            succeed Multi\n                                |> keep AaaRecord.fromCbor\n                                |> keep TcpPort.fromCbor\n\n                        2 ->\n                            succeed Dns\n                                |> SrvRecord.fromCbor\n\n                        _ ->\n                            D.fail\n                )\n\n","type":"Cbor.Decode.Decoder a -> Cbor.Decode.Decoder (a -> b) -> Cbor.Decode.Decoder b"},{"name":"length","comment":" Decode only the length of a (definite) CBOR array.\n","type":"Cbor.Decode.Decoder Basics.Int"},{"name":"list","comment":" Decode a `List` of items `a`. The list can be definite or indefinite.\n\n    D.decode (D.list D.int) Bytes<0x82, 0x0E, 0x18, 0x2A> == Just [ 14, 42 ]\n\n    D.decode (D.list D.int) Bytes<0x9F, 0x01, 0x02, 0xFF> == Just [ 1, 1 ]\n\n    D.decode (D.list (D.list D.bool)) Bytes<0x81, 0x9F, 0xF4, 0xFF> == Just [ [ False ] ]\n\n","type":"Cbor.Decode.Decoder a -> Cbor.Decode.Decoder (List.List a)"},{"name":"map","comment":" Transform a decoder. For example, maybe you just want to know the length of a string:\n\n    import String\n\n    stringLength : Decoder Int\n    stringLength =\n        D.map String.length D.string\n\n","type":"(a -> value) -> Cbor.Decode.Decoder a -> Cbor.Decode.Decoder value"},{"name":"map2","comment":" Try two decoders and then combine the result. Can be used to decode objects\nwith many fields:\n\n    type alias Point =\n        { x : Float, y : Float }\n\n    point : Decoder Point\n    point =\n        D.map2 Point D.float D.float\n\nIt tries each individual decoder and puts the result together with the Point\nconstructor.\n\n","type":"(a -> b -> value) -> Cbor.Decode.Decoder a -> Cbor.Decode.Decoder b -> Cbor.Decode.Decoder value"},{"name":"map3","comment":" Try three decoders and then combine the result. Can be used to decode\nobjects with many fields:\n\n    type alias Person =\n        { name : String, age : Int, height : Float }\n\n    person : Decoder Person\n    person =\n        D.map3 Person D.string D.int D.float\n\nLike `map2` it tries each decoder in order and then give the results to the\n`Person` constructor. That can be any function though!\n\n","type":"(a -> b -> c -> value) -> Cbor.Decode.Decoder a -> Cbor.Decode.Decoder b -> Cbor.Decode.Decoder c -> Cbor.Decode.Decoder value"},{"name":"map4","comment":" Try four decoders and then combine the result. See also 'map3' for some\nexamples.\n","type":"(a -> b -> c -> d -> value) -> Cbor.Decode.Decoder a -> Cbor.Decode.Decoder b -> Cbor.Decode.Decoder c -> Cbor.Decode.Decoder d -> Cbor.Decode.Decoder value"},{"name":"map5","comment":" Try five decoders and then combine the result. See also 'map3' for some\nexamples.\n","type":"(a -> b -> c -> d -> e -> value) -> Cbor.Decode.Decoder a -> Cbor.Decode.Decoder b -> Cbor.Decode.Decoder c -> Cbor.Decode.Decoder d -> Cbor.Decode.Decoder e -> Cbor.Decode.Decoder value"},{"name":"maybe","comment":" Helpful for dealing with optional items. Turns [`null`](https://package.elm-lang.org/packages/elm-toulouse/cbor/latest/Cbor-Encode#null)\nor [`undefined`](https://package.elm-lang.org/packages/elm-toulouse/cbor/latest/Cbor-Encode#undefined) into [`Nothing`](https://package.elm-lang.org/packages/elm/core/latest/Maybe#Maybe).\n\n    D.decode (D.maybe D.bool) Bytes<0xF6> == Just Nothing\n\n    D.decode (D.maybe D.bool) Bytes<0xF4> == Just (Just False)\n\n","type":"Cbor.Decode.Decoder a -> Cbor.Decode.Decoder (Maybe.Maybe a)"},{"name":"oneOf","comment":" Decode something that can have one of many shapes without prior information\non the correct shape.\n\n    type IntOrString\n        = IntVariant Int\n        | StringVariant String\n\n    intOrString : Decoder IntOrString\n    intOrString =\n        D.oneOf [ D.map IntVariant D.int, D.map StringVariant D.string ]\n\n    Bytes<0x64, 0xF0, 0x9F, 0x8C, 0x88>\n        |> D.decode intOrString\n    --> (Just <| StringVariant \"🌈\")\n\n","type":"List.List (Cbor.Decode.Decoder a) -> Cbor.Decode.Decoder a"},{"name":"optionalElem","comment":" Decode an optional element of a record or tuple and step through the\ndecoder. Note that optional elements only make sense at the end of a structure.\n\nIn particular, optional elements must be contiguous and can only be optional\n(resp. missing) if all their successors are also optional (resp. missing).\n\nFor example, consider:\n\n    type alias Foo =\n        Foo\n            { a : Int\n            , b : Maybe Int\n            , c : Maybe Int\n            }\n\n    decodeFoo =\n        tuple Foo <|\n            elems\n                >> elem int\n                >> optionalElem int\n                >> optionalElem int\n\n  - It is possible for `c` to be missing.\n  - It is possible for `b` and `c` to be missing.\n  - But it isn't possible for only `b` to be missing as this is undistinguishable from `c` missing.\n\nIf you need such behavior, use [`elem`](#elem) with [`maybe`](#maybe).\n\n","type":"Cbor.Decode.Decoder field -> Cbor.Decode.Decoder (Cbor.Decode.Step Basics.Never (Maybe.Maybe field -> steps)) -> Cbor.Decode.Decoder (Cbor.Decode.Step Basics.Never steps)"},{"name":"optionalField","comment":" Decode an optional field of record and step through the decoder. This\nensures that the decoded key matches the expected key. If it doesn't, the entire\ndecoder is failed. When the key is missing, returns `Nothing` as a value.\n\nSee [`record`](#record) for detail about usage.\n\n","type":"k -> Cbor.Decode.Decoder field -> Cbor.Decode.Decoder (Cbor.Decode.Step k (Maybe.Maybe field -> steps)) -> Cbor.Decode.Decoder (Cbor.Decode.Step k steps)"},{"name":"raw","comment":" Decode the next cbor item as a raw sequence of [`Bytes`](https://package.elm-lang.org/packages/elm/bytes/latest/Bytes#Bytes).\nNote that this primitive is innefficient since it needs to parse the underlying\nCBOR first, and re-encode it into a sequence afterwards. Use for debugging\npurpose only.\n","type":"Cbor.Decode.Decoder Bytes.Bytes"},{"name":"record","comment":" Decode a (definite) CBOR map into a record. Keys in the map can be arbitrary\nCBOR but are expected to be homogeneous across the record.\n\n    type alias Album =\n        { artist : String\n        , title : String\n        , label : Maybe String\n        }\n\n    -- In this example, we use compact integer as keys.\n    decodeAlbumCompact : D.Decoder Album\n    decodeAlbumCompact =\n        D.record D.int Album <|\n            D.fields\n                >> D.field 0 D.string\n                >> D.field 1 D.string\n                >> D.optionalField 2 D.string\n\n    -- In this example, we use more verbose string keys.\n    decodeAlbumVerbose : D.Decoder Album\n    decodeAlbumVerbose =\n        D.record D.string Album <|\n            D.fields\n                >> D.field \"artist\" D.string\n                >> D.field \"title\" D.string\n                >> D.optionalField \"label\" D.string\n\n","type":"Cbor.Decode.Decoder k -> steps -> (Cbor.Decode.Step k steps -> Cbor.Decode.Decoder (Cbor.Decode.Step k record)) -> Cbor.Decode.Decoder record"},{"name":"size","comment":" Decode only the size of a (definite) CBOR map.\n","type":"Cbor.Decode.Decoder Basics.Int"},{"name":"string","comment":" Decode a bunch UTF-8 bytes into a [`String`](https://package.elm-lang.org/packages/elm/core/latest/String#String).\nIn case of streaming, all string chunks are decoded at once and concatenated as if they were\none single string. See also [`Cbor.Encode.beginString`](https://package.elm-lang.org/packages/elm-toulouse/cbor/latest/Cbor-Encode#beginString).\n","type":"Cbor.Decode.Decoder String.String"},{"name":"succeed","comment":" Always succeed to produce a certain Elm value.\n\n    D.decode (D.succeed 14) Bytes<0x42, 0x28> == Just 14\n\n    D.decode (D.list (D.int |> D.andThen (\\_ -> D.succeed 1))) Bytes<0x83, 0x00, 0x00, 0x00>\n        == Just [ 1, 1, 1 ]\n\nThis particularly handy when used in combination with [`andThen`](#andThen).\n\n","type":"a -> Cbor.Decode.Decoder a"},{"name":"tag","comment":" This implementation does little interpretation of the tags and is limited to\nonly decoding the tag's value. The tag's payload has to be specified as any\nother decoder. So, using the previous example, one could decode a bignum as:\n\n    D.decode (D.tag |> D.andThen (\\tag -> D.bytes)) input\n\nYou may also use [`tagged`](#tagged) if you as a helper to decode a tagged value, while\nverifying that the tag matches what you expect.\n\n    D.decode (D.tagged PositiveBigNum D.bytes) input\n\n","type":"Cbor.Decode.Decoder Cbor.Tag.Tag"},{"name":"tagged","comment":" Decode a value that is tagged with the given [`Tag`](https://package.elm-lang.org/packages/elm-toulouse/cbor/latest/Cbor-Tag#Tag).\nFails if the value is not tagged, or, tagged with some other [`Tag`](https://package.elm-lang.org/packages/elm-toulouse/cbor/latest/Cbor-Tag#Tag)\n\n    D.decode (D.tagged Cbor D.int) Bytes<0xD8, 0x0E> == Just ( Cbor, 14 )\n\n    D.decode (D.tagged Base64 D.int) Bytes<0xD8, 0x0E> == Nothing\n\n    D.decode (D.tagged Cbor D.int) Bytes<0x0E> == Nothing\n\n","type":"Cbor.Tag.Tag -> Cbor.Decode.Decoder a -> Cbor.Decode.Decoder ( Cbor.Tag.Tag, a )"},{"name":"thenIgnore","comment":" Decode something and then another thing, but only continue with the first\nresult.\n\n    thenIgnore ignored a =\n        a |> andThen (\\result -> map (always result) ignored)\n\n","type":"Cbor.Decode.Decoder ignored -> Cbor.Decode.Decoder a -> Cbor.Decode.Decoder a"},{"name":"traverse","comment":" Apply a decoder to all elements of a `List`, in order, and yield the\nresulting resulting `List`.\n","type":"(a -> Cbor.Decode.Decoder b) -> List.List a -> Cbor.Decode.Decoder (List.List b)"},{"name":"tuple","comment":" Decode a (definite) CBOR array into a record / tuple.\n\n    type alias Track =\n        { title : String\n        , duration : Int\n        }\n\n    decodeTrack : D.Decoder Track\n    decodeTrack =\n        D.tuple Track <|\n            D.elems\n                >> D.elem D.string\n                >> D.elem D.int\n\n","type":"steps -> (Cbor.Decode.Step Basics.Never steps -> Cbor.Decode.Decoder (Cbor.Decode.Step Basics.Never tuple)) -> Cbor.Decode.Decoder tuple"}],"binops":[]},{"name":"Cbor.Encode","comment":" The Concise Binary Object Representation (CBOR) is a data format whose design\ngoals include the possibility of extremely small code size, fairly small message\nsize, and extensibility without the need for version negotiation. These design\ngoals make it different from earlier binary serializations such as ASN.1 and\nMessagePack.\n\n\n## Encoder\n\n@docs Encoder, encode, sequence, maybe, keyValue\n\n\n## Primitives\n\n@docs bool, int, float, string, bytes, null, undefined\n\n\n## Fancier Primitives\n\n@docs float16, float32, float64\n\n\n## Simple Data-Structures\n\n@docs list, indefiniteList, length, associativeList, dict, size\n\n\n## Records & Tuples\n\n@docs Step, record, fields, field, optionalField, tuple, elems, elem, optionalElem\n\n\n## Streaming\n\nFour CBOR items (arrays, maps, byte strings, and text strings) can be encoded\nwith an indefinite length. This is useful if the encoding of the item needs to\nbegin before the number of items inside the array or map, or the total length\nof the string, is known. (The application of this is often referred to as\n\"streaming\" within a data item.)\n\n> **NOTE**:\n>\n> Indefinite-length arrays and maps are dealt with differently than\n> indefinite-length byte strings and text strings.\n\n@docs beginString, beginBytes, beginList, beginDict, break\n\n\n## Tagging\n\n@docs tag, tagged\n\n\n## Debugging\n\n@docs any, raw\n\n","unions":[{"name":"Encoder","comment":" Describes how to encode a data structure or a type into binary CBOR\n","args":[],"cases":[]},{"name":"Step","comment":" An intermediate (opaque) step in the encoding of a record or tuple. See\n[`record`](#record) or [`tuple`](#tuple) for more detail.\n","args":["k","result"],"cases":[]}],"aliases":[],"values":[{"name":"any","comment":" Encode any generic CBOR item. This is particularly useful when dealing with\nheterogeneous data structures (e.g. tuples).\n\n    E.list E.any [ CborInt 42, CborBool True, CborString \"awesome!\" ]\n\n","type":"Cbor.CborItem -> Cbor.Encode.Encoder"},{"name":"associativeList","comment":" Turn a `(key, value)` associative list into a (definite) CBOR map. Note\nthat, if keys are `comparable`, you should consider using a [`Dict`](https://package.elm-lang.org/packages/elm/core/latest/Dict#Dict) and\n[`dict`](#dict) instead.\n","type":"(k -> Cbor.Encode.Encoder) -> (v -> Cbor.Encode.Encoder) -> List.List ( k, v ) -> Cbor.Encode.Encoder"},{"name":"beginBytes","comment":" Encode a [`Bytes`](https://package.elm-lang.org/packages/elm/bytes/latest/Bytes#Bytes)\nof indefinite length in chunks. This indicates the beginning of multiple calls\nto [`bytes`](#bytes), followed by a [`break`](#break) to signal the end of the\nstream. For example:\n\n    E.sequence\n        [ E.beginBytes\n        , E.bytes Bytes<0x01, 0x02>\n        , E.bytes Bytes<0x03, 0x04>\n        , E.break\n        ]\n\n","type":"Cbor.Encode.Encoder"},{"name":"beginDict","comment":" Encode a [`Dict`](https://package.elm-lang.org/packages/elm/core/latest/Dict#Dict)\nof indefinite length. This indicates the beginning of multiple calls for\nencoding pairs of elements, followed by a [`break`](#break) to signal the end of\nthe stream. For example:\n\n    E.sequence\n        [ E.beginDict\n        , E.keyValue E.int E.string ( 1, \"elm\" )\n        , E.keyValue E.int E.string ( 2, \"rocks\" )\n        , E.keyValue E.int E.string ( 3, \"!\" )\n        , E.break\n        ]\n\n","type":"Cbor.Encode.Encoder"},{"name":"beginList","comment":" Encode a `List` of indefinite length. This indicates the beginning of\nmultiple calls for encoding elements, followed by a [`break`](#break) to signal\nthe end of the stream. For example:\n\n    E.sequence\n        [ E.beginList\n        , E.string \"elm\"\n        , E.string \"rocks\"\n        , E.string \"!\"\n        , E.break\n        ]\n\n","type":"Cbor.Encode.Encoder"},{"name":"beginString","comment":" Encode a [`String`](https://package.elm-lang.org/packages/elm/core/latest/String#String)\nof indefinite length in chunks. This indicates the beginning of multiple calls\nto [`string`](#string), followed by a [`break`](#break) to signal the end of the\nstream. For example:\n\n    E.sequence\n        [ E.beginString\n        , E.string \"elm\"\n        , E.string \"rocks\"\n        , E.string \"!\"\n        , E.break\n        ]\n\n","type":"Cbor.Encode.Encoder"},{"name":"bool","comment":" Encode booleans.\n\n    E.bool False == Bytes<0xF4>\n\n    E.bool True == Bytes<0xF5>\n\n","type":"Basics.Bool -> Cbor.Encode.Encoder"},{"name":"break","comment":" Encode termination of an indefinite structure. See\n[`beginString`](#beginString), [`beginBytes`](#beginBytes),\n[`beginList`](#beginList), [`beginDict`](#beginDict) for detail about usage.\n","type":"Cbor.Encode.Encoder"},{"name":"bytes","comment":" Encode raw [`Bytes`](https://package.elm-lang.org/packages/elm/bytes/latest/Bytes#Bytes) of fixed size as a (definite) CBOR byte string.\n\n    E.bytes Bytes<> == Bytes<0x40>\n\n    E.bytes Bytes<0x01, 0x02, 0x03, 0x04> = Bytes<0x44, 0x01, 0x02, 0x03, 0x04>\n\n","type":"Bytes.Bytes -> Cbor.Encode.Encoder"},{"name":"dict","comment":" Turn a [`Dict`](https://package.elm-lang.org/packages/elm/core/latest/Dict#Dict) into a (definite) CBOR map.\n\n    E.dict E.string E.int (Dict.fromList [ ( \"a\", 1 ), ( \"b\", 2 ) ])\n        == Bytes<0xA2, 0x61, 0x61, 0x01, 0x61, 0x62, 0x02>\n\n","type":"(k -> Cbor.Encode.Encoder) -> (v -> Cbor.Encode.Encoder) -> Dict.Dict k v -> Cbor.Encode.Encoder"},{"name":"elem","comment":" Encode an elements of a tuple and step through the encoding. See [`tuple`](#tuple)\nfor detail about usage.\n","type":"(elem -> Cbor.Encode.Encoder) -> (tuple -> elem) -> Cbor.Encode.Step Basics.Never tuple -> Cbor.Encode.Step Basics.Never tuple"},{"name":"elems","comment":" A helper that makes writing tuple encoders nicer. It is equivalent to\n`identity`, but let us align encoders to fight compulsory OCDs.\n","type":"Cbor.Encode.Step Basics.Never tuple -> Cbor.Encode.Step Basics.Never tuple"},{"name":"encode","comment":" Turn a CBOR `Encoder` into [`Bytes`](https://package.elm-lang.org/packages/elm/bytes/latest/Bytes#Bytes).\n","type":"Cbor.Encode.Encoder -> Bytes.Bytes"},{"name":"field","comment":" Encode a field of record and step through the encoding. See [`record`](#record)\nfor detail about usage.\n","type":"k -> (field -> Cbor.Encode.Encoder) -> (record -> field) -> Cbor.Encode.Step k record -> Cbor.Encode.Step k record"},{"name":"fields","comment":" A helper that makes writing record encoders nicer. It is equivalent to\n`identity`, but let us align encoders to fight compulsory OCDs.\n","type":"Cbor.Encode.Step k record -> Cbor.Encode.Step k record"},{"name":"float","comment":" Encode floating numbers with maximum precision (64-bit).\n\n    E.float 0 == Bytes<0xFB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00>\n\n    E.float -4.1 == Bytes<0xFB, 0xC0, 0x10, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66>\n\n> **NOTE**:\n>\n> This is an alias for [`float64`](#float64).\n\n","type":"Basics.Float -> Cbor.Encode.Encoder"},{"name":"float16","comment":" Encode floating numbers with half-precision (16-bit).\n\n    E.float16 0.0 == Bytes<0xF9, 0x00, 0x00>\n\n    E.float16 -0.0 == Bytes<0xF9, 0x80, 0x00>\n\n    E.float16 1.5 == Bytes<0xF9, 0x3E, 0x00>\n\n","type":"Basics.Float -> Cbor.Encode.Encoder"},{"name":"float32","comment":" Encode floating numbers with simple precision (32-bit).\n\n    E.float32 0.0 == Bytes<0xFA, 0x00, 0x00, 0x00, 0x00>\n\n    E.float32 3.4028234663852886e38 == Bytes<0xFA, 0x7F, 0x7F, 0xFF, 0xFF>\n\n","type":"Basics.Float -> Cbor.Encode.Encoder"},{"name":"float64","comment":" Encode floating numbers with double precision (64-bit).\n\n    E.float64 0 == Bytes<0xFB, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00>\n\n    E.float64 -4.1 == Bytes<0xFB, 0xC0, 0x10, 0x66, 0x66, 0x66, 0x66, 0x66, 0x66>\n\n","type":"Basics.Float -> Cbor.Encode.Encoder"},{"name":"indefiniteList","comment":" Turn a `List` into a (indefinite) CBOR array\n","type":"(a -> Cbor.Encode.Encoder) -> List.List a -> Cbor.Encode.Encoder"},{"name":"int","comment":" Encode integers from `-9007199254740992` (`-2⁵³`) to `9007199254740991` (`2⁵³ - 1`).\n\n    E.int 0 == Bytes<0x00>\n\n    E.int 1337 == Bytes<0x19, 0x05, 0x39>\n\n","type":"Basics.Int -> Cbor.Encode.Encoder"},{"name":"keyValue","comment":" Encode a key-value pair as a sequence of a key and a value. This is merely a\nshorthand for a `sequence` on a 2-tuple.\n\n    E.keyValue E.string E.int ( \"a\", 14 )\n        == E.sequence\n            [ E.string \"a\"\n            , E.int 14\n            ]\n\n","type":"(a -> Cbor.Encode.Encoder) -> (b -> Cbor.Encode.Encoder) -> ( a, b ) -> Cbor.Encode.Encoder"},{"name":"length","comment":" Encode a (definite) list length only. This may be useful to stream a\ndefinite list or simply, to have even more fine-grained control over the\ncreation of a definite list.\n\n    E.sequence\n        [ E.length 2\n        , E.int 1\n        , E.int 2\n        ]\n        == E.list E.int [ 1, 2 ]\n\n","type":"Basics.Int -> Cbor.Encode.Encoder"},{"name":"list","comment":" Turn a `List` into a (definite) CBOR array\n\n    E.list E.int [1,2,3] == Bytes<0x83, 0x01, 0x02, 0x03>\n\n","type":"(a -> Cbor.Encode.Encoder) -> List.List a -> Cbor.Encode.Encoder"},{"name":"maybe","comment":" Optionally encode a value. `Nothing` is encoded as [`null`](#null).\n","type":"(a -> Cbor.Encode.Encoder) -> Maybe.Maybe a -> Cbor.Encode.Encoder"},{"name":"null","comment":" Create a CBOR `null` value. This can be decoded using [`Cbor.decode.maybe`](https://package.elm-lang.org/packages/elm-toulouse/cbor/latest/Cbor-Decode#maybe).\n\n    E.null == Bytes<0xF6>\n\n","type":"Cbor.Encode.Encoder"},{"name":"optionalElem","comment":" Optionally encode an element in a tuple. See [`tuple`](#tuple)\nfor detail about usage.\n","type":"(elem -> Cbor.Encode.Encoder) -> (tuple -> Maybe.Maybe elem) -> Cbor.Encode.Step Basics.Never tuple -> Cbor.Encode.Step Basics.Never tuple"},{"name":"optionalField","comment":" Encode an optional field of record and step through the encoding. See [`record`](#record)\nfor detail about usage.\n\n> **NOTE**:\n>\n> When the value is `Nothing`, the field (and its key) is completely omitted\n> from the final record.\n\n","type":"k -> (field -> Cbor.Encode.Encoder) -> (record -> Maybe.Maybe field) -> Cbor.Encode.Step k record -> Cbor.Encode.Step k record"},{"name":"raw","comment":" Unsafe encoder to inject any arbitrary bytes into the encoding sequence. **Do\nnot use** unless you know what you're doing, this may result in invalid CBOR\nencoding!\n","type":"Bytes.Bytes -> Cbor.Encode.Encoder"},{"name":"record","comment":" Encode a record as a (definite) CBOR map. Keys in the map can be arbitrary\nCBOR but are expected to be homogeneous across the record.\n\n    type alias Album =\n        { artist : String\n        , title : String\n        , label : Maybe String\n        }\n\n    -- In this example, we use compact integer as keys.\n    encodeAlbumCompact : Album -> E.Encoder\n    encodeAlbumCompact =\n        E.record E.int <|\n            E.fields\n                >> E.field 0 E.string .artist\n                >> E.field 1 E.string .title\n                >> E.optionalField 2 E.string .genre\n\n    -- In this example, we use more verbose string keys.\n    encodeAlbumVerbose : Album -> E.Encoder\n    encodeAlbumVerbose =\n        E.record E.string <|\n            E.fields\n                >> E.field \"artist\" E.string .artist\n                >> E.field \"title\" E.string .title\n                >> E.optionalField \"label\" E.string .genre\n\n","type":"(k -> Cbor.Encode.Encoder) -> (Cbor.Encode.Step k record -> Cbor.Encode.Step k record) -> record -> Cbor.Encode.Encoder"},{"name":"sequence","comment":" Combine a bunch of encoders sequentially.\n","type":"List.List Cbor.Encode.Encoder -> Cbor.Encode.Encoder"},{"name":"size","comment":" Encode a (definite) dict size only. This may be useful to stream a\ndefinite dict or simply, to have even more fine-grained control over the\ncreation of a definite dict.\n","type":"Basics.Int -> Cbor.Encode.Encoder"},{"name":"string","comment":" Encode a [`String`](https://package.elm-lang.org/packages/elm/core/latest/String#String) of fixed size as a (definite) CBOR text string.\n\n    E.string \"\" == Bytes<0x60>\n\n    E.string \"IETF\" == Bytes <0x64, 0x49, 0x45, 0x54, 0x46>\n\n    E.string \"🌈\" == Bytes<0x64, 0xF0, 0x9F, 0x8C, 0x88>\n\n","type":"String.String -> Cbor.Encode.Encoder"},{"name":"tag","comment":" Encode a particular [`Tag`](https://package.elm-lang.org/packages/elm-toulouse/cbor/latest/Cbor-Tag#Tag) as a CBOR tag prefix.\n","type":"Cbor.Tag.Tag -> Cbor.Encode.Encoder"},{"name":"tagged","comment":" Helper to quickly a tagged value\n\n    E.tagged t encodeA a == E.sequence [ E.tag t, encodeA a ]\n\n","type":"Cbor.Tag.Tag -> (a -> Cbor.Encode.Encoder) -> a -> Cbor.Encode.Encoder"},{"name":"tuple","comment":" Encode a record / tuple as a (definite) CBOR array.\n\n    type alias Track =\n        { title : String\n        , duration : Int\n        }\n\n    encodeTrack : Track -> E.Encoder\n    encodeTrack =\n        E.tuple <|\n            E.elems\n                >> E.elem E.string .title\n                >> E.elem E.int .duration\n\n","type":"(Cbor.Encode.Step Basics.Never tuple -> Cbor.Encode.Step Basics.Never tuple) -> tuple -> Cbor.Encode.Encoder"},{"name":"undefined","comment":" Create a CBOR `undefined` value. This can be decoded using [`Cbor.decode.maybe`](https://package.elm-lang.org/packages/elm-toulouse/cbor/latest/Cbor-Decode#maybe).\n\n    E.undefined == Bytes<0xF7>\n\n","type":"Cbor.Encode.Encoder"}],"binops":[]},{"name":"Cbor.Tag","comment":" Optional semantic tags as specified in the RFC 7049. Tags can be used to\ngive an extra meaning to a generic piece of data that follows it. For instance,\none could encode a bignum as a raw byte string and add a corresponding tag 0x02\nto indicates what meaning can be given to that bytestring.\n\n@docs Tag\n\n","unions":[{"name":"Tag","comment":" Known CBOR tag from the specification. For custom tags, use 'Unknown' as a\nconstructor\n","args":[],"cases":[["StandardDateTime",[]],["EpochDateTime",[]],["PositiveBigNum",[]],["NegativeBigNum",[]],["DecimalFraction",[]],["BigFloat",[]],["Base64UrlConversion",[]],["Base64Conversion",[]],["Base16Conversion",[]],["Cbor",[]],["Uri",[]],["Base64Url",[]],["Base64",[]],["Regex",[]],["Mime",[]],["IsCbor",[]],["Unknown",["Basics.Int"]]]}],"aliases":[],"values":[],"binops":[]}]