[
    {
        "name": "Xml.Decode",
        "comment": "\n\n@docs decode\n\n@docs decodeInt, decodeFloat, decodeString, decodeString, decodeBool\n\n@docs decodeChildren\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "decode",
                "comment": " Try to decode a string and turn it into an XML value\n    import Xml exposing(Value(Tag, Object))\n    import Xml.Encode exposing (null)\n    import Dict\n\n    decode \"<name></name>\"\n    --> Ok (Object [Tag \"name\" Dict.empty null])\n",
                "type": "String -> Result String Value"
            },
            {
                "name": "decodeBool",
                "comment": " Decode a bool\n",
                "type": "String -> Result String Value"
            },
            {
                "name": "decodeChildren",
                "comment": " Decode children from a string\n\n    import Xml exposing (Value(Object, Tag, StrNode))\n\n    decodeChildren \"<name>hello</name>\"\n    --> Ok (Object [Tag \"name\" Dict.empty (StrNode \"hello\")] )\n\n",
                "type": "String -> Result String Value"
            },
            {
                "name": "decodeFloat",
                "comment": " Decode a float\n    import Xml exposing (Value(FloatNode))\n\n    decodeFloat \"hello\"\n    --> Err \"could not convert string 'hello' to a Float\"\n\n    decodeFloat \"5\"\n    --> Ok (FloatNode 5.0)\n\n    decodeFloat \"5.5\"\n    --> Ok (FloatNode 5.5)\n\n",
                "type": "String -> Result String Value"
            },
            {
                "name": "decodeInt",
                "comment": " Decode a int\n    import Xml exposing (Value(IntNode))\n\n    decodeInt \"hello\"\n    --> Err \"could not convert string 'hello' to an Int\"\n\n    decodeInt \"5\"\n    --> Ok (IntNode 5)\n",
                "type": "String -> Result String Value"
            },
            {
                "name": "decodeString",
                "comment": " Decode a string\n\n    import Xml exposing (Value(StrNode))\n\n    decodeString \"hello\"\n    --> Ok (StrNode \"hello\")\n",
                "type": "String -> Result String Value"
            }
        ],
        "binops": []
    },
    {
        "name": "Xml.Encode",
        "comment": "\n    Use this module for turning your Elm data into an `Xml` representation that can be either\n    queried or decoded, or turned into a string.\n\n@docs encode\n\n@docs string, int, float, bool, object, null, list\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "bool",
                "comment": " Encode a bool\n\n    bool True |> encode 0\n    --> \"true\"\n\n    bool True |> encode 0\n    --> \"true\"\n",
                "type": "Bool -> Value"
            },
            {
                "name": "encode",
                "comment": " Take a value, then generate a string from it\n",
                "type": "Int -> Value -> String"
            },
            {
                "name": "float",
                "comment": " Encode a float\n\n    float 1.576 |> encode 0\n    --> \"1.576\"\n",
                "type": "Float -> Value"
            },
            {
                "name": "int",
                "comment": " Encode an int\n\n    int 15 |> encode 0\n    --> \"15\"\n",
                "type": "Int -> Value"
            },
            {
                "name": "list",
                "comment": " Encode a list of nodes, e.g\n    import Dict\n\n    list [ object [ (\"Root\", Dict.empty, null) ], int 5 ] |> encode 0\n    --> \"<Root></Root>\\n5\"\n",
                "type": "List Value -> Value"
            },
            {
                "name": "null",
                "comment": " Empty contents\n\n    null |> encode 0\n    --> \"\"\n",
                "type": "Value"
            },
            {
                "name": "object",
                "comment": " Encode an \"object\" (a tag)\n",
                "type": "List ( String, Dict String Value, Value ) -> Value"
            },
            {
                "name": "string",
                "comment": " Encode a string\n\n    string \"hello\" |> encode 0\n    --> \"hello\"\n",
                "type": "String -> Value"
            }
        ],
        "binops": []
    },
    {
        "name": "Xml.Query",
        "comment": "\n\n# Search the parsed XML\n\n@docs tags, contains\n\n@docs tag, collect, default\n\n@docs string, int, float, bool\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "bool",
                "comment": " Try to turn a value into an int\n\n    bool (BoolNode True)\n    --> Ok True\n\n    bool (StrNode \"hello\")\n    --> Err \"Not a bool\"\n",
                "type": "Value -> Result String Bool"
            },
            {
                "name": "collect",
                "comment": " Collect as many values that pass the given converter\n\n    collect (tag \"name\" string) [Tag \"name\" Dict.empty (StrNode \"noah\")]\n    --> [ \"noah\" ]\n\n    collect (tag \"name\" string) [Tag \"name\" Dict.empty (IntNode 5)]\n    --> [ ]\n",
                "type": "(Value -> Result String a) -> List Value -> List a"
            },
            {
                "name": "contains",
                "comment": " check if a XML value contains another XML value\n",
                "type": "Value -> Value -> Bool"
            },
            {
                "name": "default",
                "comment": "\n    Set a default for a result\n\n    >> default \"Cat\" (Ok \"Fish\")\n    Ok \"Fish\"\n\n    >> default \"Dog\" (Err \"flip\")\n    Ok \"Dog\"\n",
                "type": "b -> Result a b -> Result a b"
            },
            {
                "name": "float",
                "comment": " Try to turn a value into an int\n\n    float (FloatNode 5.5)\n    --> Ok 5.5\n\n    float (StrNode \"hello\")\n    --> Err \"Not a float\"\n",
                "type": "Value -> Result String Float"
            },
            {
                "name": "int",
                "comment": " Try to turn a value into an int\n\n    int (IntNode 5)\n    --> Ok 5\n\n    int (StrNode \"hello\")\n    --> Err \"Not an int\"\n",
                "type": "Value -> Result String Int"
            },
            {
                "name": "string",
                "comment": " Try to turn a value into a string\n\n    string (IntNode 5)\n    --> Err \"Not a string.\"\n\n    string (StrNode \"hello\")\n    --> Ok \"hello\"\n",
                "type": "Value -> Result String String"
            },
            {
                "name": "tag",
                "comment": " Try to get a given tag name out from an XML value, then grab the value from that\n    Grabs the first tag that matches in the object\n\n    import Xml exposing (Value(..))\n\n    tag \"name\" string (Tag \"name\" Dict.empty (StrNode \"noah\"))\n    --> Ok \"noah\"\n\n    tag \"name\" string (Tag \"name\" Dict.empty (IntNode 5))\n    --> Err \"Not a string.\"\n\n    tag \"name\" string (StrNode \"noah\")\n    --> Err \"No tag called 'name' found.\"\n",
                "type": "String -> (Value -> Result String a) -> Value -> Result String a"
            },
            {
                "name": "tags",
                "comment": " Search an XML value for any tags matching\n\n    import Xml exposing (Value(..))\n    import Xml.Encode exposing (object, null, encode)\n    import Dict\n\n    object [ (\"name\", Dict.empty, null)] |> tags \"name\"\n    --> [Tag \"name\" Dict.empty (Object []) ]\n\n",
                "type": "String -> Value -> List Value"
            }
        ],
        "binops": []
    },
    {
        "name": "Xml",
        "comment": "\n\nThe main data structure along with some trivial helpers.\n\n@docs Value\n\n@docs foldl, map, xmlToJson, jsonToXml\n",
        "unions": [
            {
                "name": "Value",
                "comment": " Representation of the XML tree\n",
                "args": [],
                "cases": [
                    [
                        "Tag",
                        [
                            "String",
                            "Dict String Value",
                            "Value"
                        ]
                    ],
                    [
                        "StrNode",
                        [
                            "String"
                        ]
                    ],
                    [
                        "IntNode",
                        [
                            "Int"
                        ]
                    ],
                    [
                        "FloatNode",
                        [
                            "Float"
                        ]
                    ],
                    [
                        "BoolNode",
                        [
                            "Bool"
                        ]
                    ],
                    [
                        "Object",
                        [
                            "List Value"
                        ]
                    ],
                    [
                        "DocType",
                        [
                            "String",
                            "Dict String Value"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "foldl",
                "comment": " Standard foldl\n",
                "type": "(Value -> a -> a) -> a -> Value -> a"
            },
            {
                "name": "jsonToXml",
                "comment": " Convert a `Json.Value` into an `Xml.Value`\n\n    jsonToXml (Json.string \"hello\")\n    --> StrNode \"hello\"\n\n    jsonToXml (Json.int 5)\n    --> IntNode 5\n\n    jsonToXml (Json.float 10.5)\n    --> FloatNode 10.5\n\n    jsonToXml (Json.bool True)\n    --> BoolNode True\n\n    jsonToXml (Json.object [(\"name\", Json.string \"hello\")])\n    --> Object [ Tag \"name\" Dict.empty (StrNode \"hello\") ]\n\n    jsonToXml (Json.list [Json.string \"name\", Json.string \"hello\"])\n    --> Object [ StrNode \"name\", StrNode \"hello\" ]\n\n",
                "type": "Value -> Value"
            },
            {
                "name": "map",
                "comment": "\n    Standard mapping of a value to another value\n",
                "type": "(Value -> Value) -> Value -> Value"
            },
            {
                "name": "xmlToJson",
                "comment": " Convert an `Xml.Value` to a `Json.Value`\n\n    import Dict\n    import Json.Encode as Json\n\n    xmlToJson (StrNode \"hello\")\n    --> Json.string \"hello\"\n\n    xmlToJson (IntNode 5)\n    --> Json.int 5\n\n    xmlToJson (FloatNode 5)\n    --> Json.float 5\n\n    xmlToJson (BoolNode True)\n    --> Json.bool True\n\n    xmlToJson (Object [ IntNode 5, BoolNode True ])\n    --> Json.list [Json.int 5, Json.bool True]\n\n    xmlToJson (DocType \"\" Dict.empty)\n    --> Json.null\n",
                "type": "Value -> Value"
            }
        ],
        "binops": []
    }
]