Generated-output differences

Test case

test/inputs/graphql/github1.graphql

1 generated file · +9 −1

Mgraphql-elixirdefault / QuickType.ex+9 −1

		@@ -20,10 +20,18 @@ defmodule User do
20	20	def encode_login(value) when is_binary(value), do: value
21	21	def encode_login(_), do: {:error, "Unexpected type when encoding User.login"}
22	22
	23	+ def decode_real_name(value) when is_nil(value), do: value
	24	+ def decode_real_name(value) when is_binary(value), do: value
	25	+ def decode_real_name(_), do: {:error, "Unexpected type when decoding User.real_name"}
	26	+
	27	+ def encode_real_name(value) when is_nil(value), do: value
	28	+ def encode_real_name(value) when is_binary(value), do: value
	29	+ def encode_real_name(_), do: {:error, "Unexpected type when encoding User.real_name"}
	30	+
23	31	def from_map(m) do
24	32	%User{
25	33	login: decode_login(m["login"]),
26		- real_name: Map.fetch!(m, "realName"),
	34	+ real_name: decode_real_name(Map.fetch!(m, "realName")),
27	35	}
28	36	end

Test case

test/inputs/graphql/github4.graphql

1 generated file · +9 −1

Mgraphql-elixirdefault / QuickType.ex+9 −1

		@@ -175,10 +175,18 @@ defmodule User do
175	175	def encode_login(value) when is_binary(value), do: value
176	176	def encode_login(_), do: {:error, "Unexpected type when encoding User.login"}
177	177
	178	+ def decode_name(value) when is_nil(value), do: value
	179	+ def decode_name(value) when is_binary(value), do: value
	180	+ def decode_name(_), do: {:error, "Unexpected type when decoding User.name"}
	181	+
	182	+ def encode_name(value) when is_nil(value), do: value
	183	+ def encode_name(value) when is_binary(value), do: value
	184	+ def encode_name(_), do: {:error, "Unexpected type when encoding User.name"}
	185	+
178	186	def from_map(m) do
179	187	%User{
180	188	login: decode_login(m["login"]),
181		- name: Map.fetch!(m, "name"),
	189	+ name: decode_name(Map.fetch!(m, "name")),
182	190	repository: m["repository"] && Repository.from_map(m["repository"]),
183	191	}
184	192	end

Test case

test/inputs/graphql/github5.graphql

1 generated file · +9 −1

Mgraphql-elixirdefault / QuickType.ex+9 −1

		@@ -20,10 +20,18 @@ defmodule User do
20	20	def encode_login(value) when is_binary(value), do: value
21	21	def encode_login(_), do: {:error, "Unexpected type when encoding User.login"}
22	22
	23	+ def decode_name(value) when is_nil(value), do: value
	24	+ def decode_name(value) when is_binary(value), do: value
	25	+ def decode_name(_), do: {:error, "Unexpected type when decoding User.name"}
	26	+
	27	+ def encode_name(value) when is_nil(value), do: value
	28	+ def encode_name(value) when is_binary(value), do: value
	29	+ def encode_name(_), do: {:error, "Unexpected type when encoding User.name"}
	30	+
23	31	def from_map(m) do
24	32	%User{
25	33	login: decode_login(m["login"]),
26		- name: m["name"],
	34	+ name: m["name"] && decode_name(m["name"]),
27	35	}
28	36	end

Test case

test/inputs/graphql/github9.graphql

1 generated file · +9 −1

Mgraphql-elixirdefault / QuickType.ex+9 −1

		@@ -146,9 +146,17 @@ defmodule AddReactionPayload do
146	146	subject: Reactable.t()
147	147	}
148	148
	149	+ def decode_client_mutation_id(value) when is_nil(value), do: value
	150	+ def decode_client_mutation_id(value) when is_binary(value), do: value
	151	+ def decode_client_mutation_id(_), do: {:error, "Unexpected type when decoding AddReactionPayload.client_mutation_id"}
	152	+
	153	+ def encode_client_mutation_id(value) when is_nil(value), do: value
	154	+ def encode_client_mutation_id(value) when is_binary(value), do: value
	155	+ def encode_client_mutation_id(_), do: {:error, "Unexpected type when encoding AddReactionPayload.client_mutation_id"}
	156	+
149	157	def from_map(m) do
150	158	%AddReactionPayload{
151		- client_mutation_id: Map.fetch!(m, "clientMutationId"),
	159	+ client_mutation_id: decode_client_mutation_id(Map.fetch!(m, "clientMutationId")),
152	160	reaction: Reaction.from_map(m["reaction"]),
153	161	subject: Reactable.from_map(m["subject"]),
154	162	}

Test case

test/inputs/json/misc/050b0.json

1 generated file · +18 −2

Melixirdefault / QuickType.ex+18 −2

		@@ -248,10 +248,18 @@ defmodule OtherName do
248	248	def encode_name(value) when is_binary(value), do: value
249	249	def encode_name(_), do: {:error, "Unexpected type when encoding OtherName.name"}
250	250
	251	+ def decode_note(value) when is_nil(value), do: value
	252	+ def decode_note(value) when is_binary(value), do: value
	253	+ def decode_note(_), do: {:error, "Unexpected type when decoding OtherName.note"}
	254	+
	255	+ def encode_note(value) when is_nil(value), do: value
	256	+ def encode_note(value) when is_binary(value), do: value
	257	+ def encode_note(_), do: {:error, "Unexpected type when encoding OtherName.note"}
	258	+
251	259	def from_map(m) do
252	260	%OtherName{
253	261	name: decode_name(m["name"]),
254		- note: Map.fetch!(m, "note"),
	262	+ note: decode_note(Map.fetch!(m, "note")),
255	263	}
256	264	end
257	265
		@@ -463,6 +471,14 @@ defmodule TopLevelElement do
463	471	def encode_other_names(value) when is_list(value), do: value
464	472	def encode_other_names(_), do: {:error, "Unexpected type when encoding TopLevelElement.other_names"}
465	473
	474	+ def decode_superseded_by(value) when is_nil(value), do: value
	475	+ def decode_superseded_by(value) when is_binary(value), do: value
	476	+ def decode_superseded_by(_), do: {:error, "Unexpected type when decoding TopLevelElement.superseded_by"}
	477	+
	478	+ def encode_superseded_by(value) when is_nil(value), do: value
	479	+ def encode_superseded_by(value) when is_binary(value), do: value
	480	+ def encode_superseded_by(_), do: {:error, "Unexpected type when encoding TopLevelElement.superseded_by"}
	481	+
466	482	def decode_text(value) when is_list(value), do: value
467	483	def decode_text(_), do: {:error, "Unexpected type when decoding TopLevelElement.text"}
468	484
		@@ -477,7 +493,7 @@ defmodule TopLevelElement do
477	493	links: Enum.map(m["links"], &Link.from_map/1),
478	494	name: decode_name(m["name"]),
479	495	other_names: Enum.map(m["other_names"], &OtherName.from_map/1),
480		- superseded_by: Map.fetch!(m, "superseded_by"),
	496	+ superseded_by: decode_superseded_by(Map.fetch!(m, "superseded_by")),
481	497	text: Enum.map(m["text"], &Text.from_map/1),
482	498	}
483	499	end

Test case

test/inputs/json/misc/0a91a.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -1573,12 +1573,20 @@ defmodule Payload do
1573	1573	size: integer() | nil
1574	1574	}
1575	1575
	1576	+ def decode_description(value) when is_nil(value), do: value
	1577	+ def decode_description(value) when is_binary(value), do: value
	1578	+ def decode_description(_), do: {:error, "Unexpected type when decoding Payload.description"}
	1579	+
	1580	+ def encode_description(value) when is_nil(value), do: value
	1581	+ def encode_description(value) when is_binary(value), do: value
	1582	+ def encode_description(_), do: {:error, "Unexpected type when encoding Payload.description"}
	1583	+
1576	1584	def from_map(m) do
1577	1585	%Payload{
1578	1586	action: m["action"],
1579	1587	before: m["before"],
1580	1588	commits: m["commits"] && Enum.map(m["commits"], &Commit.from_map/1),
1581		- description: m["description"],
	1589	+ description: m["description"] && decode_description(m["description"]),
1582	1590	distinct_size: m["distinct_size"],
1583	1591	head: m["head"],
1584	1592	master_branch: m["master_branch"],

Test case

test/inputs/json/misc/10be4.json

1 generated file · +18 −2

Melixirdefault / QuickType.ex+18 −2

		@@ -257,10 +257,18 @@ defmodule OtherName do
257	257	def encode_name(value) when is_binary(value), do: value
258	258	def encode_name(_), do: {:error, "Unexpected type when encoding OtherName.name"}
259	259
	260	+ def decode_note(value) when is_nil(value), do: value
	261	+ def decode_note(value) when is_binary(value), do: value
	262	+ def decode_note(_), do: {:error, "Unexpected type when decoding OtherName.note"}
	263	+
	264	+ def encode_note(value) when is_nil(value), do: value
	265	+ def encode_note(value) when is_binary(value), do: value
	266	+ def encode_note(_), do: {:error, "Unexpected type when encoding OtherName.note"}
	267	+
260	268	def from_map(m) do
261	269	%OtherName{
262	270	name: decode_name(m["name"]),
263		- note: Map.fetch!(m, "note"),
	271	+ note: decode_note(Map.fetch!(m, "note")),
264	272	}
265	273	end
266	274
		@@ -474,6 +482,14 @@ defmodule TopLevelElement do
474	482	def encode_other_names(value) when is_list(value), do: value
475	483	def encode_other_names(_), do: {:error, "Unexpected type when encoding TopLevelElement.other_names"}
476	484
	485	+ def decode_superseded_by(value) when is_nil(value), do: value
	486	+ def decode_superseded_by(value) when is_binary(value), do: value
	487	+ def decode_superseded_by(_), do: {:error, "Unexpected type when decoding TopLevelElement.superseded_by"}
	488	+
	489	+ def encode_superseded_by(value) when is_nil(value), do: value
	490	+ def encode_superseded_by(value) when is_binary(value), do: value
	491	+ def encode_superseded_by(_), do: {:error, "Unexpected type when encoding TopLevelElement.superseded_by"}
	492	+
477	493	def decode_text(value) when is_list(value), do: value
478	494	def decode_text(_), do: {:error, "Unexpected type when decoding TopLevelElement.text"}
479	495
		@@ -488,7 +504,7 @@ defmodule TopLevelElement do
488	504	links: Enum.map(m["links"], &Link.from_map/1),
489	505	name: decode_name(m["name"]),
490	506	other_names: Enum.map(m["other_names"], &OtherName.from_map/1),
491		- superseded_by: Map.fetch!(m, "superseded_by"),
	507	+ superseded_by: decode_superseded_by(Map.fetch!(m, "superseded_by")),
492	508	text: Enum.map(m["text"], &Text.from_map/1),
493	509	}
494	510	end

Test case

test/inputs/json/misc/1b409.json

1 generated file · +45 −5

Melixirdefault / QuickType.ex+45 −5

		@@ -80,6 +80,14 @@ defmodule Extra do
80	80	def encode_address(value) when is_binary(value), do: value
81	81	def encode_address(_), do: {:error, "Unexpected type when encoding Extra.address"}
82	82
	83	+ def decode_fax(value) when is_nil(value), do: value
	84	+ def decode_fax(value) when is_binary(value), do: value
	85	+ def decode_fax(_), do: {:error, "Unexpected type when decoding Extra.fax"}
	86	+
	87	+ def encode_fax(value) when is_nil(value), do: value
	88	+ def encode_fax(value) when is_binary(value), do: value
	89	+ def encode_fax(_), do: {:error, "Unexpected type when encoding Extra.fax"}
	90	+
83	91	def decode_office(value) when is_binary(value), do: value
84	92	def decode_office(_), do: {:error, "Unexpected type when decoding Extra.office"}
85	93
		@@ -90,7 +98,7 @@ defmodule Extra do
90	98	%Extra{
91	99	address: decode_address(m["address"]),
92	100	contact_form: m["contact_form"],
93		- fax: m["fax"],
	101	+ fax: m["fax"] && decode_fax(m["fax"]),
94	102	office: decode_office(m["office"]),
95	103	rss_url: m["rss_url"],
96	104	}
		@@ -397,12 +405,36 @@ defmodule Person do
397	405	def encode_osid(value) when is_binary(value), do: value
398	406	def encode_osid(_), do: {:error, "Unexpected type when encoding Person.osid"}
399	407
	408	+ def decode_pvsid(value) when is_nil(value), do: value
	409	+ def decode_pvsid(value) when is_binary(value), do: value
	410	+ def decode_pvsid(_), do: {:error, "Unexpected type when decoding Person.pvsid"}
	411	+
	412	+ def encode_pvsid(value) when is_nil(value), do: value
	413	+ def encode_pvsid(value) when is_binary(value), do: value
	414	+ def encode_pvsid(_), do: {:error, "Unexpected type when encoding Person.pvsid"}
	415	+
400	416	def decode_sortname(value) when is_binary(value), do: value
401	417	def decode_sortname(_), do: {:error, "Unexpected type when decoding Person.sortname"}
402	418
403	419	def encode_sortname(value) when is_binary(value), do: value
404	420	def encode_sortname(_), do: {:error, "Unexpected type when encoding Person.sortname"}
405	421
	422	+ def decode_twitterid(value) when is_nil(value), do: value
	423	+ def decode_twitterid(value) when is_binary(value), do: value
	424	+ def decode_twitterid(_), do: {:error, "Unexpected type when decoding Person.twitterid"}
	425	+
	426	+ def encode_twitterid(value) when is_nil(value), do: value
	427	+ def encode_twitterid(value) when is_binary(value), do: value
	428	+ def encode_twitterid(_), do: {:error, "Unexpected type when encoding Person.twitterid"}
	429	+
	430	+ def decode_youtubeid(value) when is_nil(value), do: value
	431	+ def decode_youtubeid(value) when is_binary(value), do: value
	432	+ def decode_youtubeid(_), do: {:error, "Unexpected type when decoding Person.youtubeid"}
	433	+
	434	+ def encode_youtubeid(value) when is_nil(value), do: value
	435	+ def encode_youtubeid(value) when is_binary(value), do: value
	436	+ def encode_youtubeid(_), do: {:error, "Unexpected type when encoding Person.youtubeid"}
	437	+
406	438	def from_map(m) do
407	439	%Person{
408	440	bioguideid: decode_bioguideid(m["bioguideid"]),
		@@ -419,10 +451,10 @@ defmodule Person do
419	451	namemod: Namemod.decode(m["namemod"]),
420	452	nickname: decode_nickname(m["nickname"]),
421	453	osid: decode_osid(m["osid"]),
422		- pvsid: Map.fetch!(m, "pvsid"),
	454	+ pvsid: decode_pvsid(Map.fetch!(m, "pvsid")),
423	455	sortname: decode_sortname(m["sortname"]),
424		- twitterid: Map.fetch!(m, "twitterid"),
425		- youtubeid: Map.fetch!(m, "youtubeid"),
	456	+ twitterid: decode_twitterid(Map.fetch!(m, "twitterid")),
	457	+ youtubeid: decode_youtubeid(Map.fetch!(m, "youtubeid")),
426	458	}
427	459	end
428	460
		@@ -670,6 +702,14 @@ defmodule Object do
670	702	def encode_id(value) when is_integer(value), do: value
671	703	def encode_id(_), do: {:error, "Unexpected type when encoding Object.id"}
672	704
	705	+ def decode_leadership_title(value) when is_nil(value), do: value
	706	+ def decode_leadership_title(value) when is_binary(value), do: value
	707	+ def decode_leadership_title(_), do: {:error, "Unexpected type when decoding Object.leadership_title"}
	708	+
	709	+ def encode_leadership_title(value) when is_nil(value), do: value
	710	+ def encode_leadership_title(value) when is_binary(value), do: value
	711	+ def encode_leadership_title(_), do: {:error, "Unexpected type when encoding Object.leadership_title"}
	712	+
673	713	def decode_phone(value) when is_binary(value), do: value
674	714	def decode_phone(_), do: {:error, "Unexpected type when decoding Object.phone"}
675	715
		@@ -716,7 +756,7 @@ defmodule Object do
716	756	enddate: decode_enddate(m["enddate"]),
717	757	extra: Extra.from_map(m["extra"]),
718	758	id: decode_id(m["id"]),
719		- leadership_title: Map.fetch!(m, "leadership_title"),
	759	+ leadership_title: decode_leadership_title(Map.fetch!(m, "leadership_title")),
720	760	party: Party.decode(m["party"]),
721	761	person: Person.from_map(m["person"]),
722	762	phone: decode_phone(m["phone"]),

Test case

test/inputs/json/misc/27332.json

1 generated file · +72 −8

Melixirdefault / QuickType.ex+72 −8

		@@ -777,6 +777,22 @@ defmodule ChildData do
777	777	def encode_author(value) when is_binary(value), do: value
778	778	def encode_author(_), do: {:error, "Unexpected type when encoding ChildData.author"}
779	779
	780	+ def decode_author_flair_css_class(value) when is_nil(value), do: value
	781	+ def decode_author_flair_css_class(value) when is_binary(value), do: value
	782	+ def decode_author_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_css_class"}
	783	+
	784	+ def encode_author_flair_css_class(value) when is_nil(value), do: value
	785	+ def encode_author_flair_css_class(value) when is_binary(value), do: value
	786	+ def encode_author_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_css_class"}
	787	+
	788	+ def decode_author_flair_text(value) when is_nil(value), do: value
	789	+ def decode_author_flair_text(value) when is_binary(value), do: value
	790	+ def decode_author_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_text"}
	791	+
	792	+ def encode_author_flair_text(value) when is_nil(value), do: value
	793	+ def encode_author_flair_text(value) when is_binary(value), do: value
	794	+ def encode_author_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_text"}
	795	+
780	796	def decode_banned_at_utc(value) when is_nil(value), do: value
781	797	def decode_banned_at_utc(_), do: {:error, "Unexpected type when decoding ChildData.banned_at_utc"}
782	798
		@@ -835,6 +851,14 @@ defmodule ChildData do
835	851	def encode_created_utc(value) when is_integer(value), do: value
836	852	def encode_created_utc(_), do: {:error, "Unexpected type when encoding ChildData.created_utc"}
837	853
	854	+ def decode_distinguished(value) when is_nil(value), do: value
	855	+ def decode_distinguished(value) when is_binary(value), do: value
	856	+ def decode_distinguished(_), do: {:error, "Unexpected type when decoding ChildData.distinguished"}
	857	+
	858	+ def encode_distinguished(value) when is_nil(value), do: value
	859	+ def encode_distinguished(value) when is_binary(value), do: value
	860	+ def encode_distinguished(_), do: {:error, "Unexpected type when encoding ChildData.distinguished"}
	861	+
838	862	def decode_downs(value) when is_integer(value), do: value
839	863	def decode_downs(_), do: {:error, "Unexpected type when decoding ChildData.downs"}
840	864
		@@ -889,6 +913,22 @@ defmodule ChildData do
889	913	def encode_likes(value) when is_nil(value), do: value
890	914	def encode_likes(_), do: {:error, "Unexpected type when encoding ChildData.likes"}
891	915
	916	+ def decode_link_flair_css_class(value) when is_nil(value), do: value
	917	+ def decode_link_flair_css_class(value) when is_binary(value), do: value
	918	+ def decode_link_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_css_class"}
	919	+
	920	+ def encode_link_flair_css_class(value) when is_nil(value), do: value
	921	+ def encode_link_flair_css_class(value) when is_binary(value), do: value
	922	+ def encode_link_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_css_class"}
	923	+
	924	+ def decode_link_flair_text(value) when is_nil(value), do: value
	925	+ def decode_link_flair_text(value) when is_binary(value), do: value
	926	+ def decode_link_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_text"}
	927	+
	928	+ def encode_link_flair_text(value) when is_nil(value), do: value
	929	+ def encode_link_flair_text(value) when is_binary(value), do: value
	930	+ def encode_link_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_text"}
	931	+
892	932	def decode_locked(value) when is_boolean(value), do: value
893	933	def decode_locked(_), do: {:error, "Unexpected type when decoding ChildData.locked"}
894	934
		@@ -967,6 +1007,14 @@ defmodule ChildData do
967	1007	def encode_selftext(value) when is_binary(value), do: value
968	1008	def encode_selftext(_), do: {:error, "Unexpected type when encoding ChildData.selftext"}
969	1009
	1010	+ def decode_selftext_html(value) when is_nil(value), do: value
	1011	+ def decode_selftext_html(value) when is_binary(value), do: value
	1012	+ def decode_selftext_html(_), do: {:error, "Unexpected type when decoding ChildData.selftext_html"}
	1013	+
	1014	+ def encode_selftext_html(value) when is_nil(value), do: value
	1015	+ def encode_selftext_html(value) when is_binary(value), do: value
	1016	+ def encode_selftext_html(_), do: {:error, "Unexpected type when encoding ChildData.selftext_html"}
	1017	+
970	1018	def decode_spoiler(value) when is_boolean(value), do: value
971	1019	def decode_spoiler(_), do: {:error, "Unexpected type when decoding ChildData.spoiler"}
972	1020
		@@ -991,6 +1039,22 @@ defmodule ChildData do
991	1039	def encode_thumbnail(value) when is_binary(value), do: value
992	1040	def encode_thumbnail(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail"}
993	1041
	1042	+ def decode_thumbnail_height(value) when is_integer(value), do: value
	1043	+ def decode_thumbnail_height(value) when is_nil(value), do: value
	1044	+ def decode_thumbnail_height(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_height"}
	1045	+
	1046	+ def encode_thumbnail_height(value) when is_integer(value), do: value
	1047	+ def encode_thumbnail_height(value) when is_nil(value), do: value
	1048	+ def encode_thumbnail_height(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_height"}
	1049	+
	1050	+ def decode_thumbnail_width(value) when is_integer(value), do: value
	1051	+ def decode_thumbnail_width(value) when is_nil(value), do: value
	1052	+ def decode_thumbnail_width(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_width"}
	1053	+
	1054	+ def encode_thumbnail_width(value) when is_integer(value), do: value
	1055	+ def encode_thumbnail_width(value) when is_nil(value), do: value
	1056	+ def encode_thumbnail_width(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_width"}
	1057	+
994	1058	def decode_title(value) when is_binary(value), do: value
995	1059	def decode_title(_), do: {:error, "Unexpected type when decoding ChildData.title"}
996	1060
		@@ -1033,8 +1097,8 @@ defmodule ChildData do
1033	1097	approved_by: decode_approved_by(m["approved_by"]),
1034	1098	archived: decode_archived(m["archived"]),
1035	1099	author: decode_author(m["author"]),
1036		- author_flair_css_class: Map.fetch!(m, "author_flair_css_class"),
1037		- author_flair_text: Map.fetch!(m, "author_flair_text"),
	1100	+ author_flair_css_class: decode_author_flair_css_class(Map.fetch!(m, "author_flair_css_class")),
	1101	+ author_flair_text: decode_author_flair_text(Map.fetch!(m, "author_flair_text")),
1038	1102	banned_at_utc: decode_banned_at_utc(m["banned_at_utc"]),
1039	1103	banned_by: decode_banned_by(m["banned_by"]),
1040	1104	brand_safe: decode_brand_safe(m["brand_safe"]),
		@@ -1044,7 +1108,7 @@ defmodule ChildData do
1044	1108	contest_mode: decode_contest_mode(m["contest_mode"]),
1045	1109	created: decode_created(m["created"]),
1046	1110	created_utc: decode_created_utc(m["created_utc"]),
1047		- distinguished: Map.fetch!(m, "distinguished"),
	1111	+ distinguished: decode_distinguished(Map.fetch!(m, "distinguished")),
1048	1112	domain: Domain.decode(m["domain"]),
1049	1113	downs: decode_downs(m["downs"]),
1050	1114	edited: decode_edited(m["edited"]),
		@@ -1055,8 +1119,8 @@ defmodule ChildData do
1055	1119	is_self: decode_is_self(m["is_self"]),
1056	1120	is_video: decode_is_video(m["is_video"]),
1057	1121	likes: decode_likes(m["likes"]),
1058		- link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
1059		- link_flair_text: Map.fetch!(m, "link_flair_text"),
	1122	+ link_flair_css_class: decode_link_flair_css_class(Map.fetch!(m, "link_flair_css_class")),
	1123	+ link_flair_text: decode_link_flair_text(Map.fetch!(m, "link_flair_text")),
1060	1124	locked: decode_locked(m["locked"]),
1061	1125	media: m["media"] && Media.from_map(m["media"]),
1062	1126	media_embed: MediaEmbed.from_map(m["media_embed"]),
		@@ -1076,7 +1140,7 @@ defmodule ChildData do
1076	1140	secure_media: m["secure_media"] && Media.from_map(m["secure_media"]),
1077	1141	secure_media_embed: MediaEmbed.from_map(m["secure_media_embed"]),
1078	1142	selftext: decode_selftext(m["selftext"]),
1079		- selftext_html: Map.fetch!(m, "selftext_html"),
	1143	+ selftext_html: decode_selftext_html(Map.fetch!(m, "selftext_html")),
1080	1144	spoiler: decode_spoiler(m["spoiler"]),
1081	1145	stickied: decode_stickied(m["stickied"]),
1082	1146	subreddit: Subreddit.decode(m["subreddit"]),
		@@ -1085,8 +1149,8 @@ defmodule ChildData do
1085	1149	subreddit_type: SubredditType.decode(m["subreddit_type"]),
1086	1150	suggested_sort: decode_suggested_sort(m["suggested_sort"]),
1087	1151	thumbnail: decode_thumbnail(m["thumbnail"]),
1088		- thumbnail_height: Map.fetch!(m, "thumbnail_height"),
1089		- thumbnail_width: Map.fetch!(m, "thumbnail_width"),
	1152	+ thumbnail_height: decode_thumbnail_height(Map.fetch!(m, "thumbnail_height")),
	1153	+ thumbnail_width: decode_thumbnail_width(Map.fetch!(m, "thumbnail_width")),
1090	1154	title: decode_title(m["title"]),
1091	1155	ups: decode_ups(m["ups"]),
1092	1156	url: decode_url(m["url"]),

Test case

test/inputs/json/misc/29f47.json

1 generated file · +47 −5

Melixirdefault / QuickType.ex+47 −5

		@@ -758,6 +758,16 @@ defmodule ChildData do
758	758	def encode_downs(value) when is_integer(value), do: value
759	759	def encode_downs(_), do: {:error, "Unexpected type when encoding ChildData.downs"}
760	760
	761	+ def decode_edited(value) when is_boolean(value), do: value
	762	+ def decode_edited(value) when is_float(value), do: value
	763	+ def decode_edited(value) when is_integer(value), do: value
	764	+ def decode_edited(_), do: {:error, "Unexpected type when decoding ChildData.edited"}
	765	+
	766	+ def encode_edited(value) when is_boolean(value), do: value
	767	+ def encode_edited(value) when is_float(value), do: value
	768	+ def encode_edited(value) when is_integer(value), do: value
	769	+ def encode_edited(_), do: {:error, "Unexpected type when encoding ChildData.edited"}
	770	+
761	771	def decode_gilded(value) when is_integer(value), do: value
762	772	def decode_gilded(_), do: {:error, "Unexpected type when decoding ChildData.gilded"}
763	773
		@@ -902,6 +912,14 @@ defmodule ChildData do
902	912	def encode_selftext(value) when is_binary(value), do: value
903	913	def encode_selftext(_), do: {:error, "Unexpected type when encoding ChildData.selftext"}
904	914
	915	+ def decode_selftext_html(value) when is_nil(value), do: value
	916	+ def decode_selftext_html(value) when is_binary(value), do: value
	917	+ def decode_selftext_html(_), do: {:error, "Unexpected type when decoding ChildData.selftext_html"}
	918	+
	919	+ def encode_selftext_html(value) when is_nil(value), do: value
	920	+ def encode_selftext_html(value) when is_binary(value), do: value
	921	+ def encode_selftext_html(_), do: {:error, "Unexpected type when encoding ChildData.selftext_html"}
	922	+
905	923	def decode_spoiler(value) when is_boolean(value), do: value
906	924	def decode_spoiler(_), do: {:error, "Unexpected type when decoding ChildData.spoiler"}
907	925
		@@ -914,12 +932,36 @@ defmodule ChildData do
914	932	def encode_stickied(value) when is_boolean(value), do: value
915	933	def encode_stickied(_), do: {:error, "Unexpected type when encoding ChildData.stickied"}
916	934
	935	+ def decode_suggested_sort(value) when is_nil(value), do: value
	936	+ def decode_suggested_sort(value) when is_binary(value), do: value
	937	+ def decode_suggested_sort(_), do: {:error, "Unexpected type when decoding ChildData.suggested_sort"}
	938	+
	939	+ def encode_suggested_sort(value) when is_nil(value), do: value
	940	+ def encode_suggested_sort(value) when is_binary(value), do: value
	941	+ def encode_suggested_sort(_), do: {:error, "Unexpected type when encoding ChildData.suggested_sort"}
	942	+
917	943	def decode_thumbnail(value) when is_binary(value), do: value
918	944	def decode_thumbnail(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail"}
919	945
920	946	def encode_thumbnail(value) when is_binary(value), do: value
921	947	def encode_thumbnail(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail"}
922	948
	949	+ def decode_thumbnail_height(value) when is_integer(value), do: value
	950	+ def decode_thumbnail_height(value) when is_nil(value), do: value
	951	+ def decode_thumbnail_height(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_height"}
	952	+
	953	+ def encode_thumbnail_height(value) when is_integer(value), do: value
	954	+ def encode_thumbnail_height(value) when is_nil(value), do: value
	955	+ def encode_thumbnail_height(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_height"}
	956	+
	957	+ def decode_thumbnail_width(value) when is_integer(value), do: value
	958	+ def decode_thumbnail_width(value) when is_nil(value), do: value
	959	+ def decode_thumbnail_width(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_width"}
	960	+
	961	+ def encode_thumbnail_width(value) when is_integer(value), do: value
	962	+ def encode_thumbnail_width(value) when is_nil(value), do: value
	963	+ def encode_thumbnail_width(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_width"}
	964	+
923	965	def decode_title(value) when is_binary(value), do: value
924	966	def decode_title(_), do: {:error, "Unexpected type when decoding ChildData.title"}
925	967
		@@ -976,7 +1018,7 @@ defmodule ChildData do
976	1018	distinguished: Distinguished.decode(m["distinguished"]),
977	1019	domain: Domain.decode(m["domain"]),
978	1020	downs: decode_downs(m["downs"]),
979		- edited: Map.fetch!(m, "edited"),
	1021	+ edited: decode_edited(Map.fetch!(m, "edited")),
980	1022	gilded: decode_gilded(m["gilded"]),
981	1023	hidden: decode_hidden(m["hidden"]),
982	1024	hide_score: decode_hide_score(m["hide_score"]),
		@@ -1005,17 +1047,17 @@ defmodule ChildData do
1005	1047	secure_media: decode_secure_media(m["secure_media"]),
1006	1048	secure_media_embed: MediaEmbed.from_map(m["secure_media_embed"]),
1007	1049	selftext: decode_selftext(m["selftext"]),
1008		- selftext_html: Map.fetch!(m, "selftext_html"),
	1050	+ selftext_html: decode_selftext_html(Map.fetch!(m, "selftext_html")),
1009	1051	spoiler: decode_spoiler(m["spoiler"]),
1010	1052	stickied: decode_stickied(m["stickied"]),
1011	1053	subreddit: Subreddit.decode(m["subreddit"]),
1012	1054	subreddit_id: SubredditID.decode(m["subreddit_id"]),
1013	1055	subreddit_name_prefixed: SubredditNamePrefixed.decode(m["subreddit_name_prefixed"]),
1014	1056	subreddit_type: SubredditType.decode(m["subreddit_type"]),
1015		- suggested_sort: Map.fetch!(m, "suggested_sort"),
	1057	+ suggested_sort: decode_suggested_sort(Map.fetch!(m, "suggested_sort")),
1016	1058	thumbnail: decode_thumbnail(m["thumbnail"]),
1017		- thumbnail_height: Map.fetch!(m, "thumbnail_height"),
1018		- thumbnail_width: Map.fetch!(m, "thumbnail_width"),
	1059	+ thumbnail_height: decode_thumbnail_height(Map.fetch!(m, "thumbnail_height")),
	1060	+ thumbnail_width: decode_thumbnail_width(Map.fetch!(m, "thumbnail_width")),
1019	1061	title: decode_title(m["title"]),
1020	1062	ups: decode_ups(m["ups"]),
1021	1063	url: decode_url(m["url"]),

Test case

test/inputs/json/misc/2d4e2.json

1 generated file · +27 −3

Melixirdefault / QuickType.ex+27 −3

		@@ -414,6 +414,22 @@ defmodule Person do
414	414	def encode_sortname(value) when is_binary(value), do: value
415	415	def encode_sortname(_), do: {:error, "Unexpected type when encoding Person.sortname"}
416	416
	417	+ def decode_twitterid(value) when is_nil(value), do: value
	418	+ def decode_twitterid(value) when is_binary(value), do: value
	419	+ def decode_twitterid(_), do: {:error, "Unexpected type when decoding Person.twitterid"}
	420	+
	421	+ def encode_twitterid(value) when is_nil(value), do: value
	422	+ def encode_twitterid(value) when is_binary(value), do: value
	423	+ def encode_twitterid(_), do: {:error, "Unexpected type when encoding Person.twitterid"}
	424	+
	425	+ def decode_youtubeid(value) when is_nil(value), do: value
	426	+ def decode_youtubeid(value) when is_binary(value), do: value
	427	+ def decode_youtubeid(_), do: {:error, "Unexpected type when decoding Person.youtubeid"}
	428	+
	429	+ def encode_youtubeid(value) when is_nil(value), do: value
	430	+ def encode_youtubeid(value) when is_binary(value), do: value
	431	+ def encode_youtubeid(_), do: {:error, "Unexpected type when encoding Person.youtubeid"}
	432	+
417	433	def from_map(m) do
418	434	%Person{
419	435	bioguideid: decode_bioguideid(m["bioguideid"]),
		@@ -432,8 +448,8 @@ defmodule Person do
432	448	osid: decode_osid(m["osid"]),
433	449	pvsid: decode_pvsid(m["pvsid"]),
434	450	sortname: decode_sortname(m["sortname"]),
435		- twitterid: Map.fetch!(m, "twitterid"),
436		- youtubeid: Map.fetch!(m, "youtubeid"),
	451	+ twitterid: decode_twitterid(Map.fetch!(m, "twitterid")),
	452	+ youtubeid: decode_youtubeid(Map.fetch!(m, "youtubeid")),
437	453	}
438	454	end
439	455
		@@ -860,6 +876,14 @@ defmodule Object do
860	876	def encode_id(value) when is_integer(value), do: value
861	877	def encode_id(_), do: {:error, "Unexpected type when encoding Object.id"}
862	878
	879	+ def decode_leadership_title(value) when is_nil(value), do: value
	880	+ def decode_leadership_title(value) when is_binary(value), do: value
	881	+ def decode_leadership_title(_), do: {:error, "Unexpected type when decoding Object.leadership_title"}
	882	+
	883	+ def encode_leadership_title(value) when is_nil(value), do: value
	884	+ def encode_leadership_title(value) when is_binary(value), do: value
	885	+ def encode_leadership_title(_), do: {:error, "Unexpected type when encoding Object.leadership_title"}
	886	+
863	887	def decode_phone(value) when is_binary(value), do: value
864	888	def decode_phone(_), do: {:error, "Unexpected type when decoding Object.phone"}
865	889
		@@ -894,7 +918,7 @@ defmodule Object do
894	918	enddate: decode_enddate(m["enddate"]),
895	919	extra: Extra.from_map(m["extra"]),
896	920	id: decode_id(m["id"]),
897		- leadership_title: Map.fetch!(m, "leadership_title"),
	921	+ leadership_title: decode_leadership_title(Map.fetch!(m, "leadership_title")),
898	922	party: Party.decode(m["party"]),
899	923	person: Person.from_map(m["person"]),
900	924	phone: decode_phone(m["phone"]),

Test case

test/inputs/json/misc/32431.json

1 generated file · +29 −3

Melixirdefault / QuickType.ex+29 −3

		@@ -287,12 +287,30 @@ defmodule Properties do
287	287	def encode_detail(value) when is_binary(value), do: value
288	288	def encode_detail(_), do: {:error, "Unexpected type when encoding Properties.detail"}
289	289
	290	+ def decode_dmin(value) when is_float(value), do: value
	291	+ def decode_dmin(value) when is_integer(value), do: value
	292	+ def decode_dmin(value) when is_nil(value), do: value
	293	+ def decode_dmin(_), do: {:error, "Unexpected type when decoding Properties.dmin"}
	294	+
	295	+ def encode_dmin(value) when is_float(value), do: value
	296	+ def encode_dmin(value) when is_integer(value), do: value
	297	+ def encode_dmin(value) when is_nil(value), do: value
	298	+ def encode_dmin(_), do: {:error, "Unexpected type when encoding Properties.dmin"}
	299	+
290	300	def decode_felt(value) when is_nil(value), do: value
291	301	def decode_felt(_), do: {:error, "Unexpected type when decoding Properties.felt"}
292	302
293	303	def encode_felt(value) when is_nil(value), do: value
294	304	def encode_felt(_), do: {:error, "Unexpected type when encoding Properties.felt"}
295	305
	306	+ def decode_gap(value) when is_integer(value), do: value
	307	+ def decode_gap(value) when is_nil(value), do: value
	308	+ def decode_gap(_), do: {:error, "Unexpected type when decoding Properties.gap"}
	309	+
	310	+ def encode_gap(value) when is_integer(value), do: value
	311	+ def encode_gap(value) when is_nil(value), do: value
	312	+ def encode_gap(_), do: {:error, "Unexpected type when encoding Properties.gap"}
	313	+
296	314	def decode_ids(value) when is_binary(value), do: value
297	315	def decode_ids(_), do: {:error, "Unexpected type when decoding Properties.ids"}
298	316
		@@ -319,6 +337,14 @@ defmodule Properties do
319	337	def encode_net(value) when is_binary(value), do: value
320	338	def encode_net(_), do: {:error, "Unexpected type when encoding Properties.net"}
321	339
	340	+ def decode_nst(value) when is_integer(value), do: value
	341	+ def decode_nst(value) when is_nil(value), do: value
	342	+ def decode_nst(_), do: {:error, "Unexpected type when decoding Properties.nst"}
	343	+
	344	+ def encode_nst(value) when is_integer(value), do: value
	345	+ def encode_nst(value) when is_nil(value), do: value
	346	+ def encode_nst(_), do: {:error, "Unexpected type when encoding Properties.nst"}
	347	+
322	348	def decode_place(value) when is_binary(value), do: value
323	349	def decode_place(_), do: {:error, "Unexpected type when decoding Properties.place"}
324	350
		@@ -393,15 +419,15 @@ defmodule Properties do
393	419	cdi: decode_cdi(m["cdi"]),
394	420	code: decode_code(m["code"]),
395	421	detail: decode_detail(m["detail"]),
396		- dmin: Map.fetch!(m, "dmin"),
	422	+ dmin: decode_dmin(Map.fetch!(m, "dmin")),
397	423	felt: decode_felt(m["felt"]),
398		- gap: Map.fetch!(m, "gap"),
	424	+ gap: decode_gap(Map.fetch!(m, "gap")),
399	425	ids: decode_ids(m["ids"]),
400	426	mag: decode_mag(m["mag"]),
401	427	mag_type: MagType.decode(m["magType"]),
402	428	mmi: decode_mmi(m["mmi"]),
403	429	net: decode_net(m["net"]),
404		- nst: Map.fetch!(m, "nst"),
	430	+ nst: decode_nst(Map.fetch!(m, "nst")),
405	431	place: decode_place(m["place"]),
406	432	rms: decode_rms(m["rms"]),
407	433	sig: decode_sig(m["sig"]),

Test case

test/inputs/json/misc/32d5c.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -20,6 +20,14 @@ defmodule TopLevelElement do
20	20	preferred_name: String.t()
21	21	}
22	22
	23	+ def decode_birth_date(value) when is_nil(value), do: value
	24	+ def decode_birth_date(value) when is_binary(value), do: value
	25	+ def decode_birth_date(_), do: {:error, "Unexpected type when decoding TopLevelElement.birth_date"}
	26	+
	27	+ def encode_birth_date(value) when is_nil(value), do: value
	28	+ def encode_birth_date(value) when is_binary(value), do: value
	29	+ def encode_birth_date(_), do: {:error, "Unexpected type when encoding TopLevelElement.birth_date"}
	30	+
23	31	def decode_birth_date_is_protected(value) when is_boolean(value), do: value
24	32	def decode_birth_date_is_protected(_), do: {:error, "Unexpected type when decoding TopLevelElement.birth_date_is_protected"}
25	33
		@@ -64,7 +72,7 @@ defmodule TopLevelElement do
64	72
65	73	def from_map(m) do
66	74	%TopLevelElement{
67		- birth_date: Map.fetch!(m, "BirthDate"),
	75	+ birth_date: decode_birth_date(Map.fetch!(m, "BirthDate")),
68	76	birth_date_is_protected: decode_birth_date_is_protected(m["BirthDateIsProtected"]),
69	77	gender_type_id: decode_gender_type_id(m["GenderTypeID"]),
70	78	notes: decode_notes(m["Notes"]),

Test case

test/inputs/json/misc/337ed.json

1 generated file · +153 −17

Melixirdefault / QuickType.ex+153 −17

		@@ -302,6 +302,30 @@ defmodule Result do
302	302	uri: String.t()
303	303	}
304	304
	305	+ def decode_cost_absolute(value) when is_integer(value), do: value
	306	+ def decode_cost_absolute(value) when is_nil(value), do: value
	307	+ def decode_cost_absolute(_), do: {:error, "Unexpected type when decoding Result.cost_absolute"}
	308	+
	309	+ def encode_cost_absolute(value) when is_integer(value), do: value
	310	+ def encode_cost_absolute(value) when is_nil(value), do: value
	311	+ def encode_cost_absolute(_), do: {:error, "Unexpected type when encoding Result.cost_absolute"}
	312	+
	313	+ def decode_cost_max(value) when is_integer(value), do: value
	314	+ def decode_cost_max(value) when is_nil(value), do: value
	315	+ def decode_cost_max(_), do: {:error, "Unexpected type when decoding Result.cost_max"}
	316	+
	317	+ def encode_cost_max(value) when is_integer(value), do: value
	318	+ def encode_cost_max(value) when is_nil(value), do: value
	319	+ def encode_cost_max(_), do: {:error, "Unexpected type when encoding Result.cost_max"}
	320	+
	321	+ def decode_cost_min(value) when is_integer(value), do: value
	322	+ def decode_cost_min(value) when is_nil(value), do: value
	323	+ def decode_cost_min(_), do: {:error, "Unexpected type when decoding Result.cost_min"}
	324	+
	325	+ def encode_cost_min(value) when is_integer(value), do: value
	326	+ def encode_cost_min(value) when is_nil(value), do: value
	327	+ def encode_cost_min(_), do: {:error, "Unexpected type when encoding Result.cost_min"}
	328	+
305	329	def decode_created_at(value) when is_binary(value), do: value
306	330	def decode_created_at(_), do: {:error, "Unexpected type when decoding Result.created_at"}
307	331
		@@ -338,12 +362,28 @@ defmodule Result do
338	362	def encode_eur_sources_grants(value) when is_integer(value), do: value
339	363	def encode_eur_sources_grants(_), do: {:error, "Unexpected type when encoding Result.eur_sources_grants"}
340	364
	365	+ def decode_eur_sources_grants_src(value) when is_nil(value), do: value
	366	+ def decode_eur_sources_grants_src(value) when is_binary(value), do: value
	367	+ def decode_eur_sources_grants_src(_), do: {:error, "Unexpected type when decoding Result.eur_sources_grants_src"}
	368	+
	369	+ def encode_eur_sources_grants_src(value) when is_nil(value), do: value
	370	+ def encode_eur_sources_grants_src(value) when is_binary(value), do: value
	371	+ def encode_eur_sources_grants_src(_), do: {:error, "Unexpected type when encoding Result.eur_sources_grants_src"}
	372	+
341	373	def decode_eur_sources_procurement(value) when is_integer(value), do: value
342	374	def decode_eur_sources_procurement(_), do: {:error, "Unexpected type when decoding Result.eur_sources_procurement"}
343	375
344	376	def encode_eur_sources_procurement(value) when is_integer(value), do: value
345	377	def encode_eur_sources_procurement(_), do: {:error, "Unexpected type when encoding Result.eur_sources_procurement"}
346	378
	379	+ def decode_eur_sources_procurement_src(value) when is_nil(value), do: value
	380	+ def decode_eur_sources_procurement_src(value) when is_binary(value), do: value
	381	+ def decode_eur_sources_procurement_src(_), do: {:error, "Unexpected type when decoding Result.eur_sources_procurement_src"}
	382	+
	383	+ def encode_eur_sources_procurement_src(value) when is_nil(value), do: value
	384	+ def encode_eur_sources_procurement_src(value) when is_binary(value), do: value
	385	+ def encode_eur_sources_procurement_src(_), do: {:error, "Unexpected type when encoding Result.eur_sources_procurement_src"}
	386	+
347	387	def decode_id(value) when is_binary(value), do: value
348	388	def decode_id(_), do: {:error, "Unexpected type when decoding Result.id"}
349	389
		@@ -356,6 +396,70 @@ defmodule Result do
356	396	def encode_new_organisation(value) when is_nil(value), do: value
357	397	def encode_new_organisation(_), do: {:error, "Unexpected type when encoding Result.new_organisation"}
358	398
	399	+ def decode_no_clients(value) when is_nil(value), do: value
	400	+ def decode_no_clients(value) when is_binary(value), do: value
	401	+ def decode_no_clients(_), do: {:error, "Unexpected type when decoding Result.no_clients"}
	402	+
	403	+ def encode_no_clients(value) when is_nil(value), do: value
	404	+ def encode_no_clients(value) when is_binary(value), do: value
	405	+ def encode_no_clients(_), do: {:error, "Unexpected type when encoding Result.no_clients"}
	406	+
	407	+ def decode_other_financial_information(value) when is_nil(value), do: value
	408	+ def decode_other_financial_information(value) when is_binary(value), do: value
	409	+ def decode_other_financial_information(_), do: {:error, "Unexpected type when decoding Result.other_financial_information"}
	410	+
	411	+ def encode_other_financial_information(value) when is_nil(value), do: value
	412	+ def encode_other_financial_information(value) when is_binary(value), do: value
	413	+ def encode_other_financial_information(_), do: {:error, "Unexpected type when encoding Result.other_financial_information"}
	414	+
	415	+ def decode_other_sources_contributions(value) when is_integer(value), do: value
	416	+ def decode_other_sources_contributions(value) when is_nil(value), do: value
	417	+ def decode_other_sources_contributions(_), do: {:error, "Unexpected type when decoding Result.other_sources_contributions"}
	418	+
	419	+ def encode_other_sources_contributions(value) when is_integer(value), do: value
	420	+ def encode_other_sources_contributions(value) when is_nil(value), do: value
	421	+ def encode_other_sources_contributions(_), do: {:error, "Unexpected type when encoding Result.other_sources_contributions"}
	422	+
	423	+ def decode_other_sources_donation(value) when is_integer(value), do: value
	424	+ def decode_other_sources_donation(value) when is_nil(value), do: value
	425	+ def decode_other_sources_donation(_), do: {:error, "Unexpected type when decoding Result.other_sources_donation"}
	426	+
	427	+ def encode_other_sources_donation(value) when is_integer(value), do: value
	428	+ def encode_other_sources_donation(value) when is_nil(value), do: value
	429	+ def encode_other_sources_donation(_), do: {:error, "Unexpected type when encoding Result.other_sources_donation"}
	430	+
	431	+ def decode_other_sources_total(value) when is_integer(value), do: value
	432	+ def decode_other_sources_total(value) when is_nil(value), do: value
	433	+ def decode_other_sources_total(_), do: {:error, "Unexpected type when decoding Result.other_sources_total"}
	434	+
	435	+ def encode_other_sources_total(value) when is_integer(value), do: value
	436	+ def encode_other_sources_total(value) when is_nil(value), do: value
	437	+ def encode_other_sources_total(_), do: {:error, "Unexpected type when encoding Result.other_sources_total"}
	438	+
	439	+ def decode_public_financing_infranational(value) when is_integer(value), do: value
	440	+ def decode_public_financing_infranational(value) when is_nil(value), do: value
	441	+ def decode_public_financing_infranational(_), do: {:error, "Unexpected type when decoding Result.public_financing_infranational"}
	442	+
	443	+ def encode_public_financing_infranational(value) when is_integer(value), do: value
	444	+ def encode_public_financing_infranational(value) when is_nil(value), do: value
	445	+ def encode_public_financing_infranational(_), do: {:error, "Unexpected type when encoding Result.public_financing_infranational"}
	446	+
	447	+ def decode_public_financing_national(value) when is_integer(value), do: value
	448	+ def decode_public_financing_national(value) when is_nil(value), do: value
	449	+ def decode_public_financing_national(_), do: {:error, "Unexpected type when decoding Result.public_financing_national"}
	450	+
	451	+ def encode_public_financing_national(value) when is_integer(value), do: value
	452	+ def encode_public_financing_national(value) when is_nil(value), do: value
	453	+ def encode_public_financing_national(_), do: {:error, "Unexpected type when encoding Result.public_financing_national"}
	454	+
	455	+ def decode_public_financing_total(value) when is_integer(value), do: value
	456	+ def decode_public_financing_total(value) when is_nil(value), do: value
	457	+ def decode_public_financing_total(_), do: {:error, "Unexpected type when decoding Result.public_financing_total"}
	458	+
	459	+ def encode_public_financing_total(value) when is_integer(value), do: value
	460	+ def encode_public_financing_total(value) when is_nil(value), do: value
	461	+ def encode_public_financing_total(_), do: {:error, "Unexpected type when encoding Result.public_financing_total"}
	462	+
359	463	def decode_representative(value) when is_binary(value), do: value
360	464	def decode_representative(_), do: {:error, "Unexpected type when decoding Result.representative"}
361	465
		@@ -368,6 +472,38 @@ defmodule Result do
368	472	def encode_start_date(value) when is_binary(value), do: value
369	473	def encode_start_date(_), do: {:error, "Unexpected type when encoding Result.start_date"}
370	474
	475	+ def decode_total_budget(value) when is_integer(value), do: value
	476	+ def decode_total_budget(value) when is_nil(value), do: value
	477	+ def decode_total_budget(_), do: {:error, "Unexpected type when decoding Result.total_budget"}
	478	+
	479	+ def encode_total_budget(value) when is_integer(value), do: value
	480	+ def encode_total_budget(value) when is_nil(value), do: value
	481	+ def encode_total_budget(_), do: {:error, "Unexpected type when encoding Result.total_budget"}
	482	+
	483	+ def decode_turnover_absolute(value) when is_integer(value), do: value
	484	+ def decode_turnover_absolute(value) when is_nil(value), do: value
	485	+ def decode_turnover_absolute(_), do: {:error, "Unexpected type when decoding Result.turnover_absolute"}
	486	+
	487	+ def encode_turnover_absolute(value) when is_integer(value), do: value
	488	+ def encode_turnover_absolute(value) when is_nil(value), do: value
	489	+ def encode_turnover_absolute(_), do: {:error, "Unexpected type when encoding Result.turnover_absolute"}
	490	+
	491	+ def decode_turnover_max(value) when is_integer(value), do: value
	492	+ def decode_turnover_max(value) when is_nil(value), do: value
	493	+ def decode_turnover_max(_), do: {:error, "Unexpected type when decoding Result.turnover_max"}
	494	+
	495	+ def encode_turnover_max(value) when is_integer(value), do: value
	496	+ def encode_turnover_max(value) when is_nil(value), do: value
	497	+ def encode_turnover_max(_), do: {:error, "Unexpected type when encoding Result.turnover_max"}
	498	+
	499	+ def decode_turnover_min(value) when is_integer(value), do: value
	500	+ def decode_turnover_min(value) when is_nil(value), do: value
	501	+ def decode_turnover_min(_), do: {:error, "Unexpected type when decoding Result.turnover_min"}
	502	+
	503	+ def encode_turnover_min(value) when is_integer(value), do: value
	504	+ def encode_turnover_min(value) when is_nil(value), do: value
	505	+ def encode_turnover_min(_), do: {:error, "Unexpected type when encoding Result.turnover_min"}
	506	+
371	507	def decode_updated_at(value) when is_binary(value), do: value
372	508	def decode_updated_at(_), do: {:error, "Unexpected type when decoding Result.updated_at"}
373	509
		@@ -382,35 +518,35 @@ defmodule Result do
382	518
383	519	def from_map(m) do
384	520	%Result{
385		- cost_absolute: Map.fetch!(m, "cost_absolute"),
386		- cost_max: Map.fetch!(m, "cost_max"),
387		- cost_min: Map.fetch!(m, "cost_min"),
	521	+ cost_absolute: decode_cost_absolute(Map.fetch!(m, "cost_absolute")),
	522	+ cost_max: decode_cost_max(Map.fetch!(m, "cost_max")),
	523	+ cost_min: decode_cost_min(Map.fetch!(m, "cost_min")),
388	524	created_at: decode_created_at(m["created_at"]),
389	525	custom_incomes: Enum.map(m["customIncomes"], &CustomIncome.from_map/1),
390	526	direct_rep_costs_max: decode_direct_rep_costs_max(m["direct_rep_costs_max"]),
391	527	direct_rep_costs_min: decode_direct_rep_costs_min(m["direct_rep_costs_min"]),
392	528	end_date: decode_end_date(m["end_date"]),
393	529	eur_sources_grants: decode_eur_sources_grants(m["eur_sources_grants"]),
394		- eur_sources_grants_src: Map.fetch!(m, "eur_sources_grants_src"),
	530	+ eur_sources_grants_src: decode_eur_sources_grants_src(Map.fetch!(m, "eur_sources_grants_src")),
395	531	eur_sources_procurement: decode_eur_sources_procurement(m["eur_sources_procurement"]),
396		- eur_sources_procurement_src: Map.fetch!(m, "eur_sources_procurement_src"),
	532	+ eur_sources_procurement_src: decode_eur_sources_procurement_src(Map.fetch!(m, "eur_sources_procurement_src")),
397	533	id: decode_id(m["id"]),
398	534	new_organisation: decode_new_organisation(m["new_organisation"]),
399		- no_clients: Map.fetch!(m, "no_clients"),
400		- other_financial_information: Map.fetch!(m, "other_financial_information"),
401		- other_sources_contributions: Map.fetch!(m, "other_sources_contributions"),
402		- other_sources_donation: Map.fetch!(m, "other_sources_donation"),
403		- other_sources_total: Map.fetch!(m, "other_sources_total"),
404		- public_financing_infranational: Map.fetch!(m, "public_financing_infranational"),
405		- public_financing_national: Map.fetch!(m, "public_financing_national"),
406		- public_financing_total: Map.fetch!(m, "public_financing_total"),
	535	+ no_clients: decode_no_clients(Map.fetch!(m, "no_clients")),
	536	+ other_financial_information: decode_other_financial_information(Map.fetch!(m, "other_financial_information")),
	537	+ other_sources_contributions: decode_other_sources_contributions(Map.fetch!(m, "other_sources_contributions")),
	538	+ other_sources_donation: decode_other_sources_donation(Map.fetch!(m, "other_sources_donation")),
	539	+ other_sources_total: decode_other_sources_total(Map.fetch!(m, "other_sources_total")),
	540	+ public_financing_infranational: decode_public_financing_infranational(Map.fetch!(m, "public_financing_infranational")),
	541	+ public_financing_national: decode_public_financing_national(Map.fetch!(m, "public_financing_national")),
	542	+ public_financing_total: decode_public_financing_total(Map.fetch!(m, "public_financing_total")),
407	543	representative: decode_representative(m["representative"]),
408	544	start_date: decode_start_date(m["start_date"]),
409	545	status: Status.decode(m["status"]),
410		- total_budget: Map.fetch!(m, "total_budget"),
411		- turnover_absolute: Map.fetch!(m, "turnover_absolute"),
412		- turnover_max: Map.fetch!(m, "turnover_max"),
413		- turnover_min: Map.fetch!(m, "turnover_min"),
	546	+ total_budget: decode_total_budget(Map.fetch!(m, "total_budget")),
	547	+ turnover_absolute: decode_turnover_absolute(Map.fetch!(m, "turnover_absolute")),
	548	+ turnover_max: decode_turnover_max(Map.fetch!(m, "turnover_max")),
	549	+ turnover_min: decode_turnover_min(Map.fetch!(m, "turnover_min")),
414	550	type: ResultType.decode(m["type"]),
415	551	updated_at: decode_updated_at(m["updated_at"]),
416	552	uri: decode_uri(m["uri"]),

Test case

test/inputs/json/misc/34702.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -438,6 +438,14 @@ defmodule FeatureProperties do
438	438	def encode_longitude(value) when is_integer(value), do: value
439	439	def encode_longitude(_), do: {:error, "Unexpected type when encoding FeatureProperties.longitude"}
440	440
	441	+ def decode_no(value) when is_nil(value), do: value
	442	+ def decode_no(value) when is_binary(value), do: value
	443	+ def decode_no(_), do: {:error, "Unexpected type when decoding FeatureProperties.no"}
	444	+
	445	+ def encode_no(value) when is_nil(value), do: value
	446	+ def encode_no(value) when is_binary(value), do: value
	447	+ def encode_no(_), do: {:error, "Unexpected type when encoding FeatureProperties.no"}
	448	+
441	449	def decode_phone(value) when is_float(value), do: value
442	450	def decode_phone(value) when is_integer(value), do: value
443	451	def decode_phone(_), do: {:error, "Unexpected type when decoding FeatureProperties.phone"}
		@@ -484,7 +492,7 @@ defmodule FeatureProperties do
484	492	latitude: decode_latitude(m["latitude"]),
485	493	local_govt: decode_local_govt(m["local_govt"]),
486	494	longitude: decode_longitude(m["longitude"]),
487		- no: Map.fetch!(m, "no"),
	495	+ no: decode_no(Map.fetch!(m, "no")),
488	496	phone: decode_phone(m["phone"]),
489	497	postcode: decode_postcode(m["postcode"]),
490	498	psa: decode_psa(m["psa"]),

Test case

test/inputs/json/misc/4d6fb.json

1 generated file · +18 −2

Melixirdefault / QuickType.ex+18 −2

		@@ -1000,6 +1000,22 @@ defmodule ChildData do
1000	1000	def encode_thumbnail(value) when is_binary(value), do: value
1001	1001	def encode_thumbnail(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail"}
1002	1002
	1003	+ def decode_thumbnail_height(value) when is_integer(value), do: value
	1004	+ def decode_thumbnail_height(value) when is_nil(value), do: value
	1005	+ def decode_thumbnail_height(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_height"}
	1006	+
	1007	+ def encode_thumbnail_height(value) when is_integer(value), do: value
	1008	+ def encode_thumbnail_height(value) when is_nil(value), do: value
	1009	+ def encode_thumbnail_height(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_height"}
	1010	+
	1011	+ def decode_thumbnail_width(value) when is_integer(value), do: value
	1012	+ def decode_thumbnail_width(value) when is_nil(value), do: value
	1013	+ def decode_thumbnail_width(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_width"}
	1014	+
	1015	+ def encode_thumbnail_width(value) when is_integer(value), do: value
	1016	+ def encode_thumbnail_width(value) when is_nil(value), do: value
	1017	+ def encode_thumbnail_width(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_width"}
	1018	+
1003	1019	def decode_title(value) when is_binary(value), do: value
1004	1020	def decode_title(_), do: {:error, "Unexpected type when decoding ChildData.title"}
1005	1021
		@@ -1094,8 +1110,8 @@ defmodule ChildData do
1094	1110	subreddit_type: SubredditType.decode(m["subreddit_type"]),
1095	1111	suggested_sort: decode_suggested_sort(m["suggested_sort"]),
1096	1112	thumbnail: decode_thumbnail(m["thumbnail"]),
1097		- thumbnail_height: Map.fetch!(m, "thumbnail_height"),
1098		- thumbnail_width: Map.fetch!(m, "thumbnail_width"),
	1113	+ thumbnail_height: decode_thumbnail_height(Map.fetch!(m, "thumbnail_height")),
	1114	+ thumbnail_width: decode_thumbnail_width(Map.fetch!(m, "thumbnail_width")),
1099	1115	title: decode_title(m["title"]),
1100	1116	ups: decode_ups(m["ups"]),
1101	1117	url: decode_url(m["url"]),

Test case

test/inputs/json/misc/570ec.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -157,10 +157,18 @@ defmodule OtherName do
157	157	def encode_name(value) when is_binary(value), do: value
158	158	def encode_name(_), do: {:error, "Unexpected type when encoding OtherName.name"}
159	159
	160	+ def decode_note(value) when is_nil(value), do: value
	161	+ def decode_note(value) when is_binary(value), do: value
	162	+ def decode_note(_), do: {:error, "Unexpected type when decoding OtherName.note"}
	163	+
	164	+ def encode_note(value) when is_nil(value), do: value
	165	+ def encode_note(value) when is_binary(value), do: value
	166	+ def encode_note(_), do: {:error, "Unexpected type when encoding OtherName.note"}
	167	+
160	168	def from_map(m) do
161	169	%OtherName{
162	170	name: decode_name(m["name"]),
163		- note: Map.fetch!(m, "note"),
	171	+ note: decode_note(Map.fetch!(m, "note")),
164	172	}
165	173	end

Test case

test/inputs/json/misc/66121.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -414,6 +414,14 @@ defmodule TopLevelElement do
414	414	def encode_other_names(value) when is_list(value), do: value
415	415	def encode_other_names(_), do: {:error, "Unexpected type when encoding TopLevelElement.other_names"}
416	416
	417	+ def decode_superseded_by(value) when is_nil(value), do: value
	418	+ def decode_superseded_by(value) when is_binary(value), do: value
	419	+ def decode_superseded_by(_), do: {:error, "Unexpected type when decoding TopLevelElement.superseded_by"}
	420	+
	421	+ def encode_superseded_by(value) when is_nil(value), do: value
	422	+ def encode_superseded_by(value) when is_binary(value), do: value
	423	+ def encode_superseded_by(_), do: {:error, "Unexpected type when encoding TopLevelElement.superseded_by"}
	424	+
417	425	def decode_text(value) when is_list(value), do: value
418	426	def decode_text(_), do: {:error, "Unexpected type when decoding TopLevelElement.text"}
419	427
		@@ -428,7 +436,7 @@ defmodule TopLevelElement do
428	436	links: Enum.map(m["links"], &Link.from_map/1),
429	437	name: decode_name(m["name"]),
430	438	other_names: decode_other_names(m["other_names"]),
431		- superseded_by: Map.fetch!(m, "superseded_by"),
	439	+ superseded_by: decode_superseded_by(Map.fetch!(m, "superseded_by")),
432	440	text: Enum.map(m["text"], &Text.from_map/1),
433	441	}
434	442	end

Test case

test/inputs/json/misc/6de06.json

1 generated file · +72 −8

Melixirdefault / QuickType.ex+72 −8

		@@ -655,6 +655,22 @@ defmodule ChildData do
655	655	def encode_author(value) when is_binary(value), do: value
656	656	def encode_author(_), do: {:error, "Unexpected type when encoding ChildData.author"}
657	657
	658	+ def decode_author_flair_css_class(value) when is_nil(value), do: value
	659	+ def decode_author_flair_css_class(value) when is_binary(value), do: value
	660	+ def decode_author_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_css_class"}
	661	+
	662	+ def encode_author_flair_css_class(value) when is_nil(value), do: value
	663	+ def encode_author_flair_css_class(value) when is_binary(value), do: value
	664	+ def encode_author_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_css_class"}
	665	+
	666	+ def decode_author_flair_text(value) when is_nil(value), do: value
	667	+ def decode_author_flair_text(value) when is_binary(value), do: value
	668	+ def decode_author_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_text"}
	669	+
	670	+ def encode_author_flair_text(value) when is_nil(value), do: value
	671	+ def encode_author_flair_text(value) when is_binary(value), do: value
	672	+ def encode_author_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_text"}
	673	+
658	674	def decode_banned_at_utc(value) when is_nil(value), do: value
659	675	def decode_banned_at_utc(_), do: {:error, "Unexpected type when decoding ChildData.banned_at_utc"}
660	676
		@@ -779,6 +795,22 @@ defmodule ChildData do
779	795	def encode_likes(value) when is_nil(value), do: value
780	796	def encode_likes(_), do: {:error, "Unexpected type when encoding ChildData.likes"}
781	797
	798	+ def decode_link_flair_css_class(value) when is_nil(value), do: value
	799	+ def decode_link_flair_css_class(value) when is_binary(value), do: value
	800	+ def decode_link_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_css_class"}
	801	+
	802	+ def encode_link_flair_css_class(value) when is_nil(value), do: value
	803	+ def encode_link_flair_css_class(value) when is_binary(value), do: value
	804	+ def encode_link_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_css_class"}
	805	+
	806	+ def decode_link_flair_text(value) when is_nil(value), do: value
	807	+ def decode_link_flair_text(value) when is_binary(value), do: value
	808	+ def decode_link_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_text"}
	809	+
	810	+ def encode_link_flair_text(value) when is_nil(value), do: value
	811	+ def encode_link_flair_text(value) when is_binary(value), do: value
	812	+ def encode_link_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_text"}
	813	+
782	814	def decode_locked(value) when is_boolean(value), do: value
783	815	def decode_locked(_), do: {:error, "Unexpected type when decoding ChildData.locked"}
784	816
		@@ -857,6 +889,14 @@ defmodule ChildData do
857	889	def encode_selftext(value) when is_binary(value), do: value
858	890	def encode_selftext(_), do: {:error, "Unexpected type when encoding ChildData.selftext"}
859	891
	892	+ def decode_selftext_html(value) when is_nil(value), do: value
	893	+ def decode_selftext_html(value) when is_binary(value), do: value
	894	+ def decode_selftext_html(_), do: {:error, "Unexpected type when decoding ChildData.selftext_html"}
	895	+
	896	+ def encode_selftext_html(value) when is_nil(value), do: value
	897	+ def encode_selftext_html(value) when is_binary(value), do: value
	898	+ def encode_selftext_html(_), do: {:error, "Unexpected type when encoding ChildData.selftext_html"}
	899	+
860	900	def decode_spoiler(value) when is_boolean(value), do: value
861	901	def decode_spoiler(_), do: {:error, "Unexpected type when decoding ChildData.spoiler"}
862	902
		@@ -887,12 +927,36 @@ defmodule ChildData do
887	927	def encode_subreddit_name_prefixed(value) when is_binary(value), do: value
888	928	def encode_subreddit_name_prefixed(_), do: {:error, "Unexpected type when encoding ChildData.subreddit_name_prefixed"}
889	929
	930	+ def decode_suggested_sort(value) when is_nil(value), do: value
	931	+ def decode_suggested_sort(value) when is_binary(value), do: value
	932	+ def decode_suggested_sort(_), do: {:error, "Unexpected type when decoding ChildData.suggested_sort"}
	933	+
	934	+ def encode_suggested_sort(value) when is_nil(value), do: value
	935	+ def encode_suggested_sort(value) when is_binary(value), do: value
	936	+ def encode_suggested_sort(_), do: {:error, "Unexpected type when encoding ChildData.suggested_sort"}
	937	+
890	938	def decode_thumbnail(value) when is_binary(value), do: value
891	939	def decode_thumbnail(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail"}
892	940
893	941	def encode_thumbnail(value) when is_binary(value), do: value
894	942	def encode_thumbnail(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail"}
895	943
	944	+ def decode_thumbnail_height(value) when is_integer(value), do: value
	945	+ def decode_thumbnail_height(value) when is_nil(value), do: value
	946	+ def decode_thumbnail_height(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_height"}
	947	+
	948	+ def encode_thumbnail_height(value) when is_integer(value), do: value
	949	+ def encode_thumbnail_height(value) when is_nil(value), do: value
	950	+ def encode_thumbnail_height(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_height"}
	951	+
	952	+ def decode_thumbnail_width(value) when is_integer(value), do: value
	953	+ def decode_thumbnail_width(value) when is_nil(value), do: value
	954	+ def decode_thumbnail_width(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_width"}
	955	+
	956	+ def encode_thumbnail_width(value) when is_integer(value), do: value
	957	+ def encode_thumbnail_width(value) when is_nil(value), do: value
	958	+ def encode_thumbnail_width(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_width"}
	959	+
896	960	def decode_title(value) when is_binary(value), do: value
897	961	def decode_title(_), do: {:error, "Unexpected type when decoding ChildData.title"}
898	962
		@@ -935,8 +999,8 @@ defmodule ChildData do
935	999	approved_by: decode_approved_by(m["approved_by"]),
936	1000	archived: decode_archived(m["archived"]),
937	1001	author: decode_author(m["author"]),
938		- author_flair_css_class: Map.fetch!(m, "author_flair_css_class"),
939		- author_flair_text: Map.fetch!(m, "author_flair_text"),
	1002	+ author_flair_css_class: decode_author_flair_css_class(Map.fetch!(m, "author_flair_css_class")),
	1003	+ author_flair_text: decode_author_flair_text(Map.fetch!(m, "author_flair_text")),
940	1004	banned_at_utc: decode_banned_at_utc(m["banned_at_utc"]),
941	1005	banned_by: decode_banned_by(m["banned_by"]),
942	1006	brand_safe: decode_brand_safe(m["brand_safe"]),
		@@ -957,8 +1021,8 @@ defmodule ChildData do
957	1021	is_self: decode_is_self(m["is_self"]),
958	1022	is_video: decode_is_video(m["is_video"]),
959	1023	likes: decode_likes(m["likes"]),
960		- link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
961		- link_flair_text: Map.fetch!(m, "link_flair_text"),
	1024	+ link_flair_css_class: decode_link_flair_css_class(Map.fetch!(m, "link_flair_css_class")),
	1025	+ link_flair_text: decode_link_flair_text(Map.fetch!(m, "link_flair_text")),
962	1026	locked: decode_locked(m["locked"]),
963	1027	media: m["media"] && Media.from_map(m["media"]),
964	1028	media_embed: MediaEmbed.from_map(m["media_embed"]),
		@@ -978,17 +1042,17 @@ defmodule ChildData do
978	1042	secure_media: m["secure_media"] && Media.from_map(m["secure_media"]),
979	1043	secure_media_embed: MediaEmbed.from_map(m["secure_media_embed"]),
980	1044	selftext: decode_selftext(m["selftext"]),
981		- selftext_html: Map.fetch!(m, "selftext_html"),
	1045	+ selftext_html: decode_selftext_html(Map.fetch!(m, "selftext_html")),
982	1046	spoiler: decode_spoiler(m["spoiler"]),
983	1047	stickied: decode_stickied(m["stickied"]),
984	1048	subreddit: decode_subreddit(m["subreddit"]),
985	1049	subreddit_id: decode_subreddit_id(m["subreddit_id"]),
986	1050	subreddit_name_prefixed: decode_subreddit_name_prefixed(m["subreddit_name_prefixed"]),
987	1051	subreddit_type: SubredditType.decode(m["subreddit_type"]),
988		- suggested_sort: Map.fetch!(m, "suggested_sort"),
	1052	+ suggested_sort: decode_suggested_sort(Map.fetch!(m, "suggested_sort")),
989	1053	thumbnail: decode_thumbnail(m["thumbnail"]),
990		- thumbnail_height: Map.fetch!(m, "thumbnail_height"),
991		- thumbnail_width: Map.fetch!(m, "thumbnail_width"),
	1054	+ thumbnail_height: decode_thumbnail_height(Map.fetch!(m, "thumbnail_height")),
	1055	+ thumbnail_width: decode_thumbnail_width(Map.fetch!(m, "thumbnail_width")),
992	1056	title: decode_title(m["title"]),
993	1057	ups: decode_ups(m["ups"]),
994	1058	url: decode_url(m["url"]),

Test case

test/inputs/json/misc/734ad.json

1 generated file · +170 −18

Melixirdefault / QuickType.ex+170 −18

		@@ -145,6 +145,14 @@ defmodule Result do
145	145	web_site_url: nil | String.t()
146	146	}
147	147
	148	+ def decode_acronym(value) when is_nil(value), do: value
	149	+ def decode_acronym(value) when is_binary(value), do: value
	150	+ def decode_acronym(_), do: {:error, "Unexpected type when decoding Result.acronym"}
	151	+
	152	+ def encode_acronym(value) when is_nil(value), do: value
	153	+ def encode_acronym(value) when is_binary(value), do: value
	154	+ def encode_acronym(_), do: {:error, "Unexpected type when encoding Result.acronym"}
	155	+
148	156	def decode_activity_consult_committees(value) when is_binary(value), do: value
149	157	def decode_activity_consult_committees(_), do: {:error, "Unexpected type when decoding Result.activity_consult_committees"}
150	158
		@@ -181,12 +189,56 @@ defmodule Result do
181	189	def encode_activity_inter_groups(value) when is_binary(value), do: value
182	190	def encode_activity_inter_groups(_), do: {:error, "Unexpected type when encoding Result.activity_inter_groups"}
183	191
	192	+ def decode_activity_other(value) when is_nil(value), do: value
	193	+ def decode_activity_other(value) when is_binary(value), do: value
	194	+ def decode_activity_other(_), do: {:error, "Unexpected type when decoding Result.activity_other"}
	195	+
	196	+ def encode_activity_other(value) when is_nil(value), do: value
	197	+ def encode_activity_other(value) when is_binary(value), do: value
	198	+ def encode_activity_other(_), do: {:error, "Unexpected type when encoding Result.activity_other"}
	199	+
184	200	def decode_activity_relevant_comm(value) when is_binary(value), do: value
185	201	def decode_activity_relevant_comm(_), do: {:error, "Unexpected type when decoding Result.activity_relevant_comm"}
186	202
187	203	def encode_activity_relevant_comm(value) when is_binary(value), do: value
188	204	def encode_activity_relevant_comm(_), do: {:error, "Unexpected type when encoding Result.activity_relevant_comm"}
189	205
	206	+ def decode_be_office_lat(value) when is_float(value), do: value
	207	+ def decode_be_office_lat(value) when is_integer(value), do: value
	208	+ def decode_be_office_lat(value) when is_nil(value), do: value
	209	+ def decode_be_office_lat(_), do: {:error, "Unexpected type when decoding Result.be_office_lat"}
	210	+
	211	+ def encode_be_office_lat(value) when is_float(value), do: value
	212	+ def encode_be_office_lat(value) when is_integer(value), do: value
	213	+ def encode_be_office_lat(value) when is_nil(value), do: value
	214	+ def encode_be_office_lat(_), do: {:error, "Unexpected type when encoding Result.be_office_lat"}
	215	+
	216	+ def decode_be_office_lon(value) when is_float(value), do: value
	217	+ def decode_be_office_lon(value) when is_integer(value), do: value
	218	+ def decode_be_office_lon(value) when is_nil(value), do: value
	219	+ def decode_be_office_lon(_), do: {:error, "Unexpected type when decoding Result.be_office_lon"}
	220	+
	221	+ def encode_be_office_lon(value) when is_float(value), do: value
	222	+ def encode_be_office_lon(value) when is_integer(value), do: value
	223	+ def encode_be_office_lon(value) when is_nil(value), do: value
	224	+ def encode_be_office_lon(_), do: {:error, "Unexpected type when encoding Result.be_office_lon"}
	225	+
	226	+ def decode_be_office_post_code(value) when is_nil(value), do: value
	227	+ def decode_be_office_post_code(value) when is_binary(value), do: value
	228	+ def decode_be_office_post_code(_), do: {:error, "Unexpected type when decoding Result.be_office_post_code"}
	229	+
	230	+ def encode_be_office_post_code(value) when is_nil(value), do: value
	231	+ def encode_be_office_post_code(value) when is_binary(value), do: value
	232	+ def encode_be_office_post_code(_), do: {:error, "Unexpected type when encoding Result.be_office_post_code"}
	233	+
	234	+ def decode_be_office_postbox(value) when is_nil(value), do: value
	235	+ def decode_be_office_postbox(value) when is_binary(value), do: value
	236	+ def decode_be_office_postbox(_), do: {:error, "Unexpected type when decoding Result.be_office_postbox"}
	237	+
	238	+ def encode_be_office_postbox(value) when is_nil(value), do: value
	239	+ def encode_be_office_postbox(value) when is_binary(value), do: value
	240	+ def encode_be_office_postbox(_), do: {:error, "Unexpected type when encoding Result.be_office_postbox"}
	241	+
190	242	def decode_code_of_conduct(value) when is_binary(value), do: value
191	243	def decode_code_of_conduct(_), do: {:error, "Unexpected type when decoding Result.code_of_conduct"}
192	244
		@@ -229,12 +281,48 @@ defmodule Result do
229	281	def encode_head_office_country(value) when is_binary(value), do: value
230	282	def encode_head_office_country(_), do: {:error, "Unexpected type when encoding Result.head_office_country"}
231	283
	284	+ def decode_head_office_lat(value) when is_float(value), do: value
	285	+ def decode_head_office_lat(value) when is_integer(value), do: value
	286	+ def decode_head_office_lat(value) when is_nil(value), do: value
	287	+ def decode_head_office_lat(_), do: {:error, "Unexpected type when decoding Result.head_office_lat"}
	288	+
	289	+ def encode_head_office_lat(value) when is_float(value), do: value
	290	+ def encode_head_office_lat(value) when is_integer(value), do: value
	291	+ def encode_head_office_lat(value) when is_nil(value), do: value
	292	+ def encode_head_office_lat(_), do: {:error, "Unexpected type when encoding Result.head_office_lat"}
	293	+
	294	+ def decode_head_office_lon(value) when is_float(value), do: value
	295	+ def decode_head_office_lon(value) when is_integer(value), do: value
	296	+ def decode_head_office_lon(value) when is_nil(value), do: value
	297	+ def decode_head_office_lon(_), do: {:error, "Unexpected type when decoding Result.head_office_lon"}
	298	+
	299	+ def encode_head_office_lon(value) when is_float(value), do: value
	300	+ def encode_head_office_lon(value) when is_integer(value), do: value
	301	+ def encode_head_office_lon(value) when is_nil(value), do: value
	302	+ def encode_head_office_lon(_), do: {:error, "Unexpected type when encoding Result.head_office_lon"}
	303	+
232	304	def decode_head_office_phone(value) when is_binary(value), do: value
233	305	def decode_head_office_phone(_), do: {:error, "Unexpected type when decoding Result.head_office_phone"}
234	306
235	307	def encode_head_office_phone(value) when is_binary(value), do: value
236	308	def encode_head_office_phone(_), do: {:error, "Unexpected type when encoding Result.head_office_phone"}
237	309
	310	+ def decode_head_office_post_code(value) when is_nil(value), do: value
	311	+ def decode_head_office_post_code(value) when is_binary(value), do: value
	312	+ def decode_head_office_post_code(_), do: {:error, "Unexpected type when decoding Result.head_office_post_code"}
	313	+
	314	+ def encode_head_office_post_code(value) when is_nil(value), do: value
	315	+ def encode_head_office_post_code(value) when is_binary(value), do: value
	316	+ def encode_head_office_post_code(_), do: {:error, "Unexpected type when encoding Result.head_office_post_code"}
	317	+
	318	+ def decode_head_office_postbox(value) when is_nil(value), do: value
	319	+ def decode_head_office_postbox(value) when is_binary(value), do: value
	320	+ def decode_head_office_postbox(_), do: {:error, "Unexpected type when decoding Result.head_office_postbox"}
	321	+
	322	+ def encode_head_office_postbox(value) when is_nil(value), do: value
	323	+ def encode_head_office_postbox(value) when is_binary(value), do: value
	324	+ def encode_head_office_postbox(_), do: {:error, "Unexpected type when encoding Result.head_office_postbox"}
	325	+
238	326	def decode_head_office_street(value) when is_binary(value), do: value
239	327	def decode_head_office_street(_), do: {:error, "Unexpected type when decoding Result.head_office_street"}
240	328
		@@ -301,6 +389,38 @@ defmodule Result do
301	389	def encode_members(value) when is_integer(value), do: value
302	390	def encode_members(_), do: {:error, "Unexpected type when encoding Result.members"}
303	391
	392	+ def decode_members_100(value) when is_integer(value), do: value
	393	+ def decode_members_100(value) when is_nil(value), do: value
	394	+ def decode_members_100(_), do: {:error, "Unexpected type when decoding Result.members_100"}
	395	+
	396	+ def encode_members_100(value) when is_integer(value), do: value
	397	+ def encode_members_100(value) when is_nil(value), do: value
	398	+ def encode_members_100(_), do: {:error, "Unexpected type when encoding Result.members_100"}
	399	+
	400	+ def decode_members_25(value) when is_integer(value), do: value
	401	+ def decode_members_25(value) when is_nil(value), do: value
	402	+ def decode_members_25(_), do: {:error, "Unexpected type when decoding Result.members_25"}
	403	+
	404	+ def encode_members_25(value) when is_integer(value), do: value
	405	+ def encode_members_25(value) when is_nil(value), do: value
	406	+ def encode_members_25(_), do: {:error, "Unexpected type when encoding Result.members_25"}
	407	+
	408	+ def decode_members_50(value) when is_integer(value), do: value
	409	+ def decode_members_50(value) when is_nil(value), do: value
	410	+ def decode_members_50(_), do: {:error, "Unexpected type when decoding Result.members_50"}
	411	+
	412	+ def encode_members_50(value) when is_integer(value), do: value
	413	+ def encode_members_50(value) when is_nil(value), do: value
	414	+ def encode_members_50(_), do: {:error, "Unexpected type when encoding Result.members_50"}
	415	+
	416	+ def decode_members_75(value) when is_integer(value), do: value
	417	+ def decode_members_75(value) when is_nil(value), do: value
	418	+ def decode_members_75(_), do: {:error, "Unexpected type when decoding Result.members_75"}
	419	+
	420	+ def encode_members_75(value) when is_integer(value), do: value
	421	+ def encode_members_75(value) when is_nil(value), do: value
	422	+ def encode_members_75(_), do: {:error, "Unexpected type when encoding Result.members_75"}
	423	+
304	424	def decode_members_fte(value) when is_float(value), do: value
305	425	def decode_members_fte(value) when is_integer(value), do: value
306	426	def decode_members_fte(_), do: {:error, "Unexpected type when decoding Result.members_fte"}
		@@ -321,6 +441,30 @@ defmodule Result do
321	441	def encode_native_name(value) when is_nil(value), do: value
322	442	def encode_native_name(_), do: {:error, "Unexpected type when encoding Result.native_name"}
323	443
	444	+ def decode_networking(value) when is_nil(value), do: value
	445	+ def decode_networking(value) when is_binary(value), do: value
	446	+ def decode_networking(_), do: {:error, "Unexpected type when decoding Result.networking"}
	447	+
	448	+ def encode_networking(value) when is_nil(value), do: value
	449	+ def encode_networking(value) when is_binary(value), do: value
	450	+ def encode_networking(_), do: {:error, "Unexpected type when encoding Result.networking"}
	451	+
	452	+ def decode_number_of_natural_persons(value) when is_integer(value), do: value
	453	+ def decode_number_of_natural_persons(value) when is_nil(value), do: value
	454	+ def decode_number_of_natural_persons(_), do: {:error, "Unexpected type when decoding Result.number_of_natural_persons"}
	455	+
	456	+ def encode_number_of_natural_persons(value) when is_integer(value), do: value
	457	+ def encode_number_of_natural_persons(value) when is_nil(value), do: value
	458	+ def encode_number_of_natural_persons(_), do: {:error, "Unexpected type when encoding Result.number_of_natural_persons"}
	459	+
	460	+ def decode_other_code_of_conduct(value) when is_nil(value), do: value
	461	+ def decode_other_code_of_conduct(value) when is_binary(value), do: value
	462	+ def decode_other_code_of_conduct(_), do: {:error, "Unexpected type when decoding Result.other_code_of_conduct"}
	463	+
	464	+ def encode_other_code_of_conduct(value) when is_nil(value), do: value
	465	+ def encode_other_code_of_conduct(value) when is_binary(value), do: value
	466	+ def encode_other_code_of_conduct(_), do: {:error, "Unexpected type when encoding Result.other_code_of_conduct"}
	467	+
324	468	def decode_registration_date(value) when is_binary(value), do: value
325	469	def decode_registration_date(_), do: {:error, "Unexpected type when decoding Result.registration_date"}
326	470
		@@ -357,23 +501,31 @@ defmodule Result do
357	501	def encode_uri(value) when is_binary(value), do: value
358	502	def encode_uri(_), do: {:error, "Unexpected type when encoding Result.uri"}
359	503
	504	+ def decode_web_site_url(value) when is_nil(value), do: value
	505	+ def decode_web_site_url(value) when is_binary(value), do: value
	506	+ def decode_web_site_url(_), do: {:error, "Unexpected type when decoding Result.web_site_url"}
	507	+
	508	+ def encode_web_site_url(value) when is_nil(value), do: value
	509	+ def encode_web_site_url(value) when is_binary(value), do: value
	510	+ def encode_web_site_url(_), do: {:error, "Unexpected type when encoding Result.web_site_url"}
	511	+
360	512	def from_map(m) do
361	513	%Result{
362		- acronym: Map.fetch!(m, "acronym"),
	514	+ acronym: decode_acronym(Map.fetch!(m, "acronym")),
363	515	activity_consult_committees: decode_activity_consult_committees(m["activity_consult_committees"]),
364	516	activity_eu_legislative: decode_activity_eu_legislative(m["activity_eu_legislative"]),
365	517	activity_expert_groups: decode_activity_expert_groups(m["activity_expert_groups"]),
366	518	activity_high_level_groups: decode_activity_high_level_groups(m["activity_high_level_groups"]),
367	519	activity_industry_forums: decode_activity_industry_forums(m["activity_industry_forums"]),
368	520	activity_inter_groups: decode_activity_inter_groups(m["activity_inter_groups"]),
369		- activity_other: Map.fetch!(m, "activity_other"),
	521	+ activity_other: decode_activity_other(Map.fetch!(m, "activity_other")),
370	522	activity_relevant_comm: decode_activity_relevant_comm(m["activity_relevant_comm"]),
371	523	be_office_country: m["be_office_country"],
372		- be_office_lat: m["be_office_lat"],
373		- be_office_lon: m["be_office_lon"],
	524	+ be_office_lat: m["be_office_lat"] && decode_be_office_lat(m["be_office_lat"]),
	525	+ be_office_lon: m["be_office_lon"] && decode_be_office_lon(m["be_office_lon"]),
374	526	be_office_phone: m["be_office_phone"],
375		- be_office_post_code: m["be_office_post_code"],
376		- be_office_postbox: m["be_office_postbox"],
	527	+ be_office_post_code: m["be_office_post_code"] && decode_be_office_post_code(m["be_office_post_code"]),
	528	+ be_office_postbox: m["be_office_postbox"] && decode_be_office_postbox(m["be_office_postbox"]),
377	529	be_office_street: m["be_office_street"],
378	530	be_office_town: m["be_office_town"],
379	531	code_of_conduct: decode_code_of_conduct(m["code_of_conduct"]),
		@@ -383,11 +535,11 @@ defmodule Result do
383	535	goals: decode_goals(m["goals"]),
384	536	head: decode_head(m["head"]),
385	537	head_office_country: decode_head_office_country(m["head_office_country"]),
386		- head_office_lat: Map.fetch!(m, "head_office_lat"),
387		- head_office_lon: Map.fetch!(m, "head_office_lon"),
	538	+ head_office_lat: decode_head_office_lat(Map.fetch!(m, "head_office_lat")),
	539	+ head_office_lon: decode_head_office_lon(Map.fetch!(m, "head_office_lon")),
388	540	head_office_phone: decode_head_office_phone(m["head_office_phone"]),
389		- head_office_post_code: Map.fetch!(m, "head_office_post_code"),
390		- head_office_postbox: Map.fetch!(m, "head_office_postbox"),
	541	+ head_office_post_code: decode_head_office_post_code(Map.fetch!(m, "head_office_post_code")),
	542	+ head_office_postbox: decode_head_office_postbox(Map.fetch!(m, "head_office_postbox")),
391	543	head_office_street: decode_head_office_street(m["head_office_street"]),
392	544	head_office_town: decode_head_office_town(m["head_office_town"]),
393	545	id: decode_id(m["id"]),
		@@ -399,16 +551,16 @@ defmodule Result do
399	551	main_category: decode_main_category(m["main_category"]),
400	552	main_category_title: decode_main_category_title(m["main_category_title"]),
401	553	members: decode_members(m["members"]),
402		- members_100: Map.fetch!(m, "members_100"),
403		- members_25: Map.fetch!(m, "members_25"),
404		- members_50: Map.fetch!(m, "members_50"),
405		- members_75: Map.fetch!(m, "members_75"),
	554	+ members_100: decode_members_100(Map.fetch!(m, "members_100")),
	555	+ members_25: decode_members_25(Map.fetch!(m, "members_25")),
	556	+ members_50: decode_members_50(Map.fetch!(m, "members_50")),
	557	+ members_75: decode_members_75(Map.fetch!(m, "members_75")),
406	558	members_fte: decode_members_fte(m["members_fte"]),
407	559	name: decode_name(m["name"]),
408	560	native_name: decode_native_name(m["native_name"]),
409		- networking: Map.fetch!(m, "networking"),
410		- number_of_natural_persons: Map.fetch!(m, "number_of_natural_persons"),
411		- other_code_of_conduct: Map.fetch!(m, "other_code_of_conduct"),
	561	+ networking: decode_networking(Map.fetch!(m, "networking")),
	562	+ number_of_natural_persons: decode_number_of_natural_persons(Map.fetch!(m, "number_of_natural_persons")),
	563	+ other_code_of_conduct: decode_other_code_of_conduct(Map.fetch!(m, "other_code_of_conduct")),
412	564	registration_date: decode_registration_date(m["registration_date"]),
413	565	status: Status.decode(m["status"]),
414	566	structure_members: decode_structure_members(m["structure_members"]),
		@@ -416,7 +568,7 @@ defmodule Result do
416	568	sub_category_title: decode_sub_category_title(m["sub_category_title"]),
417	569	updated_at: decode_updated_at(m["updated_at"]),
418	570	uri: decode_uri(m["uri"]),
419		- web_site_url: Map.fetch!(m, "web_site_url"),
	571	+ web_site_url: decode_web_site_url(Map.fetch!(m, "web_site_url")),
420	572	}
421	573	end

Test case

test/inputs/json/misc/7f568.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -205,6 +205,14 @@ defmodule TopLevelElement do
205	205	def encode_created_at(value) when is_binary(value), do: value
206	206	def encode_created_at(_), do: {:error, "Unexpected type when encoding TopLevelElement.created_at"}
207	207
	208	+ def decode_description(value) when is_nil(value), do: value
	209	+ def decode_description(value) when is_binary(value), do: value
	210	+ def decode_description(_), do: {:error, "Unexpected type when decoding TopLevelElement.description"}
	211	+
	212	+ def encode_description(value) when is_nil(value), do: value
	213	+ def encode_description(value) when is_binary(value), do: value
	214	+ def encode_description(_), do: {:error, "Unexpected type when encoding TopLevelElement.description"}
	215	+
208	216	def decode_forks_url(value) when is_binary(value), do: value
209	217	def decode_forks_url(_), do: {:error, "Unexpected type when decoding TopLevelElement.forks_url"}
210	218
		@@ -271,7 +279,7 @@ defmodule TopLevelElement do
271	279	comments_url: decode_comments_url(m["comments_url"]),
272	280	commits_url: decode_commits_url(m["commits_url"]),
273	281	created_at: decode_created_at(m["created_at"]),
274		- description: Map.fetch!(m, "description"),
	282	+ description: decode_description(Map.fetch!(m, "description")),
275	283	files: m["files"]
276	284	|> Map.new(fn {key, value} -> {key, FileValue.from_map(value)} end),
277	285	forks_url: decode_forks_url(m["forks_url"]),

Test case

test/inputs/json/misc/80aff.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -72,6 +72,14 @@ defmodule Result do
72	72	def encode_name(value) when is_binary(value), do: value
73	73	def encode_name(_), do: {:error, "Unexpected type when encoding Result.name"}
74	74
	75	+ def decode_parent(value) when is_integer(value), do: value
	76	+ def decode_parent(value) when is_nil(value), do: value
	77	+ def decode_parent(_), do: {:error, "Unexpected type when decoding Result.parent"}
	78	+
	79	+ def encode_parent(value) when is_integer(value), do: value
	80	+ def encode_parent(value) when is_nil(value), do: value
	81	+ def encode_parent(_), do: {:error, "Unexpected type when encoding Result.parent"}
	82	+
75	83	def decode_updated_at(value) when is_binary(value), do: value
76	84	def decode_updated_at(_), do: {:error, "Unexpected type when decoding Result.updated_at"}
77	85
		@@ -90,7 +98,7 @@ defmodule Result do
90	98	id: decode_id(m["id"]),
91	99	items: decode_items(m["items"]),
92	100	name: decode_name(m["name"]),
93		- parent: Map.fetch!(m, "parent"),
	101	+ parent: decode_parent(Map.fetch!(m, "parent")),
94	102	updated_at: decode_updated_at(m["updated_at"]),
95	103	uri: decode_uri(m["uri"]),
96	104	}

Test case

test/inputs/json/misc/8592b.json

1 generated file · +45 −5

Melixirdefault / QuickType.ex+45 −5

		@@ -559,6 +559,22 @@ defmodule ChildData do
559	559	def encode_author(value) when is_binary(value), do: value
560	560	def encode_author(_), do: {:error, "Unexpected type when encoding ChildData.author"}
561	561
	562	+ def decode_author_flair_css_class(value) when is_nil(value), do: value
	563	+ def decode_author_flair_css_class(value) when is_binary(value), do: value
	564	+ def decode_author_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_css_class"}
	565	+
	566	+ def encode_author_flair_css_class(value) when is_nil(value), do: value
	567	+ def encode_author_flair_css_class(value) when is_binary(value), do: value
	568	+ def encode_author_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_css_class"}
	569	+
	570	+ def decode_author_flair_text(value) when is_nil(value), do: value
	571	+ def decode_author_flair_text(value) when is_binary(value), do: value
	572	+ def decode_author_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_text"}
	573	+
	574	+ def encode_author_flair_text(value) when is_nil(value), do: value
	575	+ def encode_author_flair_text(value) when is_binary(value), do: value
	576	+ def encode_author_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_text"}
	577	+
562	578	def decode_banned_at_utc(value) when is_nil(value), do: value
563	579	def decode_banned_at_utc(_), do: {:error, "Unexpected type when decoding ChildData.banned_at_utc"}
564	580
		@@ -785,6 +801,14 @@ defmodule ChildData do
785	801	def encode_selftext(value) when is_binary(value), do: value
786	802	def encode_selftext(_), do: {:error, "Unexpected type when encoding ChildData.selftext"}
787	803
	804	+ def decode_selftext_html(value) when is_nil(value), do: value
	805	+ def decode_selftext_html(value) when is_binary(value), do: value
	806	+ def decode_selftext_html(_), do: {:error, "Unexpected type when decoding ChildData.selftext_html"}
	807	+
	808	+ def encode_selftext_html(value) when is_nil(value), do: value
	809	+ def encode_selftext_html(value) when is_binary(value), do: value
	810	+ def encode_selftext_html(_), do: {:error, "Unexpected type when encoding ChildData.selftext_html"}
	811	+
788	812	def decode_spoiler(value) when is_boolean(value), do: value
789	813	def decode_spoiler(_), do: {:error, "Unexpected type when decoding ChildData.spoiler"}
790	814
		@@ -803,6 +827,22 @@ defmodule ChildData do
803	827	def encode_thumbnail(value) when is_binary(value), do: value
804	828	def encode_thumbnail(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail"}
805	829
	830	+ def decode_thumbnail_height(value) when is_integer(value), do: value
	831	+ def decode_thumbnail_height(value) when is_nil(value), do: value
	832	+ def decode_thumbnail_height(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_height"}
	833	+
	834	+ def encode_thumbnail_height(value) when is_integer(value), do: value
	835	+ def encode_thumbnail_height(value) when is_nil(value), do: value
	836	+ def encode_thumbnail_height(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_height"}
	837	+
	838	+ def decode_thumbnail_width(value) when is_integer(value), do: value
	839	+ def decode_thumbnail_width(value) when is_nil(value), do: value
	840	+ def decode_thumbnail_width(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_width"}
	841	+
	842	+ def encode_thumbnail_width(value) when is_integer(value), do: value
	843	+ def encode_thumbnail_width(value) when is_nil(value), do: value
	844	+ def encode_thumbnail_width(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_width"}
	845	+
806	846	def decode_title(value) when is_binary(value), do: value
807	847	def decode_title(_), do: {:error, "Unexpected type when decoding ChildData.title"}
808	848
		@@ -845,8 +885,8 @@ defmodule ChildData do
845	885	approved_by: decode_approved_by(m["approved_by"]),
846	886	archived: decode_archived(m["archived"]),
847	887	author: decode_author(m["author"]),
848		- author_flair_css_class: Map.fetch!(m, "author_flair_css_class"),
849		- author_flair_text: Map.fetch!(m, "author_flair_text"),
	888	+ author_flair_css_class: decode_author_flair_css_class(Map.fetch!(m, "author_flair_css_class")),
	889	+ author_flair_text: decode_author_flair_text(Map.fetch!(m, "author_flair_text")),
850	890	banned_at_utc: decode_banned_at_utc(m["banned_at_utc"]),
851	891	banned_by: decode_banned_by(m["banned_by"]),
852	892	brand_safe: decode_brand_safe(m["brand_safe"]),
		@@ -888,7 +928,7 @@ defmodule ChildData do
888	928	secure_media: decode_secure_media(m["secure_media"]),
889	929	secure_media_embed: MediaEmbed.from_map(m["secure_media_embed"]),
890	930	selftext: decode_selftext(m["selftext"]),
891		- selftext_html: Map.fetch!(m, "selftext_html"),
	931	+ selftext_html: decode_selftext_html(Map.fetch!(m, "selftext_html")),
892	932	spoiler: decode_spoiler(m["spoiler"]),
893	933	stickied: decode_stickied(m["stickied"]),
894	934	subreddit: Subreddit.decode(m["subreddit"]),
		@@ -897,8 +937,8 @@ defmodule ChildData do
897	937	subreddit_type: SubredditType.decode(m["subreddit_type"]),
898	938	suggested_sort: SuggestedSort.decode(m["suggested_sort"]),
899	939	thumbnail: decode_thumbnail(m["thumbnail"]),
900		- thumbnail_height: Map.fetch!(m, "thumbnail_height"),
901		- thumbnail_width: Map.fetch!(m, "thumbnail_width"),
	940	+ thumbnail_height: decode_thumbnail_height(Map.fetch!(m, "thumbnail_height")),
	941	+ thumbnail_width: decode_thumbnail_width(Map.fetch!(m, "thumbnail_width")),
902	942	title: decode_title(m["title"]),
903	943	ups: decode_ups(m["ups"]),
904	944	url: decode_url(m["url"]),

Test case

test/inputs/json/misc/996bd.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -378,6 +378,14 @@ defmodule TopLevelElement do
378	378	def encode_other_names(value) when is_list(value), do: value
379	379	def encode_other_names(_), do: {:error, "Unexpected type when encoding TopLevelElement.other_names"}
380	380
	381	+ def decode_superseded_by(value) when is_nil(value), do: value
	382	+ def decode_superseded_by(value) when is_binary(value), do: value
	383	+ def decode_superseded_by(_), do: {:error, "Unexpected type when decoding TopLevelElement.superseded_by"}
	384	+
	385	+ def encode_superseded_by(value) when is_nil(value), do: value
	386	+ def encode_superseded_by(value) when is_binary(value), do: value
	387	+ def encode_superseded_by(_), do: {:error, "Unexpected type when encoding TopLevelElement.superseded_by"}
	388	+
381	389	def decode_text(value) when is_list(value), do: value
382	390	def decode_text(_), do: {:error, "Unexpected type when decoding TopLevelElement.text"}
383	391
		@@ -392,7 +400,7 @@ defmodule TopLevelElement do
392	400	links: Enum.map(m["links"], &Link.from_map/1),
393	401	name: decode_name(m["name"]),
394	402	other_names: decode_other_names(m["other_names"]),
395		- superseded_by: Map.fetch!(m, "superseded_by"),
	403	+ superseded_by: decode_superseded_by(Map.fetch!(m, "superseded_by")),
396	404	text: Enum.map(m["text"], &Text.from_map/1),
397	405	}
398	406	end

Test case

test/inputs/json/misc/9ac3b.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -180,6 +180,14 @@ defmodule Result do
180	180	def encode_name(value) when is_binary(value), do: value
181	181	def encode_name(_), do: {:error, "Unexpected type when encoding Result.name"}
182	182
	183	+ def decode_position(value) when is_nil(value), do: value
	184	+ def decode_position(value) when is_binary(value), do: value
	185	+ def decode_position(_), do: {:error, "Unexpected type when decoding Result.position"}
	186	+
	187	+ def encode_position(value) when is_nil(value), do: value
	188	+ def encode_position(value) when is_binary(value), do: value
	189	+ def encode_position(_), do: {:error, "Unexpected type when encoding Result.position"}
	190	+
183	191	def decode_updated_at(value) when is_binary(value), do: value
184	192	def decode_updated_at(_), do: {:error, "Unexpected type when decoding Result.updated_at"}
185	193
		@@ -200,7 +208,7 @@ defmodule Result do
200	208	id: decode_id(m["id"]),
201	209	last_name: decode_last_name(m["last_name"]),
202	210	name: decode_name(m["name"]),
203		- position: Map.fetch!(m, "position"),
	211	+ position: decode_position(Map.fetch!(m, "position")),
204	212	status: Status.decode(m["status"]),
205	213	title: m["title"] && Title.decode(m["title"]),
206	214	updated_at: decode_updated_at(m["updated_at"]),

Test case

test/inputs/json/misc/ad8be.json

1 generated file · +18 −2

Melixirdefault / QuickType.ex+18 −2

		@@ -257,10 +257,18 @@ defmodule OtherName do
257	257	def encode_name(value) when is_binary(value), do: value
258	258	def encode_name(_), do: {:error, "Unexpected type when encoding OtherName.name"}
259	259
	260	+ def decode_note(value) when is_nil(value), do: value
	261	+ def decode_note(value) when is_binary(value), do: value
	262	+ def decode_note(_), do: {:error, "Unexpected type when decoding OtherName.note"}
	263	+
	264	+ def encode_note(value) when is_nil(value), do: value
	265	+ def encode_note(value) when is_binary(value), do: value
	266	+ def encode_note(_), do: {:error, "Unexpected type when encoding OtherName.note"}
	267	+
260	268	def from_map(m) do
261	269	%OtherName{
262	270	name: decode_name(m["name"]),
263		- note: Map.fetch!(m, "note"),
	271	+ note: decode_note(Map.fetch!(m, "note")),
264	272	}
265	273	end
266	274
		@@ -474,6 +482,14 @@ defmodule TopLevelElement do
474	482	def encode_other_names(value) when is_list(value), do: value
475	483	def encode_other_names(_), do: {:error, "Unexpected type when encoding TopLevelElement.other_names"}
476	484
	485	+ def decode_superseded_by(value) when is_nil(value), do: value
	486	+ def decode_superseded_by(value) when is_binary(value), do: value
	487	+ def decode_superseded_by(_), do: {:error, "Unexpected type when decoding TopLevelElement.superseded_by"}
	488	+
	489	+ def encode_superseded_by(value) when is_nil(value), do: value
	490	+ def encode_superseded_by(value) when is_binary(value), do: value
	491	+ def encode_superseded_by(_), do: {:error, "Unexpected type when encoding TopLevelElement.superseded_by"}
	492	+
477	493	def decode_text(value) when is_list(value), do: value
478	494	def decode_text(_), do: {:error, "Unexpected type when decoding TopLevelElement.text"}
479	495
		@@ -488,7 +504,7 @@ defmodule TopLevelElement do
488	504	links: Enum.map(m["links"], &Link.from_map/1),
489	505	name: decode_name(m["name"]),
490	506	other_names: Enum.map(m["other_names"], &OtherName.from_map/1),
491		- superseded_by: Map.fetch!(m, "superseded_by"),
	507	+ superseded_by: decode_superseded_by(Map.fetch!(m, "superseded_by")),
492	508	text: Enum.map(m["text"], &Text.from_map/1),
493	509	}
494	510	end

Test case

test/inputs/json/misc/ae7f0.json

1 generated file · +18 −2

Melixirdefault / QuickType.ex+18 −2

		@@ -480,6 +480,22 @@ defmodule ChildData do
480	480	def encode_likes(value) when is_nil(value), do: value
481	481	def encode_likes(_), do: {:error, "Unexpected type when encoding ChildData.likes"}
482	482
	483	+ def decode_link_flair_css_class(value) when is_nil(value), do: value
	484	+ def decode_link_flair_css_class(value) when is_binary(value), do: value
	485	+ def decode_link_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_css_class"}
	486	+
	487	+ def encode_link_flair_css_class(value) when is_nil(value), do: value
	488	+ def encode_link_flair_css_class(value) when is_binary(value), do: value
	489	+ def encode_link_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_css_class"}
	490	+
	491	+ def decode_link_flair_text(value) when is_nil(value), do: value
	492	+ def decode_link_flair_text(value) when is_binary(value), do: value
	493	+ def decode_link_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_text"}
	494	+
	495	+ def encode_link_flair_text(value) when is_nil(value), do: value
	496	+ def encode_link_flair_text(value) when is_binary(value), do: value
	497	+ def encode_link_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_text"}
	498	+
483	499	def decode_locked(value) when is_boolean(value), do: value
484	500	def decode_locked(_), do: {:error, "Unexpected type when decoding ChildData.locked"}
485	501
		@@ -664,8 +680,8 @@ defmodule ChildData do
664	680	is_self: decode_is_self(m["is_self"]),
665	681	is_video: decode_is_video(m["is_video"]),
666	682	likes: decode_likes(m["likes"]),
667		- link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
668		- link_flair_text: Map.fetch!(m, "link_flair_text"),
	683	+ link_flair_css_class: decode_link_flair_css_class(Map.fetch!(m, "link_flair_css_class")),
	684	+ link_flair_text: decode_link_flair_text(Map.fetch!(m, "link_flair_text")),
669	685	locked: decode_locked(m["locked"]),
670	686	media: decode_media(m["media"]),
671	687	media_embed: MediaEmbed.from_map(m["media_embed"]),

Test case

test/inputs/json/misc/af2d1.json

1 generated file · +72 −8

Melixirdefault / QuickType.ex+72 −8

		@@ -604,12 +604,28 @@ defmodule FeatureProperties do
604	604	def encode_asset_numb(value) when is_binary(value), do: value
605	605	def encode_asset_numb(_), do: {:error, "Unexpected type when encoding FeatureProperties.asset_numb"}
606	606
	607	+ def decode_comments(value) when is_nil(value), do: value
	608	+ def decode_comments(value) when is_binary(value), do: value
	609	+ def decode_comments(_), do: {:error, "Unexpected type when decoding FeatureProperties.comments"}
	610	+
	611	+ def encode_comments(value) when is_nil(value), do: value
	612	+ def encode_comments(value) when is_binary(value), do: value
	613	+ def encode_comments(_), do: {:error, "Unexpected type when encoding FeatureProperties.comments"}
	614	+
607	615	def decode_condition(value) when is_integer(value), do: value
608	616	def decode_condition(_), do: {:error, "Unexpected type when decoding FeatureProperties.condition"}
609	617
610	618	def encode_condition(value) when is_integer(value), do: value
611	619	def encode_condition(_), do: {:error, "Unexpected type when encoding FeatureProperties.condition"}
612	620
	621	+ def decode_constructi(value) when is_nil(value), do: value
	622	+ def decode_constructi(value) when is_binary(value), do: value
	623	+ def decode_constructi(_), do: {:error, "Unexpected type when decoding FeatureProperties.constructi"}
	624	+
	625	+ def encode_constructi(value) when is_nil(value), do: value
	626	+ def encode_constructi(value) when is_binary(value), do: value
	627	+ def encode_constructi(_), do: {:error, "Unexpected type when encoding FeatureProperties.constructi"}
	628	+
613	629	def decode_createdate(value) when is_nil(value), do: value
614	630	def decode_createdate(_), do: {:error, "Unexpected type when decoding FeatureProperties.createdate"}
615	631
		@@ -634,6 +650,30 @@ defmodule FeatureProperties do
634	650	def encode_documents(value) when is_binary(value), do: value
635	651	def encode_documents(_), do: {:error, "Unexpected type when encoding FeatureProperties.documents"}
636	652
	653	+ def decode_drawing_nu(value) when is_nil(value), do: value
	654	+ def decode_drawing_nu(value) when is_binary(value), do: value
	655	+ def decode_drawing_nu(_), do: {:error, "Unexpected type when decoding FeatureProperties.drawing_nu"}
	656	+
	657	+ def encode_drawing_nu(value) when is_nil(value), do: value
	658	+ def encode_drawing_nu(value) when is_binary(value), do: value
	659	+ def encode_drawing_nu(_), do: {:error, "Unexpected type when encoding FeatureProperties.drawing_nu"}
	660	+
	661	+ def decode_file_numbe(value) when is_nil(value), do: value
	662	+ def decode_file_numbe(value) when is_binary(value), do: value
	663	+ def decode_file_numbe(_), do: {:error, "Unexpected type when decoding FeatureProperties.file_numbe"}
	664	+
	665	+ def encode_file_numbe(value) when is_nil(value), do: value
	666	+ def encode_file_numbe(value) when is_binary(value), do: value
	667	+ def encode_file_numbe(_), do: {:error, "Unexpected type when encoding FeatureProperties.file_numbe"}
	668	+
	669	+ def decode_folder_num(value) when is_nil(value), do: value
	670	+ def decode_folder_num(value) when is_binary(value), do: value
	671	+ def decode_folder_num(_), do: {:error, "Unexpected type when decoding FeatureProperties.folder_num"}
	672	+
	673	+ def encode_folder_num(value) when is_nil(value), do: value
	674	+ def encode_folder_num(value) when is_binary(value), do: value
	675	+ def encode_folder_num(_), do: {:error, "Unexpected type when encoding FeatureProperties.folder_num"}
	676	+
637	677	def decode_historic_c(value) when is_integer(value), do: value
638	678	def decode_historic_c(_), do: {:error, "Unexpected type when decoding FeatureProperties.historic_c"}
639	679
		@@ -670,12 +710,36 @@ defmodule FeatureProperties do
670	710	def encode_number_lan(value) when is_integer(value), do: value
671	711	def encode_number_lan(_), do: {:error, "Unexpected type when encoding FeatureProperties.number_lan"}
672	712
	713	+ def decode_owner(value) when is_nil(value), do: value
	714	+ def decode_owner(value) when is_binary(value), do: value
	715	+ def decode_owner(_), do: {:error, "Unexpected type when decoding FeatureProperties.owner"}
	716	+
	717	+ def encode_owner(value) when is_nil(value), do: value
	718	+ def encode_owner(value) when is_binary(value), do: value
	719	+ def encode_owner(_), do: {:error, "Unexpected type when encoding FeatureProperties.owner"}
	720	+
	721	+ def decode_project_nu(value) when is_nil(value), do: value
	722	+ def decode_project_nu(value) when is_binary(value), do: value
	723	+ def decode_project_nu(_), do: {:error, "Unexpected type when decoding FeatureProperties.project_nu"}
	724	+
	725	+ def encode_project_nu(value) when is_nil(value), do: value
	726	+ def encode_project_nu(value) when is_binary(value), do: value
	727	+ def encode_project_nu(_), do: {:error, "Unexpected type when encoding FeatureProperties.project_nu"}
	728	+
673	729	def decode_rec_id(value) when is_integer(value), do: value
674	730	def decode_rec_id(_), do: {:error, "Unexpected type when decoding FeatureProperties.rec_id"}
675	731
676	732	def encode_rec_id(value) when is_integer(value), do: value
677	733	def encode_rec_id(_), do: {:error, "Unexpected type when encoding FeatureProperties.rec_id"}
678	734
	735	+ def decode_record_cre(value) when is_nil(value), do: value
	736	+ def decode_record_cre(value) when is_binary(value), do: value
	737	+ def decode_record_cre(_), do: {:error, "Unexpected type when decoding FeatureProperties.record_cre"}
	738	+
	739	+ def encode_record_cre(value) when is_nil(value), do: value
	740	+ def encode_record_cre(value) when is_binary(value), do: value
	741	+ def encode_record_cre(_), do: {:error, "Unexpected type when encoding FeatureProperties.record_cre"}
	742	+
679	743	def decode_shape_area(value) when is_float(value), do: value
680	744	def decode_shape_area(value) when is_integer(value), do: value
681	745	def decode_shape_area(_), do: {:error, "Unexpected type when decoding FeatureProperties.shape_area"}
		@@ -737,16 +801,16 @@ defmodule FeatureProperties do
737	801	add_improv: m["add_improv"] && AddImprov.decode(m["add_improv"]),
738	802	area: decode_area(m["area_"]),
739	803	asset_numb: decode_asset_numb(m["asset_numb"]),
740		- comments: Map.fetch!(m, "comments"),
	804	+ comments: decode_comments(Map.fetch!(m, "comments")),
741	805	condition: decode_condition(m["condition"]),
742		- constructi: Map.fetch!(m, "constructi"),
	806	+ constructi: decode_constructi(Map.fetch!(m, "constructi")),
743	807	createdate: decode_createdate(m["createdate"]),
744	808	createuser: decode_createuser(m["createuser"]),
745	809	disposal_d: decode_disposal_d(m["disposal_d"]),
746	810	documents: decode_documents(m["documents"]),
747		- drawing_nu: Map.fetch!(m, "drawing_nu"),
748		- file_numbe: Map.fetch!(m, "file_numbe"),
749		- folder_num: Map.fetch!(m, "folder_num"),
	811	+ drawing_nu: decode_drawing_nu(Map.fetch!(m, "drawing_nu")),
	812	+ file_numbe: decode_file_numbe(Map.fetch!(m, "file_numbe")),
	813	+ folder_num: decode_folder_num(Map.fetch!(m, "folder_num")),
750	814	funding_ba: m["funding_ba"] && FundingBa.decode(m["funding_ba"]),
751	815	historic_c: decode_historic_c(m["historic_c"]),
752	816	inspection: decode_inspection(m["inspection"]),
		@@ -757,11 +821,11 @@ defmodule FeatureProperties do
757	821	mi_prinx: decode_mi_prinx(m["mi_prinx"]),
758	822	mi_symbolo: MiSymbolo.decode(m["mi_symbolo"]),
759	823	number_lan: decode_number_lan(m["number_lan"]),
760		- owner: Map.fetch!(m, "owner"),
	824	+ owner: decode_owner(Map.fetch!(m, "owner")),
761	825	positional: m["positional"] && LevelAccu.decode(m["positional"]),
762		- project_nu: Map.fetch!(m, "project_nu"),
	826	+ project_nu: decode_project_nu(Map.fetch!(m, "project_nu")),
763	827	rec_id: decode_rec_id(m["rec_id"]),
764		- record_cre: Map.fetch!(m, "record_cre"),
	828	+ record_cre: decode_record_cre(Map.fetch!(m, "record_cre")),
765	829	shape_area: decode_shape_area(m["shape_area"]),
766	830	shape_leng: decode_shape_leng(m["shape_leng"]),
767	831	status: Status.decode(m["status"]),

Test case

test/inputs/json/misc/be234.json

1 generated file · +18 −2

Melixirdefault / QuickType.ex+18 −2

		@@ -833,6 +833,14 @@ defmodule ChildData do
833	833	def encode_author_flair_css_class(value) when is_nil(value), do: value
834	834	def encode_author_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_css_class"}
835	835
	836	+ def decode_author_flair_text(value) when is_nil(value), do: value
	837	+ def decode_author_flair_text(value) when is_binary(value), do: value
	838	+ def decode_author_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_text"}
	839	+
	840	+ def encode_author_flair_text(value) when is_nil(value), do: value
	841	+ def encode_author_flair_text(value) when is_binary(value), do: value
	842	+ def encode_author_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_text"}
	843	+
836	844	def decode_banned_at_utc(value) when is_nil(value), do: value
837	845	def decode_banned_at_utc(_), do: {:error, "Unexpected type when decoding ChildData.banned_at_utc"}
838	846
		@@ -891,6 +899,14 @@ defmodule ChildData do
891	899	def encode_created_utc(value) when is_integer(value), do: value
892	900	def encode_created_utc(_), do: {:error, "Unexpected type when encoding ChildData.created_utc"}
893	901
	902	+ def decode_distinguished(value) when is_nil(value), do: value
	903	+ def decode_distinguished(value) when is_binary(value), do: value
	904	+ def decode_distinguished(_), do: {:error, "Unexpected type when decoding ChildData.distinguished"}
	905	+
	906	+ def encode_distinguished(value) when is_nil(value), do: value
	907	+ def encode_distinguished(value) when is_binary(value), do: value
	908	+ def encode_distinguished(_), do: {:error, "Unexpected type when encoding ChildData.distinguished"}
	909	+
894	910	def decode_downs(value) when is_integer(value), do: value
895	911	def decode_downs(_), do: {:error, "Unexpected type when decoding ChildData.downs"}
896	912
		@@ -1120,7 +1136,7 @@ defmodule ChildData do
1120	1136	archived: decode_archived(m["archived"]),
1121	1137	author: decode_author(m["author"]),
1122	1138	author_flair_css_class: decode_author_flair_css_class(m["author_flair_css_class"]),
1123		- author_flair_text: Map.fetch!(m, "author_flair_text"),
	1139	+ author_flair_text: decode_author_flair_text(Map.fetch!(m, "author_flair_text")),
1124	1140	banned_at_utc: decode_banned_at_utc(m["banned_at_utc"]),
1125	1141	banned_by: decode_banned_by(m["banned_by"]),
1126	1142	brand_safe: decode_brand_safe(m["brand_safe"]),
		@@ -1130,7 +1146,7 @@ defmodule ChildData do
1130	1146	contest_mode: decode_contest_mode(m["contest_mode"]),
1131	1147	created: decode_created(m["created"]),
1132	1148	created_utc: decode_created_utc(m["created_utc"]),
1133		- distinguished: Map.fetch!(m, "distinguished"),
	1149	+ distinguished: decode_distinguished(Map.fetch!(m, "distinguished")),
1134	1150	domain: Domain.decode(m["domain"]),
1135	1151	downs: decode_downs(m["downs"]),
1136	1152	edited: decode_edited(m["edited"]),

Test case

test/inputs/json/misc/d23d5.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -47,6 +47,14 @@ defmodule Result do
47	47	uri: String.t()
48	48	}
49	49
	50	+ def decode_acronym(value) when is_nil(value), do: value
	51	+ def decode_acronym(value) when is_binary(value), do: value
	52	+ def decode_acronym(_), do: {:error, "Unexpected type when decoding Result.acronym"}
	53	+
	54	+ def encode_acronym(value) when is_nil(value), do: value
	55	+ def encode_acronym(value) when is_binary(value), do: value
	56	+ def encode_acronym(_), do: {:error, "Unexpected type when encoding Result.acronym"}
	57	+
50	58	def decode_created_at(value) when is_binary(value), do: value
51	59	def decode_created_at(_), do: {:error, "Unexpected type when decoding Result.created_at"}
52	60
		@@ -79,7 +87,7 @@ defmodule Result do
79	87
80	88	def from_map(m) do
81	89	%Result{
82		- acronym: Map.fetch!(m, "acronym"),
	90	+ acronym: decode_acronym(Map.fetch!(m, "acronym")),
83	91	created_at: decode_created_at(m["created_at"]),
84	92	id: decode_id(m["id"]),
85	93	name: decode_name(m["name"]),

Test case

test/inputs/json/misc/f22f5.json

1 generated file · +18 −2

Melixirdefault / QuickType.ex+18 −2

		@@ -441,6 +441,22 @@ defmodule ChildData do
441	441	def encode_likes(value) when is_nil(value), do: value
442	442	def encode_likes(_), do: {:error, "Unexpected type when encoding ChildData.likes"}
443	443
	444	+ def decode_link_flair_css_class(value) when is_nil(value), do: value
	445	+ def decode_link_flair_css_class(value) when is_binary(value), do: value
	446	+ def decode_link_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_css_class"}
	447	+
	448	+ def encode_link_flair_css_class(value) when is_nil(value), do: value
	449	+ def encode_link_flair_css_class(value) when is_binary(value), do: value
	450	+ def encode_link_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_css_class"}
	451	+
	452	+ def decode_link_flair_text(value) when is_nil(value), do: value
	453	+ def decode_link_flair_text(value) when is_binary(value), do: value
	454	+ def decode_link_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_text"}
	455	+
	456	+ def encode_link_flair_text(value) when is_nil(value), do: value
	457	+ def encode_link_flair_text(value) when is_binary(value), do: value
	458	+ def encode_link_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_text"}
	459	+
444	460	def decode_locked(value) when is_boolean(value), do: value
445	461	def decode_locked(_), do: {:error, "Unexpected type when decoding ChildData.locked"}
446	462
		@@ -625,8 +641,8 @@ defmodule ChildData do
625	641	is_self: decode_is_self(m["is_self"]),
626	642	is_video: decode_is_video(m["is_video"]),
627	643	likes: decode_likes(m["likes"]),
628		- link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
629		- link_flair_text: Map.fetch!(m, "link_flair_text"),
	644	+ link_flair_css_class: decode_link_flair_css_class(Map.fetch!(m, "link_flair_css_class")),
	645	+ link_flair_text: decode_link_flair_text(Map.fetch!(m, "link_flair_text")),
630	646	locked: decode_locked(m["locked"]),
631	647	media: decode_media(m["media"]),
632	648	media_embed: MediaEmbed.from_map(m["media_embed"]),

Test case

test/inputs/json/priority/bug2590.json

1 generated file · +18 −2

Melixirdefault / QuickType.ex+18 −2

		@@ -15,6 +15,22 @@ defmodule Invoice do
15	15	name: String.t()
16	16	}
17	17
	18	+ def decode_created_at(value) when is_nil(value), do: value
	19	+ def decode_created_at(value) when is_binary(value), do: value
	20	+ def decode_created_at(_), do: {:error, "Unexpected type when decoding Invoice.created_at"}
	21	+
	22	+ def encode_created_at(value) when is_nil(value), do: value
	23	+ def encode_created_at(value) when is_binary(value), do: value
	24	+ def encode_created_at(_), do: {:error, "Unexpected type when encoding Invoice.created_at"}
	25	+
	26	+ def decode_due_date(value) when is_nil(value), do: value
	27	+ def decode_due_date(value) when is_binary(value), do: value
	28	+ def decode_due_date(_), do: {:error, "Unexpected type when decoding Invoice.due_date"}
	29	+
	30	+ def encode_due_date(value) when is_nil(value), do: value
	31	+ def encode_due_date(value) when is_binary(value), do: value
	32	+ def encode_due_date(_), do: {:error, "Unexpected type when encoding Invoice.due_date"}
	33	+
18	34	def decode_name(value) when is_binary(value), do: value
19	35	def decode_name(_), do: {:error, "Unexpected type when decoding Invoice.name"}
20	36
		@@ -23,8 +39,8 @@ defmodule Invoice do
23	39
24	40	def from_map(m) do
25	41	%Invoice{
26		- created_at: Map.fetch!(m, "createdAt"),
27		- due_date: Map.fetch!(m, "dueDate"),
	42	+ created_at: decode_created_at(Map.fetch!(m, "createdAt")),
	43	+ due_date: decode_due_date(Map.fetch!(m, "dueDate")),
28	44	name: decode_name(m["name"]),
29	45	}
30	46	end

Test case

test/inputs/json/priority/nbl-stats.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -1206,6 +1206,14 @@ defmodule Pl do
1206	1206	def encode_s_free_throws_percentage(value) when is_integer(value), do: value
1207	1207	def encode_s_free_throws_percentage(_), do: {:error, "Unexpected type when encoding Pl.s_free_throws_percentage"}
1208	1208
	1209	+ def decode_s_minutes(value) when is_integer(value), do: value
	1210	+ def decode_s_minutes(value) when is_binary(value), do: value
	1211	+ def decode_s_minutes(_), do: {:error, "Unexpected type when decoding Pl.s_minutes"}
	1212	+
	1213	+ def encode_s_minutes(value) when is_integer(value), do: value
	1214	+ def encode_s_minutes(value) when is_binary(value), do: value
	1215	+ def encode_s_minutes(_), do: {:error, "Unexpected type when encoding Pl.s_minutes"}
	1216	+
1209	1217	def decode_s_plus_minus_points(value) when is_integer(value), do: value
1210	1218	def decode_s_plus_minus_points(_), do: {:error, "Unexpected type when decoding Pl.s_plus_minus_points"}
1211	1219
		@@ -1347,7 +1355,7 @@ defmodule Pl do
1347	1355	s_free_throws_attempted: decode_s_free_throws_attempted(m["sFreeThrowsAttempted"]),
1348	1356	s_free_throws_made: decode_s_free_throws_made(m["sFreeThrowsMade"]),
1349	1357	s_free_throws_percentage: decode_s_free_throws_percentage(m["sFreeThrowsPercentage"]),
1350		- s_minutes: Map.fetch!(m, "sMinutes"),
	1358	+ s_minutes: decode_s_minutes(Map.fetch!(m, "sMinutes")),
1351	1359	s_plus_minus_points: decode_s_plus_minus_points(m["sPlusMinusPoints"]),
1352	1360	s_points: decode_s_points(m["sPoints"]),
1353	1361	s_points_fast_break: decode_s_points_fast_break(m["sPointsFastBreak"]),

Test case

test/inputs/json/priority/optional-union.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -12,9 +12,17 @@ defmodule TopLevelElement do
12	12	a: integer() | String.t() | nil
13	13	}
14	14
	15	+ def decode_a(value) when is_integer(value), do: value
	16	+ def decode_a(value) when is_binary(value), do: value
	17	+ def decode_a(_), do: {:error, "Unexpected type when decoding TopLevelElement.a"}
	18	+
	19	+ def encode_a(value) when is_integer(value), do: value
	20	+ def encode_a(value) when is_binary(value), do: value
	21	+ def encode_a(_), do: {:error, "Unexpected type when encoding TopLevelElement.a"}
	22	+
15	23	def from_map(m) do
16	24	%TopLevelElement{
17		- a: m["a"],
	25	+ a: m["a"] && decode_a(m["a"]),
18	26	}
19	27	end

Test case

test/inputs/json/samples/github-events.json

1 generated file · +18 −2

Melixirdefault / QuickType.ex+18 −2

		@@ -640,6 +640,14 @@ defmodule Milestone do
640	640	def encode_description(value) when is_binary(value), do: value
641	641	def encode_description(_), do: {:error, "Unexpected type when encoding Milestone.description"}
642	642
	643	+ def decode_due_on(value) when is_nil(value), do: value
	644	+ def decode_due_on(value) when is_binary(value), do: value
	645	+ def decode_due_on(_), do: {:error, "Unexpected type when decoding Milestone.due_on"}
	646	+
	647	+ def encode_due_on(value) when is_nil(value), do: value
	648	+ def encode_due_on(value) when is_binary(value), do: value
	649	+ def encode_due_on(_), do: {:error, "Unexpected type when encoding Milestone.due_on"}
	650	+
643	651	def decode_html_url(value) when is_binary(value), do: value
644	652	def decode_html_url(_), do: {:error, "Unexpected type when decoding Milestone.html_url"}
645	653
		@@ -701,7 +709,7 @@ defmodule Milestone do
701	709	created_at: decode_created_at(m["created_at"]),
702	710	creator: User.from_map(m["creator"]),
703	711	description: decode_description(m["description"]),
704		- due_on: Map.fetch!(m, "due_on"),
	712	+ due_on: decode_due_on(Map.fetch!(m, "due_on")),
705	713	html_url: decode_html_url(m["html_url"]),
706	714	id: decode_id(m["id"]),
707	715	labels_url: decode_labels_url(m["labels_url"]),
		@@ -860,6 +868,14 @@ defmodule Issue do
860	868	def encode_body(value) when is_binary(value), do: value
861	869	def encode_body(_), do: {:error, "Unexpected type when encoding Issue.body"}
862	870
	871	+ def decode_closed_at(value) when is_nil(value), do: value
	872	+ def decode_closed_at(value) when is_binary(value), do: value
	873	+ def decode_closed_at(_), do: {:error, "Unexpected type when decoding Issue.closed_at"}
	874	+
	875	+ def encode_closed_at(value) when is_nil(value), do: value
	876	+ def encode_closed_at(value) when is_binary(value), do: value
	877	+ def encode_closed_at(_), do: {:error, "Unexpected type when encoding Issue.closed_at"}
	878	+
863	879	def decode_comments(value) when is_integer(value), do: value
864	880	def decode_comments(_), do: {:error, "Unexpected type when decoding Issue.comments"}
865	881
		@@ -955,7 +971,7 @@ defmodule Issue do
955	971	assignee: decode_assignee(m["assignee"]),
956	972	assignees: decode_assignees(m["assignees"]),
957	973	body: decode_body(m["body"]),
958		- closed_at: Map.fetch!(m, "closed_at"),
	974	+ closed_at: decode_closed_at(Map.fetch!(m, "closed_at")),
959	975	comments: decode_comments(m["comments"]),
960	976	comments_url: decode_comments_url(m["comments_url"]),
961	977	created_at: decode_created_at(m["created_at"]),

Test case

test/inputs/json/samples/kitchen-sink.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -54,6 +54,14 @@ defmodule PersonElement do
54	54	optional_value: boolean() | nil
55	55	}
56	56
	57	+ def decode_int_or_string(value) when is_integer(value), do: value
	58	+ def decode_int_or_string(value) when is_binary(value), do: value
	59	+ def decode_int_or_string(_), do: {:error, "Unexpected type when decoding PersonElement.int_or_string"}
	60	+
	61	+ def encode_int_or_string(value) when is_integer(value), do: value
	62	+ def encode_int_or_string(value) when is_binary(value), do: value
	63	+ def encode_int_or_string(_), do: {:error, "Unexpected type when encoding PersonElement.int_or_string"}
	64	+
57	65	def decode_name(value) when is_binary(value), do: value
58	66	def decode_name(_), do: {:error, "Unexpected type when decoding PersonElement.name"}
59	67
		@@ -62,7 +70,7 @@ defmodule PersonElement do
62	70
63	71	def from_map(m) do
64	72	%PersonElement{
65		- int_or_string: Map.fetch!(m, "intOrString"),
	73	+ int_or_string: decode_int_or_string(Map.fetch!(m, "intOrString")),
66	74	name: decode_name(m["name"]),
67	75	optional_value: m["optionalValue"],
68	76	}

Test case

test/inputs/json/samples/null-safe.json

1 generated file · +9 −1

Melixirdefault / QuickType.ex+9 −1

		@@ -79,12 +79,20 @@ defmodule Item do
79	79	def encode_name(value) when is_binary(value), do: value
80	80	def encode_name(_), do: {:error, "Unexpected type when encoding Item.name"}
81	81
	82	+ def decode_sex(value) when is_integer(value), do: value
	83	+ def decode_sex(value) when is_nil(value), do: value
	84	+ def decode_sex(_), do: {:error, "Unexpected type when decoding Item.sex"}
	85	+
	86	+ def encode_sex(value) when is_integer(value), do: value
	87	+ def encode_sex(value) when is_nil(value), do: value
	88	+ def encode_sex(_), do: {:error, "Unexpected type when encoding Item.sex"}
	89	+
82	90	def from_map(m) do
83	91	%Item{
84	92	address: m["address"] && Address.from_map(m["address"]),
85	93	created_at: m["created_at"],
86	94	name: decode_name(m["name"]),
87		- sex: Map.fetch!(m, "sex"),
	95	+ sex: decode_sex(Map.fetch!(m, "sex")),
88	96	}
89	97	end

Test case

test/inputs/json/samples/reddit.json

1 generated file · +45 −5

Melixirdefault / QuickType.ex+45 −5

		@@ -686,6 +686,22 @@ defmodule ChildData do
686	686	def encode_author(value) when is_binary(value), do: value
687	687	def encode_author(_), do: {:error, "Unexpected type when encoding ChildData.author"}
688	688
	689	+ def decode_author_flair_css_class(value) when is_nil(value), do: value
	690	+ def decode_author_flair_css_class(value) when is_binary(value), do: value
	691	+ def decode_author_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_css_class"}
	692	+
	693	+ def encode_author_flair_css_class(value) when is_nil(value), do: value
	694	+ def encode_author_flair_css_class(value) when is_binary(value), do: value
	695	+ def encode_author_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_css_class"}
	696	+
	697	+ def decode_author_flair_text(value) when is_nil(value), do: value
	698	+ def decode_author_flair_text(value) when is_binary(value), do: value
	699	+ def decode_author_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_text"}
	700	+
	701	+ def encode_author_flair_text(value) when is_nil(value), do: value
	702	+ def encode_author_flair_text(value) when is_binary(value), do: value
	703	+ def encode_author_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_text"}
	704	+
689	705	def decode_banned_at_utc(value) when is_nil(value), do: value
690	706	def decode_banned_at_utc(_), do: {:error, "Unexpected type when decoding ChildData.banned_at_utc"}
691	707
		@@ -740,6 +756,14 @@ defmodule ChildData do
740	756	def encode_created_utc(value) when is_integer(value), do: value
741	757	def encode_created_utc(_), do: {:error, "Unexpected type when encoding ChildData.created_utc"}
742	758
	759	+ def decode_distinguished(value) when is_nil(value), do: value
	760	+ def decode_distinguished(value) when is_binary(value), do: value
	761	+ def decode_distinguished(_), do: {:error, "Unexpected type when decoding ChildData.distinguished"}
	762	+
	763	+ def encode_distinguished(value) when is_nil(value), do: value
	764	+ def encode_distinguished(value) when is_binary(value), do: value
	765	+ def encode_distinguished(_), do: {:error, "Unexpected type when encoding ChildData.distinguished"}
	766	+
743	767	def decode_downs(value) when is_integer(value), do: value
744	768	def decode_downs(_), do: {:error, "Unexpected type when decoding ChildData.downs"}
745	769
		@@ -794,6 +818,22 @@ defmodule ChildData do
794	818	def encode_likes(value) when is_nil(value), do: value
795	819	def encode_likes(_), do: {:error, "Unexpected type when encoding ChildData.likes"}
796	820
	821	+ def decode_link_flair_css_class(value) when is_nil(value), do: value
	822	+ def decode_link_flair_css_class(value) when is_binary(value), do: value
	823	+ def decode_link_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_css_class"}
	824	+
	825	+ def encode_link_flair_css_class(value) when is_nil(value), do: value
	826	+ def encode_link_flair_css_class(value) when is_binary(value), do: value
	827	+ def encode_link_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_css_class"}
	828	+
	829	+ def decode_link_flair_text(value) when is_nil(value), do: value
	830	+ def decode_link_flair_text(value) when is_binary(value), do: value
	831	+ def decode_link_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_text"}
	832	+
	833	+ def encode_link_flair_text(value) when is_nil(value), do: value
	834	+ def encode_link_flair_text(value) when is_binary(value), do: value
	835	+ def encode_link_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_text"}
	836	+
797	837	def decode_locked(value) when is_boolean(value), do: value
798	838	def decode_locked(_), do: {:error, "Unexpected type when decoding ChildData.locked"}
799	839
		@@ -968,8 +1008,8 @@ defmodule ChildData do
968	1008	approved_by: decode_approved_by(m["approved_by"]),
969	1009	archived: decode_archived(m["archived"]),
970	1010	author: decode_author(m["author"]),
971		- author_flair_css_class: Map.fetch!(m, "author_flair_css_class"),
972		- author_flair_text: Map.fetch!(m, "author_flair_text"),
	1011	+ author_flair_css_class: decode_author_flair_css_class(Map.fetch!(m, "author_flair_css_class")),
	1012	+ author_flair_text: decode_author_flair_text(Map.fetch!(m, "author_flair_text")),
973	1013	banned_at_utc: decode_banned_at_utc(m["banned_at_utc"]),
974	1014	banned_by: decode_banned_by(m["banned_by"]),
975	1015	brand_safe: decode_brand_safe(m["brand_safe"]),
		@@ -979,7 +1019,7 @@ defmodule ChildData do
979	1019	contest_mode: decode_contest_mode(m["contest_mode"]),
980	1020	created: decode_created(m["created"]),
981	1021	created_utc: decode_created_utc(m["created_utc"]),
982		- distinguished: Map.fetch!(m, "distinguished"),
	1022	+ distinguished: decode_distinguished(Map.fetch!(m, "distinguished")),
983	1023	domain: Domain.decode(m["domain"]),
984	1024	downs: decode_downs(m["downs"]),
985	1025	edited: decode_edited(m["edited"]),
		@@ -990,8 +1030,8 @@ defmodule ChildData do
990	1030	is_self: decode_is_self(m["is_self"]),
991	1031	is_video: decode_is_video(m["is_video"]),
992	1032	likes: decode_likes(m["likes"]),
993		- link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
994		- link_flair_text: Map.fetch!(m, "link_flair_text"),
	1033	+ link_flair_css_class: decode_link_flair_css_class(Map.fetch!(m, "link_flair_css_class")),
	1034	+ link_flair_text: decode_link_flair_text(Map.fetch!(m, "link_flair_text")),
995	1035	locked: decode_locked(m["locked"]),
996	1036	media: decode_media(m["media"]),
997	1037	media_embed: MediaEmbed.from_map(m["media_embed"]),

Test case

test/inputs/json/samples/us-senators.json

1 generated file · +27 −3

Melixirdefault / QuickType.ex+27 −3

		@@ -407,6 +407,22 @@ defmodule Person do
407	407	def encode_sortname(value) when is_binary(value), do: value
408	408	def encode_sortname(_), do: {:error, "Unexpected type when encoding Person.sortname"}
409	409
	410	+ def decode_twitterid(value) when is_nil(value), do: value
	411	+ def decode_twitterid(value) when is_binary(value), do: value
	412	+ def decode_twitterid(_), do: {:error, "Unexpected type when decoding Person.twitterid"}
	413	+
	414	+ def encode_twitterid(value) when is_nil(value), do: value
	415	+ def encode_twitterid(value) when is_binary(value), do: value
	416	+ def encode_twitterid(_), do: {:error, "Unexpected type when encoding Person.twitterid"}
	417	+
	418	+ def decode_youtubeid(value) when is_nil(value), do: value
	419	+ def decode_youtubeid(value) when is_binary(value), do: value
	420	+ def decode_youtubeid(_), do: {:error, "Unexpected type when decoding Person.youtubeid"}
	421	+
	422	+ def encode_youtubeid(value) when is_nil(value), do: value
	423	+ def encode_youtubeid(value) when is_binary(value), do: value
	424	+ def encode_youtubeid(_), do: {:error, "Unexpected type when encoding Person.youtubeid"}
	425	+
410	426	def from_map(m) do
411	427	%Person{
412	428	bioguideid: decode_bioguideid(m["bioguideid"]),
		@@ -424,8 +440,8 @@ defmodule Person do
424	440	osid: decode_osid(m["osid"]),
425	441	pvsid: decode_pvsid(m["pvsid"]),
426	442	sortname: decode_sortname(m["sortname"]),
427		- twitterid: Map.fetch!(m, "twitterid"),
428		- youtubeid: Map.fetch!(m, "youtubeid"),
	443	+ twitterid: decode_twitterid(Map.fetch!(m, "twitterid")),
	444	+ youtubeid: decode_youtubeid(Map.fetch!(m, "youtubeid")),
429	445	}
430	446	end
431	447
		@@ -844,6 +860,14 @@ defmodule Object do
844	860	def encode_enddate(value) when is_binary(value), do: value
845	861	def encode_enddate(_), do: {:error, "Unexpected type when encoding Object.enddate"}
846	862
	863	+ def decode_leadership_title(value) when is_nil(value), do: value
	864	+ def decode_leadership_title(value) when is_binary(value), do: value
	865	+ def decode_leadership_title(_), do: {:error, "Unexpected type when decoding Object.leadership_title"}
	866	+
	867	+ def encode_leadership_title(value) when is_nil(value), do: value
	868	+ def encode_leadership_title(value) when is_binary(value), do: value
	869	+ def encode_leadership_title(_), do: {:error, "Unexpected type when encoding Object.leadership_title"}
	870	+
847	871	def decode_phone(value) when is_binary(value), do: value
848	872	def decode_phone(_), do: {:error, "Unexpected type when decoding Object.phone"}
849	873
		@@ -877,7 +901,7 @@ defmodule Object do
877	901	district: decode_district(m["district"]),
878	902	enddate: decode_enddate(m["enddate"]),
879	903	extra: Extra.from_map(m["extra"]),
880		- leadership_title: Map.fetch!(m, "leadership_title"),
	904	+ leadership_title: decode_leadership_title(Map.fetch!(m, "leadership_title")),
881	905	party: Party.decode(m["party"]),
882	906	person: Person.from_map(m["person"]),
883	907	phone: decode_phone(m["phone"]),

Test case

test/inputs/schema/accessors.schema

1 generated file · +11 −1

Mschema-elixirdefault / QuickType.ex+11 −1

		@@ -75,12 +75,22 @@ defmodule TopLevel do
75	75	def encode_foo(value) when is_binary(value), do: value
76	76	def encode_foo(_), do: {:error, "Unexpected type when encoding TopLevel.foo"}
77	77
	78	+ def decode_unionization(value) when is_boolean(value), do: value
	79	+ def decode_unionization(value) when is_float(value), do: value
	80	+ def decode_unionization(value) when is_integer(value), do: value
	81	+ def decode_unionization(_), do: {:error, "Unexpected type when decoding TopLevel.unionization"}
	82	+
	83	+ def encode_unionization(value) when is_boolean(value), do: value
	84	+ def encode_unionization(value) when is_float(value), do: value
	85	+ def encode_unionization(value) when is_integer(value), do: value
	86	+ def encode_unionization(_), do: {:error, "Unexpected type when encoding TopLevel.unionization"}
	87	+
78	88	def from_map(m) do
79	89	%TopLevel{
80	90	barre: decode_barre(m["bar"]),
81	91	enumerification: EnumEnum.decode(m["enum"]),
82	92	foo: decode_foo(m["foo"]),
83		- unionization: Map.fetch!(m, "union"),
	93	+ unionization: decode_unionization(Map.fetch!(m, "union")),
84	94	}
85	95	end

Test case

test/inputs/schema/bool-string.schema

1 generated file · +27 −3

Mschema-elixirdefault / QuickType.ex+27 −3

		@@ -27,21 +27,45 @@ defmodule TopLevel do
27	27	def encode_arr_nullable_element(value) when is_binary(value), do: value
28	28	def encode_arr_nullable_element(_), do: {:error, "Unexpected type when encoding TopLevel.arr_nullable"}
29	29
	30	+ def decode_nullable(value) when is_nil(value), do: value
	31	+ def decode_nullable(value) when is_binary(value), do: value
	32	+ def decode_nullable(_), do: {:error, "Unexpected type when decoding TopLevel.nullable"}
	33	+
	34	+ def encode_nullable(value) when is_nil(value), do: value
	35	+ def encode_nullable(value) when is_binary(value), do: value
	36	+ def encode_nullable(_), do: {:error, "Unexpected type when encoding TopLevel.nullable"}
	37	+
30	38	def decode_one(value) when is_binary(value), do: value
31	39	def decode_one(_), do: {:error, "Unexpected type when decoding TopLevel.one"}
32	40
33	41	def encode_one(value) when is_binary(value), do: value
34	42	def encode_one(_), do: {:error, "Unexpected type when encoding TopLevel.one"}
35	43
	44	+ def decode_union_with_bool(value) when is_boolean(value), do: value
	45	+ def decode_union_with_bool(value) when is_binary(value), do: value
	46	+ def decode_union_with_bool(_), do: {:error, "Unexpected type when decoding TopLevel.union_with_bool"}
	47	+
	48	+ def encode_union_with_bool(value) when is_boolean(value), do: value
	49	+ def encode_union_with_bool(value) when is_binary(value), do: value
	50	+ def encode_union_with_bool(_), do: {:error, "Unexpected type when encoding TopLevel.union_with_bool"}
	51	+
	52	+ def decode_union_with_bool_and_enum(value) when is_boolean(value), do: value
	53	+ def decode_union_with_bool_and_enum(value) when is_binary(value), do: value
	54	+ def decode_union_with_bool_and_enum(_), do: {:error, "Unexpected type when decoding TopLevel.union_with_bool_and_enum"}
	55	+
	56	+ def encode_union_with_bool_and_enum(value) when is_boolean(value), do: value
	57	+ def encode_union_with_bool_and_enum(value) when is_binary(value), do: value
	58	+ def encode_union_with_bool_and_enum(_), do: {:error, "Unexpected type when encoding TopLevel.union_with_bool_and_enum"}
	59	+
36	60	def from_map(m) do
37	61	%TopLevel{
38	62	arr_nullable: m["arrNullable"] && Enum.map(m["arrNullable"], &decode_arr_nullable_element/1),
39	63	arr_one: m["arrOne"],
40		- nullable: Map.fetch!(m, "nullable"),
	64	+ nullable: decode_nullable(Map.fetch!(m, "nullable")),
41	65	one: decode_one(m["one"]),
42	66	optional: m["optional"],
43		- union_with_bool: Map.fetch!(m, "unionWithBool"),
44		- union_with_bool_and_enum: Map.fetch!(m, "unionWithBoolAndEnum"),
	67	+ union_with_bool: decode_union_with_bool(Map.fetch!(m, "unionWithBool")),
	68	+ union_with_bool_and_enum: decode_union_with_bool_and_enum(Map.fetch!(m, "unionWithBoolAndEnum")),
45	69	}
46	70	end

Test case

test/inputs/schema/class-map-union.schema

1 generated file · +0 −86

Dschema-elixirdefault / QuickType.ex+0 −86

		@@ -1,86 +0,0 @@
1		-# This file was autogenerated using quicktype https://github.com/quicktype/quicktype
2		-#
3		-# Add Jason to your mix.exs
4		-#
5		-# Decode a JSON string: TopLevel.from_json(data)
6		-# Encode into a JSON string: TopLevel.to_json(struct)
7		-
8		-defmodule UnionClass do
9		- defstruct [:quux]
10		-
11		- @type t :: %__MODULE__{
12		- quux: integer() | nil
13		- }
14		-
15		- def from_map(m) do
16		- %UnionClass{
17		- quux: m["quux"],
18		- }
19		- end
20		-
21		- def from_json(json) do
22		- json
23		- |> Jason.decode!()
24		- |> from_map()
25		- end
26		-
27		- def to_map(struct) do
28		- %{
29		- "quux" => struct.quux,
30		- }
31		- end
32		-
33		- def to_json(struct) do
34		- struct
35		- |> to_map()
36		- |> Jason.encode!()
37		- end
38		-end
39		-
40		-defmodule TopLevel do
41		- defstruct [:union]
42		-
43		- @type t :: %__MODULE__{
44		- union: %{String.t() => boolean() | UnionClass.t() | float() | String.t()} | nil
45		- }
46		-
47		- def decode_union_value(%{} = value), do: UnionClass.from_map(value)
48		- def decode_union_value(value) when is_boolean(value), do: value
49		- def decode_union_value(value) when is_float(value), do: value
50		- def decode_union_value(value) when is_integer(value), do: value
51		- def decode_union_value(value) when is_binary(value), do: value
52		- def decode_union_value(_), do: {:error, "Unexpected type when decoding TopLevel.union"}
53		-
54		- def encode_union_value(%UnionClass{} = value), do: UnionClass.to_map(value)
55		- def encode_union_value(value) when is_boolean(value), do: value
56		- def encode_union_value(value) when is_float(value), do: value
57		- def encode_union_value(value) when is_integer(value), do: value
58		- def encode_union_value(value) when is_binary(value), do: value
59		- def encode_union_value(_), do: {:error, "Unexpected type when encoding TopLevel.union"}
60		-
61		- def from_map(m) do
62		- %TopLevel{
63		- union: m["union"]
64		- |> Map.new(fn {key, value} -> {key, decode_union_value(value)} end),
65		- }
66		- end
67		-
68		- def from_json(json) do
69		- json
70		- |> Jason.decode!()
71		- |> from_map()
72		- end
73		-
74		- def to_map(struct) do
75		- %{
76		- "union" => struct.union
77		- |> Map.new(fn {key, value} -> {key, encode_union_value(value)} end),
78		- }
79		- end
80		-
81		- def to_json(struct) do
82		- struct
83		- |> to_map()
84		- |> Jason.encode!()
85		- end
86		-end

Test case

test/inputs/schema/description.schema

1 generated file · +11 −1

Mschema-elixirdefault / QuickType.ex+11 −1

		@@ -127,13 +127,23 @@ defmodule TopLevel do
127	127	def encode_object_or_string(value) when is_binary(value), do: value
128	128	def encode_object_or_string(_), do: {:error, "Unexpected type when encoding TopLevel.object_or_string"}
129	129
	130	+ def decode_union(value) when is_float(value), do: value
	131	+ def decode_union(value) when is_integer(value), do: value
	132	+ def decode_union(value) when is_binary(value), do: value
	133	+ def decode_union(_), do: {:error, "Unexpected type when decoding TopLevel.union"}
	134	+
	135	+ def encode_union(value) when is_float(value), do: value
	136	+ def encode_union(value) when is_integer(value), do: value
	137	+ def encode_union(value) when is_binary(value), do: value
	138	+ def encode_union(_), do: {:error, "Unexpected type when encoding TopLevel.union"}
	139	+
130	140	def from_map(m) do
131	141	%TopLevel{
132	142	bar: m["bar"],
133	143	enum: EnumEnum.decode(m["enum"]),
134	144	foo: m["foo"],
135	145	object_or_string: decode_object_or_string(m["object-or-string"]),
136		- union: Map.fetch!(m, "union"),
	146	+ union: decode_union(Map.fetch!(m, "union")),
137	147	}
138	148	end

Test case

test/inputs/schema/implicit-class-array-union.schema

1 generated file · +0 −96

Dschema-elixirdefault / QuickType.ex+0 −96

		@@ -1,96 +0,0 @@
1		-# This file was autogenerated using quicktype https://github.com/quicktype/quicktype
2		-#
3		-# Add Jason to your mix.exs
4		-#
5		-# Decode a JSON string: TopLevel.from_json(data)
6		-# Encode into a JSON string: TopLevel.to_json(struct)
7		-
8		-defmodule FooClass do
9		- @enforce_keys [:bar]
10		- defstruct [:bar]
11		-
12		- @type t :: %__MODULE__{
13		- bar: integer()
14		- }
15		-
16		- def decode_bar(value) when is_integer(value), do: value
17		- def decode_bar(_), do: {:error, "Unexpected type when decoding FooClass.bar"}
18		-
19		- def encode_bar(value) when is_integer(value), do: value
20		- def encode_bar(_), do: {:error, "Unexpected type when encoding FooClass.bar"}
21		-
22		- def from_map(m) do
23		- %FooClass{
24		- bar: decode_bar(m["bar"]),
25		- }
26		- end
27		-
28		- def from_json(json) do
29		- json
30		- |> Jason.decode!()
31		- |> from_map()
32		- end
33		-
34		- def to_map(struct) do
35		- %{
36		- "bar" => struct.bar,
37		- }
38		- end
39		-
40		- def to_json(struct) do
41		- struct
42		- |> to_map()
43		- |> Jason.encode!()
44		- end
45		-end
46		-
47		-defmodule TopLevel do
48		- @enforce_keys [:foo]
49		- defstruct [:foo]
50		-
51		- @type t :: %__MODULE__{
52		- foo: [integer()] | boolean() | FooClass.t() | float() | integer() | nil | String.t()
53		- }
54		-
55		- def decode_foo(%{"bar" => _,} = value), do: FooClass.from_map(value)
56		- def decode_foo(value) when is_boolean(value), do: value
57		- def decode_foo(value) when is_float(value), do: value
58		- def decode_foo(value) when is_integer(value), do: value
59		- def decode_foo(value) when is_nil(value), do: value
60		- def decode_foo(value) when is_binary(value), do: value
61		- def decode_foo(value) when is_list(value), do: value
62		- def decode_foo(_), do: {:error, "Unexpected type when decoding TopLevel.foo"}
63		-
64		- def encode_foo(%FooClass{} = value), do: FooClass.to_map(value)
65		- def encode_foo(value) when is_boolean(value), do: value
66		- def encode_foo(value) when is_float(value), do: value
67		- def encode_foo(value) when is_integer(value), do: value
68		- def encode_foo(value) when is_nil(value), do: value
69		- def encode_foo(value) when is_binary(value), do: value
70		- def encode_foo(value) when is_list(value), do: value
71		- def encode_foo(_), do: {:error, "Unexpected type when encoding TopLevel.foo"}
72		-
73		- def from_map(m) do
74		- %TopLevel{
75		- foo: decode_foo(m["foo"]),
76		- }
77		- end
78		-
79		- def from_json(json) do
80		- json
81		- |> Jason.decode!()
82		- |> from_map()
83		- end
84		-
85		- def to_map(struct) do
86		- %{
87		- "foo" => encode_foo(struct.foo),
88		- }
89		- end
90		-
91		- def to_json(struct) do
92		- struct
93		- |> to_map()
94		- |> Jason.encode!()
95		- end
96		-end

Test case

test/inputs/schema/integer-string.schema

1 generated file · +27 −3

Mschema-elixirdefault / QuickType.ex+27 −3

		@@ -27,21 +27,45 @@ defmodule TopLevel do
27	27	def encode_arr_nullable_element(value) when is_binary(value), do: value
28	28	def encode_arr_nullable_element(_), do: {:error, "Unexpected type when encoding TopLevel.arr_nullable"}
29	29
	30	+ def decode_nullable(value) when is_nil(value), do: value
	31	+ def decode_nullable(value) when is_binary(value), do: value
	32	+ def decode_nullable(_), do: {:error, "Unexpected type when decoding TopLevel.nullable"}
	33	+
	34	+ def encode_nullable(value) when is_nil(value), do: value
	35	+ def encode_nullable(value) when is_binary(value), do: value
	36	+ def encode_nullable(_), do: {:error, "Unexpected type when encoding TopLevel.nullable"}
	37	+
30	38	def decode_one(value) when is_binary(value), do: value
31	39	def decode_one(_), do: {:error, "Unexpected type when decoding TopLevel.one"}
32	40
33	41	def encode_one(value) when is_binary(value), do: value
34	42	def encode_one(_), do: {:error, "Unexpected type when encoding TopLevel.one"}
35	43
	44	+ def decode_union_with_int(value) when is_integer(value), do: value
	45	+ def decode_union_with_int(value) when is_binary(value), do: value
	46	+ def decode_union_with_int(_), do: {:error, "Unexpected type when decoding TopLevel.union_with_int"}
	47	+
	48	+ def encode_union_with_int(value) when is_integer(value), do: value
	49	+ def encode_union_with_int(value) when is_binary(value), do: value
	50	+ def encode_union_with_int(_), do: {:error, "Unexpected type when encoding TopLevel.union_with_int"}
	51	+
	52	+ def decode_union_with_int_and_enum(value) when is_integer(value), do: value
	53	+ def decode_union_with_int_and_enum(value) when is_binary(value), do: value
	54	+ def decode_union_with_int_and_enum(_), do: {:error, "Unexpected type when decoding TopLevel.union_with_int_and_enum"}
	55	+
	56	+ def encode_union_with_int_and_enum(value) when is_integer(value), do: value
	57	+ def encode_union_with_int_and_enum(value) when is_binary(value), do: value
	58	+ def encode_union_with_int_and_enum(_), do: {:error, "Unexpected type when encoding TopLevel.union_with_int_and_enum"}
	59	+
36	60	def from_map(m) do
37	61	%TopLevel{
38	62	arr_nullable: m["arrNullable"] && Enum.map(m["arrNullable"], &decode_arr_nullable_element/1),
39	63	arr_one: m["arrOne"],
40		- nullable: Map.fetch!(m, "nullable"),
	64	+ nullable: decode_nullable(Map.fetch!(m, "nullable")),
41	65	one: decode_one(m["one"]),
42	66	optional: m["optional"],
43		- union_with_int: Map.fetch!(m, "unionWithInt"),
44		- union_with_int_and_enum: Map.fetch!(m, "unionWithIntAndEnum"),
	67	+ union_with_int: decode_union_with_int(Map.fetch!(m, "unionWithInt")),
	68	+ union_with_int_and_enum: decode_union_with_int_and_enum(Map.fetch!(m, "unionWithIntAndEnum")),
45	69	}
46	70	end

Test case

test/inputs/schema/minmaxlength.schema

1 generated file · +11 −1

Mschema-elixirdefault / QuickType.ex+11 −1

		@@ -26,6 +26,16 @@ defmodule TopLevel do
26	26	def encode_intersection(value) when is_binary(value), do: value
27	27	def encode_intersection(_), do: {:error, "Unexpected type when encoding TopLevel.intersection"}
28	28
	29	+ def decode_in_union(value) when is_float(value), do: value
	30	+ def decode_in_union(value) when is_integer(value), do: value
	31	+ def decode_in_union(value) when is_binary(value), do: value
	32	+ def decode_in_union(_), do: {:error, "Unexpected type when decoding TopLevel.in_union"}
	33	+
	34	+ def encode_in_union(value) when is_float(value), do: value
	35	+ def encode_in_union(value) when is_integer(value), do: value
	36	+ def encode_in_union(value) when is_binary(value), do: value
	37	+ def encode_in_union(_), do: {:error, "Unexpected type when encoding TopLevel.in_union"}
	38	+
29	39	def decode_maxlength(value) when is_binary(value), do: value
30	40	def decode_maxlength(_), do: {:error, "Unexpected type when decoding TopLevel.maxlength"}
31	41
		@@ -65,7 +75,7 @@ defmodule TopLevel do
65	75	def from_map(m) do
66	76	%TopLevel{
67	77	intersection: decode_intersection(m["intersection"]),
68		- in_union: Map.fetch!(m, "inUnion"),
	78	+ in_union: decode_in_union(Map.fetch!(m, "inUnion")),
69	79	maxlength: decode_maxlength(m["maxlength"]),
70	80	minlength: decode_minlength(m["minlength"]),
71	81	min_max_intersection: decode_min_max_intersection(m["minMaxIntersection"]),

Test case

test/inputs/schema/nullable-optional-one-of.schema

1 generated file · +9 −1

Mschema-elixirdefault / QuickType.ex+9 −1

		@@ -60,9 +60,17 @@ defmodule TopLevel do
60	60	kind: Kind.t()
61	61	}
62	62
	63	+ def decode_b(value) when is_nil(value), do: value
	64	+ def decode_b(value) when is_binary(value), do: value
	65	+ def decode_b(_), do: {:error, "Unexpected type when decoding TopLevel.b"}
	66	+
	67	+ def encode_b(value) when is_nil(value), do: value
	68	+ def encode_b(value) when is_binary(value), do: value
	69	+ def encode_b(_), do: {:error, "Unexpected type when encoding TopLevel.b"}
	70	+
63	71	def from_map(m) do
64	72	%TopLevel{
65		- b: m["b"],
	73	+ b: m["b"] && decode_b(m["b"]),
66	74	kind: Kind.decode(m["kind"]),
67	75	}
68	76	end

Test case

test/inputs/schema/strict-optional.schema

1 generated file · +11 −1

Mschema-elixirdefault / QuickType.ex+11 −1

		@@ -13,9 +13,19 @@ defmodule TopLevel do
13	13	foo: float() | nil
14	14	}
15	15
	16	+ def decode_foo(value) when is_float(value), do: value
	17	+ def decode_foo(value) when is_integer(value), do: value
	18	+ def decode_foo(value) when is_nil(value), do: value
	19	+ def decode_foo(_), do: {:error, "Unexpected type when decoding TopLevel.foo"}
	20	+
	21	+ def encode_foo(value) when is_float(value), do: value
	22	+ def encode_foo(value) when is_integer(value), do: value
	23	+ def encode_foo(value) when is_nil(value), do: value
	24	+ def encode_foo(_), do: {:error, "Unexpected type when encoding TopLevel.foo"}
	25	+
16	26	def from_map(m) do
17	27	%TopLevel{
18		- foo: Map.fetch!(m, "foo"),
	28	+ foo: decode_foo(Map.fetch!(m, "foo")),
19	29	}
20	30	end

Test case

test/inputs/schema/union-int-double.schema

1 generated file · +11 −1

Mschema-elixirdefault / QuickType.ex+11 −1

		@@ -13,9 +13,19 @@ defmodule TopLevel do
13	13	value: float() | String.t()
14	14	}
15	15
	16	+ def decode_value(value) when is_float(value), do: value
	17	+ def decode_value(value) when is_integer(value), do: value
	18	+ def decode_value(value) when is_binary(value), do: value
	19	+ def decode_value(_), do: {:error, "Unexpected type when decoding TopLevel.value"}
	20	+
	21	+ def encode_value(value) when is_float(value), do: value
	22	+ def encode_value(value) when is_integer(value), do: value
	23	+ def encode_value(value) when is_binary(value), do: value
	24	+ def encode_value(_), do: {:error, "Unexpected type when encoding TopLevel.value"}
	25	+
16	26	def from_map(m) do
17	27	%TopLevel{
18		- value: Map.fetch!(m, "value"),
	28	+ value: decode_value(Map.fetch!(m, "value")),
19	29	}
20	30	end

Test case

test/inputs/schema/uuid.schema

1 generated file · +9 −1

Mschema-elixirdefault / QuickType.ex+9 −1

		@@ -26,6 +26,14 @@ defmodule TopLevel do
26	26	def encode_arr_nullable_element(value) when is_binary(value), do: value
27	27	def encode_arr_nullable_element(_), do: {:error, "Unexpected type when encoding TopLevel.arr_nullable"}
28	28
	29	+ def decode_nullable(value) when is_nil(value), do: value
	30	+ def decode_nullable(value) when is_binary(value), do: value
	31	+ def decode_nullable(_), do: {:error, "Unexpected type when decoding TopLevel.nullable"}
	32	+
	33	+ def encode_nullable(value) when is_nil(value), do: value
	34	+ def encode_nullable(value) when is_binary(value), do: value
	35	+ def encode_nullable(_), do: {:error, "Unexpected type when encoding TopLevel.nullable"}
	36	+
29	37	def decode_one(value) when is_binary(value), do: value
30	38	def decode_one(_), do: {:error, "Unexpected type when decoding TopLevel.one"}
31	39
		@@ -42,7 +50,7 @@ defmodule TopLevel do
42	50	%TopLevel{
43	51	arr_nullable: m["arrNullable"] && Enum.map(m["arrNullable"], &decode_arr_nullable_element/1),
44	52	arr_one: m["arrOne"],
45		- nullable: Map.fetch!(m, "nullable"),
	53	+ nullable: decode_nullable(Map.fetch!(m, "nullable")),
46	54	one: decode_one(m["one"]),
47	55	optional: m["optional"],
48	56	union_with_enum: decode_union_with_enum(m["unionWithEnum"]),

Test case

test/inputs/schema/vega-lite.schema

1 generated file · +341 −31

Mschema-elixirdefault / QuickType.ex+341 −31

		@@ -892,6 +892,26 @@ defmodule AxisConfig do
892	892	title_y: float() | nil
893	893	}
894	894
	895	+ def decode_label_bound(value) when is_boolean(value), do: value
	896	+ def decode_label_bound(value) when is_float(value), do: value
	897	+ def decode_label_bound(value) when is_integer(value), do: value
	898	+ def decode_label_bound(_), do: {:error, "Unexpected type when decoding AxisConfig.label_bound"}
	899	+
	900	+ def encode_label_bound(value) when is_boolean(value), do: value
	901	+ def encode_label_bound(value) when is_float(value), do: value
	902	+ def encode_label_bound(value) when is_integer(value), do: value
	903	+ def encode_label_bound(_), do: {:error, "Unexpected type when encoding AxisConfig.label_bound"}
	904	+
	905	+ def decode_label_flush(value) when is_boolean(value), do: value
	906	+ def decode_label_flush(value) when is_float(value), do: value
	907	+ def decode_label_flush(value) when is_integer(value), do: value
	908	+ def decode_label_flush(_), do: {:error, "Unexpected type when decoding AxisConfig.label_flush"}
	909	+
	910	+ def encode_label_flush(value) when is_boolean(value), do: value
	911	+ def encode_label_flush(value) when is_float(value), do: value
	912	+ def encode_label_flush(value) when is_integer(value), do: value
	913	+ def encode_label_flush(_), do: {:error, "Unexpected type when encoding AxisConfig.label_flush"}
	914	+
895	915	def decode_label_overlap(value) when is_boolean(value), do: value
896	916	def decode_label_overlap(value) when is_binary(value), do: LabelOverlapEnum.decode(value)
897	917	def decode_label_overlap(value) when is_nil(value), do: value
		@@ -902,6 +922,16 @@ defmodule AxisConfig do
902	922	def encode_label_overlap(value) when is_nil(value), do: value
903	923	def encode_label_overlap(_), do: {:error, "Unexpected type when encoding AxisConfig.label_overlap"}
904	924
	925	+ def decode_title_font_weight(value) when is_float(value), do: value
	926	+ def decode_title_font_weight(value) when is_integer(value), do: value
	927	+ def decode_title_font_weight(value) when is_binary(value), do: value
	928	+ def decode_title_font_weight(_), do: {:error, "Unexpected type when decoding AxisConfig.title_font_weight"}
	929	+
	930	+ def encode_title_font_weight(value) when is_float(value), do: value
	931	+ def encode_title_font_weight(value) when is_integer(value), do: value
	932	+ def encode_title_font_weight(value) when is_binary(value), do: value
	933	+ def encode_title_font_weight(_), do: {:error, "Unexpected type when encoding AxisConfig.title_font_weight"}
	934	+
905	935	def from_map(m) do
906	936	%AxisConfig{
907	937	band_position: m["bandPosition"],
		@@ -914,9 +944,9 @@ defmodule AxisConfig do
914	944	grid_opacity: m["gridOpacity"],
915	945	grid_width: m["gridWidth"],
916	946	label_angle: m["labelAngle"],
917		- label_bound: m["labelBound"],
	947	+ label_bound: m["labelBound"] && decode_label_bound(m["labelBound"]),
918	948	label_color: m["labelColor"],
919		- label_flush: m["labelFlush"],
	949	+ label_flush: m["labelFlush"] && decode_label_flush(m["labelFlush"]),
920	950	label_font: m["labelFont"],
921	951	label_font_size: m["labelFontSize"],
922	952	label_limit: m["labelLimit"],
		@@ -937,7 +967,7 @@ defmodule AxisConfig do
937	967	title_color: m["titleColor"],
938	968	title_font: m["titleFont"],
939	969	title_font_size: m["titleFontSize"],
940		- title_font_weight: m["titleFontWeight"],
	970	+ title_font_weight: m["titleFontWeight"] && decode_title_font_weight(m["titleFontWeight"]),
941	971	title_limit: m["titleLimit"],
942	972	title_max_length: m["titleMaxLength"],
943	973	title_padding: m["titlePadding"],
		@@ -1101,6 +1131,26 @@ defmodule VGAxisConfig do
1101	1131	title_y: float() | nil
1102	1132	}
1103	1133
	1134	+ def decode_label_bound(value) when is_boolean(value), do: value
	1135	+ def decode_label_bound(value) when is_float(value), do: value
	1136	+ def decode_label_bound(value) when is_integer(value), do: value
	1137	+ def decode_label_bound(_), do: {:error, "Unexpected type when decoding VGAxisConfig.label_bound"}
	1138	+
	1139	+ def encode_label_bound(value) when is_boolean(value), do: value
	1140	+ def encode_label_bound(value) when is_float(value), do: value
	1141	+ def encode_label_bound(value) when is_integer(value), do: value
	1142	+ def encode_label_bound(_), do: {:error, "Unexpected type when encoding VGAxisConfig.label_bound"}
	1143	+
	1144	+ def decode_label_flush(value) when is_boolean(value), do: value
	1145	+ def decode_label_flush(value) when is_float(value), do: value
	1146	+ def decode_label_flush(value) when is_integer(value), do: value
	1147	+ def decode_label_flush(_), do: {:error, "Unexpected type when decoding VGAxisConfig.label_flush"}
	1148	+
	1149	+ def encode_label_flush(value) when is_boolean(value), do: value
	1150	+ def encode_label_flush(value) when is_float(value), do: value
	1151	+ def encode_label_flush(value) when is_integer(value), do: value
	1152	+ def encode_label_flush(_), do: {:error, "Unexpected type when encoding VGAxisConfig.label_flush"}
	1153	+
1104	1154	def decode_label_overlap(value) when is_boolean(value), do: value
1105	1155	def decode_label_overlap(value) when is_binary(value), do: LabelOverlapEnum.decode(value)
1106	1156	def decode_label_overlap(value) when is_nil(value), do: value
		@@ -1111,6 +1161,16 @@ defmodule VGAxisConfig do
1111	1161	def encode_label_overlap(value) when is_nil(value), do: value
1112	1162	def encode_label_overlap(_), do: {:error, "Unexpected type when encoding VGAxisConfig.label_overlap"}
1113	1163
	1164	+ def decode_title_font_weight(value) when is_float(value), do: value
	1165	+ def decode_title_font_weight(value) when is_integer(value), do: value
	1166	+ def decode_title_font_weight(value) when is_binary(value), do: value
	1167	+ def decode_title_font_weight(_), do: {:error, "Unexpected type when decoding VGAxisConfig.title_font_weight"}
	1168	+
	1169	+ def encode_title_font_weight(value) when is_float(value), do: value
	1170	+ def encode_title_font_weight(value) when is_integer(value), do: value
	1171	+ def encode_title_font_weight(value) when is_binary(value), do: value
	1172	+ def encode_title_font_weight(_), do: {:error, "Unexpected type when encoding VGAxisConfig.title_font_weight"}
	1173	+
1114	1174	def from_map(m) do
1115	1175	%VGAxisConfig{
1116	1176	band_position: m["bandPosition"],
		@@ -1123,9 +1183,9 @@ defmodule VGAxisConfig do
1123	1183	grid_opacity: m["gridOpacity"],
1124	1184	grid_width: m["gridWidth"],
1125	1185	label_angle: m["labelAngle"],
1126		- label_bound: m["labelBound"],
	1186	+ label_bound: m["labelBound"] && decode_label_bound(m["labelBound"]),
1127	1187	label_color: m["labelColor"],
1128		- label_flush: m["labelFlush"],
	1188	+ label_flush: m["labelFlush"] && decode_label_flush(m["labelFlush"]),
1129	1189	label_font: m["labelFont"],
1130	1190	label_font_size: m["labelFontSize"],
1131	1191	label_limit: m["labelLimit"],
		@@ -1145,7 +1205,7 @@ defmodule VGAxisConfig do
1145	1205	title_color: m["titleColor"],
1146	1206	title_font: m["titleFont"],
1147	1207	title_font_size: m["titleFontSize"],
1148		- title_font_weight: m["titleFontWeight"],
	1208	+ title_font_weight: m["titleFontWeight"] && decode_title_font_weight(m["titleFontWeight"]),
1149	1209	title_limit: m["titleLimit"],
1150	1210	title_max_length: m["titleMaxLength"],
1151	1211	title_padding: m["titlePadding"],
		@@ -1637,6 +1697,16 @@ defmodule LegendConfig do
1637	1697	title_padding: float() | nil
1638	1698	}
1639	1699
	1700	+ def decode_title_font_weight(value) when is_float(value), do: value
	1701	+ def decode_title_font_weight(value) when is_integer(value), do: value
	1702	+ def decode_title_font_weight(value) when is_binary(value), do: value
	1703	+ def decode_title_font_weight(_), do: {:error, "Unexpected type when decoding LegendConfig.title_font_weight"}
	1704	+
	1705	+ def encode_title_font_weight(value) when is_float(value), do: value
	1706	+ def encode_title_font_weight(value) when is_integer(value), do: value
	1707	+ def encode_title_font_weight(value) when is_binary(value), do: value
	1708	+ def encode_title_font_weight(_), do: {:error, "Unexpected type when encoding LegendConfig.title_font_weight"}
	1709	+
1640	1710	def from_map(m) do
1641	1711	%LegendConfig{
1642	1712	corner_radius: m["cornerRadius"],
		@@ -1672,7 +1742,7 @@ defmodule LegendConfig do
1672	1742	title_color: m["titleColor"],
1673	1743	title_font: m["titleFont"],
1674	1744	title_font_size: m["titleFontSize"],
1675		- title_font_weight: m["titleFontWeight"],
	1745	+ title_font_weight: m["titleFontWeight"] && decode_title_font_weight(m["titleFontWeight"]),
1676	1746	title_limit: m["titleLimit"],
1677	1747	title_padding: m["titlePadding"],
1678	1748	}
		@@ -2030,6 +2100,16 @@ defmodule ScaleConfig do
2030	2100	use_unaggregated_domain: boolean() | nil
2031	2101	}
2032	2102
	2103	+ def decode_range_step(value) when is_float(value), do: value
	2104	+ def decode_range_step(value) when is_integer(value), do: value
	2105	+ def decode_range_step(value) when is_nil(value), do: value
	2106	+ def decode_range_step(_), do: {:error, "Unexpected type when decoding ScaleConfig.range_step"}
	2107	+
	2108	+ def encode_range_step(value) when is_float(value), do: value
	2109	+ def encode_range_step(value) when is_integer(value), do: value
	2110	+ def encode_range_step(value) when is_nil(value), do: value
	2111	+ def encode_range_step(_), do: {:error, "Unexpected type when encoding ScaleConfig.range_step"}
	2112	+
2033	2113	def from_map(m) do
2034	2114	%ScaleConfig{
2035	2115	band_padding_inner: m["bandPaddingInner"],
		@@ -2047,7 +2127,7 @@ defmodule ScaleConfig do
2047	2127	min_size: m["minSize"],
2048	2128	min_stroke_width: m["minStrokeWidth"],
2049	2129	point_padding: m["pointPadding"],
2050		- range_step: m["rangeStep"],
	2130	+ range_step: m["rangeStep"] && decode_range_step(m["rangeStep"]),
2051	2131	round: m["round"],
2052	2132	text_x_range_step: m["textXRangeStep"],
2053	2133	use_unaggregated_domain: m["useUnaggregatedDomain"],
		@@ -2396,6 +2476,22 @@ defmodule IntervalSelectionConfig do
2396	2476	zoom: boolean() | String.t() | nil
2397	2477	}
2398	2478
	2479	+ def decode_translate(value) when is_boolean(value), do: value
	2480	+ def decode_translate(value) when is_binary(value), do: value
	2481	+ def decode_translate(_), do: {:error, "Unexpected type when decoding IntervalSelectionConfig.translate"}
	2482	+
	2483	+ def encode_translate(value) when is_boolean(value), do: value
	2484	+ def encode_translate(value) when is_binary(value), do: value
	2485	+ def encode_translate(_), do: {:error, "Unexpected type when encoding IntervalSelectionConfig.translate"}
	2486	+
	2487	+ def decode_zoom(value) when is_boolean(value), do: value
	2488	+ def decode_zoom(value) when is_binary(value), do: value
	2489	+ def decode_zoom(_), do: {:error, "Unexpected type when decoding IntervalSelectionConfig.zoom"}
	2490	+
	2491	+ def encode_zoom(value) when is_boolean(value), do: value
	2492	+ def encode_zoom(value) when is_binary(value), do: value
	2493	+ def encode_zoom(_), do: {:error, "Unexpected type when encoding IntervalSelectionConfig.zoom"}
	2494	+
2399	2495	def from_map(m) do
2400	2496	%IntervalSelectionConfig{
2401	2497	bind: m["bind"] && BindEnum.decode(m["bind"]),
		@@ -2405,8 +2501,8 @@ defmodule IntervalSelectionConfig do
2405	2501	mark: m["mark"] && BrushConfig.from_map(m["mark"]),
2406	2502	on: m["on"],
2407	2503	resolve: m["resolve"] && SelectionResolution.decode(m["resolve"]),
2408		- translate: m["translate"],
2409		- zoom: m["zoom"],
	2504	+ translate: m["translate"] && decode_translate(m["translate"]),
	2505	+ zoom: m["zoom"] && decode_zoom(m["zoom"]),
2410	2506	}
2411	2507	end
2412	2508
		@@ -2466,6 +2562,14 @@ defmodule MultiSelectionConfig do
2466	2562	toggle: boolean() | String.t() | nil
2467	2563	}
2468	2564
	2565	+ def decode_toggle(value) when is_boolean(value), do: value
	2566	+ def decode_toggle(value) when is_binary(value), do: value
	2567	+ def decode_toggle(_), do: {:error, "Unexpected type when decoding MultiSelectionConfig.toggle"}
	2568	+
	2569	+ def encode_toggle(value) when is_boolean(value), do: value
	2570	+ def encode_toggle(value) when is_binary(value), do: value
	2571	+ def encode_toggle(_), do: {:error, "Unexpected type when encoding MultiSelectionConfig.toggle"}
	2572	+
2469	2573	def from_map(m) do
2470	2574	%MultiSelectionConfig{
2471	2575	empty: m["empty"] && Empty.decode(m["empty"]),
		@@ -2474,7 +2578,7 @@ defmodule MultiSelectionConfig do
2474	2578	nearest: m["nearest"],
2475	2579	on: m["on"],
2476	2580	resolve: m["resolve"] && SelectionResolution.decode(m["resolve"]),
2477		- toggle: m["toggle"],
	2581	+ toggle: m["toggle"] && decode_toggle(m["toggle"]),
2478	2582	}
2479	2583	end
2480	2584
		@@ -4188,14 +4292,34 @@ defmodule DateTimeClass do
4188	4292	year: float() | nil
4189	4293	}
4190	4294
	4295	+ def decode_day(value) when is_float(value), do: value
	4296	+ def decode_day(value) when is_integer(value), do: value
	4297	+ def decode_day(value) when is_binary(value), do: value
	4298	+ def decode_day(_), do: {:error, "Unexpected type when decoding DateTimeClass.day"}
	4299	+
	4300	+ def encode_day(value) when is_float(value), do: value
	4301	+ def encode_day(value) when is_integer(value), do: value
	4302	+ def encode_day(value) when is_binary(value), do: value
	4303	+ def encode_day(_), do: {:error, "Unexpected type when encoding DateTimeClass.day"}
	4304	+
	4305	+ def decode_month(value) when is_float(value), do: value
	4306	+ def decode_month(value) when is_integer(value), do: value
	4307	+ def decode_month(value) when is_binary(value), do: value
	4308	+ def decode_month(_), do: {:error, "Unexpected type when decoding DateTimeClass.month"}
	4309	+
	4310	+ def encode_month(value) when is_float(value), do: value
	4311	+ def encode_month(value) when is_integer(value), do: value
	4312	+ def encode_month(value) when is_binary(value), do: value
	4313	+ def encode_month(_), do: {:error, "Unexpected type when encoding DateTimeClass.month"}
	4314	+
4191	4315	def from_map(m) do
4192	4316	%DateTimeClass{
4193	4317	date: m["date"],
4194		- day: m["day"],
	4318	+ day: m["day"] && decode_day(m["day"]),
4195	4319	hours: m["hours"],
4196	4320	milliseconds: m["milliseconds"],
4197	4321	minutes: m["minutes"],
4198		- month: m["month"],
	4322	+ month: m["month"] && decode_month(m["month"]),
4199	4323	quarter: m["quarter"],
4200	4324	seconds: m["seconds"],
4201	4325	utc: m["utc"],
		@@ -4499,6 +4623,18 @@ defmodule ConditionalValueDef do
4499	4623	def encode_test(value) when is_nil(value), do: value
4500	4624	def encode_test(_), do: {:error, "Unexpected type when encoding ConditionalValueDef.test"}
4501	4625
	4626	+ def decode_value(value) when is_boolean(value), do: value
	4627	+ def decode_value(value) when is_float(value), do: value
	4628	+ def decode_value(value) when is_integer(value), do: value
	4629	+ def decode_value(value) when is_binary(value), do: value
	4630	+ def decode_value(_), do: {:error, "Unexpected type when decoding ConditionalValueDef.value"}
	4631	+
	4632	+ def encode_value(value) when is_boolean(value), do: value
	4633	+ def encode_value(value) when is_float(value), do: value
	4634	+ def encode_value(value) when is_integer(value), do: value
	4635	+ def encode_value(value) when is_binary(value), do: value
	4636	+ def encode_value(_), do: {:error, "Unexpected type when encoding ConditionalValueDef.value"}
	4637	+
4502	4638	def decode_selection(%{} = value), do: Selection.from_map(value)
4503	4639	def decode_selection(value) when is_binary(value), do: value
4504	4640	def decode_selection(value) when is_nil(value), do: value
		@@ -4512,7 +4648,7 @@ defmodule ConditionalValueDef do
4512	4648	def from_map(m) do
4513	4649	%ConditionalValueDef{
4514	4650	test: decode_test(m["test"]),
4515		- value: Map.fetch!(m, "value"),
	4651	+ value: decode_value(Map.fetch!(m, "value")),
4516	4652	selection: decode_selection(m["selection"]),
4517	4653	}
4518	4654	end
		@@ -4704,6 +4840,14 @@ defmodule Legend do
4704	4840	zindex: float() | nil
4705	4841	}
4706	4842
	4843	+ def decode_title(value) when is_nil(value), do: value
	4844	+ def decode_title(value) when is_binary(value), do: value
	4845	+ def decode_title(_), do: {:error, "Unexpected type when decoding Legend.title"}
	4846	+
	4847	+ def encode_title(value) when is_nil(value), do: value
	4848	+ def encode_title(value) when is_binary(value), do: value
	4849	+ def encode_title(_), do: {:error, "Unexpected type when encoding Legend.title"}
	4850	+
4707	4851	def decode_values_element(%{} = value), do: DateTimeClass.from_map(value)
4708	4852	def decode_values_element(value) when is_float(value), do: value
4709	4853	def decode_values_element(value) when is_integer(value), do: value
		@@ -4724,7 +4868,7 @@ defmodule Legend do
4724	4868	orient: m["orient"] && LegendOrient.decode(m["orient"]),
4725	4869	padding: m["padding"],
4726	4870	tick_count: m["tickCount"],
4727		- title: m["title"],
	4871	+ title: m["title"] && decode_title(m["title"]),
4728	4872	type: m["type"] && LegendType.decode(m["type"]),
4729	4873	values: m["values"] && Enum.map(m["values"], &decode_values_element/1),
4730	4874	zindex: m["zindex"],
		@@ -5252,6 +5396,16 @@ defmodule Scale do
5252	5396	def encode_range(value) when is_nil(value), do: value
5253	5397	def encode_range(_), do: {:error, "Unexpected type when encoding Scale.range"}
5254	5398
	5399	+ def decode_range_step(value) when is_float(value), do: value
	5400	+ def decode_range_step(value) when is_integer(value), do: value
	5401	+ def decode_range_step(value) when is_nil(value), do: value
	5402	+ def decode_range_step(_), do: {:error, "Unexpected type when decoding Scale.range_step"}
	5403	+
	5404	+ def encode_range_step(value) when is_float(value), do: value
	5405	+ def encode_range_step(value) when is_integer(value), do: value
	5406	+ def encode_range_step(value) when is_nil(value), do: value
	5407	+ def encode_range_step(_), do: {:error, "Unexpected type when encoding Scale.range_step"}
	5408	+
5255	5409	def decode_scheme(%{"name" => _,} = value), do: SchemeParams.from_map(value)
5256	5410	def decode_scheme(value) when is_binary(value), do: value
5257	5411	def decode_scheme(value) when is_nil(value), do: value
		@@ -5274,7 +5428,7 @@ defmodule Scale do
5274	5428	padding_inner: m["paddingInner"],
5275	5429	padding_outer: m["paddingOuter"],
5276	5430	range: decode_range(m["range"]),
5277		- range_step: m["rangeStep"],
	5431	+ range_step: m["rangeStep"] && decode_range_step(m["rangeStep"]),
5278	5432	round: m["round"],
5279	5433	scheme: decode_scheme(m["scheme"]),
5280	5434	type: m["type"] && ScaleType.decode(m["type"]),
		@@ -5516,6 +5670,18 @@ defmodule ConditionalPredicateMarkPropFieldDefClass do
5516	5670	def encode_test(value) when is_nil(value), do: value
5517	5671	def encode_test(_), do: {:error, "Unexpected type when encoding ConditionalPredicateMarkPropFieldDefClass.test"}
5518	5672
	5673	+ def decode_value(value) when is_boolean(value), do: value
	5674	+ def decode_value(value) when is_float(value), do: value
	5675	+ def decode_value(value) when is_integer(value), do: value
	5676	+ def decode_value(value) when is_binary(value), do: value
	5677	+ def decode_value(_), do: {:error, "Unexpected type when decoding ConditionalPredicateMarkPropFieldDefClass.value"}
	5678	+
	5679	+ def encode_value(value) when is_boolean(value), do: value
	5680	+ def encode_value(value) when is_float(value), do: value
	5681	+ def encode_value(value) when is_integer(value), do: value
	5682	+ def encode_value(value) when is_binary(value), do: value
	5683	+ def encode_value(_), do: {:error, "Unexpected type when encoding ConditionalPredicateMarkPropFieldDefClass.value"}
	5684	+
5519	5685	def decode_selection(%{} = value), do: Selection.from_map(value)
5520	5686	def decode_selection(value) when is_binary(value), do: value
5521	5687	def decode_selection(value) when is_nil(value), do: value
		@@ -5559,7 +5725,7 @@ defmodule ConditionalPredicateMarkPropFieldDefClass do
5559	5725	def from_map(m) do
5560	5726	%ConditionalPredicateMarkPropFieldDefClass{
5561	5727	test: decode_test(m["test"]),
5562		- value: m["value"],
	5728	+ value: m["value"] && decode_value(m["value"]),
5563	5729	selection: decode_selection(m["selection"]),
5564	5730	aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
5565	5731	bin: decode_bin(m["bin"]),
		@@ -5711,6 +5877,18 @@ defmodule MarkPropDefWithCondition do
5711	5877	def encode_sort(value) when is_nil(value), do: value
5712	5878	def encode_sort(_), do: {:error, "Unexpected type when encoding MarkPropDefWithCondition.sort"}
5713	5879
	5880	+ def decode_value(value) when is_boolean(value), do: value
	5881	+ def decode_value(value) when is_float(value), do: value
	5882	+ def decode_value(value) when is_integer(value), do: value
	5883	+ def decode_value(value) when is_binary(value), do: value
	5884	+ def decode_value(_), do: {:error, "Unexpected type when decoding MarkPropDefWithCondition.value"}
	5885	+
	5886	+ def encode_value(value) when is_boolean(value), do: value
	5887	+ def encode_value(value) when is_float(value), do: value
	5888	+ def encode_value(value) when is_integer(value), do: value
	5889	+ def encode_value(value) when is_binary(value), do: value
	5890	+ def encode_value(_), do: {:error, "Unexpected type when encoding MarkPropDefWithCondition.value"}
	5891	+
5714	5892	def from_map(m) do
5715	5893	%MarkPropDefWithCondition{
5716	5894	aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
		@@ -5722,7 +5900,7 @@ defmodule MarkPropDefWithCondition do
5722	5900	sort: decode_sort(m["sort"]),
5723	5901	time_unit: m["timeUnit"] && TimeUnit.decode(m["timeUnit"]),
5724	5902	type: m["type"] && Type.decode(m["type"]),
5725		- value: m["value"],
	5903	+ value: m["value"] && decode_value(m["value"]),
5726	5904	}
5727	5905	end
5728	5906
		@@ -5772,11 +5950,19 @@ defmodule Header do
5772	5950	title: nil | String.t() | nil
5773	5951	}
5774	5952
	5953	+ def decode_title(value) when is_nil(value), do: value
	5954	+ def decode_title(value) when is_binary(value), do: value
	5955	+ def decode_title(_), do: {:error, "Unexpected type when decoding Header.title"}
	5956	+
	5957	+ def encode_title(value) when is_nil(value), do: value
	5958	+ def encode_title(value) when is_binary(value), do: value
	5959	+ def encode_title(_), do: {:error, "Unexpected type when encoding Header.title"}
	5960	+
5775	5961	def from_map(m) do
5776	5962	%Header{
5777	5963	format: m["format"],
5778	5964	label_angle: m["labelAngle"],
5779		- title: m["title"],
	5965	+ title: m["title"] && decode_title(m["title"]),
5780	5966	}
5781	5967	end
5782	5968
		@@ -5993,6 +6179,18 @@ defmodule ConditionalPredicateFieldDefClass do
5993	6179	def encode_test(value) when is_nil(value), do: value
5994	6180	def encode_test(_), do: {:error, "Unexpected type when encoding ConditionalPredicateFieldDefClass.test"}
5995	6181
	6182	+ def decode_value(value) when is_boolean(value), do: value
	6183	+ def decode_value(value) when is_float(value), do: value
	6184	+ def decode_value(value) when is_integer(value), do: value
	6185	+ def decode_value(value) when is_binary(value), do: value
	6186	+ def decode_value(_), do: {:error, "Unexpected type when decoding ConditionalPredicateFieldDefClass.value"}
	6187	+
	6188	+ def encode_value(value) when is_boolean(value), do: value
	6189	+ def encode_value(value) when is_float(value), do: value
	6190	+ def encode_value(value) when is_integer(value), do: value
	6191	+ def encode_value(value) when is_binary(value), do: value
	6192	+ def encode_value(_), do: {:error, "Unexpected type when encoding ConditionalPredicateFieldDefClass.value"}
	6193	+
5996	6194	def decode_selection(%{} = value), do: Selection.from_map(value)
5997	6195	def decode_selection(value) when is_binary(value), do: value
5998	6196	def decode_selection(value) when is_nil(value), do: value
		@@ -6026,7 +6224,7 @@ defmodule ConditionalPredicateFieldDefClass do
6026	6224	def from_map(m) do
6027	6225	%ConditionalPredicateFieldDefClass{
6028	6226	test: decode_test(m["test"]),
6029		- value: m["value"],
	6227	+ value: m["value"] && decode_value(m["value"]),
6030	6228	selection: decode_selection(m["selection"]),
6031	6229	aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
6032	6230	bin: decode_bin(m["bin"]),
		@@ -6129,6 +6327,18 @@ defmodule DefWithCondition do
6129	6327	def encode_field(value) when is_nil(value), do: value
6130	6328	def encode_field(_), do: {:error, "Unexpected type when encoding DefWithCondition.field"}
6131	6329
	6330	+ def decode_value(value) when is_boolean(value), do: value
	6331	+ def decode_value(value) when is_float(value), do: value
	6332	+ def decode_value(value) when is_integer(value), do: value
	6333	+ def decode_value(value) when is_binary(value), do: value
	6334	+ def decode_value(_), do: {:error, "Unexpected type when decoding DefWithCondition.value"}
	6335	+
	6336	+ def encode_value(value) when is_boolean(value), do: value
	6337	+ def encode_value(value) when is_float(value), do: value
	6338	+ def encode_value(value) when is_integer(value), do: value
	6339	+ def encode_value(value) when is_binary(value), do: value
	6340	+ def encode_value(_), do: {:error, "Unexpected type when encoding DefWithCondition.value"}
	6341	+
6132	6342	def from_map(m) do
6133	6343	%DefWithCondition{
6134	6344	aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
		@@ -6137,7 +6347,7 @@ defmodule DefWithCondition do
6137	6347	field: decode_field(m["field"]),
6138	6348	time_unit: m["timeUnit"] && TimeUnit.decode(m["timeUnit"]),
6139	6349	type: m["type"] && Type.decode(m["type"]),
6140		- value: m["value"],
	6350	+ value: m["value"] && decode_value(m["value"]),
6141	6351	}
6142	6352	end
6143	6353
		@@ -6279,6 +6489,18 @@ defmodule ConditionalPredicateTextFieldDefClass do
6279	6489	def encode_test(value) when is_nil(value), do: value
6280	6490	def encode_test(_), do: {:error, "Unexpected type when encoding ConditionalPredicateTextFieldDefClass.test"}
6281	6491
	6492	+ def decode_value(value) when is_boolean(value), do: value
	6493	+ def decode_value(value) when is_float(value), do: value
	6494	+ def decode_value(value) when is_integer(value), do: value
	6495	+ def decode_value(value) when is_binary(value), do: value
	6496	+ def decode_value(_), do: {:error, "Unexpected type when decoding ConditionalPredicateTextFieldDefClass.value"}
	6497	+
	6498	+ def encode_value(value) when is_boolean(value), do: value
	6499	+ def encode_value(value) when is_float(value), do: value
	6500	+ def encode_value(value) when is_integer(value), do: value
	6501	+ def encode_value(value) when is_binary(value), do: value
	6502	+ def encode_value(_), do: {:error, "Unexpected type when encoding ConditionalPredicateTextFieldDefClass.value"}
	6503	+
6282	6504	def decode_selection(%{} = value), do: Selection.from_map(value)
6283	6505	def decode_selection(value) when is_binary(value), do: value
6284	6506	def decode_selection(value) when is_nil(value), do: value
		@@ -6312,7 +6534,7 @@ defmodule ConditionalPredicateTextFieldDefClass do
6312	6534	def from_map(m) do
6313	6535	%ConditionalPredicateTextFieldDefClass{
6314	6536	test: decode_test(m["test"]),
6315		- value: m["value"],
	6537	+ value: m["value"] && decode_value(m["value"]),
6316	6538	selection: decode_selection(m["selection"]),
6317	6539	aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
6318	6540	bin: decode_bin(m["bin"]),
		@@ -6421,6 +6643,18 @@ defmodule TextDefWithCondition do
6421	6643	def encode_field(value) when is_nil(value), do: value
6422	6644	def encode_field(_), do: {:error, "Unexpected type when encoding TextDefWithCondition.field"}
6423	6645
	6646	+ def decode_value(value) when is_boolean(value), do: value
	6647	+ def decode_value(value) when is_float(value), do: value
	6648	+ def decode_value(value) when is_integer(value), do: value
	6649	+ def decode_value(value) when is_binary(value), do: value
	6650	+ def decode_value(_), do: {:error, "Unexpected type when decoding TextDefWithCondition.value"}
	6651	+
	6652	+ def encode_value(value) when is_boolean(value), do: value
	6653	+ def encode_value(value) when is_float(value), do: value
	6654	+ def encode_value(value) when is_integer(value), do: value
	6655	+ def encode_value(value) when is_binary(value), do: value
	6656	+ def encode_value(_), do: {:error, "Unexpected type when encoding TextDefWithCondition.value"}
	6657	+
6424	6658	def from_map(m) do
6425	6659	%TextDefWithCondition{
6426	6660	aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
		@@ -6430,7 +6664,7 @@ defmodule TextDefWithCondition do
6430	6664	format: m["format"],
6431	6665	time_unit: m["timeUnit"] && TimeUnit.decode(m["timeUnit"]),
6432	6666	type: m["type"] && Type.decode(m["type"]),
6433		- value: m["value"],
	6667	+ value: m["value"] && decode_value(m["value"]),
6434	6668	}
6435	6669	end
6436	6670
		@@ -6513,6 +6747,26 @@ defmodule Axis do
6513	6747	zindex: float() | nil
6514	6748	}
6515	6749
	6750	+ def decode_label_bound(value) when is_boolean(value), do: value
	6751	+ def decode_label_bound(value) when is_float(value), do: value
	6752	+ def decode_label_bound(value) when is_integer(value), do: value
	6753	+ def decode_label_bound(_), do: {:error, "Unexpected type when decoding Axis.label_bound"}
	6754	+
	6755	+ def encode_label_bound(value) when is_boolean(value), do: value
	6756	+ def encode_label_bound(value) when is_float(value), do: value
	6757	+ def encode_label_bound(value) when is_integer(value), do: value
	6758	+ def encode_label_bound(_), do: {:error, "Unexpected type when encoding Axis.label_bound"}
	6759	+
	6760	+ def decode_label_flush(value) when is_boolean(value), do: value
	6761	+ def decode_label_flush(value) when is_float(value), do: value
	6762	+ def decode_label_flush(value) when is_integer(value), do: value
	6763	+ def decode_label_flush(_), do: {:error, "Unexpected type when decoding Axis.label_flush"}
	6764	+
	6765	+ def encode_label_flush(value) when is_boolean(value), do: value
	6766	+ def encode_label_flush(value) when is_float(value), do: value
	6767	+ def encode_label_flush(value) when is_integer(value), do: value
	6768	+ def encode_label_flush(_), do: {:error, "Unexpected type when encoding Axis.label_flush"}
	6769	+
6516	6770	def decode_label_overlap(value) when is_boolean(value), do: value
6517	6771	def decode_label_overlap(value) when is_binary(value), do: LabelOverlapEnum.decode(value)
6518	6772	def decode_label_overlap(value) when is_nil(value), do: value
		@@ -6523,6 +6777,14 @@ defmodule Axis do
6523	6777	def encode_label_overlap(value) when is_nil(value), do: value
6524	6778	def encode_label_overlap(_), do: {:error, "Unexpected type when encoding Axis.label_overlap"}
6525	6779
	6780	+ def decode_title(value) when is_nil(value), do: value
	6781	+ def decode_title(value) when is_binary(value), do: value
	6782	+ def decode_title(_), do: {:error, "Unexpected type when decoding Axis.title"}
	6783	+
	6784	+ def encode_title(value) when is_nil(value), do: value
	6785	+ def encode_title(value) when is_binary(value), do: value
	6786	+ def encode_title(_), do: {:error, "Unexpected type when encoding Axis.title"}
	6787	+
6526	6788	def decode_values_element(%{} = value), do: DateTimeClass.from_map(value)
6527	6789	def decode_values_element(value) when is_float(value), do: value
6528	6790	def decode_values_element(value) when is_integer(value), do: value
		@@ -6539,8 +6801,8 @@ defmodule Axis do
6539	6801	format: m["format"],
6540	6802	grid: m["grid"],
6541	6803	label_angle: m["labelAngle"],
6542		- label_bound: m["labelBound"],
6543		- label_flush: m["labelFlush"],
	6804	+ label_bound: m["labelBound"] && decode_label_bound(m["labelBound"]),
	6805	+ label_flush: m["labelFlush"] && decode_label_flush(m["labelFlush"]),
6544	6806	label_overlap: decode_label_overlap(m["labelOverlap"]),
6545	6807	label_padding: m["labelPadding"],
6546	6808	labels: m["labels"],
		@@ -6552,7 +6814,7 @@ defmodule Axis do
6552	6814	tick_count: m["tickCount"],
6553	6815	ticks: m["ticks"],
6554	6816	tick_size: m["tickSize"],
6555		- title: m["title"],
	6817	+ title: m["title"] && decode_title(m["title"]),
6556	6818	title_max_length: m["titleMaxLength"],
6557	6819	title_padding: m["titlePadding"],
6558	6820	values: m["values"] && Enum.map(m["values"], &decode_values_element/1),
		@@ -6664,6 +6926,18 @@ defmodule XClass do
6664	6926	def encode_sort(value) when is_nil(value), do: value
6665	6927	def encode_sort(_), do: {:error, "Unexpected type when encoding XClass.sort"}
6666	6928
	6929	+ def decode_value(value) when is_boolean(value), do: value
	6930	+ def decode_value(value) when is_float(value), do: value
	6931	+ def decode_value(value) when is_integer(value), do: value
	6932	+ def decode_value(value) when is_binary(value), do: value
	6933	+ def decode_value(_), do: {:error, "Unexpected type when decoding XClass.value"}
	6934	+
	6935	+ def encode_value(value) when is_boolean(value), do: value
	6936	+ def encode_value(value) when is_float(value), do: value
	6937	+ def encode_value(value) when is_integer(value), do: value
	6938	+ def encode_value(value) when is_binary(value), do: value
	6939	+ def encode_value(_), do: {:error, "Unexpected type when encoding XClass.value"}
	6940	+
6667	6941	def from_map(m) do
6668	6942	%XClass{
6669	6943	aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
		@@ -6675,7 +6949,7 @@ defmodule XClass do
6675	6949	stack: m["stack"] && StackOffset.decode(m["stack"]),
6676	6950	time_unit: m["timeUnit"] && TimeUnit.decode(m["timeUnit"]),
6677	6951	type: m["type"] && Type.decode(m["type"]),
6678		- value: m["value"],
	6952	+ value: m["value"] && decode_value(m["value"]),
6679	6953	}
6680	6954	end
6681	6955
		@@ -6755,6 +7029,18 @@ defmodule X2Class do
6755	7029	def encode_field(value) when is_nil(value), do: value
6756	7030	def encode_field(_), do: {:error, "Unexpected type when encoding X2Class.field"}
6757	7031
	7032	+ def decode_value(value) when is_boolean(value), do: value
	7033	+ def decode_value(value) when is_float(value), do: value
	7034	+ def decode_value(value) when is_integer(value), do: value
	7035	+ def decode_value(value) when is_binary(value), do: value
	7036	+ def decode_value(_), do: {:error, "Unexpected type when decoding X2Class.value"}
	7037	+
	7038	+ def encode_value(value) when is_boolean(value), do: value
	7039	+ def encode_value(value) when is_float(value), do: value
	7040	+ def encode_value(value) when is_integer(value), do: value
	7041	+ def encode_value(value) when is_binary(value), do: value
	7042	+ def encode_value(_), do: {:error, "Unexpected type when encoding X2Class.value"}
	7043	+
6758	7044	def from_map(m) do
6759	7045	%X2Class{
6760	7046	aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
		@@ -6762,7 +7048,7 @@ defmodule X2Class do
6762	7048	field: decode_field(m["field"]),
6763	7049	time_unit: m["timeUnit"] && TimeUnit.decode(m["timeUnit"]),
6764	7050	type: m["type"] && Type.decode(m["type"]),
6765		- value: m["value"],
	7051	+ value: m["value"] && decode_value(m["value"]),
6766	7052	}
6767	7053	end
6768	7054
		@@ -7710,6 +7996,30 @@ defmodule SelectionDef do
7710	7996	def encode_bind(value) when is_nil(value), do: value
7711	7997	def encode_bind(_), do: {:error, "Unexpected type when encoding SelectionDef.bind"}
7712	7998
	7999	+ def decode_toggle(value) when is_boolean(value), do: value
	8000	+ def decode_toggle(value) when is_binary(value), do: value
	8001	+ def decode_toggle(_), do: {:error, "Unexpected type when decoding SelectionDef.toggle"}
	8002	+
	8003	+ def encode_toggle(value) when is_boolean(value), do: value
	8004	+ def encode_toggle(value) when is_binary(value), do: value
	8005	+ def encode_toggle(_), do: {:error, "Unexpected type when encoding SelectionDef.toggle"}
	8006	+
	8007	+ def decode_translate(value) when is_boolean(value), do: value
	8008	+ def decode_translate(value) when is_binary(value), do: value
	8009	+ def decode_translate(_), do: {:error, "Unexpected type when decoding SelectionDef.translate"}
	8010	+
	8011	+ def encode_translate(value) when is_boolean(value), do: value
	8012	+ def encode_translate(value) when is_binary(value), do: value
	8013	+ def encode_translate(_), do: {:error, "Unexpected type when encoding SelectionDef.translate"}
	8014	+
	8015	+ def decode_zoom(value) when is_boolean(value), do: value
	8016	+ def decode_zoom(value) when is_binary(value), do: value
	8017	+ def decode_zoom(_), do: {:error, "Unexpected type when decoding SelectionDef.zoom"}
	8018	+
	8019	+ def encode_zoom(value) when is_boolean(value), do: value
	8020	+ def encode_zoom(value) when is_binary(value), do: value
	8021	+ def encode_zoom(_), do: {:error, "Unexpected type when encoding SelectionDef.zoom"}
	8022	+
7713	8023	def from_map(m) do
7714	8024	%SelectionDef{
7715	8025	bind: decode_bind(m["bind"]),
		@@ -7720,10 +8030,10 @@ defmodule SelectionDef do
7720	8030	on: m["on"],
7721	8031	resolve: m["resolve"] && SelectionResolution.decode(m["resolve"]),
7722	8032	type: SelectionDefType.decode(m["type"]),
7723		- toggle: m["toggle"],
	8033	+ toggle: m["toggle"] && decode_toggle(m["toggle"]),
7724	8034	mark: m["mark"] && BrushConfig.from_map(m["mark"]),
7725		- translate: m["translate"],
7726		- zoom: m["zoom"],
	8035	+ translate: m["translate"] && decode_translate(m["translate"]),
	8036	+ zoom: m["zoom"] && decode_zoom(m["zoom"]),
7727	8037	}
7728	8038	end