[{"name":"Cbor","comment":"\n\n@docs CborItem\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",[]]]}],"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, 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\n\n\n## Mapping\n\n@docs succeed, fail, andThen, ignoreThen, thenIgnore, map, map2, map3, map4, map5, traverse\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":"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":"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":"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":"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":[]}]