[
    {
        "name": "Elm.Parser",
        "comment": "\n\n\n# Parsing Syntax\n\n@docs parse\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "parse",
                "comment": " Parse a string\n",
                "type": "String -> Result (List String) RawFile"
            }
        ],
        "binops": []
    },
    {
        "name": "Elm.Processing",
        "comment": "\n\n\n# Elm.Processing\n\nProcessing raw files with the context of other files and dependencies.\n\n\n# Types\n\n@docs ProcessContext\n\n\n# Functions\n\n@docs init, addFile, addDependency, process\n\n",
        "unions": [
            {
                "name": "ProcessContext",
                "comment": " Opaque type to hold context for the processing\n",
                "args": [],
                "cases": []
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "addDependency",
                "comment": " Add a whole depenency with its modules to the context.\n",
                "type": "Dependency -> ProcessContext -> ProcessContext"
            },
            {
                "name": "addFile",
                "comment": " Add a file to the context that may be a dependency for the file that will be processed.\n",
                "type": "RawFile -> ProcessContext -> ProcessContext"
            },
            {
                "name": "init",
                "comment": " Initialise an empty context\n",
                "type": "ProcessContext"
            },
            {
                "name": "process",
                "comment": " Process a rawfile with a context.\nOperator precedence and documentation will be fixed.\n",
                "type": "ProcessContext -> RawFile -> File"
            }
        ],
        "binops": []
    },
    {
        "name": "Elm.Dependency",
        "comment": "\n\n\n# Elm.Dependency\n\n@docs Dependency, Version\n\n",
        "unions": [],
        "aliases": [
            {
                "name": "Dependency",
                "comment": " Record that represents a dependency\n",
                "args": [],
                "type": "{ name : String, version : Version, interfaces : Dict ModuleName Interface }"
            },
            {
                "name": "Version",
                "comment": " Alias for a version\n",
                "args": [],
                "type": "String"
            }
        ],
        "values": [],
        "binops": []
    },
    {
        "name": "Elm.RawFile",
        "comment": "\n\n\n# Elm.RawFile\n\n@docs RawFile\n\n@docs moduleName, imports\n\n",
        "unions": [],
        "aliases": [
            {
                "name": "RawFile",
                "comment": " A Raw file\n",
                "args": [],
                "type": "RawFile"
            }
        ],
        "values": [
            {
                "name": "imports",
                "comment": " Retrieve the imports for a raw file\n",
                "type": "RawFile -> List Import"
            },
            {
                "name": "moduleName",
                "comment": " Retrieve the module name for a raw file\n",
                "type": "RawFile -> Maybe ModuleName"
            }
        ],
        "binops": []
    },
    {
        "name": "Elm.Json.Decode",
        "comment": "\n\n\n# Elm.Json.Decode\n\nDecoding Elm Code from Json\n\n@docs decode\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "decode",
                "comment": " Decode a file stored in Json\n",
                "type": "Decoder RawFile"
            }
        ],
        "binops": []
    },
    {
        "name": "Elm.Json.Encode",
        "comment": "\n\n\n# Elm.Json.Encode\n\nEncoding Elm Code to Json\n\n@docs encode\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "encode",
                "comment": " Encode a file to a value\n",
                "type": "RawFile -> Value"
            }
        ],
        "binops": []
    },
    {
        "name": "Elm.Interface",
        "comment": "\n\n\n# Elm.Interface\n\n\n## Types\n\n@docs Interface, Exposed\n\n\n## Functions\n\n@docs build, exposesAlias, exposesFunction, operators\n\n",
        "unions": [
            {
                "name": "Exposed",
                "comment": " Union type for the things that a module can expose\n",
                "args": [],
                "cases": [
                    [
                        "Function",
                        [
                            "String"
                        ]
                    ],
                    [
                        "Type",
                        [
                            "( String, List String )"
                        ]
                    ],
                    [
                        "Alias",
                        [
                            "String"
                        ]
                    ],
                    [
                        "Operator",
                        [
                            "Infix"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "Interface",
                "comment": " An interface\n",
                "args": [],
                "type": "List Exposed"
            }
        ],
        "values": [
            {
                "name": "build",
                "comment": " Build an interface from a file\n",
                "type": "RawFile -> Interface"
            },
            {
                "name": "exposesAlias",
                "comment": " Interface property whether a certain alias is exposed.\n",
                "type": "String -> Interface -> Bool"
            },
            {
                "name": "exposesFunction",
                "comment": " Interface property whether a certain function is exposed.\n",
                "type": "String -> Interface -> Bool"
            },
            {
                "name": "operators",
                "comment": " Retrieve all infix operators exposed\n",
                "type": "Interface -> List Infix"
            }
        ],
        "binops": []
    },
    {
        "name": "Elm.Writer",
        "comment": "\n\n\n# Elm.Writer\n\nWrite a file to a string.\n\n@docs write, writeFile, writePattern, writeExpression\n\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "write",
                "comment": " Transform a writer to a string\n",
                "type": "Writer -> String"
            },
            {
                "name": "writeExpression",
                "comment": " Writer an expression\n",
                "type": "Expression -> Writer"
            },
            {
                "name": "writeFile",
                "comment": " Write a file\n",
                "type": "File -> Writer"
            },
            {
                "name": "writePattern",
                "comment": " Write a pattern\n",
                "type": "Pattern -> Writer"
            }
        ],
        "binops": []
    },
    {
        "name": "Elm.Syntax.File",
        "comment": " File Syntax\n\n\n# Types\n\n@docs File\n\n",
        "unions": [],
        "aliases": [
            {
                "name": "File",
                "comment": " Type annotation for a file\n",
                "args": [],
                "type": "{ moduleDefinition : Module, imports : List Import, declarations : List Declaration, comments : List ( String, Range ) }"
            }
        ],
        "values": [],
        "binops": []
    },
    {
        "name": "Elm.Syntax.Declaration",
        "comment": " Declarations Syntax\n\n\n# Types\n\n@docs Declaration\n\n",
        "unions": [
            {
                "name": "Declaration",
                "comment": " Union type that represents all different top level declarations.\n",
                "args": [],
                "cases": [
                    [
                        "FuncDecl",
                        [
                            "Function"
                        ]
                    ],
                    [
                        "AliasDecl",
                        [
                            "TypeAlias"
                        ]
                    ],
                    [
                        "TypeDecl",
                        [
                            "Type"
                        ]
                    ],
                    [
                        "PortDeclaration",
                        [
                            "FunctionSignature"
                        ]
                    ],
                    [
                        "InfixDeclaration",
                        [
                            "Infix"
                        ]
                    ],
                    [
                        "Destructuring",
                        [
                            "Pattern",
                            "Expression"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [],
        "binops": []
    },
    {
        "name": "Elm.Syntax.TypeAlias",
        "comment": " Type Alias Syntax\n\n\n# Types\n\n@docs TypeAlias\n\n",
        "unions": [],
        "aliases": [
            {
                "name": "TypeAlias",
                "comment": " Definition for a type alias\n",
                "args": [],
                "type": "{ documentation : Maybe Documentation, name : String, generics : List String, typeAnnotation : TypeAnnotation, range : Range }"
            }
        ],
        "values": [],
        "binops": []
    },
    {
        "name": "Elm.Syntax.Expression",
        "comment": " Expression Syntax\n\n\n# Expression\n\n@docs Expression, InnerExpression, Lambda\n\n\n# Lets\n\n@docs LetBlock, LetDeclaration\n\n\n# Records\n\n@docs RecordUpdate,RecordSetter\n\n\n# Cases\n\n@docs CaseBlock, Cases, Case\n\n\n# Functions\n\n@docs Function, FunctionDeclaration, FunctionSignature\n\n",
        "unions": [
            {
                "name": "InnerExpression",
                "comment": " Union type containing all possible expressions\n",
                "args": [],
                "cases": [
                    [
                        "UnitExpr",
                        []
                    ],
                    [
                        "Application",
                        [
                            "List Expression"
                        ]
                    ],
                    [
                        "OperatorApplication",
                        [
                            "String",
                            "InfixDirection",
                            "Expression",
                            "Expression"
                        ]
                    ],
                    [
                        "FunctionOrValue",
                        [
                            "String"
                        ]
                    ],
                    [
                        "IfBlock",
                        [
                            "Expression",
                            "Expression",
                            "Expression"
                        ]
                    ],
                    [
                        "PrefixOperator",
                        [
                            "String"
                        ]
                    ],
                    [
                        "Operator",
                        [
                            "String"
                        ]
                    ],
                    [
                        "Integer",
                        [
                            "Int"
                        ]
                    ],
                    [
                        "Floatable",
                        [
                            "Float"
                        ]
                    ],
                    [
                        "Negation",
                        [
                            "Expression"
                        ]
                    ],
                    [
                        "Literal",
                        [
                            "String"
                        ]
                    ],
                    [
                        "CharLiteral",
                        [
                            "Char"
                        ]
                    ],
                    [
                        "TupledExpression",
                        [
                            "List Expression"
                        ]
                    ],
                    [
                        "ParenthesizedExpression",
                        [
                            "Expression"
                        ]
                    ],
                    [
                        "LetExpression",
                        [
                            "LetBlock"
                        ]
                    ],
                    [
                        "CaseExpression",
                        [
                            "CaseBlock"
                        ]
                    ],
                    [
                        "LambdaExpression",
                        [
                            "Lambda"
                        ]
                    ],
                    [
                        "RecordExpr",
                        [
                            "List RecordSetter"
                        ]
                    ],
                    [
                        "ListExpr",
                        [
                            "List Expression"
                        ]
                    ],
                    [
                        "QualifiedExpr",
                        [
                            "ModuleName",
                            "String"
                        ]
                    ],
                    [
                        "RecordAccess",
                        [
                            "Expression",
                            "String"
                        ]
                    ],
                    [
                        "RecordAccessFunction",
                        [
                            "String"
                        ]
                    ],
                    [
                        "RecordUpdateExpression",
                        [
                            "RecordUpdate"
                        ]
                    ],
                    [
                        "GLSLExpression",
                        [
                            "String"
                        ]
                    ]
                ]
            },
            {
                "name": "LetDeclaration",
                "comment": " Union type for all possible declations in a let block\n",
                "args": [],
                "cases": [
                    [
                        "LetFunction",
                        [
                            "Function"
                        ]
                    ],
                    [
                        "LetDestructuring",
                        [
                            "Pattern",
                            "Expression"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "Case",
                "comment": " A case in a case block\n",
                "args": [],
                "type": "( Pattern, Expression )"
            },
            {
                "name": "CaseBlock",
                "comment": " Expression for a case block\n",
                "args": [],
                "type": "{ expression : Expression, cases : Cases }"
            },
            {
                "name": "Cases",
                "comment": " Type alias for a list of cases\n",
                "args": [],
                "type": "List Case"
            },
            {
                "name": "Expression",
                "comment": " Wrapper type for an expresion on a certain range\n",
                "args": [],
                "type": "( Range, InnerExpression )"
            },
            {
                "name": "Function",
                "comment": " Type alias for a full function\n",
                "args": [],
                "type": "{ documentation : Maybe Documentation, signature : Maybe FunctionSignature, declaration : FunctionDeclaration }"
            },
            {
                "name": "FunctionDeclaration",
                "comment": " Type alias for declaring a function\n",
                "args": [],
                "type": "{ operatorDefinition : Bool, name : VariablePointer, arguments : List Pattern, expression : Expression }"
            },
            {
                "name": "FunctionSignature",
                "comment": " Type alias for a function signature\n",
                "args": [],
                "type": "{ operatorDefinition : Bool, name : String, typeAnnotation : TypeAnnotation, range : Range }"
            },
            {
                "name": "Lambda",
                "comment": " Expression for a lambda\n",
                "args": [],
                "type": "{ args : List Pattern, expression : Expression }"
            },
            {
                "name": "LetBlock",
                "comment": " Expression for a let block\n",
                "args": [],
                "type": "{ declarations : List LetDeclaration, expression : Expression }"
            },
            {
                "name": "RecordSetter",
                "comment": " Expression for setting a record field\n",
                "args": [],
                "type": "( String, Expression )"
            },
            {
                "name": "RecordUpdate",
                "comment": " Expression for updating a record\n",
                "args": [],
                "type": "{ name : String, updates : List RecordSetter }"
            }
        ],
        "values": [],
        "binops": []
    },
    {
        "name": "Elm.Syntax.Type",
        "comment": " Type Syntax\n\n\n# Types\n\n@docs Type, ValueConstructor\n\n",
        "unions": [],
        "aliases": [
            {
                "name": "Type",
                "comment": " Syntax for a type\n",
                "args": [],
                "type": "{ name : String, generics : List String, constructors : List ValueConstructor }"
            },
            {
                "name": "ValueConstructor",
                "comment": " Syntax for a type value constructor\n",
                "args": [],
                "type": "{ name : String, arguments : List TypeAnnotation, range : Range }"
            }
        ],
        "values": [],
        "binops": []
    },
    {
        "name": "Elm.Syntax.Module",
        "comment": " Module Syntax\n\n\n# Module\n\n@docs Module, DefaultModuleData, EffectModuleData\n\n@docs exposingList, moduleName\n\n\n# Import\n\n@docs Import\n\n",
        "unions": [
            {
                "name": "Module",
                "comment": " Union type for different kind of modules\n",
                "args": [],
                "cases": [
                    [
                        "NormalModule",
                        [
                            "DefaultModuleData"
                        ]
                    ],
                    [
                        "PortModule",
                        [
                            "DefaultModuleData"
                        ]
                    ],
                    [
                        "EffectModule",
                        [
                            "EffectModuleData"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "DefaultModuleData",
                "comment": " Data for a default default\n",
                "args": [],
                "type": "{ moduleName : ModuleName, exposingList : Exposing TopLevelExpose }"
            },
            {
                "name": "EffectModuleData",
                "comment": " Data for an effect module\n",
                "args": [],
                "type": "{ moduleName : ModuleName, exposingList : Exposing TopLevelExpose, command : Maybe String, subscription : Maybe String }"
            },
            {
                "name": "Import",
                "comment": " Import definition\n",
                "args": [],
                "type": "{ moduleName : ModuleName, moduleAlias : Maybe ModuleName, exposingList : Maybe (Exposing TopLevelExpose), range : Range }"
            }
        ],
        "values": [
            {
                "name": "exposingList",
                "comment": " Get the exposing list for a module.\n",
                "type": "Module -> Exposing TopLevelExpose"
            },
            {
                "name": "moduleName",
                "comment": " Get the name for a module. For older modules this may not be present.\n",
                "type": "Module -> Maybe ModuleName"
            }
        ],
        "binops": []
    },
    {
        "name": "Elm.Syntax.TypeAnnotation",
        "comment": " Type Annotation Syntax\n\n\n# Types\n\n@docs TypeAnnotation, RecordDefinition, RecordField\n\n",
        "unions": [
            {
                "name": "TypeAnnotation",
                "comment": " Union type for different type aliases\n",
                "args": [],
                "cases": [
                    [
                        "GenericType",
                        [
                            "String",
                            "Range"
                        ]
                    ],
                    [
                        "Typed",
                        [
                            "ModuleName",
                            "String",
                            "List TypeAnnotation",
                            "Range"
                        ]
                    ],
                    [
                        "Unit",
                        [
                            "Range"
                        ]
                    ],
                    [
                        "Tupled",
                        [
                            "List TypeAnnotation",
                            "Range"
                        ]
                    ],
                    [
                        "Record",
                        [
                            "RecordDefinition",
                            "Range"
                        ]
                    ],
                    [
                        "GenericRecord",
                        [
                            "String",
                            "RecordDefinition",
                            "Range"
                        ]
                    ],
                    [
                        "FunctionTypeAnnotation",
                        [
                            "TypeAnnotation",
                            "TypeAnnotation",
                            "Range"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "RecordDefinition",
                "comment": " List of fields for a record\n",
                "args": [],
                "type": "List RecordField"
            },
            {
                "name": "RecordField",
                "comment": " Single field of a record. A name and its type\n",
                "args": [],
                "type": "( String, TypeAnnotation )"
            }
        ],
        "values": [],
        "binops": []
    },
    {
        "name": "Elm.Syntax.Pattern",
        "comment": " Pattern Syntax\n\n\n# Types\n\n@docs Pattern, QualifiedNameRef\n\n",
        "unions": [
            {
                "name": "Pattern",
                "comment": " Union type for all the patterns\n",
                "args": [],
                "cases": [
                    [
                        "AllPattern",
                        [
                            "Range"
                        ]
                    ],
                    [
                        "UnitPattern",
                        [
                            "Range"
                        ]
                    ],
                    [
                        "CharPattern",
                        [
                            "Char",
                            "Range"
                        ]
                    ],
                    [
                        "StringPattern",
                        [
                            "String",
                            "Range"
                        ]
                    ],
                    [
                        "IntPattern",
                        [
                            "Int",
                            "Range"
                        ]
                    ],
                    [
                        "FloatPattern",
                        [
                            "Float",
                            "Range"
                        ]
                    ],
                    [
                        "TuplePattern",
                        [
                            "List Pattern",
                            "Range"
                        ]
                    ],
                    [
                        "RecordPattern",
                        [
                            "List VariablePointer",
                            "Range"
                        ]
                    ],
                    [
                        "UnConsPattern",
                        [
                            "Pattern",
                            "Pattern",
                            "Range"
                        ]
                    ],
                    [
                        "ListPattern",
                        [
                            "List Pattern",
                            "Range"
                        ]
                    ],
                    [
                        "VarPattern",
                        [
                            "String",
                            "Range"
                        ]
                    ],
                    [
                        "NamedPattern",
                        [
                            "QualifiedNameRef",
                            "List Pattern",
                            "Range"
                        ]
                    ],
                    [
                        "QualifiedNamePattern",
                        [
                            "QualifiedNameRef",
                            "Range"
                        ]
                    ],
                    [
                        "AsPattern",
                        [
                            "Pattern",
                            "VariablePointer",
                            "Range"
                        ]
                    ],
                    [
                        "ParenthesizedPattern",
                        [
                            "Pattern",
                            "Range"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "QualifiedNameRef",
                "comment": " Qualified name reference\n",
                "args": [],
                "type": "{ moduleName : List String, name : String }"
            }
        ],
        "values": [],
        "binops": []
    },
    {
        "name": "Elm.Syntax.Exposing",
        "comment": " Exposing Syntax\n\n\n# Types\n\n@docs Exposing, TopLevelExpose, ExposedType, ValueConstructorExpose\n\n\n# Functions\n\n@docs topLevelExposeRange, exposesFunction, operators\n\n",
        "unions": [
            {
                "name": "Exposing",
                "comment": " Diffent kind of exposing declarations\n",
                "args": [
                    "a"
                ],
                "cases": [
                    [
                        "All",
                        [
                            "Range"
                        ]
                    ],
                    [
                        "Explicit",
                        [
                            "List a"
                        ]
                    ]
                ]
            },
            {
                "name": "TopLevelExpose",
                "comment": " An exposed entity\n",
                "args": [],
                "cases": [
                    [
                        "InfixExpose",
                        [
                            "String",
                            "Range"
                        ]
                    ],
                    [
                        "FunctionExpose",
                        [
                            "String",
                            "Range"
                        ]
                    ],
                    [
                        "TypeOrAliasExpose",
                        [
                            "String",
                            "Range"
                        ]
                    ],
                    [
                        "TypeExpose",
                        [
                            "ExposedType"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "ExposedType",
                "comment": " Exposed Type\n",
                "args": [],
                "type": "{ name : String, constructors : Maybe (Exposing ValueConstructorExpose), range : Range }"
            },
            {
                "name": "ValueConstructorExpose",
                "comment": " Exposed Value Constructor\n",
                "args": [],
                "type": "( String, Range )"
            }
        ],
        "values": [
            {
                "name": "exposesFunction",
                "comment": " Check whether an import/module exposing list exposes a certain function\n",
                "type": "String -> Exposing TopLevelExpose -> Bool"
            },
            {
                "name": "operators",
                "comment": " Get all operator names from a list of TopLevelExposes\n",
                "type": "List TopLevelExpose -> List String"
            },
            {
                "name": "topLevelExposeRange",
                "comment": " Find out the range of a top level expose\n",
                "type": "TopLevelExpose -> Range"
            }
        ],
        "binops": []
    },
    {
        "name": "Elm.Syntax.Documentation",
        "comment": " Documenation Syntax\n\n\n# Types\n\n@docs Documentation\n\n",
        "unions": [],
        "aliases": [
            {
                "name": "Documentation",
                "comment": " Documentation comment\n",
                "args": [],
                "type": "{ text : String, range : Range }"
            }
        ],
        "values": [],
        "binops": []
    },
    {
        "name": "Elm.Syntax.Base",
        "comment": " Base Syntax\n\n\n# Types\n\n@docs ModuleName, VariablePointer\n\n",
        "unions": [],
        "aliases": [
            {
                "name": "ModuleName",
                "comment": " Base representation for a module name\n",
                "args": [],
                "type": "List String"
            },
            {
                "name": "VariablePointer",
                "comment": " A simple variable\n",
                "args": [],
                "type": "{ value : String, range : Range }"
            }
        ],
        "values": [],
        "binops": []
    },
    {
        "name": "Elm.Syntax.Range",
        "comment": " Source Code Ranges\n\n\n# Types\n\n@docs Range, Location\n\n\n# Functions\n\n@docs emptyRange, combine\n\n\n# Json\n\n@docs encode, decode\n\n",
        "unions": [],
        "aliases": [
            {
                "name": "Location",
                "comment": " Source location\n",
                "args": [],
                "type": "{ row : Int, column : Int }"
            },
            {
                "name": "Range",
                "comment": " Range for a piece of code with a start and end\n",
                "args": [],
                "type": "{ start : Location, end : Location }"
            }
        ],
        "values": [
            {
                "name": "combine",
                "comment": " Compute the smallest area of a list of ranges.\n",
                "type": "List Range -> Range"
            },
            {
                "name": "decode",
                "comment": " Decode a range\n",
                "type": "Decoder Range"
            },
            {
                "name": "emptyRange",
                "comment": " Construct an empty range\n",
                "type": "Range"
            },
            {
                "name": "encode",
                "comment": " Encode a range\n",
                "type": "Range -> Value"
            }
        ],
        "binops": []
    },
    {
        "name": "Elm.Syntax.Infix",
        "comment": " Infix Syntax\n\n#Types\n\n@docs Infix, InfixDirection\n\n\n# Json\n\n@docs encode, encodeDirection, decode, decodeDirection\n\n",
        "unions": [
            {
                "name": "InfixDirection",
                "comment": " Union type for infix direction\n",
                "args": [],
                "cases": [
                    [
                        "Left",
                        []
                    ],
                    [
                        "Right",
                        []
                    ]
                ]
            }
        ],
        "aliases": [
            {
                "name": "Infix",
                "comment": " Type annotation for a infix definition\n",
                "args": [],
                "type": "{ direction : InfixDirection, precedence : Int, operator : String }"
            }
        ],
        "values": [
            {
                "name": "decode",
                "comment": " Decode an infix\n",
                "type": "Decoder Infix"
            },
            {
                "name": "decodeDirection",
                "comment": " Decode a infix direction\n",
                "type": "Decoder InfixDirection"
            },
            {
                "name": "encode",
                "comment": " Encode an infix\n",
                "type": "Infix -> Value"
            },
            {
                "name": "encodeDirection",
                "comment": " Encode the infix direction\n",
                "type": "InfixDirection -> Value"
            }
        ],
        "binops": []
    }
]