[
    {
        "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    >>> 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    >>> 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    >>> 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    >>> object [ (\"name\", Dict.empty, null)] |> tags \"name\"\n    [Tag \"name\" Dict.empty (Object []) ]\n\n",
                "type": "String -> Value -> List 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    >>> 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    >>> float 1.576 |> encode 0\n    \"1.576\"\n",
                "type": "Float -> Value"
            },
            {
                "name": "int",
                "comment": " Encode an int\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    >>> 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    >>> 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    >>> string \"hello\" |> encode 0\n    \"hello\"\n",
                "type": "String -> Value"
            }
        ],
        "binops": []
    },
    {
        "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    >>> 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    >>> 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    >>> 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    >>> 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    >>> decodeString \"hello\"\n    Ok (StrNode \"hello\")\n",
                "type": "String -> Result String 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\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": "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    >>> 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": []
    }
]