[
    {
        "name": "Test.Extra",
        "comment": " Extends `Test` with specialized test and describe function.\n\n## Describing JSON Decoders\n\nWrite concise test for JSON decoders\n\n@docs DecoderExpectation, describeDecoder, testDecoder\n",
        "unions": [
            {
                "name": "DecoderExpectation",
                "comment": " Expectation for a decoder result.\n\n* `FailsToDecode` - expect the decoder to fail, the failure message can be anything\n* `FailsToDecodeWith String` - expect the decoder to fail with a specific message\n* `DecodesTo a` - expect the decoder to succeed, decoding to the provided value\n",
                "args": [
                    "a"
                ],
                "cases": [
                    [
                        "FailsToDecode",
                        []
                    ],
                    [
                        "FailsToDecodeWith",
                        [
                            "String"
                        ]
                    ],
                    [
                        "DecodesTo",
                        [
                            "a"
                        ]
                    ]
                ]
            }
        ],
        "aliases": [],
        "values": [
            {
                "name": "describeDecoder",
                "comment": " Exercise a decoder over a list of input/expectation pairs.\n\nFor example\n\n```elm\ndescribeDecoder \"int\"\n  Json.Decode.int\n  [ ( \"\", FailsToDecode )\n  , ( \"foo\", FailsToDecode )\n  , ( \"1\", DecodesTo 1 )\n  , ( \"1.5\", FailsToDecode )\n  ]\n```\n",
                "type": "String -> Decoder a -> List ( String, DecoderExpectation a ) -> Test"
            },
            {
                "name": "testDecoder",
                "comment": " Exercise a decoder with a JSON encoded string.\n\nFor example\n\n```elm\ntestDecoder Json.Decode.string\n  \"\\\"foo\\\"\"\n  (DecodesTo \"foo\")\n```\n",
                "type": "Decoder a -> ( String, DecoderExpectation a ) -> Test"
            }
        ],
        "binops": []
    },
    {
        "name": "Expect.Extra",
        "comment": " Extends `Expect` with more `Expectation`s.\n\n@docs contain, member\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "contain",
                "comment": " Alias of `member`.\n\nReads better with bdd style tests.\n\n    expect [0, 1, 2] to contain 1\n\n    -- Passes because [0, 1, 2] contains 1\n",
                "type": "a -> List a -> Expectation"
            },
            {
                "name": "member",
                "comment": " Passes if value is a member of list.\n\n    member 1 [0, 1, 2]\n\n    -- Passes because 1 is a member of [0, 1, 2]\n",
                "type": "a -> List a -> Expectation"
            }
        ],
        "binops": []
    },
    {
        "name": "Fuzz.Extra",
        "comment": " Extends `Fuzz` with more `Fuzzer`s.\n\n@docs eitherOr, uniformOrCrash, stringMaxLength, sequence\n\n## Deprecated\n\nDo not use this. It will be deprecated in version 2.\n\n@docs union\n",
        "unions": [],
        "aliases": [],
        "values": [
            {
                "name": "eitherOr",
                "comment": " Combine two fuzzers.\n\n    fuzzMaybeInt : Fuzzer (Maybe Int)\n    fuzzMaybeInt =\n        Fuzz.Extra.eitherOr\n            (Fuzz.constant Nothing)\n            (Fuzz.int |> Fuzz.map Just)\n",
                "type": "Fuzzer a -> Fuzzer a -> Fuzzer a"
            },
            {
                "name": "sequence",
                "comment": " Sequence a list of fuzzers into a fuzzer of a list.\n",
                "type": "List (Fuzzer a) -> Fuzzer (List a)"
            },
            {
                "name": "stringMaxLength",
                "comment": " Generates random printable ASCII with a maximum length.\n",
                "type": "Int -> Fuzzer String"
            },
            {
                "name": "uniformOrCrash",
                "comment": " Generates among the provided values with uniform distribution\n\nLike `Fuzz.frequencyOrCrash` but with uniform distribution.\n\n    httpMethod : Fuzzer Method\n    httpMethod =\n        [ GET, POST, PUT, DELETE, OPTIONS ]\n            |> List.map Fuzz.constant\n            |> uniformOrCrash\n\nSame as for `frequencyOrCrash`: \"This is useful in tests, where a crash will\nsimply cause the test run to fail. There is no danger to a production system\nthere.\"\n",
                "type": "List (Fuzzer a) -> Fuzzer a"
            },
            {
                "name": "union",
                "comment": " Create a fuzzer for a union type.\n\n__Deprecated__: use `uniformOrCrash`\n",
                "type": "List a -> a -> Shrinker a -> Fuzzer a"
            }
        ],
        "binops": []
    }
]