[{"name":"TsJson.Decode","comment":" The `TsJson.Decode` module is what you use for\n\n  - Flags\n  - ToElm Ports\n\nBy building a Decoder with this API, you're also describing the source of truth for how to take a TypeScript type and\nturn it into an Elm type. Note that there is complete type information here just by using this API (no magic parsing or\nstatic analysis needed).\n\nLet's take this example:\n\n    import Json.Decode\n\n\n    int\n        |> map String.fromInt\n        |> runExample \"1000\"\n    --> { decoded = Ok \"1000\"\n    --> , tsType = \"number\"\n    --> }\n\nIn this example, there are no differences from how we would write this with the `elm/json` API. Let's consider the type\ninformation from two different sides: the Elm types (which would be used in an Elm type annotation), and the TypeScript\ntypes (which show up in the TypeScript Declaration file that `elm-ts-interop` generates to gives you nice autocompletion and type information).\n\n\n### The Elm type information\n\n  - The initial `Decoder`, `TsJson.Decode.int`, has the Elm type `TsJson.Decode.Decoder Int`. So Elm knows\n    this `Decoder` will either fail, or give us an `Int`.\n  - When we call `TsJson.Decode.map String.fromInt`, the Elm type information changes. We're mapping with\n    `String.fromInt : Int -> String`. So that means we'll now decode into an Elm `String` instead of an `Int`. And that's\n    the final Elm type we'll end up with.\n\n\n### The TypeScript type information\n\n  - `TsJson.Decode.int` expects a number from TypeScript.\n  - `TsJson.Decode.map` applies a function to the decoded Elm value, but it doesn't change what we expect from TypeScript.\n    So we still expect a `number` from TypeScript. And we're done, so that's the final type we expect to receive from TypeScript.\n\n\n### Summary\n\nWe can apply more Decoders, like `TsJson.Decode.list`, for example, to expect an array of that type from TypeScript,\nand a `List` of that Elm type. From there, it's just the same concept. **All the type information about the type that Elm will decode into, and the type that Elm expects from TypeScript, is built up as you build a Decoder**.\n\nThat means that the source of truth is the Decoder itself. Note that the Decoder doesn't specify just the Elm format, or just the TypeScript type as the source\nof truth. It specifies **how to turn a TypeScript type into an Elm type as the source of truth**. That means that\n\n  - You can change the decoder to change either type independently\n  - The two sides (Elm and TS) will always be in sync (as long as you are re-running the `elm-ts-interop` CLI at the appropriate time)\n\n\n## Decoders\n\n@docs Decoder\n\n@docs succeed, fail\n\n\n## Built-Ins\n\n@docs bool, float, int, string\n\n\n## Objects\n\n@docs field, at\n\n\n## Composite Types\n\n@docs list, array, nullable, oneOf, dict, keyValuePairs, oneOrMore, optionalField, optionalNullableField\n\n@docs index, tuple, triple\n\n\n## Arbitrary-Length Tuples\n\n[TypeScript allows you to define a tuple](https://www.typescriptlang.org/docs/handbook/basic-types.html#tuple) that can\nhave any length of items with specific types.\n\nTypeScript tuples are much like an Elm tuples, except two key differences:\n\n  - Elm tuples can only have 2 or 3 items, while TypeScript tuples can have any length\n  - Elm tuples are a distinct type, while TypeScript tuples are just arrays with a statically known length\n\n@docs TupleBuilder, startTuple, buildTuple, element\n\n\n## Transformations\n\n@docs map\n\n\n## Combining\n\n@docs map2, andMap\n\n\n## TypeScript Literals\n\n@docs literal, null\n\n\n## Continuation\n\n@docs andThen, AndThenContinuation, andThenInit, andThenDecoder\n\n\n## elm/json Decoder Escape Hatches\n\nIf you have an existing decoder, you can use it with an [`unknown` type](https://mariusschulz.com/blog/the-unknown-type-in-typescript) in TypeScript.\n\nYou can also decode an arbitrary JSON value as with `elm/json`, and then use `elm/json` to process it further.\n\n@docs value, unknownAndThen, maybe\n\n\n## Using Decoders\n\nUsually you don't need to use these functions directly, but instead the code generated by the `elm-ts-interop` command line\ntool will use these for you under the hood. These can be helpful for debugging, or for building new tools on top of this package.\n\n@docs decoder, tsType\n\n\n## mapN for Combining More Than Two Items\n\n@docs map3, map4, map5, map6, map7, map8\n\n\n## Internals\n\n@docs runExample\n\n","unions":[{"name":"AndThenContinuation","comment":" This type allows you to combine all the possible Decoders you could run in an [`andThen`](#andThen) continuation.\n\nThis API allows you to define all possible Decoders you might use up front, so that all possible TypeScript types\nthe continuation could decode are known _after building up the decoder instead of after running the decoder._\n\n","args":["a"],"cases":[]},{"name":"Decoder","comment":" Just like a `Decoder` in `elm/json`, except these `Decoder`s track the TypeScript types that they can successfully handle.\n","args":["value"],"cases":[]},{"name":"TupleBuilder","comment":" ","args":["value"],"cases":[]}],"aliases":[],"values":[{"name":"andMap","comment":" This is useful for building up a decoder with multiple fields in a pipeline style.\nSee <https://github.com/elm-community/json-extra/blob/2.0.0/docs/andMap.md>.\n\n    import Json.Decode\n\n\n    type alias Country = { name : String, populationInMillions : Int }\n\n    succeed Country\n        |> andMap (field \"name\" string)\n        |> andMap (field \"population\" (int |> map (\\totalPopulation -> floor (toFloat totalPopulation / 1000000.0))))\n        |> runExample \"\"\" {\"name\": \"Norway\", \"population\":5328000} \"\"\"\n    --> { decoded = Ok { name = \"Norway\", populationInMillions = 5 }\n    --> , tsType = \"{ name : string; population : number }\"\n    --> }\n\n","type":"TsJson.Decode.Decoder a -> TsJson.Decode.Decoder (a -> b) -> TsJson.Decode.Decoder b"},{"name":"andThen","comment":"\n\n    import Json.Decode\n\n\n    example : AndThenContinuation (Int -> Decoder String)\n    example =\n        andThenInit\n            (\\v1Decoder v2PlusDecoder version ->\n                case version of\n                    1 -> v1Decoder\n                    _ -> v2PlusDecoder\n            )\n            |> andThenDecoder (field \"payload\" string)\n            |> andThenDecoder (at [ \"data\", \"payload\" ] string)\n\n\n    field \"version\" int |> andThen example\n        |> runExample \"\"\"{\"version\": 1, \"payload\": \"Hello\"}\"\"\"\n    --> { decoded = Ok \"Hello\"\n    --> , tsType = \"({ version : number } & { data : { payload : string } } | { payload : string })\"\n    --> }\n\n","type":"TsJson.Decode.AndThenContinuation (value -> TsJson.Decode.Decoder decodesTo) -> TsJson.Decode.Decoder value -> TsJson.Decode.Decoder decodesTo"},{"name":"andThenDecoder","comment":" ","type":"TsJson.Decode.Decoder value -> TsJson.Decode.AndThenContinuation (TsJson.Decode.Decoder value -> final) -> TsJson.Decode.AndThenContinuation final"},{"name":"andThenInit","comment":" ","type":"a -> TsJson.Decode.AndThenContinuation a"},{"name":"array","comment":" Exactly the same as the [`list`](#list) `Decoder` except that it wraps the decoded `List` into an Elm `Array`.\n","type":"TsJson.Decode.Decoder value -> TsJson.Decode.Decoder (Array.Array value)"},{"name":"at","comment":"\n\n    import Json.Decode\n    import Json.Encode\n\n    type Mode\n        = DarkMode\n        | LightMode\n\n    modeDecoder : Decoder Mode\n    modeDecoder =\n        oneOf [ literal DarkMode <| Json.Encode.string \"dark\", literal LightMode <| Json.Encode.string \"light\" ]\n            |> (at [ \"options\", \"mode\" ])\n\n    modeDecoder\n        |> runExample \"\"\"{\n                           \"options\": { \"mode\": \"dark\" },\n                           \"version\": \"1.2.3\"\n                         }\"\"\"\n    --> { decoded = Ok DarkMode\n    --> , tsType = \"\"\"{ options : { mode : \"dark\" | \"light\" } }\"\"\"\n    --> }\n\n","type":"List.List String.String -> TsJson.Decode.Decoder value -> TsJson.Decode.Decoder value"},{"name":"bool","comment":"\n\n    import Json.Decode\n\n\n    bool\n        |> runExample \"true\"\n    --> { decoded = Ok True\n    --> , tsType = \"boolean\"\n    --> }\n\n","type":"TsJson.Decode.Decoder Basics.Bool"},{"name":"buildTuple","comment":" ","type":"TsJson.Decode.TupleBuilder a -> TsJson.Decode.Decoder a"},{"name":"decoder","comment":" Get a regular JSON Decoder that you can run using the `elm/json` API.\n","type":"TsJson.Decode.Decoder value -> Json.Decode.Decoder value"},{"name":"dict","comment":"\n\n    import Json.Decode\n    import Json.Encode\n    import Dict exposing (Dict)\n\n\n    dict int\n        |> runExample \"\"\"{\"alice\":42,\"bob\":99}\"\"\"\n    --> { decoded = Ok (Dict.fromList [ ( \"alice\", 42 ), ( \"bob\", 99 ) ])\n    --> , tsType = \"{ [key: string]: number }\"\n    --> }\n\n","type":"TsJson.Decode.Decoder value -> TsJson.Decode.Decoder (Dict.Dict String.String value)"},{"name":"element","comment":"\n\n    import Json.Decode\n\n\n    startTuple (\\a b c d -> { a = a, b = b, c = c, d = d })\n        |> element string\n        |> element int\n        |> element bool\n        |> element string\n        |> buildTuple\n        |> runExample \"\"\"[\"abc\", 123, true, \"xyz\"]\"\"\"\n    --> { decoded = Ok { a = \"abc\", b = 123, c = True, d = \"xyz\" }\n    --> , tsType = \"[ string, number, boolean, string ]\"\n    --> }\n\n","type":"TsJson.Decode.Decoder a -> TsJson.Decode.TupleBuilder (a -> b) -> TsJson.Decode.TupleBuilder b"},{"name":"fail","comment":"\n\n    import Json.Decode\n\n\n    fail \"Failure message\"\n        |> runExample \"123.45\"\n    --> { decoded = Err \"Problem with the given value:\\n\\n123.45\\n\\nFailure message\"\n    --> , tsType = \"JsonValue\"\n    --> }\n\n","type":"String.String -> TsJson.Decode.Decoder value"},{"name":"field","comment":"\n\n    import Json.Decode\n\n\n    field \"first\" string\n        |> runExample \"\"\"{\"first\":\"James\",\"middle\":\"Tiberius\",\"last\":\"Kirk\"}\"\"\"\n    --> { decoded = Ok \"James\"\n    --> , tsType = \"{ first : string }\"\n    --> }\n\n","type":"String.String -> TsJson.Decode.Decoder value -> TsJson.Decode.Decoder value"},{"name":"float","comment":"\n\n    import Json.Decode\n\n\n    float\n        |> runExample \"1.23\"\n    --> { decoded = Ok 1.23\n    --> , tsType = \"number\"\n    --> }\n\n","type":"TsJson.Decode.Decoder Basics.Float"},{"name":"index","comment":"\n\n    import Json.Decode\n\n\n    index 1 int\n        |> runExample \"[0,100,200]\"\n    --> { decoded = Ok 100\n    --> , tsType = \"[JsonValue,number,...JsonValue[]]\"\n    --> }\n\n    map2 Tuple.pair\n        ( index 1 int )\n        ( index 3 string )\n        |> runExample \"\"\"[0,100,\"a\",\"b\"]\"\"\"\n    --> { decoded = Ok ( 100, \"b\" )\n    --> , tsType = \"[JsonValue,number,JsonValue,string,...JsonValue[]]\"\n    --> }\n\n","type":"Basics.Int -> TsJson.Decode.Decoder value -> TsJson.Decode.Decoder value"},{"name":"int","comment":"\n\n    import Json.Decode\n\n\n    int\n        |> runExample \"1000\"\n    --> { decoded = Ok 1000\n    --> , tsType = \"number\"\n    --> }\n\nFloating point values will cause a decoding error.\n\n    int\n        |> runExample \"1.23\"\n    --> { decoded = Err \"Problem with the given value:\\n\\n1.23\\n\\nExpecting an INT\"\n    --> , tsType = \"number\"\n    --> }\n\n","type":"TsJson.Decode.Decoder Basics.Int"},{"name":"keyValuePairs","comment":"\n\n    import Json.Decode\n\n\n    keyValuePairs int\n        |> runExample \"\"\"{ \"alice\": 42, \"bob\": 99 }\"\"\"\n    --> { decoded = Ok [ ( \"alice\", 42 ), ( \"bob\", 99 ) ]\n    --> , tsType = \"{ [key: string]: number }\"\n    --> }\n\n","type":"TsJson.Decode.Decoder value -> TsJson.Decode.Decoder (List.List ( String.String, value ))"},{"name":"list","comment":"\n\n    import Json.Decode\n\n\n    list int\n        |> runExample \"[1,2,3]\"\n    --> { decoded = Ok [ 1, 2, 3 ]\n    --> , tsType = \"number[]\"\n    --> }\n\n","type":"TsJson.Decode.Decoder value -> TsJson.Decode.Decoder (List.List value)"},{"name":"literal","comment":" TypeScript has support for literals.\n\n    import Json.Decode\n    import Json.Encode as JE\n\n\n    literal () (JE.string \"unit\")\n        |> runExample \"\"\" \"unit\" \"\"\"\n    --> { decoded = Ok ()\n    --> , tsType = \"\\\"unit\\\"\"\n    --> }\n\n","type":"value -> Json.Encode.Value -> TsJson.Decode.Decoder value"},{"name":"map","comment":"\n\n    import Json.Decode\n\n\n    int\n        |> map String.fromInt\n        |> runExample \"1000\"\n    --> { decoded = Ok \"1000\"\n    --> , tsType = \"number\"\n    --> }\n\n","type":"(value -> mapped) -> TsJson.Decode.Decoder value -> TsJson.Decode.Decoder mapped"},{"name":"map2","comment":" You can use [`map2`](#map2), [`map3`](#map3), etc. to build up decoders that have somewhat clearer error messages if something goes wrong.\nSome people prefer the pipeline style using [`andMap`](#andMap) as it has fewer parentheses and you don't have to change the number when\nyou add a new field. It's a matter of personal preference.\n\n    import Json.Decode\n\n\n    type alias Country = { name : String, populationInMillions : Int }\n\n    map2 Country\n        (field \"name\" string)\n        (field \"population\" (int |> map (\\totalPopulation -> floor (toFloat totalPopulation / 1000000.0))))\n        |> runExample \"\"\" {\"name\": \"Norway\", \"population\":5328000} \"\"\"\n    --> { decoded = Ok { name = \"Norway\", populationInMillions = 5 }\n    --> , tsType = \"{ name : string; population : number }\"\n    --> }\n\n","type":"(value1 -> value2 -> mapped) -> TsJson.Decode.Decoder value1 -> TsJson.Decode.Decoder value2 -> TsJson.Decode.Decoder mapped"},{"name":"map3","comment":" ","type":"(value1 -> value2 -> value3 -> mapped) -> TsJson.Decode.Decoder value1 -> TsJson.Decode.Decoder value2 -> TsJson.Decode.Decoder value3 -> TsJson.Decode.Decoder mapped"},{"name":"map4","comment":" ","type":"(value1 -> value2 -> value3 -> value4 -> mapped) -> TsJson.Decode.Decoder value1 -> TsJson.Decode.Decoder value2 -> TsJson.Decode.Decoder value3 -> TsJson.Decode.Decoder value4 -> TsJson.Decode.Decoder mapped"},{"name":"map5","comment":" ","type":"(value1 -> value2 -> value3 -> value4 -> value5 -> mapped) -> TsJson.Decode.Decoder value1 -> TsJson.Decode.Decoder value2 -> TsJson.Decode.Decoder value3 -> TsJson.Decode.Decoder value4 -> TsJson.Decode.Decoder value5 -> TsJson.Decode.Decoder mapped"},{"name":"map6","comment":" ","type":"(value1 -> value2 -> value3 -> value4 -> value5 -> value6 -> mapped) -> TsJson.Decode.Decoder value1 -> TsJson.Decode.Decoder value2 -> TsJson.Decode.Decoder value3 -> TsJson.Decode.Decoder value4 -> TsJson.Decode.Decoder value5 -> TsJson.Decode.Decoder value6 -> TsJson.Decode.Decoder mapped"},{"name":"map7","comment":" ","type":"(value1 -> value2 -> value3 -> value4 -> value5 -> value6 -> value7 -> mapped) -> TsJson.Decode.Decoder value1 -> TsJson.Decode.Decoder value2 -> TsJson.Decode.Decoder value3 -> TsJson.Decode.Decoder value4 -> TsJson.Decode.Decoder value5 -> TsJson.Decode.Decoder value6 -> TsJson.Decode.Decoder value7 -> TsJson.Decode.Decoder mapped"},{"name":"map8","comment":" ","type":"(value1 -> value2 -> value3 -> value4 -> value5 -> value6 -> value7 -> value8 -> mapped) -> TsJson.Decode.Decoder value1 -> TsJson.Decode.Decoder value2 -> TsJson.Decode.Decoder value3 -> TsJson.Decode.Decoder value4 -> TsJson.Decode.Decoder value5 -> TsJson.Decode.Decoder value6 -> TsJson.Decode.Decoder value7 -> TsJson.Decode.Decoder value8 -> TsJson.Decode.Decoder mapped"},{"name":"maybe","comment":" This function is somewhat risky in that it could cover up a failing Decoder by turning it into a `Nothing`. In\nsome cases, this may be what you're looking for, but if you're trying to deal with optional fields, it's safer to use\n[`optionalField`](#optionalField) and it will give you better type information. See the `thisShouldBeABoolean` example below. In that example,\nwe're decoding a JSON value which should have been a `boolean` but instead is a `string`. We'd like the `Decoder` to fail\nto let us know it wasn't able to process the value correctly, but instead it covers up the failure and decodes to `Nothing`.\n\nSo use this `Decoder` with care!\n\n    import Json.Decode\n\n\n    json : String\n    json = \"\"\"{ \"name\": \"tom\", \"age\": 42, \"thisShouldBeABoolean\": \"true\" }\"\"\"\n\n\n    -- WARNING: uh oh, this may not be the desired behavior!\n    maybe (field \"thisShouldBeABoolean\" bool)\n        |> runExample json\n    --> { decoded = Ok Nothing\n    --> , tsType = \"{ thisShouldBeABoolean : boolean } | JsonValue\"\n    --> }\n\n    maybe (field \"height\" float)\n        |> runExample json\n    --> { decoded = Ok Nothing\n    --> , tsType = \"{ height : number } | JsonValue\"\n    --> }\n\n    field \"height\" (maybe float)\n        |> runExample json\n    --> { decoded = Err \"Problem with the given value:\\n\\n{\\n        \\\"name\\\": \\\"tom\\\",\\n        \\\"age\\\": 42,\\n        \\\"thisShouldBeABoolean\\\": \\\"true\\\"\\n    }\\n\\nExpecting an OBJECT with a field named `height`\"\n    --> , tsType = \"{ height : number | JsonValue }\"\n    --> }\n\n","type":"TsJson.Decode.Decoder value -> TsJson.Decode.Decoder (Maybe.Maybe value)"},{"name":"null","comment":"\n\n    import Json.Decode\n\n\n    null False\n        |> runExample \"null\"\n    --> { decoded = Ok False\n    --> , tsType = \"null\"\n    --> }\n\n","type":"value -> TsJson.Decode.Decoder value"},{"name":"nullable","comment":"\n\n    import Json.Decode\n\n\n    nullable int |> runExample \"13\"\n    --> { decoded = Ok (Just 13)\n    --> , tsType = \"number | null\"\n    --> }\n\n    nullable int |> runExample \"null\"\n    --> { decoded = Ok Nothing\n    --> , tsType = \"number | null\"\n    --> }\n\n    nullable int |> runExample \"true\"\n    --> { decoded = Err \"Json.Decode.oneOf failed in the following 2 ways:\\n\\n\\n\\n(1) Problem with the given value:\\n    \\n    true\\n    \\n    Expecting null\\n\\n\\n\\n(2) Problem with the given value:\\n    \\n    true\\n    \\n    Expecting an INT\"\n    --> , tsType = \"number | null\"\n    --> }\n\n","type":"TsJson.Decode.Decoder value -> TsJson.Decode.Decoder (Maybe.Maybe value)"},{"name":"oneOf","comment":" You can express quite a bit with `oneOf`! The resulting TypeScript types will be a Union of all the TypeScript types\nfor each [`Decoder`](#Decoder) in the List.\n\n    import Json.Decode\n    import Json.Encode\n\n    list ( oneOf [ int |> map toFloat, float ] )\n        |> runExample \"[1, 2, 3.14159, 4]\"\n    --> { decoded = Ok [1.0, 2.0, 3.14159, 4.0]\n    --> , tsType = \"\"\"(number | number)[]\"\"\"\n    --> }\n\n","type":"List.List (TsJson.Decode.Decoder value) -> TsJson.Decode.Decoder value"},{"name":"oneOrMore","comment":"\n\n    import Json.Decode\n    import Json.Encode\n\n\n    oneOrMore (::) int\n        |> runExample \"[12345]\"\n    --> { decoded = Ok [ 12345 ]\n    --> , tsType = \"\"\"[ number, ...(number)[] ]\"\"\"\n    --> }\n\n    type TestResult\n        = Pass\n        | Fail String\n\n    testCaseDecoder : Decoder TestResult\n    testCaseDecoder =\n        oneOf [\n            field \"tag\" (literal Pass (Json.Encode.string \"pass\"))\n          , map2 (\\() message -> Fail message)\n              ( field \"tag\" (literal () (Json.Encode.string \"fail\")) )\n              ( field \"message\" string )\n        ]\n\n    oneOrMore (::) testCaseDecoder\n        |> runExample \"\"\"[ { \"tag\": \"pass\" } ]\"\"\"\n    --> { decoded = Ok [ Pass ]\n    --> , tsType = \"\"\"[ { tag : \"pass\" } | { message : string; tag : \"fail\" }, ...({ tag : \"pass\" } | { message : string; tag : \"fail\" })[] ]\"\"\"\n    --> }\n\n","type":"(a -> List.List a -> value) -> TsJson.Decode.Decoder a -> TsJson.Decode.Decoder value"},{"name":"optionalField","comment":" This is a safer (and more explicit) way to deal with optional fields compared to [`maybe`](#maybe). It may seem that wrapping\na [`field`](#field) `Decoder` in a [`maybe`](#maybe) `Decoder` achieves the same behavior, but the key difference is that the `maybe` version\nwill convert a failing decoder on a value that is present into `Nothing`, as if it wasn't present. Often what you want\nis for the malformed version to fail, which is exactly what this function will do.\n\n    import Json.Decode\n\n\n    json : String\n    json = \"\"\"{ \"name\": \"tom\", \"age\": null }\"\"\"\n\n    optionalField \"height\" float\n        |> runExample json\n    --> { decoded = Ok Nothing\n    --> , tsType = \"{ height? : number }\"\n    --> }\n\n    optionalField \"age\" int\n        |> runExample json\n    --> { decoded = Err \"Problem with the value at json.age:\\n\\n    null\\n\\nExpecting an INT\"\n    --> , tsType = \"{ age? : number }\"\n    --> }\n\n","type":"String.String -> TsJson.Decode.Decoder value -> TsJson.Decode.Decoder (Maybe.Maybe value)"},{"name":"optionalNullableField","comment":"\n\n    import Json.Decode\n\n\n    json : String\n    json = \"\"\"{ \"name\": \"tom\", \"age\": null }\"\"\"\n\n    optionalNullableField \"height\" float\n        |> runExample json\n    --> { decoded = Ok Nothing\n    --> , tsType = \"{ height? : number | null }\"\n    --> }\n\n    optionalNullableField \"age\" int\n        |> runExample json\n    --> { decoded = Ok Nothing\n    --> , tsType = \"{ age? : number | null }\"\n    --> }\n\n","type":"String.String -> TsJson.Decode.Decoder value -> TsJson.Decode.Decoder (Maybe.Maybe value)"},{"name":"runExample","comment":" ","type":"String.String -> TsJson.Decode.Decoder value -> { decoded : Result.Result String.String value, tsType : String.String }"},{"name":"startTuple","comment":" ","type":"a -> TsJson.Decode.TupleBuilder a"},{"name":"string","comment":"\n\n    import Json.Decode\n\n\n    string\n        |> runExample \"\"\" \"Hello!\" \"\"\"\n    --> { decoded = Ok \"Hello!\"\n    --> , tsType = \"string\"\n    --> }\n\n","type":"TsJson.Decode.Decoder String.String"},{"name":"succeed","comment":"\n\n    import Json.Decode\n\n\n    succeed \"abcdefg\"\n        |> runExample \"12345\"\n    --> { decoded = Ok \"abcdefg\"\n    --> , tsType = \"JsonValue\"\n    --> }\n\n","type":"value -> TsJson.Decode.Decoder value"},{"name":"triple","comment":"\n\n    import Json.Decode\n\n\n    triple string int bool\n        |> runExample \"\"\"[\"abc\", 123, true]\"\"\"\n    --> { decoded = Ok ( \"abc\", 123, True )\n    --> , tsType = \"[ string, number, boolean ]\"\n    --> }\n\n","type":"TsJson.Decode.Decoder value1 -> TsJson.Decode.Decoder value2 -> TsJson.Decode.Decoder value3 -> TsJson.Decode.Decoder ( value1, value2, value3 )"},{"name":"tsType","comment":" ","type":"TsJson.Decode.Decoder value -> Internal.TsJsonType.TsType"},{"name":"tuple","comment":"\n\n    import Json.Decode\n\n\n    tuple string int\n        |> runExample \"\"\"[\"abc\", 123]\"\"\"\n    --> { decoded = Ok ( \"abc\", 123 )\n    --> , tsType = \"[ string, number ]\"\n    --> }\n\n","type":"TsJson.Decode.Decoder value1 -> TsJson.Decode.Decoder value2 -> TsJson.Decode.Decoder ( value1, value2 )"},{"name":"unknownAndThen","comment":" If you need to run a regular JSON Decoder in an `andThen`, you can use this function, but it will yield a Decoder\nwith an unknown TypeScript type.\n\n    import Json.Decode as JD\n\n\n    field \"version\" int |> unknownAndThen (\\versionNumber ->\n        if versionNumber == 1 then\n          JD.field \"payload\" JD.string\n        else\n          JD.at [ \"data\", \"payload\" ] JD.string\n    )\n        |> runExample \"\"\"{\"version\": 1, \"payload\": \"Hello\"}\"\"\"\n    --> { decoded = Ok \"Hello\"\n    --> , tsType = \"JsonValue\"\n    --> }\n\n","type":"(a -> Json.Decode.Decoder b) -> TsJson.Decode.Decoder a -> TsJson.Decode.Decoder b"},{"name":"value","comment":" Gives you an escape hatch to decode to a plain `elm/json` `Json.Decode.Value`. This has the TypeScript type `unknown`.\nAvoid using this when possible.\n\n    import Json.Decode\n\n\n    value\n        |> runExample \"Hello\"\n    --> { decoded = (Json.Decode.decodeString Json.Decode.value \"Hello\" |> Result.mapError Json.Decode.errorToString)\n    --> , tsType = \"JsonValue\"\n    --> }\n\n","type":"TsJson.Decode.Decoder Json.Decode.Value"}],"binops":[]},{"name":"TsJson.Encode","comment":" The `TsJson.Encode` module is what you use for\n\n  - FromElm Ports\n\nSee [TsJson.Decode](TsJson.Decode) for the API used for Flags and ToElm Ports.\n\nBy building an `Encoder` with this API, you're also describing the source of truth for taking an Elm type and\nturning it into a JSON value with a TypeScript type. Note that there is no magic involved in this process.\nThe `elm-ts-interop` CLI simply gets the [`typeDef`](#typeDef) from your `Encoder` to generate the\nTypeScript Declaration file for your compiled Elm code.\n\n@docs Encoder\n\n\n## Built-Ins\n\n@docs string, int, float, literal, bool, null\n\n\n## Transforming\n\n@docs map\n\n\n## Objects\n\n@docs object, Property, optional, required\n\n\n## Union Types\n\n    import Json.Encode as Encode\n\n    type ToJs\n        = SendPresenceHeartbeat\n        | Alert String\n\n    unionEncoder : Encoder ToJs\n    unionEncoder =\n        union\n            (\\vSendHeartbeat vAlert value ->\n                case value of\n                    SendPresenceHeartbeat ->\n                        vSendHeartbeat\n                    Alert string ->\n                        vAlert string\n            )\n            |> variant0 \"SendPresenceHeartbeat\"\n            |> variantObject \"Alert\" [ required \"message\" identity string ]\n            |> buildUnion\n\n\n    Alert \"Hello TypeScript!\"\n            |> runExample unionEncoder\n    --> { output = \"\"\"{\"tag\":\"Alert\",\"message\":\"Hello TypeScript!\"}\"\"\"\n    --> , tsType = \"\"\"{ tag : \"Alert\"; message : string } | { tag : \"SendPresenceHeartbeat\" }\"\"\"\n    --> }\n\n@docs UnionBuilder, union, variant, variant0, variantObject, variantLiteral, variantTagged, buildUnion\n\n@docs UnionEncodeValue\n\n\n## Collections\n\n@docs list, dict, tuple, triple, maybe\n\n\n## In-Depth Example\n\nYou can use `elm-ts-interop` to build up `Encoder`s that have the same TypeScript type as a web platform API expects.\nHere's an example that we could use to call the [`scrollIntoView`](https://developer.mozilla.org/en-US/docs/Web/API/Element/scrollIntoView)\nmethod on a DOM Element.\n\n    import Json.Encode\n\n    type Behavior\n        = Auto\n        | Smooth\n\n    type Alignment\n        = Start\n        | Center\n        | End\n        | Nearest\n\n    scrollIntoViewEncoder : Encoder\n            { behavior : Maybe Behavior\n            , block : Maybe Alignment\n            , inline : Maybe Alignment\n            }\n    scrollIntoViewEncoder =\n        object\n            [ optional \"behavior\" .behavior behaviorEncoder\n            , optional \"block\" .block alignmentEncoder\n            , optional \"inline\" .inline alignmentEncoder\n            ]\n\n    behaviorEncoder : Encoder Behavior\n    behaviorEncoder =\n        union\n            (\\vAuto vSmooth value ->\n                case value of\n                    Auto ->\n                        vAuto\n                    Smooth ->\n                        vSmooth\n            )\n            |> variantLiteral (Json.Encode.string \"auto\")\n            |> variantLiteral (Json.Encode.string \"smooth\")\n            |> buildUnion\n\n\n    alignmentEncoder : Encoder Alignment\n    alignmentEncoder =\n        union\n            (\\vStart vCenter vEnd vNearest value ->\n                case value of\n                    Start ->\n                        vStart\n                    Center ->\n                        vCenter\n                    End ->\n                        vEnd\n                    Nearest ->\n                        vNearest\n            )\n            |> variantLiteral (Json.Encode.string \"start\")\n            |> variantLiteral (Json.Encode.string \"center\")\n            |> variantLiteral (Json.Encode.string \"end\")\n            |> variantLiteral (Json.Encode.string \"nearest\")\n            |> buildUnion\n\n\n    { behavior = Just Auto, block = Just Nearest, inline = Nothing }\n            |> runExample scrollIntoViewEncoder\n    --> { output = \"\"\"{\"behavior\":\"auto\",\"block\":\"nearest\"}\"\"\"\n    --> , tsType = \"\"\"{ behavior? : \"smooth\" | \"auto\"; block? : \"nearest\" | \"end\" | \"center\" | \"start\"; inline? : \"nearest\" | \"end\" | \"center\" | \"start\" }\"\"\"\n    --> }\n\n\n## Escape Hatch\n\n@docs value\n\n\n## Executing Encoders\n\nUsually you don't need to use these functions directly, but instead the code generated by the `elm-ts-interop` command line\ntool will use these for you under the hood. These can be helpful for debugging, or for building new tools on top of this package.\n\n@docs encoder, tsType\n\n\n## Documentation Helper\n\n@docs runExample\n\n","unions":[{"name":"Encoder","comment":" Similar to a `Json.Encode.Value` in `elm/json`. However, a `TsJson.Encode.Encoder` in `elm-ts-json` has this key difference from an `elm/json` `Encode.Value`:\n\n  - `elm/json` `Json.Encode.Value` - a value representing an encoded JSON value\n  - `elm-ts-interop` `TsJson.Encode.Encoder` - a _function_ for turning an Elm value into an encoded JSON value. The `Encoder` itself has a definite TypeScript type, before you even pass in an Elm value to turn into JSON.\n\nSo the `elm-ts-json` `Encoder` expects a specific type of Elm value, and knows how to turn that Elm value into JSON.\n\nLet's compare the two with an example for encoding a first and last name.\n\n    import Json.Encode\n\n    elmJsonNameEncoder : { first : String, last : String }\n        -> Json.Encode.Value\n    elmJsonNameEncoder { first, last } =\n        Json.Encode.object\n            [ ( \"first\", Json.Encode.string first )\n            , ( \"last\", Json.Encode.string last )\n            ]\n\n    { first = \"James\", last = \"Kirk\" }\n            |> elmJsonNameEncoder\n            |> Json.Encode.encode 0\n    --> \"\"\"{\"first\":\"James\",\"last\":\"Kirk\"}\"\"\"\n\n    nameEncoder : Encoder { first : String, last : String }\n    nameEncoder =\n        object\n            [ required \"first\" .first string\n            , required \"last\" .last string\n            ]\n\n    { first = \"James\", last = \"Kirk\" }\n            |> runExample nameEncoder\n    --> { output = \"\"\"{\"first\":\"James\",\"last\":\"Kirk\"}\"\"\"\n    --> , tsType = \"{ first : string; last : string }\"\n    --> }\n\n","args":["input"],"cases":[]},{"name":"Property","comment":" ","args":["input"],"cases":[]},{"name":"UnionBuilder","comment":" ","args":["match"],"cases":[]},{"name":"UnionEncodeValue","comment":" We can guarantee that you're only encoding to a given\nset of possible shapes in a union type by ensuring that\nall the encoded values come from the union pipeline,\nusing functions like `variantLiteral`, `variantObject`, etc.\n\nApplying another variant function in your union pipeline will\ngive you more functions/values to give UnionEncodeValue's with\ndifferent shapes, if you need them.\n\n","args":[],"cases":[]}],"aliases":[],"values":[{"name":"bool","comment":"\n\n    import Json.Encode as Encode\n\n    True\n        |> runExample bool\n    --> { output = \"true\"\n    --> , tsType = \"boolean\"\n    --> }\n\n","type":"TsJson.Encode.Encoder Basics.Bool"},{"name":"buildUnion","comment":" ","type":"TsJson.Encode.UnionBuilder (match -> TsJson.Encode.UnionEncodeValue) -> TsJson.Encode.Encoder match"},{"name":"dict","comment":"\n\n    import Json.Encode as Encode\n    import Dict\n\n    Dict.fromList [ ( \"a\", \"123\" ), ( \"b\", \"456\" ) ]\n        |> runExample ( dict identity string )\n    --> { output = \"\"\"{\"a\":\"123\",\"b\":\"456\"}\"\"\"\n    --> , tsType = \"{ [key: string]: string }\"\n    --> }\n\n","type":"(comparableKey -> String.String) -> TsJson.Encode.Encoder input -> TsJson.Encode.Encoder (Dict.Dict comparableKey input)"},{"name":"encoder","comment":" ","type":"TsJson.Encode.Encoder input -> input -> Json.Encode.Value"},{"name":"float","comment":"\n\n    import Json.Encode as Encode\n\n    123.45\n        |> runExample float\n    --> { output = \"123.45\"\n    --> , tsType = \"number\"\n    --> }\n\n","type":"TsJson.Encode.Encoder Basics.Float"},{"name":"int","comment":"\n\n    import Json.Encode as Encode\n\n    123\n        |> runExample int\n    --> { output = \"123\"\n    --> , tsType = \"number\"\n    --> }\n\n","type":"TsJson.Encode.Encoder Basics.Int"},{"name":"list","comment":"\n\n    import Json.Encode as Encode\n\n    [ \"Hello\", \"World!\" ]\n        |> runExample ( list string )\n    --> { output = \"\"\"[\"Hello\",\"World!\"]\"\"\"\n    --> , tsType = \"string[]\"\n    --> }\n\n","type":"TsJson.Encode.Encoder a -> TsJson.Encode.Encoder (List.List a)"},{"name":"literal","comment":" TypeScript has the concept of a [Literal Type](https://www.typescriptlang.org/docs/handbook/literal-types.html).\nA Literal Type is just a JSON value. But unlike other types, it is constrained to a specific literal.\n\nFor example, `200` is a Literal Value (not just any `number`). Elm doesn't have the concept of Literal Values that the\ncompiler checks. But you can map Elm Custom Types nicely into TypeScript Literal Types. For example, you could represent\nHTTP Status Codes in TypeScript with a Union of Literal Types like this:\n\n```typescript\ntype HttpStatus = 200 | 404 // you can include more status codes\n```\n\nThe type `HttpStatus` is limited to that set of numbers. In Elm, you might represent that discrete set of values with\na Custom Type, like so:\n\n    type HttpStatus\n        = Success\n        | NotFound\n\nHowever you name them, you can map those Elm types into equivalent TypeScript values using a union of literals like so:\n\n    import Json.Encode as Encode\n\n    httpStatusEncoder : Encoder HttpStatus\n    httpStatusEncoder =\n        union\n            (\\vSuccess vNotFound value ->\n                case value of\n                    Success ->\n                        vSuccess\n                    NotFound ->\n                        vNotFound\n            )\n            |> variantLiteral (Encode.int 200)\n            |> variantLiteral (Encode.int 404)\n            |> buildUnion\n\n    NotFound\n        |> runExample httpStatusEncoder\n    --> { output = \"404\"\n    --> , tsType = \"404 | 200\"\n    --> }\n\n","type":"Json.Encode.Value -> TsJson.Encode.Encoder a"},{"name":"map","comment":" An [`Encoder`](#Encoder) represents turning an Elm input value into a JSON value that has a TypeScript type information.\n\nThis `map` function allows you to transform the **Elm input value**, not the resulting JSON output. So this will feel\ndifferent than using [`TsJson.Decode.map`](TsJson.Decode#map), or other familiar `map` functions\nthat transform an **Elm output value**, such as `Maybe.map` and `Json.Decode.map`.\n\nThink of `TsJson.Encode.map` as changing **how to get the value that you want to turn into JSON**. For example,\nif we're passing in some nested data and need to get a field\n\n    import Json.Encode as Encode\n\n    picardData : { data : { first : String, last : String, rank : String } }\n    picardData = { data = { first = \"Jean Luc\", last = \"Picard\", rank = \"Captain\" } }\n\n    rankEncoder : Encoder { data : { officer | rank : String } }\n    rankEncoder =\n        string\n            |> map .rank\n            |> map .data\n\n    picardData\n        |> runExample rankEncoder\n    --> { output = \"\\\"Captain\\\"\"\n    --> , tsType = \"string\"\n    --> }\n\nLet's consider how the types change as we `map` the `Encoder`.\n\n    encoder1 : Encoder String\n    encoder1 =\n        string\n\n    encoder2 : Encoder { rank : String }\n    encoder2 =\n        string\n            |> map .rank\n\n    encoder3 : Encoder { data : { rank : String } }\n    encoder3 =\n        string\n            |> map .rank\n            |> map .data\n\n    (encoder1, encoder2, encoder3) |> always ()\n    --> ()\n\nSo `map` is applying a function that tells the Encoder how to get the data it needs.\n\nIf we want to send a string through a port, then we start with a [`string`](#string) `Encoder`. Then we `map` it to\nturn our input data into a String (because `string` is `Encoder String`).\n\n    encoderThing : Encoder { data : { officer | first : String, last : String } }\n    encoderThing =\n        string\n            |> map (\\outerRecord -> outerRecord.data.first ++ \" \" ++ outerRecord.data.last)\n\n    picardData\n        |> runExample encoderThing\n    --> { output = \"\\\"Jean Luc Picard\\\"\"\n    --> , tsType = \"string\"\n    --> }\n\n","type":"(input -> mappedInput) -> TsJson.Encode.Encoder mappedInput -> TsJson.Encode.Encoder input"},{"name":"maybe","comment":"\n\n    import Json.Encode as Encode\n\n    Just 42\n        |> runExample ( maybe int )\n    --> { output = \"42\"\n    --> , tsType = \"number | null\"\n    --> }\n\n","type":"TsJson.Encode.Encoder a -> TsJson.Encode.Encoder (Maybe.Maybe a)"},{"name":"null","comment":" Equivalent to `literal Encode.null`.\n\n    import Json.Encode as Encode\n\n    ()\n        |> runExample null\n    --> { output = \"null\"\n    --> , tsType = \"null\"\n    --> }\n\n","type":"TsJson.Encode.Encoder input"},{"name":"object","comment":"\n\n    import Json.Encode as Encode\n\n    nameEncoder : Encoder { first : String, last : String }\n    nameEncoder =\n        object\n            [ required \"first\" .first string\n            , required \"last\" .last string\n            ]\n\n\n    { first = \"James\", last = \"Kirk\" }\n            |> runExample nameEncoder\n    --> { output = \"\"\"{\"first\":\"James\",\"last\":\"Kirk\"}\"\"\"\n    --> , tsType = \"{ first : string; last : string }\"\n    --> }\n\n    fullNameEncoder : Encoder { first : String, middle : Maybe String, last : String }\n    fullNameEncoder =\n        object\n            [ required \"first\" .first string\n            , optional \"middle\" .middle string\n            , required \"last\" .last string\n            ]\n\n    { first = \"James\", middle = Just \"Tiberius\", last = \"Kirk\" }\n            |> runExample fullNameEncoder\n    --> { output = \"\"\"{\"first\":\"James\",\"middle\":\"Tiberius\",\"last\":\"Kirk\"}\"\"\"\n    --> , tsType = \"{ first : string; last : string; middle? : string }\"\n    --> }\n\n","type":"List.List (TsJson.Encode.Property input) -> TsJson.Encode.Encoder input"},{"name":"optional","comment":" ","type":"String.String -> (input -> Maybe.Maybe mappedInput) -> TsJson.Encode.Encoder mappedInput -> TsJson.Encode.Property input"},{"name":"required","comment":" ","type":"String.String -> (input -> mappedInput) -> TsJson.Encode.Encoder mappedInput -> TsJson.Encode.Property input"},{"name":"runExample","comment":" ","type":"TsJson.Encode.Encoder input -> input -> { output : String.String, tsType : String.String }"},{"name":"string","comment":" Encode a string.\n\n    import Json.Encode as Encode\n\n    \"Hello!\"\n        |> runExample string\n    --> { output = \"\\\"Hello!\\\"\"\n    --> , tsType = \"string\"\n    --> }\n\nYou can use `map` to apply an accessor function for how to get that String.\n\n    { data = { first = \"James\", last = \"Kirk\" } }\n        |> runExample ( string |> map .first |> map .data )\n    --> { output = \"\\\"James\\\"\"\n    --> , tsType = \"string\"\n    --> }\n\n","type":"TsJson.Encode.Encoder String.String"},{"name":"triple","comment":" Same as [`tuple`](#tuple), but with Triples\n\n    import Json.Encode as Encode\n\n    ( \"Jane Doe\", True, 123 )\n        |> runExample ( triple string bool int )\n    --> { output = \"\"\"[\"Jane Doe\",true,123]\"\"\"\n    --> , tsType = \"[ string, boolean, number ]\"\n    --> }\n\n","type":"TsJson.Encode.Encoder input1 -> TsJson.Encode.Encoder input2 -> TsJson.Encode.Encoder input3 -> TsJson.Encode.Encoder ( input1, input2, input3 )"},{"name":"tsType","comment":" ","type":"TsJson.Encode.Encoder input -> Internal.TsJsonType.TsType"},{"name":"tuple","comment":" TypeScript [has a Tuple type](https://www.typescriptlang.org/docs/handbook/basic-types.html#tuple). It's just an\nArray with 2 items, and the TypeScript compiler will enforce that there are two elements. You can turn an Elm Tuple\ninto a TypeScript Tuple.\n\n    import Json.Encode as Encode\n\n    ( \"John Doe\", True )\n        |> runExample ( tuple string bool )\n    --> { output = \"\"\"[\"John Doe\",true]\"\"\"\n    --> , tsType = \"[ string, boolean ]\"\n    --> }\n\nIf your target Elm value isn't a tuple, you can [`map`](#map) it into one\n\n    { name = \"John Smith\", isAdmin = False }\n        |> runExample\n            (tuple string bool\n                |> map\n                    (\\{ name, isAdmin } ->\n                        ( name, isAdmin )\n                    )\n            )\n    --> { output = \"\"\"[\"John Smith\",false]\"\"\"\n    --> , tsType = \"[ string, boolean ]\"\n    --> }\n\n","type":"TsJson.Encode.Encoder input1 -> TsJson.Encode.Encoder input2 -> TsJson.Encode.Encoder ( input1, input2 )"},{"name":"union","comment":" ","type":"constructor -> TsJson.Encode.UnionBuilder constructor"},{"name":"value","comment":" This is an escape hatch that allows you to send arbitrary JSON data. The type will\nbe JSON in TypeScript, so you won't have any specific type information. In some cases,\nthis is fine, but in general you'll usually want to use other functions in this module\nto build up a well-typed [`Encoder`](#Encoder).\n","type":"TsJson.Encode.Encoder Json.Encode.Value"},{"name":"variant","comment":" ","type":"TsJson.Encode.Encoder input -> TsJson.Encode.UnionBuilder ((input -> TsJson.Encode.UnionEncodeValue) -> match) -> TsJson.Encode.UnionBuilder match"},{"name":"variant0","comment":" ","type":"String.String -> TsJson.Encode.UnionBuilder (TsJson.Encode.UnionEncodeValue -> match) -> TsJson.Encode.UnionBuilder match"},{"name":"variantLiteral","comment":" ","type":"Json.Encode.Value -> TsJson.Encode.UnionBuilder (TsJson.Encode.UnionEncodeValue -> match) -> TsJson.Encode.UnionBuilder match"},{"name":"variantObject","comment":" ","type":"String.String -> List.List (TsJson.Encode.Property arg1) -> TsJson.Encode.UnionBuilder ((arg1 -> TsJson.Encode.UnionEncodeValue) -> match) -> TsJson.Encode.UnionBuilder match"},{"name":"variantTagged","comment":" Takes any Encoder and includes that data under an Object property \"data\".\n\nFor example, here's an encoded payload for a log event.\n\n    import TsJson.Encode as TsEncode\n    import Json.Encode\n\n    type alias Event = { level : String, message : String }\n    type FromElm = LogEvent Event\n\n    eventEncoder : Encoder Event\n    eventEncoder =\n        TsEncode.object\n            [ TsEncode.required \"level\" .level TsEncode.string\n            , TsEncode.required \"message\" .message TsEncode.string\n            ]\n\n\n    fromElm : TsEncode.Encoder FromElm\n    fromElm =\n        TsEncode.union\n            (\\vLogEvent value ->\n                case value of\n                    LogEvent event ->\n                        vLogEvent event\n            )\n            |> TsEncode.variantTagged \"LogEvent\" eventEncoder\n            |> TsEncode.buildUnion\n\n    (TsEncode.encoder fromElm) (LogEvent { level = \"info\", message = \"Hello\" }) |> Json.Encode.encode 0\n    --> \"\"\"{\"tag\":\"LogEvent\",\"data\":{\"level\":\"info\",\"message\":\"Hello\"}}\"\"\"\n\n","type":"String.String -> TsJson.Encode.Encoder input -> TsJson.Encode.UnionBuilder ((input -> TsJson.Encode.UnionEncodeValue) -> match) -> TsJson.Encode.UnionBuilder match"}],"binops":[]},{"name":"TsJson.Type","comment":"\n\nUsually you don't need to use this module directly, but instead use a tool that makes use of this module (like [`elm-ts-interop`](https://github.com/dillonkearns/elm-ts-interop)).\n\n@docs Type\n@docs toTypeScript, toJsonSchema\n\n","unions":[],"aliases":[{"name":"Type","comment":" Represents a JSON value with TypeScript information. ","args":[],"type":"Internal.TsJsonType.TsType"}],"values":[{"name":"toJsonSchema","comment":" You can express the same type information about a JSON values with [JSON Schema](https://json-schema.org/) format.\nOne example where this can be useful is if tooling wants to perform a runtime check of a JSON value before passing it to a TsJson.Decoder to ensure\nthat it is a valid input.\n","type":"TsJson.Type.Type -> Json.Encode.Value"},{"name":"toTypeScript","comment":" Tooling can use this function to convert the JSON type information into a string describing a TypeScript type.\n\nNote that instead of the TypeScript type `unknown`, this will use a type called `JsonValue` to be more precise.\nThis isn't a built-in TypeScript type, but since these values can only be JSON, it represents the constraints more accurately.\n\nYou can find the type definition of `JsonValue` here if you are building your own custom tooling and need to handle this type:\n<https://github.com/sindresorhus/type-fest/blob/4c9835b3c42d7a9f1d10bae19c334ce1d8e8c8a4/source/basic.d.ts#L22-L37>.\n ","type":"TsJson.Type.Type -> String.String"}],"binops":[]}]