diff --git a/base/elixir/test/inputs/json/misc/050b0.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/050b0.json/default/QuickType.ex
index c3b0990..44b7289 100644
--- a/base/elixir/test/inputs/json/misc/050b0.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/050b0.json/default/QuickType.ex
@@ -248,10 +248,18 @@ defmodule OtherName do
   def encode_name(value) when is_binary(value), do: value
   def encode_name(_), do: {:error, "Unexpected type when encoding OtherName.name"}
 
+  def decode_note(value) when is_nil(value), do: value
+  def decode_note(value) when is_binary(value), do: value
+  def decode_note(_), do: {:error, "Unexpected type when decoding OtherName.note"}
+
+  def encode_note(value) when is_nil(value), do: value
+  def encode_note(value) when is_binary(value), do: value
+  def encode_note(_), do: {:error, "Unexpected type when encoding OtherName.note"}
+
   def from_map(m) do
     %OtherName{
       name: decode_name(m["name"]),
-      note: Map.fetch!(m, "note"),
+      note: decode_note(Map.fetch!(m, "note")),
     }
   end
 
@@ -463,6 +471,14 @@ defmodule TopLevelElement do
   def encode_other_names(value) when is_list(value), do: value
   def encode_other_names(_), do: {:error, "Unexpected type when encoding TopLevelElement.other_names"}
 
+  def decode_superseded_by(value) when is_nil(value), do: value
+  def decode_superseded_by(value) when is_binary(value), do: value
+  def decode_superseded_by(_), do: {:error, "Unexpected type when decoding TopLevelElement.superseded_by"}
+
+  def encode_superseded_by(value) when is_nil(value), do: value
+  def encode_superseded_by(value) when is_binary(value), do: value
+  def encode_superseded_by(_), do: {:error, "Unexpected type when encoding TopLevelElement.superseded_by"}
+
   def decode_text(value) when is_list(value), do: value
   def decode_text(_), do: {:error, "Unexpected type when decoding TopLevelElement.text"}
 
@@ -477,7 +493,7 @@ defmodule TopLevelElement do
       links: Enum.map(m["links"], &Link.from_map/1),
       name: decode_name(m["name"]),
       other_names: Enum.map(m["other_names"], &OtherName.from_map/1),
-      superseded_by: Map.fetch!(m, "superseded_by"),
+      superseded_by: decode_superseded_by(Map.fetch!(m, "superseded_by")),
       text: Enum.map(m["text"], &Text.from_map/1),
     }
   end
diff --git a/base/elixir/test/inputs/json/misc/0a91a.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/0a91a.json/default/QuickType.ex
index 107aa35..10de669 100644
--- a/base/elixir/test/inputs/json/misc/0a91a.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/0a91a.json/default/QuickType.ex
@@ -1573,12 +1573,20 @@ defmodule Payload do
           size: integer() | nil
         }
 
+  def decode_description(value) when is_nil(value), do: value
+  def decode_description(value) when is_binary(value), do: value
+  def decode_description(_), do: {:error, "Unexpected type when decoding Payload.description"}
+
+  def encode_description(value) when is_nil(value), do: value
+  def encode_description(value) when is_binary(value), do: value
+  def encode_description(_), do: {:error, "Unexpected type when encoding Payload.description"}
+
   def from_map(m) do
     %Payload{
       action: m["action"],
       before: m["before"],
       commits: m["commits"] && Enum.map(m["commits"], &Commit.from_map/1),
-      description: m["description"],
+      description: m["description"] && decode_description(m["description"]),
       distinct_size: m["distinct_size"],
       head: m["head"],
       master_branch: m["master_branch"],
diff --git a/base/elixir/test/inputs/json/misc/10be4.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/10be4.json/default/QuickType.ex
index 9425aaf..c51f20c 100644
--- a/base/elixir/test/inputs/json/misc/10be4.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/10be4.json/default/QuickType.ex
@@ -257,10 +257,18 @@ defmodule OtherName do
   def encode_name(value) when is_binary(value), do: value
   def encode_name(_), do: {:error, "Unexpected type when encoding OtherName.name"}
 
+  def decode_note(value) when is_nil(value), do: value
+  def decode_note(value) when is_binary(value), do: value
+  def decode_note(_), do: {:error, "Unexpected type when decoding OtherName.note"}
+
+  def encode_note(value) when is_nil(value), do: value
+  def encode_note(value) when is_binary(value), do: value
+  def encode_note(_), do: {:error, "Unexpected type when encoding OtherName.note"}
+
   def from_map(m) do
     %OtherName{
       name: decode_name(m["name"]),
-      note: Map.fetch!(m, "note"),
+      note: decode_note(Map.fetch!(m, "note")),
     }
   end
 
@@ -474,6 +482,14 @@ defmodule TopLevelElement do
   def encode_other_names(value) when is_list(value), do: value
   def encode_other_names(_), do: {:error, "Unexpected type when encoding TopLevelElement.other_names"}
 
+  def decode_superseded_by(value) when is_nil(value), do: value
+  def decode_superseded_by(value) when is_binary(value), do: value
+  def decode_superseded_by(_), do: {:error, "Unexpected type when decoding TopLevelElement.superseded_by"}
+
+  def encode_superseded_by(value) when is_nil(value), do: value
+  def encode_superseded_by(value) when is_binary(value), do: value
+  def encode_superseded_by(_), do: {:error, "Unexpected type when encoding TopLevelElement.superseded_by"}
+
   def decode_text(value) when is_list(value), do: value
   def decode_text(_), do: {:error, "Unexpected type when decoding TopLevelElement.text"}
 
@@ -488,7 +504,7 @@ defmodule TopLevelElement do
       links: Enum.map(m["links"], &Link.from_map/1),
       name: decode_name(m["name"]),
       other_names: Enum.map(m["other_names"], &OtherName.from_map/1),
-      superseded_by: Map.fetch!(m, "superseded_by"),
+      superseded_by: decode_superseded_by(Map.fetch!(m, "superseded_by")),
       text: Enum.map(m["text"], &Text.from_map/1),
     }
   end
diff --git a/base/elixir/test/inputs/json/misc/1b409.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/1b409.json/default/QuickType.ex
index 7e199b3..819b61d 100644
--- a/base/elixir/test/inputs/json/misc/1b409.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/1b409.json/default/QuickType.ex
@@ -80,6 +80,14 @@ defmodule Extra do
   def encode_address(value) when is_binary(value), do: value
   def encode_address(_), do: {:error, "Unexpected type when encoding Extra.address"}
 
+  def decode_fax(value) when is_nil(value), do: value
+  def decode_fax(value) when is_binary(value), do: value
+  def decode_fax(_), do: {:error, "Unexpected type when decoding Extra.fax"}
+
+  def encode_fax(value) when is_nil(value), do: value
+  def encode_fax(value) when is_binary(value), do: value
+  def encode_fax(_), do: {:error, "Unexpected type when encoding Extra.fax"}
+
   def decode_office(value) when is_binary(value), do: value
   def decode_office(_), do: {:error, "Unexpected type when decoding Extra.office"}
 
@@ -90,7 +98,7 @@ defmodule Extra do
     %Extra{
       address: decode_address(m["address"]),
       contact_form: m["contact_form"],
-      fax: m["fax"],
+      fax: m["fax"] && decode_fax(m["fax"]),
       office: decode_office(m["office"]),
       rss_url: m["rss_url"],
     }
@@ -397,12 +405,36 @@ defmodule Person do
   def encode_osid(value) when is_binary(value), do: value
   def encode_osid(_), do: {:error, "Unexpected type when encoding Person.osid"}
 
+  def decode_pvsid(value) when is_nil(value), do: value
+  def decode_pvsid(value) when is_binary(value), do: value
+  def decode_pvsid(_), do: {:error, "Unexpected type when decoding Person.pvsid"}
+
+  def encode_pvsid(value) when is_nil(value), do: value
+  def encode_pvsid(value) when is_binary(value), do: value
+  def encode_pvsid(_), do: {:error, "Unexpected type when encoding Person.pvsid"}
+
   def decode_sortname(value) when is_binary(value), do: value
   def decode_sortname(_), do: {:error, "Unexpected type when decoding Person.sortname"}
 
   def encode_sortname(value) when is_binary(value), do: value
   def encode_sortname(_), do: {:error, "Unexpected type when encoding Person.sortname"}
 
+  def decode_twitterid(value) when is_nil(value), do: value
+  def decode_twitterid(value) when is_binary(value), do: value
+  def decode_twitterid(_), do: {:error, "Unexpected type when decoding Person.twitterid"}
+
+  def encode_twitterid(value) when is_nil(value), do: value
+  def encode_twitterid(value) when is_binary(value), do: value
+  def encode_twitterid(_), do: {:error, "Unexpected type when encoding Person.twitterid"}
+
+  def decode_youtubeid(value) when is_nil(value), do: value
+  def decode_youtubeid(value) when is_binary(value), do: value
+  def decode_youtubeid(_), do: {:error, "Unexpected type when decoding Person.youtubeid"}
+
+  def encode_youtubeid(value) when is_nil(value), do: value
+  def encode_youtubeid(value) when is_binary(value), do: value
+  def encode_youtubeid(_), do: {:error, "Unexpected type when encoding Person.youtubeid"}
+
   def from_map(m) do
     %Person{
       bioguideid: decode_bioguideid(m["bioguideid"]),
@@ -419,10 +451,10 @@ defmodule Person do
       namemod: Namemod.decode(m["namemod"]),
       nickname: decode_nickname(m["nickname"]),
       osid: decode_osid(m["osid"]),
-      pvsid: Map.fetch!(m, "pvsid"),
+      pvsid: decode_pvsid(Map.fetch!(m, "pvsid")),
       sortname: decode_sortname(m["sortname"]),
-      twitterid: Map.fetch!(m, "twitterid"),
-      youtubeid: Map.fetch!(m, "youtubeid"),
+      twitterid: decode_twitterid(Map.fetch!(m, "twitterid")),
+      youtubeid: decode_youtubeid(Map.fetch!(m, "youtubeid")),
     }
   end
 
@@ -670,6 +702,14 @@ defmodule Object do
   def encode_id(value) when is_integer(value), do: value
   def encode_id(_), do: {:error, "Unexpected type when encoding Object.id"}
 
+  def decode_leadership_title(value) when is_nil(value), do: value
+  def decode_leadership_title(value) when is_binary(value), do: value
+  def decode_leadership_title(_), do: {:error, "Unexpected type when decoding Object.leadership_title"}
+
+  def encode_leadership_title(value) when is_nil(value), do: value
+  def encode_leadership_title(value) when is_binary(value), do: value
+  def encode_leadership_title(_), do: {:error, "Unexpected type when encoding Object.leadership_title"}
+
   def decode_phone(value) when is_binary(value), do: value
   def decode_phone(_), do: {:error, "Unexpected type when decoding Object.phone"}
 
@@ -716,7 +756,7 @@ defmodule Object do
       enddate: decode_enddate(m["enddate"]),
       extra: Extra.from_map(m["extra"]),
       id: decode_id(m["id"]),
-      leadership_title: Map.fetch!(m, "leadership_title"),
+      leadership_title: decode_leadership_title(Map.fetch!(m, "leadership_title")),
       party: Party.decode(m["party"]),
       person: Person.from_map(m["person"]),
       phone: decode_phone(m["phone"]),
diff --git a/base/elixir/test/inputs/json/misc/27332.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/27332.json/default/QuickType.ex
index be06071..1da5627 100644
--- a/base/elixir/test/inputs/json/misc/27332.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/27332.json/default/QuickType.ex
@@ -777,6 +777,22 @@ defmodule ChildData do
   def encode_author(value) when is_binary(value), do: value
   def encode_author(_), do: {:error, "Unexpected type when encoding ChildData.author"}
 
+  def decode_author_flair_css_class(value) when is_nil(value), do: value
+  def decode_author_flair_css_class(value) when is_binary(value), do: value
+  def decode_author_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_css_class"}
+
+  def encode_author_flair_css_class(value) when is_nil(value), do: value
+  def encode_author_flair_css_class(value) when is_binary(value), do: value
+  def encode_author_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_css_class"}
+
+  def decode_author_flair_text(value) when is_nil(value), do: value
+  def decode_author_flair_text(value) when is_binary(value), do: value
+  def decode_author_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_text"}
+
+  def encode_author_flair_text(value) when is_nil(value), do: value
+  def encode_author_flair_text(value) when is_binary(value), do: value
+  def encode_author_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_text"}
+
   def decode_banned_at_utc(value) when is_nil(value), do: value
   def decode_banned_at_utc(_), do: {:error, "Unexpected type when decoding ChildData.banned_at_utc"}
 
@@ -835,6 +851,14 @@ defmodule ChildData do
   def encode_created_utc(value) when is_integer(value), do: value
   def encode_created_utc(_), do: {:error, "Unexpected type when encoding ChildData.created_utc"}
 
+  def decode_distinguished(value) when is_nil(value), do: value
+  def decode_distinguished(value) when is_binary(value), do: value
+  def decode_distinguished(_), do: {:error, "Unexpected type when decoding ChildData.distinguished"}
+
+  def encode_distinguished(value) when is_nil(value), do: value
+  def encode_distinguished(value) when is_binary(value), do: value
+  def encode_distinguished(_), do: {:error, "Unexpected type when encoding ChildData.distinguished"}
+
   def decode_downs(value) when is_integer(value), do: value
   def decode_downs(_), do: {:error, "Unexpected type when decoding ChildData.downs"}
 
@@ -889,6 +913,22 @@ defmodule ChildData do
   def encode_likes(value) when is_nil(value), do: value
   def encode_likes(_), do: {:error, "Unexpected type when encoding ChildData.likes"}
 
+  def decode_link_flair_css_class(value) when is_nil(value), do: value
+  def decode_link_flair_css_class(value) when is_binary(value), do: value
+  def decode_link_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_css_class"}
+
+  def encode_link_flair_css_class(value) when is_nil(value), do: value
+  def encode_link_flair_css_class(value) when is_binary(value), do: value
+  def encode_link_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_css_class"}
+
+  def decode_link_flair_text(value) when is_nil(value), do: value
+  def decode_link_flair_text(value) when is_binary(value), do: value
+  def decode_link_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_text"}
+
+  def encode_link_flair_text(value) when is_nil(value), do: value
+  def encode_link_flair_text(value) when is_binary(value), do: value
+  def encode_link_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_text"}
+
   def decode_locked(value) when is_boolean(value), do: value
   def decode_locked(_), do: {:error, "Unexpected type when decoding ChildData.locked"}
 
@@ -967,6 +1007,14 @@ defmodule ChildData do
   def encode_selftext(value) when is_binary(value), do: value
   def encode_selftext(_), do: {:error, "Unexpected type when encoding ChildData.selftext"}
 
+  def decode_selftext_html(value) when is_nil(value), do: value
+  def decode_selftext_html(value) when is_binary(value), do: value
+  def decode_selftext_html(_), do: {:error, "Unexpected type when decoding ChildData.selftext_html"}
+
+  def encode_selftext_html(value) when is_nil(value), do: value
+  def encode_selftext_html(value) when is_binary(value), do: value
+  def encode_selftext_html(_), do: {:error, "Unexpected type when encoding ChildData.selftext_html"}
+
   def decode_spoiler(value) when is_boolean(value), do: value
   def decode_spoiler(_), do: {:error, "Unexpected type when decoding ChildData.spoiler"}
 
@@ -991,6 +1039,22 @@ defmodule ChildData do
   def encode_thumbnail(value) when is_binary(value), do: value
   def encode_thumbnail(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail"}
 
+  def decode_thumbnail_height(value) when is_integer(value), do: value
+  def decode_thumbnail_height(value) when is_nil(value), do: value
+  def decode_thumbnail_height(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_height"}
+
+  def encode_thumbnail_height(value) when is_integer(value), do: value
+  def encode_thumbnail_height(value) when is_nil(value), do: value
+  def encode_thumbnail_height(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_height"}
+
+  def decode_thumbnail_width(value) when is_integer(value), do: value
+  def decode_thumbnail_width(value) when is_nil(value), do: value
+  def decode_thumbnail_width(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_width"}
+
+  def encode_thumbnail_width(value) when is_integer(value), do: value
+  def encode_thumbnail_width(value) when is_nil(value), do: value
+  def encode_thumbnail_width(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_width"}
+
   def decode_title(value) when is_binary(value), do: value
   def decode_title(_), do: {:error, "Unexpected type when decoding ChildData.title"}
 
@@ -1033,8 +1097,8 @@ defmodule ChildData do
       approved_by: decode_approved_by(m["approved_by"]),
       archived: decode_archived(m["archived"]),
       author: decode_author(m["author"]),
-      author_flair_css_class: Map.fetch!(m, "author_flair_css_class"),
-      author_flair_text: Map.fetch!(m, "author_flair_text"),
+      author_flair_css_class: decode_author_flair_css_class(Map.fetch!(m, "author_flair_css_class")),
+      author_flair_text: decode_author_flair_text(Map.fetch!(m, "author_flair_text")),
       banned_at_utc: decode_banned_at_utc(m["banned_at_utc"]),
       banned_by: decode_banned_by(m["banned_by"]),
       brand_safe: decode_brand_safe(m["brand_safe"]),
@@ -1044,7 +1108,7 @@ defmodule ChildData do
       contest_mode: decode_contest_mode(m["contest_mode"]),
       created: decode_created(m["created"]),
       created_utc: decode_created_utc(m["created_utc"]),
-      distinguished: Map.fetch!(m, "distinguished"),
+      distinguished: decode_distinguished(Map.fetch!(m, "distinguished")),
       domain: Domain.decode(m["domain"]),
       downs: decode_downs(m["downs"]),
       edited: decode_edited(m["edited"]),
@@ -1055,8 +1119,8 @@ defmodule ChildData do
       is_self: decode_is_self(m["is_self"]),
       is_video: decode_is_video(m["is_video"]),
       likes: decode_likes(m["likes"]),
-      link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
-      link_flair_text: Map.fetch!(m, "link_flair_text"),
+      link_flair_css_class: decode_link_flair_css_class(Map.fetch!(m, "link_flair_css_class")),
+      link_flair_text: decode_link_flair_text(Map.fetch!(m, "link_flair_text")),
       locked: decode_locked(m["locked"]),
       media: m["media"] && Media.from_map(m["media"]),
       media_embed: MediaEmbed.from_map(m["media_embed"]),
@@ -1076,7 +1140,7 @@ defmodule ChildData do
       secure_media: m["secure_media"] && Media.from_map(m["secure_media"]),
       secure_media_embed: MediaEmbed.from_map(m["secure_media_embed"]),
       selftext: decode_selftext(m["selftext"]),
-      selftext_html: Map.fetch!(m, "selftext_html"),
+      selftext_html: decode_selftext_html(Map.fetch!(m, "selftext_html")),
       spoiler: decode_spoiler(m["spoiler"]),
       stickied: decode_stickied(m["stickied"]),
       subreddit: Subreddit.decode(m["subreddit"]),
@@ -1085,8 +1149,8 @@ defmodule ChildData do
       subreddit_type: SubredditType.decode(m["subreddit_type"]),
       suggested_sort: decode_suggested_sort(m["suggested_sort"]),
       thumbnail: decode_thumbnail(m["thumbnail"]),
-      thumbnail_height: Map.fetch!(m, "thumbnail_height"),
-      thumbnail_width: Map.fetch!(m, "thumbnail_width"),
+      thumbnail_height: decode_thumbnail_height(Map.fetch!(m, "thumbnail_height")),
+      thumbnail_width: decode_thumbnail_width(Map.fetch!(m, "thumbnail_width")),
       title: decode_title(m["title"]),
       ups: decode_ups(m["ups"]),
       url: decode_url(m["url"]),
diff --git a/base/elixir/test/inputs/json/misc/29f47.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/29f47.json/default/QuickType.ex
index bf1c5b8..93285c7 100644
--- a/base/elixir/test/inputs/json/misc/29f47.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/29f47.json/default/QuickType.ex
@@ -758,6 +758,16 @@ defmodule ChildData do
   def encode_downs(value) when is_integer(value), do: value
   def encode_downs(_), do: {:error, "Unexpected type when encoding ChildData.downs"}
 
+  def decode_edited(value) when is_boolean(value), do: value
+  def decode_edited(value) when is_float(value), do: value
+  def decode_edited(value) when is_integer(value), do: value
+  def decode_edited(_), do: {:error, "Unexpected type when decoding ChildData.edited"}
+
+  def encode_edited(value) when is_boolean(value), do: value
+  def encode_edited(value) when is_float(value), do: value
+  def encode_edited(value) when is_integer(value), do: value
+  def encode_edited(_), do: {:error, "Unexpected type when encoding ChildData.edited"}
+
   def decode_gilded(value) when is_integer(value), do: value
   def decode_gilded(_), do: {:error, "Unexpected type when decoding ChildData.gilded"}
 
@@ -902,6 +912,14 @@ defmodule ChildData do
   def encode_selftext(value) when is_binary(value), do: value
   def encode_selftext(_), do: {:error, "Unexpected type when encoding ChildData.selftext"}
 
+  def decode_selftext_html(value) when is_nil(value), do: value
+  def decode_selftext_html(value) when is_binary(value), do: value
+  def decode_selftext_html(_), do: {:error, "Unexpected type when decoding ChildData.selftext_html"}
+
+  def encode_selftext_html(value) when is_nil(value), do: value
+  def encode_selftext_html(value) when is_binary(value), do: value
+  def encode_selftext_html(_), do: {:error, "Unexpected type when encoding ChildData.selftext_html"}
+
   def decode_spoiler(value) when is_boolean(value), do: value
   def decode_spoiler(_), do: {:error, "Unexpected type when decoding ChildData.spoiler"}
 
@@ -914,12 +932,36 @@ defmodule ChildData do
   def encode_stickied(value) when is_boolean(value), do: value
   def encode_stickied(_), do: {:error, "Unexpected type when encoding ChildData.stickied"}
 
+  def decode_suggested_sort(value) when is_nil(value), do: value
+  def decode_suggested_sort(value) when is_binary(value), do: value
+  def decode_suggested_sort(_), do: {:error, "Unexpected type when decoding ChildData.suggested_sort"}
+
+  def encode_suggested_sort(value) when is_nil(value), do: value
+  def encode_suggested_sort(value) when is_binary(value), do: value
+  def encode_suggested_sort(_), do: {:error, "Unexpected type when encoding ChildData.suggested_sort"}
+
   def decode_thumbnail(value) when is_binary(value), do: value
   def decode_thumbnail(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail"}
 
   def encode_thumbnail(value) when is_binary(value), do: value
   def encode_thumbnail(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail"}
 
+  def decode_thumbnail_height(value) when is_integer(value), do: value
+  def decode_thumbnail_height(value) when is_nil(value), do: value
+  def decode_thumbnail_height(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_height"}
+
+  def encode_thumbnail_height(value) when is_integer(value), do: value
+  def encode_thumbnail_height(value) when is_nil(value), do: value
+  def encode_thumbnail_height(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_height"}
+
+  def decode_thumbnail_width(value) when is_integer(value), do: value
+  def decode_thumbnail_width(value) when is_nil(value), do: value
+  def decode_thumbnail_width(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_width"}
+
+  def encode_thumbnail_width(value) when is_integer(value), do: value
+  def encode_thumbnail_width(value) when is_nil(value), do: value
+  def encode_thumbnail_width(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_width"}
+
   def decode_title(value) when is_binary(value), do: value
   def decode_title(_), do: {:error, "Unexpected type when decoding ChildData.title"}
 
@@ -976,7 +1018,7 @@ defmodule ChildData do
       distinguished: Distinguished.decode(m["distinguished"]),
       domain: Domain.decode(m["domain"]),
       downs: decode_downs(m["downs"]),
-      edited: Map.fetch!(m, "edited"),
+      edited: decode_edited(Map.fetch!(m, "edited")),
       gilded: decode_gilded(m["gilded"]),
       hidden: decode_hidden(m["hidden"]),
       hide_score: decode_hide_score(m["hide_score"]),
@@ -1005,17 +1047,17 @@ defmodule ChildData do
       secure_media: decode_secure_media(m["secure_media"]),
       secure_media_embed: MediaEmbed.from_map(m["secure_media_embed"]),
       selftext: decode_selftext(m["selftext"]),
-      selftext_html: Map.fetch!(m, "selftext_html"),
+      selftext_html: decode_selftext_html(Map.fetch!(m, "selftext_html")),
       spoiler: decode_spoiler(m["spoiler"]),
       stickied: decode_stickied(m["stickied"]),
       subreddit: Subreddit.decode(m["subreddit"]),
       subreddit_id: SubredditID.decode(m["subreddit_id"]),
       subreddit_name_prefixed: SubredditNamePrefixed.decode(m["subreddit_name_prefixed"]),
       subreddit_type: SubredditType.decode(m["subreddit_type"]),
-      suggested_sort: Map.fetch!(m, "suggested_sort"),
+      suggested_sort: decode_suggested_sort(Map.fetch!(m, "suggested_sort")),
       thumbnail: decode_thumbnail(m["thumbnail"]),
-      thumbnail_height: Map.fetch!(m, "thumbnail_height"),
-      thumbnail_width: Map.fetch!(m, "thumbnail_width"),
+      thumbnail_height: decode_thumbnail_height(Map.fetch!(m, "thumbnail_height")),
+      thumbnail_width: decode_thumbnail_width(Map.fetch!(m, "thumbnail_width")),
       title: decode_title(m["title"]),
       ups: decode_ups(m["ups"]),
       url: decode_url(m["url"]),
diff --git a/base/elixir/test/inputs/json/misc/2d4e2.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/2d4e2.json/default/QuickType.ex
index 1c2e2fc..dc26f7f 100644
--- a/base/elixir/test/inputs/json/misc/2d4e2.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/2d4e2.json/default/QuickType.ex
@@ -414,6 +414,22 @@ defmodule Person do
   def encode_sortname(value) when is_binary(value), do: value
   def encode_sortname(_), do: {:error, "Unexpected type when encoding Person.sortname"}
 
+  def decode_twitterid(value) when is_nil(value), do: value
+  def decode_twitterid(value) when is_binary(value), do: value
+  def decode_twitterid(_), do: {:error, "Unexpected type when decoding Person.twitterid"}
+
+  def encode_twitterid(value) when is_nil(value), do: value
+  def encode_twitterid(value) when is_binary(value), do: value
+  def encode_twitterid(_), do: {:error, "Unexpected type when encoding Person.twitterid"}
+
+  def decode_youtubeid(value) when is_nil(value), do: value
+  def decode_youtubeid(value) when is_binary(value), do: value
+  def decode_youtubeid(_), do: {:error, "Unexpected type when decoding Person.youtubeid"}
+
+  def encode_youtubeid(value) when is_nil(value), do: value
+  def encode_youtubeid(value) when is_binary(value), do: value
+  def encode_youtubeid(_), do: {:error, "Unexpected type when encoding Person.youtubeid"}
+
   def from_map(m) do
     %Person{
       bioguideid: decode_bioguideid(m["bioguideid"]),
@@ -432,8 +448,8 @@ defmodule Person do
       osid: decode_osid(m["osid"]),
       pvsid: decode_pvsid(m["pvsid"]),
       sortname: decode_sortname(m["sortname"]),
-      twitterid: Map.fetch!(m, "twitterid"),
-      youtubeid: Map.fetch!(m, "youtubeid"),
+      twitterid: decode_twitterid(Map.fetch!(m, "twitterid")),
+      youtubeid: decode_youtubeid(Map.fetch!(m, "youtubeid")),
     }
   end
 
@@ -860,6 +876,14 @@ defmodule Object do
   def encode_id(value) when is_integer(value), do: value
   def encode_id(_), do: {:error, "Unexpected type when encoding Object.id"}
 
+  def decode_leadership_title(value) when is_nil(value), do: value
+  def decode_leadership_title(value) when is_binary(value), do: value
+  def decode_leadership_title(_), do: {:error, "Unexpected type when decoding Object.leadership_title"}
+
+  def encode_leadership_title(value) when is_nil(value), do: value
+  def encode_leadership_title(value) when is_binary(value), do: value
+  def encode_leadership_title(_), do: {:error, "Unexpected type when encoding Object.leadership_title"}
+
   def decode_phone(value) when is_binary(value), do: value
   def decode_phone(_), do: {:error, "Unexpected type when decoding Object.phone"}
 
@@ -894,7 +918,7 @@ defmodule Object do
       enddate: decode_enddate(m["enddate"]),
       extra: Extra.from_map(m["extra"]),
       id: decode_id(m["id"]),
-      leadership_title: Map.fetch!(m, "leadership_title"),
+      leadership_title: decode_leadership_title(Map.fetch!(m, "leadership_title")),
       party: Party.decode(m["party"]),
       person: Person.from_map(m["person"]),
       phone: decode_phone(m["phone"]),
diff --git a/base/elixir/test/inputs/json/misc/32431.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/32431.json/default/QuickType.ex
index 9d90f88..ab8b96c 100644
--- a/base/elixir/test/inputs/json/misc/32431.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/32431.json/default/QuickType.ex
@@ -287,12 +287,30 @@ defmodule Properties do
   def encode_detail(value) when is_binary(value), do: value
   def encode_detail(_), do: {:error, "Unexpected type when encoding Properties.detail"}
 
+  def decode_dmin(value) when is_float(value), do: value
+  def decode_dmin(value) when is_integer(value), do: value
+  def decode_dmin(value) when is_nil(value), do: value
+  def decode_dmin(_), do: {:error, "Unexpected type when decoding Properties.dmin"}
+
+  def encode_dmin(value) when is_float(value), do: value
+  def encode_dmin(value) when is_integer(value), do: value
+  def encode_dmin(value) when is_nil(value), do: value
+  def encode_dmin(_), do: {:error, "Unexpected type when encoding Properties.dmin"}
+
   def decode_felt(value) when is_nil(value), do: value
   def decode_felt(_), do: {:error, "Unexpected type when decoding Properties.felt"}
 
   def encode_felt(value) when is_nil(value), do: value
   def encode_felt(_), do: {:error, "Unexpected type when encoding Properties.felt"}
 
+  def decode_gap(value) when is_integer(value), do: value
+  def decode_gap(value) when is_nil(value), do: value
+  def decode_gap(_), do: {:error, "Unexpected type when decoding Properties.gap"}
+
+  def encode_gap(value) when is_integer(value), do: value
+  def encode_gap(value) when is_nil(value), do: value
+  def encode_gap(_), do: {:error, "Unexpected type when encoding Properties.gap"}
+
   def decode_ids(value) when is_binary(value), do: value
   def decode_ids(_), do: {:error, "Unexpected type when decoding Properties.ids"}
 
@@ -319,6 +337,14 @@ defmodule Properties do
   def encode_net(value) when is_binary(value), do: value
   def encode_net(_), do: {:error, "Unexpected type when encoding Properties.net"}
 
+  def decode_nst(value) when is_integer(value), do: value
+  def decode_nst(value) when is_nil(value), do: value
+  def decode_nst(_), do: {:error, "Unexpected type when decoding Properties.nst"}
+
+  def encode_nst(value) when is_integer(value), do: value
+  def encode_nst(value) when is_nil(value), do: value
+  def encode_nst(_), do: {:error, "Unexpected type when encoding Properties.nst"}
+
   def decode_place(value) when is_binary(value), do: value
   def decode_place(_), do: {:error, "Unexpected type when decoding Properties.place"}
 
@@ -393,15 +419,15 @@ defmodule Properties do
       cdi: decode_cdi(m["cdi"]),
       code: decode_code(m["code"]),
       detail: decode_detail(m["detail"]),
-      dmin: Map.fetch!(m, "dmin"),
+      dmin: decode_dmin(Map.fetch!(m, "dmin")),
       felt: decode_felt(m["felt"]),
-      gap: Map.fetch!(m, "gap"),
+      gap: decode_gap(Map.fetch!(m, "gap")),
       ids: decode_ids(m["ids"]),
       mag: decode_mag(m["mag"]),
       mag_type: MagType.decode(m["magType"]),
       mmi: decode_mmi(m["mmi"]),
       net: decode_net(m["net"]),
-      nst: Map.fetch!(m, "nst"),
+      nst: decode_nst(Map.fetch!(m, "nst")),
       place: decode_place(m["place"]),
       rms: decode_rms(m["rms"]),
       sig: decode_sig(m["sig"]),
diff --git a/base/elixir/test/inputs/json/misc/32d5c.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/32d5c.json/default/QuickType.ex
index 6889b82..39f0048 100644
--- a/base/elixir/test/inputs/json/misc/32d5c.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/32d5c.json/default/QuickType.ex
@@ -20,6 +20,14 @@ defmodule TopLevelElement do
           preferred_name: String.t()
         }
 
+  def decode_birth_date(value) when is_nil(value), do: value
+  def decode_birth_date(value) when is_binary(value), do: value
+  def decode_birth_date(_), do: {:error, "Unexpected type when decoding TopLevelElement.birth_date"}
+
+  def encode_birth_date(value) when is_nil(value), do: value
+  def encode_birth_date(value) when is_binary(value), do: value
+  def encode_birth_date(_), do: {:error, "Unexpected type when encoding TopLevelElement.birth_date"}
+
   def decode_birth_date_is_protected(value) when is_boolean(value), do: value
   def decode_birth_date_is_protected(_), do: {:error, "Unexpected type when decoding TopLevelElement.birth_date_is_protected"}
 
@@ -64,7 +72,7 @@ defmodule TopLevelElement do
 
   def from_map(m) do
     %TopLevelElement{
-      birth_date: Map.fetch!(m, "BirthDate"),
+      birth_date: decode_birth_date(Map.fetch!(m, "BirthDate")),
       birth_date_is_protected: decode_birth_date_is_protected(m["BirthDateIsProtected"]),
       gender_type_id: decode_gender_type_id(m["GenderTypeID"]),
       notes: decode_notes(m["Notes"]),
diff --git a/base/elixir/test/inputs/json/misc/337ed.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/337ed.json/default/QuickType.ex
index 3b174ee..f467b6f 100644
--- a/base/elixir/test/inputs/json/misc/337ed.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/337ed.json/default/QuickType.ex
@@ -302,6 +302,30 @@ defmodule Result do
           uri: String.t()
         }
 
+  def decode_cost_absolute(value) when is_integer(value), do: value
+  def decode_cost_absolute(value) when is_nil(value), do: value
+  def decode_cost_absolute(_), do: {:error, "Unexpected type when decoding Result.cost_absolute"}
+
+  def encode_cost_absolute(value) when is_integer(value), do: value
+  def encode_cost_absolute(value) when is_nil(value), do: value
+  def encode_cost_absolute(_), do: {:error, "Unexpected type when encoding Result.cost_absolute"}
+
+  def decode_cost_max(value) when is_integer(value), do: value
+  def decode_cost_max(value) when is_nil(value), do: value
+  def decode_cost_max(_), do: {:error, "Unexpected type when decoding Result.cost_max"}
+
+  def encode_cost_max(value) when is_integer(value), do: value
+  def encode_cost_max(value) when is_nil(value), do: value
+  def encode_cost_max(_), do: {:error, "Unexpected type when encoding Result.cost_max"}
+
+  def decode_cost_min(value) when is_integer(value), do: value
+  def decode_cost_min(value) when is_nil(value), do: value
+  def decode_cost_min(_), do: {:error, "Unexpected type when decoding Result.cost_min"}
+
+  def encode_cost_min(value) when is_integer(value), do: value
+  def encode_cost_min(value) when is_nil(value), do: value
+  def encode_cost_min(_), do: {:error, "Unexpected type when encoding Result.cost_min"}
+
   def decode_created_at(value) when is_binary(value), do: value
   def decode_created_at(_), do: {:error, "Unexpected type when decoding Result.created_at"}
 
@@ -338,12 +362,28 @@ defmodule Result do
   def encode_eur_sources_grants(value) when is_integer(value), do: value
   def encode_eur_sources_grants(_), do: {:error, "Unexpected type when encoding Result.eur_sources_grants"}
 
+  def decode_eur_sources_grants_src(value) when is_nil(value), do: value
+  def decode_eur_sources_grants_src(value) when is_binary(value), do: value
+  def decode_eur_sources_grants_src(_), do: {:error, "Unexpected type when decoding Result.eur_sources_grants_src"}
+
+  def encode_eur_sources_grants_src(value) when is_nil(value), do: value
+  def encode_eur_sources_grants_src(value) when is_binary(value), do: value
+  def encode_eur_sources_grants_src(_), do: {:error, "Unexpected type when encoding Result.eur_sources_grants_src"}
+
   def decode_eur_sources_procurement(value) when is_integer(value), do: value
   def decode_eur_sources_procurement(_), do: {:error, "Unexpected type when decoding Result.eur_sources_procurement"}
 
   def encode_eur_sources_procurement(value) when is_integer(value), do: value
   def encode_eur_sources_procurement(_), do: {:error, "Unexpected type when encoding Result.eur_sources_procurement"}
 
+  def decode_eur_sources_procurement_src(value) when is_nil(value), do: value
+  def decode_eur_sources_procurement_src(value) when is_binary(value), do: value
+  def decode_eur_sources_procurement_src(_), do: {:error, "Unexpected type when decoding Result.eur_sources_procurement_src"}
+
+  def encode_eur_sources_procurement_src(value) when is_nil(value), do: value
+  def encode_eur_sources_procurement_src(value) when is_binary(value), do: value
+  def encode_eur_sources_procurement_src(_), do: {:error, "Unexpected type when encoding Result.eur_sources_procurement_src"}
+
   def decode_id(value) when is_binary(value), do: value
   def decode_id(_), do: {:error, "Unexpected type when decoding Result.id"}
 
@@ -356,6 +396,70 @@ defmodule Result do
   def encode_new_organisation(value) when is_nil(value), do: value
   def encode_new_organisation(_), do: {:error, "Unexpected type when encoding Result.new_organisation"}
 
+  def decode_no_clients(value) when is_nil(value), do: value
+  def decode_no_clients(value) when is_binary(value), do: value
+  def decode_no_clients(_), do: {:error, "Unexpected type when decoding Result.no_clients"}
+
+  def encode_no_clients(value) when is_nil(value), do: value
+  def encode_no_clients(value) when is_binary(value), do: value
+  def encode_no_clients(_), do: {:error, "Unexpected type when encoding Result.no_clients"}
+
+  def decode_other_financial_information(value) when is_nil(value), do: value
+  def decode_other_financial_information(value) when is_binary(value), do: value
+  def decode_other_financial_information(_), do: {:error, "Unexpected type when decoding Result.other_financial_information"}
+
+  def encode_other_financial_information(value) when is_nil(value), do: value
+  def encode_other_financial_information(value) when is_binary(value), do: value
+  def encode_other_financial_information(_), do: {:error, "Unexpected type when encoding Result.other_financial_information"}
+
+  def decode_other_sources_contributions(value) when is_integer(value), do: value
+  def decode_other_sources_contributions(value) when is_nil(value), do: value
+  def decode_other_sources_contributions(_), do: {:error, "Unexpected type when decoding Result.other_sources_contributions"}
+
+  def encode_other_sources_contributions(value) when is_integer(value), do: value
+  def encode_other_sources_contributions(value) when is_nil(value), do: value
+  def encode_other_sources_contributions(_), do: {:error, "Unexpected type when encoding Result.other_sources_contributions"}
+
+  def decode_other_sources_donation(value) when is_integer(value), do: value
+  def decode_other_sources_donation(value) when is_nil(value), do: value
+  def decode_other_sources_donation(_), do: {:error, "Unexpected type when decoding Result.other_sources_donation"}
+
+  def encode_other_sources_donation(value) when is_integer(value), do: value
+  def encode_other_sources_donation(value) when is_nil(value), do: value
+  def encode_other_sources_donation(_), do: {:error, "Unexpected type when encoding Result.other_sources_donation"}
+
+  def decode_other_sources_total(value) when is_integer(value), do: value
+  def decode_other_sources_total(value) when is_nil(value), do: value
+  def decode_other_sources_total(_), do: {:error, "Unexpected type when decoding Result.other_sources_total"}
+
+  def encode_other_sources_total(value) when is_integer(value), do: value
+  def encode_other_sources_total(value) when is_nil(value), do: value
+  def encode_other_sources_total(_), do: {:error, "Unexpected type when encoding Result.other_sources_total"}
+
+  def decode_public_financing_infranational(value) when is_integer(value), do: value
+  def decode_public_financing_infranational(value) when is_nil(value), do: value
+  def decode_public_financing_infranational(_), do: {:error, "Unexpected type when decoding Result.public_financing_infranational"}
+
+  def encode_public_financing_infranational(value) when is_integer(value), do: value
+  def encode_public_financing_infranational(value) when is_nil(value), do: value
+  def encode_public_financing_infranational(_), do: {:error, "Unexpected type when encoding Result.public_financing_infranational"}
+
+  def decode_public_financing_national(value) when is_integer(value), do: value
+  def decode_public_financing_national(value) when is_nil(value), do: value
+  def decode_public_financing_national(_), do: {:error, "Unexpected type when decoding Result.public_financing_national"}
+
+  def encode_public_financing_national(value) when is_integer(value), do: value
+  def encode_public_financing_national(value) when is_nil(value), do: value
+  def encode_public_financing_national(_), do: {:error, "Unexpected type when encoding Result.public_financing_national"}
+
+  def decode_public_financing_total(value) when is_integer(value), do: value
+  def decode_public_financing_total(value) when is_nil(value), do: value
+  def decode_public_financing_total(_), do: {:error, "Unexpected type when decoding Result.public_financing_total"}
+
+  def encode_public_financing_total(value) when is_integer(value), do: value
+  def encode_public_financing_total(value) when is_nil(value), do: value
+  def encode_public_financing_total(_), do: {:error, "Unexpected type when encoding Result.public_financing_total"}
+
   def decode_representative(value) when is_binary(value), do: value
   def decode_representative(_), do: {:error, "Unexpected type when decoding Result.representative"}
 
@@ -368,6 +472,38 @@ defmodule Result do
   def encode_start_date(value) when is_binary(value), do: value
   def encode_start_date(_), do: {:error, "Unexpected type when encoding Result.start_date"}
 
+  def decode_total_budget(value) when is_integer(value), do: value
+  def decode_total_budget(value) when is_nil(value), do: value
+  def decode_total_budget(_), do: {:error, "Unexpected type when decoding Result.total_budget"}
+
+  def encode_total_budget(value) when is_integer(value), do: value
+  def encode_total_budget(value) when is_nil(value), do: value
+  def encode_total_budget(_), do: {:error, "Unexpected type when encoding Result.total_budget"}
+
+  def decode_turnover_absolute(value) when is_integer(value), do: value
+  def decode_turnover_absolute(value) when is_nil(value), do: value
+  def decode_turnover_absolute(_), do: {:error, "Unexpected type when decoding Result.turnover_absolute"}
+
+  def encode_turnover_absolute(value) when is_integer(value), do: value
+  def encode_turnover_absolute(value) when is_nil(value), do: value
+  def encode_turnover_absolute(_), do: {:error, "Unexpected type when encoding Result.turnover_absolute"}
+
+  def decode_turnover_max(value) when is_integer(value), do: value
+  def decode_turnover_max(value) when is_nil(value), do: value
+  def decode_turnover_max(_), do: {:error, "Unexpected type when decoding Result.turnover_max"}
+
+  def encode_turnover_max(value) when is_integer(value), do: value
+  def encode_turnover_max(value) when is_nil(value), do: value
+  def encode_turnover_max(_), do: {:error, "Unexpected type when encoding Result.turnover_max"}
+
+  def decode_turnover_min(value) when is_integer(value), do: value
+  def decode_turnover_min(value) when is_nil(value), do: value
+  def decode_turnover_min(_), do: {:error, "Unexpected type when decoding Result.turnover_min"}
+
+  def encode_turnover_min(value) when is_integer(value), do: value
+  def encode_turnover_min(value) when is_nil(value), do: value
+  def encode_turnover_min(_), do: {:error, "Unexpected type when encoding Result.turnover_min"}
+
   def decode_updated_at(value) when is_binary(value), do: value
   def decode_updated_at(_), do: {:error, "Unexpected type when decoding Result.updated_at"}
 
@@ -382,35 +518,35 @@ defmodule Result do
 
   def from_map(m) do
     %Result{
-      cost_absolute: Map.fetch!(m, "cost_absolute"),
-      cost_max: Map.fetch!(m, "cost_max"),
-      cost_min: Map.fetch!(m, "cost_min"),
+      cost_absolute: decode_cost_absolute(Map.fetch!(m, "cost_absolute")),
+      cost_max: decode_cost_max(Map.fetch!(m, "cost_max")),
+      cost_min: decode_cost_min(Map.fetch!(m, "cost_min")),
       created_at: decode_created_at(m["created_at"]),
       custom_incomes: Enum.map(m["customIncomes"], &CustomIncome.from_map/1),
       direct_rep_costs_max: decode_direct_rep_costs_max(m["direct_rep_costs_max"]),
       direct_rep_costs_min: decode_direct_rep_costs_min(m["direct_rep_costs_min"]),
       end_date: decode_end_date(m["end_date"]),
       eur_sources_grants: decode_eur_sources_grants(m["eur_sources_grants"]),
-      eur_sources_grants_src: Map.fetch!(m, "eur_sources_grants_src"),
+      eur_sources_grants_src: decode_eur_sources_grants_src(Map.fetch!(m, "eur_sources_grants_src")),
       eur_sources_procurement: decode_eur_sources_procurement(m["eur_sources_procurement"]),
-      eur_sources_procurement_src: Map.fetch!(m, "eur_sources_procurement_src"),
+      eur_sources_procurement_src: decode_eur_sources_procurement_src(Map.fetch!(m, "eur_sources_procurement_src")),
       id: decode_id(m["id"]),
       new_organisation: decode_new_organisation(m["new_organisation"]),
-      no_clients: Map.fetch!(m, "no_clients"),
-      other_financial_information: Map.fetch!(m, "other_financial_information"),
-      other_sources_contributions: Map.fetch!(m, "other_sources_contributions"),
-      other_sources_donation: Map.fetch!(m, "other_sources_donation"),
-      other_sources_total: Map.fetch!(m, "other_sources_total"),
-      public_financing_infranational: Map.fetch!(m, "public_financing_infranational"),
-      public_financing_national: Map.fetch!(m, "public_financing_national"),
-      public_financing_total: Map.fetch!(m, "public_financing_total"),
+      no_clients: decode_no_clients(Map.fetch!(m, "no_clients")),
+      other_financial_information: decode_other_financial_information(Map.fetch!(m, "other_financial_information")),
+      other_sources_contributions: decode_other_sources_contributions(Map.fetch!(m, "other_sources_contributions")),
+      other_sources_donation: decode_other_sources_donation(Map.fetch!(m, "other_sources_donation")),
+      other_sources_total: decode_other_sources_total(Map.fetch!(m, "other_sources_total")),
+      public_financing_infranational: decode_public_financing_infranational(Map.fetch!(m, "public_financing_infranational")),
+      public_financing_national: decode_public_financing_national(Map.fetch!(m, "public_financing_national")),
+      public_financing_total: decode_public_financing_total(Map.fetch!(m, "public_financing_total")),
       representative: decode_representative(m["representative"]),
       start_date: decode_start_date(m["start_date"]),
       status: Status.decode(m["status"]),
-      total_budget: Map.fetch!(m, "total_budget"),
-      turnover_absolute: Map.fetch!(m, "turnover_absolute"),
-      turnover_max: Map.fetch!(m, "turnover_max"),
-      turnover_min: Map.fetch!(m, "turnover_min"),
+      total_budget: decode_total_budget(Map.fetch!(m, "total_budget")),
+      turnover_absolute: decode_turnover_absolute(Map.fetch!(m, "turnover_absolute")),
+      turnover_max: decode_turnover_max(Map.fetch!(m, "turnover_max")),
+      turnover_min: decode_turnover_min(Map.fetch!(m, "turnover_min")),
       type: ResultType.decode(m["type"]),
       updated_at: decode_updated_at(m["updated_at"]),
       uri: decode_uri(m["uri"]),
diff --git a/base/elixir/test/inputs/json/misc/34702.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/34702.json/default/QuickType.ex
index 0d669c1..c1a189a 100644
--- a/base/elixir/test/inputs/json/misc/34702.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/34702.json/default/QuickType.ex
@@ -438,6 +438,14 @@ defmodule FeatureProperties do
   def encode_longitude(value) when is_integer(value), do: value
   def encode_longitude(_), do: {:error, "Unexpected type when encoding FeatureProperties.longitude"}
 
+  def decode_no(value) when is_nil(value), do: value
+  def decode_no(value) when is_binary(value), do: value
+  def decode_no(_), do: {:error, "Unexpected type when decoding FeatureProperties.no"}
+
+  def encode_no(value) when is_nil(value), do: value
+  def encode_no(value) when is_binary(value), do: value
+  def encode_no(_), do: {:error, "Unexpected type when encoding FeatureProperties.no"}
+
   def decode_phone(value) when is_float(value), do: value
   def decode_phone(value) when is_integer(value), do: value
   def decode_phone(_), do: {:error, "Unexpected type when decoding FeatureProperties.phone"}
@@ -484,7 +492,7 @@ defmodule FeatureProperties do
       latitude: decode_latitude(m["latitude"]),
       local_govt: decode_local_govt(m["local_govt"]),
       longitude: decode_longitude(m["longitude"]),
-      no: Map.fetch!(m, "no"),
+      no: decode_no(Map.fetch!(m, "no")),
       phone: decode_phone(m["phone"]),
       postcode: decode_postcode(m["postcode"]),
       psa: decode_psa(m["psa"]),
diff --git a/base/elixir/test/inputs/json/misc/4d6fb.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/4d6fb.json/default/QuickType.ex
index b7a21b8..1987232 100644
--- a/base/elixir/test/inputs/json/misc/4d6fb.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/4d6fb.json/default/QuickType.ex
@@ -1000,6 +1000,22 @@ defmodule ChildData do
   def encode_thumbnail(value) when is_binary(value), do: value
   def encode_thumbnail(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail"}
 
+  def decode_thumbnail_height(value) when is_integer(value), do: value
+  def decode_thumbnail_height(value) when is_nil(value), do: value
+  def decode_thumbnail_height(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_height"}
+
+  def encode_thumbnail_height(value) when is_integer(value), do: value
+  def encode_thumbnail_height(value) when is_nil(value), do: value
+  def encode_thumbnail_height(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_height"}
+
+  def decode_thumbnail_width(value) when is_integer(value), do: value
+  def decode_thumbnail_width(value) when is_nil(value), do: value
+  def decode_thumbnail_width(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_width"}
+
+  def encode_thumbnail_width(value) when is_integer(value), do: value
+  def encode_thumbnail_width(value) when is_nil(value), do: value
+  def encode_thumbnail_width(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_width"}
+
   def decode_title(value) when is_binary(value), do: value
   def decode_title(_), do: {:error, "Unexpected type when decoding ChildData.title"}
 
@@ -1094,8 +1110,8 @@ defmodule ChildData do
       subreddit_type: SubredditType.decode(m["subreddit_type"]),
       suggested_sort: decode_suggested_sort(m["suggested_sort"]),
       thumbnail: decode_thumbnail(m["thumbnail"]),
-      thumbnail_height: Map.fetch!(m, "thumbnail_height"),
-      thumbnail_width: Map.fetch!(m, "thumbnail_width"),
+      thumbnail_height: decode_thumbnail_height(Map.fetch!(m, "thumbnail_height")),
+      thumbnail_width: decode_thumbnail_width(Map.fetch!(m, "thumbnail_width")),
       title: decode_title(m["title"]),
       ups: decode_ups(m["ups"]),
       url: decode_url(m["url"]),
diff --git a/base/elixir/test/inputs/json/misc/570ec.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/570ec.json/default/QuickType.ex
index 0e99691..e5249e0 100644
--- a/base/elixir/test/inputs/json/misc/570ec.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/570ec.json/default/QuickType.ex
@@ -157,10 +157,18 @@ defmodule OtherName do
   def encode_name(value) when is_binary(value), do: value
   def encode_name(_), do: {:error, "Unexpected type when encoding OtherName.name"}
 
+  def decode_note(value) when is_nil(value), do: value
+  def decode_note(value) when is_binary(value), do: value
+  def decode_note(_), do: {:error, "Unexpected type when decoding OtherName.note"}
+
+  def encode_note(value) when is_nil(value), do: value
+  def encode_note(value) when is_binary(value), do: value
+  def encode_note(_), do: {:error, "Unexpected type when encoding OtherName.note"}
+
   def from_map(m) do
     %OtherName{
       name: decode_name(m["name"]),
-      note: Map.fetch!(m, "note"),
+      note: decode_note(Map.fetch!(m, "note")),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/misc/66121.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/66121.json/default/QuickType.ex
index 285c8c9..80909c0 100644
--- a/base/elixir/test/inputs/json/misc/66121.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/66121.json/default/QuickType.ex
@@ -414,6 +414,14 @@ defmodule TopLevelElement do
   def encode_other_names(value) when is_list(value), do: value
   def encode_other_names(_), do: {:error, "Unexpected type when encoding TopLevelElement.other_names"}
 
+  def decode_superseded_by(value) when is_nil(value), do: value
+  def decode_superseded_by(value) when is_binary(value), do: value
+  def decode_superseded_by(_), do: {:error, "Unexpected type when decoding TopLevelElement.superseded_by"}
+
+  def encode_superseded_by(value) when is_nil(value), do: value
+  def encode_superseded_by(value) when is_binary(value), do: value
+  def encode_superseded_by(_), do: {:error, "Unexpected type when encoding TopLevelElement.superseded_by"}
+
   def decode_text(value) when is_list(value), do: value
   def decode_text(_), do: {:error, "Unexpected type when decoding TopLevelElement.text"}
 
@@ -428,7 +436,7 @@ defmodule TopLevelElement do
       links: Enum.map(m["links"], &Link.from_map/1),
       name: decode_name(m["name"]),
       other_names: decode_other_names(m["other_names"]),
-      superseded_by: Map.fetch!(m, "superseded_by"),
+      superseded_by: decode_superseded_by(Map.fetch!(m, "superseded_by")),
       text: Enum.map(m["text"], &Text.from_map/1),
     }
   end
diff --git a/base/elixir/test/inputs/json/misc/6de06.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/6de06.json/default/QuickType.ex
index 0551342..e130201 100644
--- a/base/elixir/test/inputs/json/misc/6de06.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/6de06.json/default/QuickType.ex
@@ -655,6 +655,22 @@ defmodule ChildData do
   def encode_author(value) when is_binary(value), do: value
   def encode_author(_), do: {:error, "Unexpected type when encoding ChildData.author"}
 
+  def decode_author_flair_css_class(value) when is_nil(value), do: value
+  def decode_author_flair_css_class(value) when is_binary(value), do: value
+  def decode_author_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_css_class"}
+
+  def encode_author_flair_css_class(value) when is_nil(value), do: value
+  def encode_author_flair_css_class(value) when is_binary(value), do: value
+  def encode_author_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_css_class"}
+
+  def decode_author_flair_text(value) when is_nil(value), do: value
+  def decode_author_flair_text(value) when is_binary(value), do: value
+  def decode_author_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_text"}
+
+  def encode_author_flair_text(value) when is_nil(value), do: value
+  def encode_author_flair_text(value) when is_binary(value), do: value
+  def encode_author_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_text"}
+
   def decode_banned_at_utc(value) when is_nil(value), do: value
   def decode_banned_at_utc(_), do: {:error, "Unexpected type when decoding ChildData.banned_at_utc"}
 
@@ -779,6 +795,22 @@ defmodule ChildData do
   def encode_likes(value) when is_nil(value), do: value
   def encode_likes(_), do: {:error, "Unexpected type when encoding ChildData.likes"}
 
+  def decode_link_flair_css_class(value) when is_nil(value), do: value
+  def decode_link_flair_css_class(value) when is_binary(value), do: value
+  def decode_link_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_css_class"}
+
+  def encode_link_flair_css_class(value) when is_nil(value), do: value
+  def encode_link_flair_css_class(value) when is_binary(value), do: value
+  def encode_link_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_css_class"}
+
+  def decode_link_flair_text(value) when is_nil(value), do: value
+  def decode_link_flair_text(value) when is_binary(value), do: value
+  def decode_link_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_text"}
+
+  def encode_link_flair_text(value) when is_nil(value), do: value
+  def encode_link_flair_text(value) when is_binary(value), do: value
+  def encode_link_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_text"}
+
   def decode_locked(value) when is_boolean(value), do: value
   def decode_locked(_), do: {:error, "Unexpected type when decoding ChildData.locked"}
 
@@ -857,6 +889,14 @@ defmodule ChildData do
   def encode_selftext(value) when is_binary(value), do: value
   def encode_selftext(_), do: {:error, "Unexpected type when encoding ChildData.selftext"}
 
+  def decode_selftext_html(value) when is_nil(value), do: value
+  def decode_selftext_html(value) when is_binary(value), do: value
+  def decode_selftext_html(_), do: {:error, "Unexpected type when decoding ChildData.selftext_html"}
+
+  def encode_selftext_html(value) when is_nil(value), do: value
+  def encode_selftext_html(value) when is_binary(value), do: value
+  def encode_selftext_html(_), do: {:error, "Unexpected type when encoding ChildData.selftext_html"}
+
   def decode_spoiler(value) when is_boolean(value), do: value
   def decode_spoiler(_), do: {:error, "Unexpected type when decoding ChildData.spoiler"}
 
@@ -887,12 +927,36 @@ defmodule ChildData do
   def encode_subreddit_name_prefixed(value) when is_binary(value), do: value
   def encode_subreddit_name_prefixed(_), do: {:error, "Unexpected type when encoding ChildData.subreddit_name_prefixed"}
 
+  def decode_suggested_sort(value) when is_nil(value), do: value
+  def decode_suggested_sort(value) when is_binary(value), do: value
+  def decode_suggested_sort(_), do: {:error, "Unexpected type when decoding ChildData.suggested_sort"}
+
+  def encode_suggested_sort(value) when is_nil(value), do: value
+  def encode_suggested_sort(value) when is_binary(value), do: value
+  def encode_suggested_sort(_), do: {:error, "Unexpected type when encoding ChildData.suggested_sort"}
+
   def decode_thumbnail(value) when is_binary(value), do: value
   def decode_thumbnail(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail"}
 
   def encode_thumbnail(value) when is_binary(value), do: value
   def encode_thumbnail(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail"}
 
+  def decode_thumbnail_height(value) when is_integer(value), do: value
+  def decode_thumbnail_height(value) when is_nil(value), do: value
+  def decode_thumbnail_height(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_height"}
+
+  def encode_thumbnail_height(value) when is_integer(value), do: value
+  def encode_thumbnail_height(value) when is_nil(value), do: value
+  def encode_thumbnail_height(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_height"}
+
+  def decode_thumbnail_width(value) when is_integer(value), do: value
+  def decode_thumbnail_width(value) when is_nil(value), do: value
+  def decode_thumbnail_width(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_width"}
+
+  def encode_thumbnail_width(value) when is_integer(value), do: value
+  def encode_thumbnail_width(value) when is_nil(value), do: value
+  def encode_thumbnail_width(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_width"}
+
   def decode_title(value) when is_binary(value), do: value
   def decode_title(_), do: {:error, "Unexpected type when decoding ChildData.title"}
 
@@ -935,8 +999,8 @@ defmodule ChildData do
       approved_by: decode_approved_by(m["approved_by"]),
       archived: decode_archived(m["archived"]),
       author: decode_author(m["author"]),
-      author_flair_css_class: Map.fetch!(m, "author_flair_css_class"),
-      author_flair_text: Map.fetch!(m, "author_flair_text"),
+      author_flair_css_class: decode_author_flair_css_class(Map.fetch!(m, "author_flair_css_class")),
+      author_flair_text: decode_author_flair_text(Map.fetch!(m, "author_flair_text")),
       banned_at_utc: decode_banned_at_utc(m["banned_at_utc"]),
       banned_by: decode_banned_by(m["banned_by"]),
       brand_safe: decode_brand_safe(m["brand_safe"]),
@@ -957,8 +1021,8 @@ defmodule ChildData do
       is_self: decode_is_self(m["is_self"]),
       is_video: decode_is_video(m["is_video"]),
       likes: decode_likes(m["likes"]),
-      link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
-      link_flair_text: Map.fetch!(m, "link_flair_text"),
+      link_flair_css_class: decode_link_flair_css_class(Map.fetch!(m, "link_flair_css_class")),
+      link_flair_text: decode_link_flair_text(Map.fetch!(m, "link_flair_text")),
       locked: decode_locked(m["locked"]),
       media: m["media"] && Media.from_map(m["media"]),
       media_embed: MediaEmbed.from_map(m["media_embed"]),
@@ -978,17 +1042,17 @@ defmodule ChildData do
       secure_media: m["secure_media"] && Media.from_map(m["secure_media"]),
       secure_media_embed: MediaEmbed.from_map(m["secure_media_embed"]),
       selftext: decode_selftext(m["selftext"]),
-      selftext_html: Map.fetch!(m, "selftext_html"),
+      selftext_html: decode_selftext_html(Map.fetch!(m, "selftext_html")),
       spoiler: decode_spoiler(m["spoiler"]),
       stickied: decode_stickied(m["stickied"]),
       subreddit: decode_subreddit(m["subreddit"]),
       subreddit_id: decode_subreddit_id(m["subreddit_id"]),
       subreddit_name_prefixed: decode_subreddit_name_prefixed(m["subreddit_name_prefixed"]),
       subreddit_type: SubredditType.decode(m["subreddit_type"]),
-      suggested_sort: Map.fetch!(m, "suggested_sort"),
+      suggested_sort: decode_suggested_sort(Map.fetch!(m, "suggested_sort")),
       thumbnail: decode_thumbnail(m["thumbnail"]),
-      thumbnail_height: Map.fetch!(m, "thumbnail_height"),
-      thumbnail_width: Map.fetch!(m, "thumbnail_width"),
+      thumbnail_height: decode_thumbnail_height(Map.fetch!(m, "thumbnail_height")),
+      thumbnail_width: decode_thumbnail_width(Map.fetch!(m, "thumbnail_width")),
       title: decode_title(m["title"]),
       ups: decode_ups(m["ups"]),
       url: decode_url(m["url"]),
diff --git a/base/elixir/test/inputs/json/misc/734ad.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/734ad.json/default/QuickType.ex
index 2c0ef7a..6d73e9b 100644
--- a/base/elixir/test/inputs/json/misc/734ad.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/734ad.json/default/QuickType.ex
@@ -145,6 +145,14 @@ defmodule Result do
           web_site_url: nil | String.t()
         }
 
+  def decode_acronym(value) when is_nil(value), do: value
+  def decode_acronym(value) when is_binary(value), do: value
+  def decode_acronym(_), do: {:error, "Unexpected type when decoding Result.acronym"}
+
+  def encode_acronym(value) when is_nil(value), do: value
+  def encode_acronym(value) when is_binary(value), do: value
+  def encode_acronym(_), do: {:error, "Unexpected type when encoding Result.acronym"}
+
   def decode_activity_consult_committees(value) when is_binary(value), do: value
   def decode_activity_consult_committees(_), do: {:error, "Unexpected type when decoding Result.activity_consult_committees"}
 
@@ -181,12 +189,56 @@ defmodule Result do
   def encode_activity_inter_groups(value) when is_binary(value), do: value
   def encode_activity_inter_groups(_), do: {:error, "Unexpected type when encoding Result.activity_inter_groups"}
 
+  def decode_activity_other(value) when is_nil(value), do: value
+  def decode_activity_other(value) when is_binary(value), do: value
+  def decode_activity_other(_), do: {:error, "Unexpected type when decoding Result.activity_other"}
+
+  def encode_activity_other(value) when is_nil(value), do: value
+  def encode_activity_other(value) when is_binary(value), do: value
+  def encode_activity_other(_), do: {:error, "Unexpected type when encoding Result.activity_other"}
+
   def decode_activity_relevant_comm(value) when is_binary(value), do: value
   def decode_activity_relevant_comm(_), do: {:error, "Unexpected type when decoding Result.activity_relevant_comm"}
 
   def encode_activity_relevant_comm(value) when is_binary(value), do: value
   def encode_activity_relevant_comm(_), do: {:error, "Unexpected type when encoding Result.activity_relevant_comm"}
 
+  def decode_be_office_lat(value) when is_float(value), do: value
+  def decode_be_office_lat(value) when is_integer(value), do: value
+  def decode_be_office_lat(value) when is_nil(value), do: value
+  def decode_be_office_lat(_), do: {:error, "Unexpected type when decoding Result.be_office_lat"}
+
+  def encode_be_office_lat(value) when is_float(value), do: value
+  def encode_be_office_lat(value) when is_integer(value), do: value
+  def encode_be_office_lat(value) when is_nil(value), do: value
+  def encode_be_office_lat(_), do: {:error, "Unexpected type when encoding Result.be_office_lat"}
+
+  def decode_be_office_lon(value) when is_float(value), do: value
+  def decode_be_office_lon(value) when is_integer(value), do: value
+  def decode_be_office_lon(value) when is_nil(value), do: value
+  def decode_be_office_lon(_), do: {:error, "Unexpected type when decoding Result.be_office_lon"}
+
+  def encode_be_office_lon(value) when is_float(value), do: value
+  def encode_be_office_lon(value) when is_integer(value), do: value
+  def encode_be_office_lon(value) when is_nil(value), do: value
+  def encode_be_office_lon(_), do: {:error, "Unexpected type when encoding Result.be_office_lon"}
+
+  def decode_be_office_post_code(value) when is_nil(value), do: value
+  def decode_be_office_post_code(value) when is_binary(value), do: value
+  def decode_be_office_post_code(_), do: {:error, "Unexpected type when decoding Result.be_office_post_code"}
+
+  def encode_be_office_post_code(value) when is_nil(value), do: value
+  def encode_be_office_post_code(value) when is_binary(value), do: value
+  def encode_be_office_post_code(_), do: {:error, "Unexpected type when encoding Result.be_office_post_code"}
+
+  def decode_be_office_postbox(value) when is_nil(value), do: value
+  def decode_be_office_postbox(value) when is_binary(value), do: value
+  def decode_be_office_postbox(_), do: {:error, "Unexpected type when decoding Result.be_office_postbox"}
+
+  def encode_be_office_postbox(value) when is_nil(value), do: value
+  def encode_be_office_postbox(value) when is_binary(value), do: value
+  def encode_be_office_postbox(_), do: {:error, "Unexpected type when encoding Result.be_office_postbox"}
+
   def decode_code_of_conduct(value) when is_binary(value), do: value
   def decode_code_of_conduct(_), do: {:error, "Unexpected type when decoding Result.code_of_conduct"}
 
@@ -229,12 +281,48 @@ defmodule Result do
   def encode_head_office_country(value) when is_binary(value), do: value
   def encode_head_office_country(_), do: {:error, "Unexpected type when encoding Result.head_office_country"}
 
+  def decode_head_office_lat(value) when is_float(value), do: value
+  def decode_head_office_lat(value) when is_integer(value), do: value
+  def decode_head_office_lat(value) when is_nil(value), do: value
+  def decode_head_office_lat(_), do: {:error, "Unexpected type when decoding Result.head_office_lat"}
+
+  def encode_head_office_lat(value) when is_float(value), do: value
+  def encode_head_office_lat(value) when is_integer(value), do: value
+  def encode_head_office_lat(value) when is_nil(value), do: value
+  def encode_head_office_lat(_), do: {:error, "Unexpected type when encoding Result.head_office_lat"}
+
+  def decode_head_office_lon(value) when is_float(value), do: value
+  def decode_head_office_lon(value) when is_integer(value), do: value
+  def decode_head_office_lon(value) when is_nil(value), do: value
+  def decode_head_office_lon(_), do: {:error, "Unexpected type when decoding Result.head_office_lon"}
+
+  def encode_head_office_lon(value) when is_float(value), do: value
+  def encode_head_office_lon(value) when is_integer(value), do: value
+  def encode_head_office_lon(value) when is_nil(value), do: value
+  def encode_head_office_lon(_), do: {:error, "Unexpected type when encoding Result.head_office_lon"}
+
   def decode_head_office_phone(value) when is_binary(value), do: value
   def decode_head_office_phone(_), do: {:error, "Unexpected type when decoding Result.head_office_phone"}
 
   def encode_head_office_phone(value) when is_binary(value), do: value
   def encode_head_office_phone(_), do: {:error, "Unexpected type when encoding Result.head_office_phone"}
 
+  def decode_head_office_post_code(value) when is_nil(value), do: value
+  def decode_head_office_post_code(value) when is_binary(value), do: value
+  def decode_head_office_post_code(_), do: {:error, "Unexpected type when decoding Result.head_office_post_code"}
+
+  def encode_head_office_post_code(value) when is_nil(value), do: value
+  def encode_head_office_post_code(value) when is_binary(value), do: value
+  def encode_head_office_post_code(_), do: {:error, "Unexpected type when encoding Result.head_office_post_code"}
+
+  def decode_head_office_postbox(value) when is_nil(value), do: value
+  def decode_head_office_postbox(value) when is_binary(value), do: value
+  def decode_head_office_postbox(_), do: {:error, "Unexpected type when decoding Result.head_office_postbox"}
+
+  def encode_head_office_postbox(value) when is_nil(value), do: value
+  def encode_head_office_postbox(value) when is_binary(value), do: value
+  def encode_head_office_postbox(_), do: {:error, "Unexpected type when encoding Result.head_office_postbox"}
+
   def decode_head_office_street(value) when is_binary(value), do: value
   def decode_head_office_street(_), do: {:error, "Unexpected type when decoding Result.head_office_street"}
 
@@ -301,6 +389,38 @@ defmodule Result do
   def encode_members(value) when is_integer(value), do: value
   def encode_members(_), do: {:error, "Unexpected type when encoding Result.members"}
 
+  def decode_members_100(value) when is_integer(value), do: value
+  def decode_members_100(value) when is_nil(value), do: value
+  def decode_members_100(_), do: {:error, "Unexpected type when decoding Result.members_100"}
+
+  def encode_members_100(value) when is_integer(value), do: value
+  def encode_members_100(value) when is_nil(value), do: value
+  def encode_members_100(_), do: {:error, "Unexpected type when encoding Result.members_100"}
+
+  def decode_members_25(value) when is_integer(value), do: value
+  def decode_members_25(value) when is_nil(value), do: value
+  def decode_members_25(_), do: {:error, "Unexpected type when decoding Result.members_25"}
+
+  def encode_members_25(value) when is_integer(value), do: value
+  def encode_members_25(value) when is_nil(value), do: value
+  def encode_members_25(_), do: {:error, "Unexpected type when encoding Result.members_25"}
+
+  def decode_members_50(value) when is_integer(value), do: value
+  def decode_members_50(value) when is_nil(value), do: value
+  def decode_members_50(_), do: {:error, "Unexpected type when decoding Result.members_50"}
+
+  def encode_members_50(value) when is_integer(value), do: value
+  def encode_members_50(value) when is_nil(value), do: value
+  def encode_members_50(_), do: {:error, "Unexpected type when encoding Result.members_50"}
+
+  def decode_members_75(value) when is_integer(value), do: value
+  def decode_members_75(value) when is_nil(value), do: value
+  def decode_members_75(_), do: {:error, "Unexpected type when decoding Result.members_75"}
+
+  def encode_members_75(value) when is_integer(value), do: value
+  def encode_members_75(value) when is_nil(value), do: value
+  def encode_members_75(_), do: {:error, "Unexpected type when encoding Result.members_75"}
+
   def decode_members_fte(value) when is_float(value), do: value
   def decode_members_fte(value) when is_integer(value), do: value
   def decode_members_fte(_), do: {:error, "Unexpected type when decoding Result.members_fte"}
@@ -321,6 +441,30 @@ defmodule Result do
   def encode_native_name(value) when is_nil(value), do: value
   def encode_native_name(_), do: {:error, "Unexpected type when encoding Result.native_name"}
 
+  def decode_networking(value) when is_nil(value), do: value
+  def decode_networking(value) when is_binary(value), do: value
+  def decode_networking(_), do: {:error, "Unexpected type when decoding Result.networking"}
+
+  def encode_networking(value) when is_nil(value), do: value
+  def encode_networking(value) when is_binary(value), do: value
+  def encode_networking(_), do: {:error, "Unexpected type when encoding Result.networking"}
+
+  def decode_number_of_natural_persons(value) when is_integer(value), do: value
+  def decode_number_of_natural_persons(value) when is_nil(value), do: value
+  def decode_number_of_natural_persons(_), do: {:error, "Unexpected type when decoding Result.number_of_natural_persons"}
+
+  def encode_number_of_natural_persons(value) when is_integer(value), do: value
+  def encode_number_of_natural_persons(value) when is_nil(value), do: value
+  def encode_number_of_natural_persons(_), do: {:error, "Unexpected type when encoding Result.number_of_natural_persons"}
+
+  def decode_other_code_of_conduct(value) when is_nil(value), do: value
+  def decode_other_code_of_conduct(value) when is_binary(value), do: value
+  def decode_other_code_of_conduct(_), do: {:error, "Unexpected type when decoding Result.other_code_of_conduct"}
+
+  def encode_other_code_of_conduct(value) when is_nil(value), do: value
+  def encode_other_code_of_conduct(value) when is_binary(value), do: value
+  def encode_other_code_of_conduct(_), do: {:error, "Unexpected type when encoding Result.other_code_of_conduct"}
+
   def decode_registration_date(value) when is_binary(value), do: value
   def decode_registration_date(_), do: {:error, "Unexpected type when decoding Result.registration_date"}
 
@@ -357,23 +501,31 @@ defmodule Result do
   def encode_uri(value) when is_binary(value), do: value
   def encode_uri(_), do: {:error, "Unexpected type when encoding Result.uri"}
 
+  def decode_web_site_url(value) when is_nil(value), do: value
+  def decode_web_site_url(value) when is_binary(value), do: value
+  def decode_web_site_url(_), do: {:error, "Unexpected type when decoding Result.web_site_url"}
+
+  def encode_web_site_url(value) when is_nil(value), do: value
+  def encode_web_site_url(value) when is_binary(value), do: value
+  def encode_web_site_url(_), do: {:error, "Unexpected type when encoding Result.web_site_url"}
+
   def from_map(m) do
     %Result{
-      acronym: Map.fetch!(m, "acronym"),
+      acronym: decode_acronym(Map.fetch!(m, "acronym")),
       activity_consult_committees: decode_activity_consult_committees(m["activity_consult_committees"]),
       activity_eu_legislative: decode_activity_eu_legislative(m["activity_eu_legislative"]),
       activity_expert_groups: decode_activity_expert_groups(m["activity_expert_groups"]),
       activity_high_level_groups: decode_activity_high_level_groups(m["activity_high_level_groups"]),
       activity_industry_forums: decode_activity_industry_forums(m["activity_industry_forums"]),
       activity_inter_groups: decode_activity_inter_groups(m["activity_inter_groups"]),
-      activity_other: Map.fetch!(m, "activity_other"),
+      activity_other: decode_activity_other(Map.fetch!(m, "activity_other")),
       activity_relevant_comm: decode_activity_relevant_comm(m["activity_relevant_comm"]),
       be_office_country: m["be_office_country"],
-      be_office_lat: m["be_office_lat"],
-      be_office_lon: m["be_office_lon"],
+      be_office_lat: m["be_office_lat"] && decode_be_office_lat(m["be_office_lat"]),
+      be_office_lon: m["be_office_lon"] && decode_be_office_lon(m["be_office_lon"]),
       be_office_phone: m["be_office_phone"],
-      be_office_post_code: m["be_office_post_code"],
-      be_office_postbox: m["be_office_postbox"],
+      be_office_post_code: m["be_office_post_code"] && decode_be_office_post_code(m["be_office_post_code"]),
+      be_office_postbox: m["be_office_postbox"] && decode_be_office_postbox(m["be_office_postbox"]),
       be_office_street: m["be_office_street"],
       be_office_town: m["be_office_town"],
       code_of_conduct: decode_code_of_conduct(m["code_of_conduct"]),
@@ -383,11 +535,11 @@ defmodule Result do
       goals: decode_goals(m["goals"]),
       head: decode_head(m["head"]),
       head_office_country: decode_head_office_country(m["head_office_country"]),
-      head_office_lat: Map.fetch!(m, "head_office_lat"),
-      head_office_lon: Map.fetch!(m, "head_office_lon"),
+      head_office_lat: decode_head_office_lat(Map.fetch!(m, "head_office_lat")),
+      head_office_lon: decode_head_office_lon(Map.fetch!(m, "head_office_lon")),
       head_office_phone: decode_head_office_phone(m["head_office_phone"]),
-      head_office_post_code: Map.fetch!(m, "head_office_post_code"),
-      head_office_postbox: Map.fetch!(m, "head_office_postbox"),
+      head_office_post_code: decode_head_office_post_code(Map.fetch!(m, "head_office_post_code")),
+      head_office_postbox: decode_head_office_postbox(Map.fetch!(m, "head_office_postbox")),
       head_office_street: decode_head_office_street(m["head_office_street"]),
       head_office_town: decode_head_office_town(m["head_office_town"]),
       id: decode_id(m["id"]),
@@ -399,16 +551,16 @@ defmodule Result do
       main_category: decode_main_category(m["main_category"]),
       main_category_title: decode_main_category_title(m["main_category_title"]),
       members: decode_members(m["members"]),
-      members_100: Map.fetch!(m, "members_100"),
-      members_25: Map.fetch!(m, "members_25"),
-      members_50: Map.fetch!(m, "members_50"),
-      members_75: Map.fetch!(m, "members_75"),
+      members_100: decode_members_100(Map.fetch!(m, "members_100")),
+      members_25: decode_members_25(Map.fetch!(m, "members_25")),
+      members_50: decode_members_50(Map.fetch!(m, "members_50")),
+      members_75: decode_members_75(Map.fetch!(m, "members_75")),
       members_fte: decode_members_fte(m["members_fte"]),
       name: decode_name(m["name"]),
       native_name: decode_native_name(m["native_name"]),
-      networking: Map.fetch!(m, "networking"),
-      number_of_natural_persons: Map.fetch!(m, "number_of_natural_persons"),
-      other_code_of_conduct: Map.fetch!(m, "other_code_of_conduct"),
+      networking: decode_networking(Map.fetch!(m, "networking")),
+      number_of_natural_persons: decode_number_of_natural_persons(Map.fetch!(m, "number_of_natural_persons")),
+      other_code_of_conduct: decode_other_code_of_conduct(Map.fetch!(m, "other_code_of_conduct")),
       registration_date: decode_registration_date(m["registration_date"]),
       status: Status.decode(m["status"]),
       structure_members: decode_structure_members(m["structure_members"]),
@@ -416,7 +568,7 @@ defmodule Result do
       sub_category_title: decode_sub_category_title(m["sub_category_title"]),
       updated_at: decode_updated_at(m["updated_at"]),
       uri: decode_uri(m["uri"]),
-      web_site_url: Map.fetch!(m, "web_site_url"),
+      web_site_url: decode_web_site_url(Map.fetch!(m, "web_site_url")),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/misc/7f568.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/7f568.json/default/QuickType.ex
index d8eba46..460b140 100644
--- a/base/elixir/test/inputs/json/misc/7f568.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/7f568.json/default/QuickType.ex
@@ -205,6 +205,14 @@ defmodule TopLevelElement do
   def encode_created_at(value) when is_binary(value), do: value
   def encode_created_at(_), do: {:error, "Unexpected type when encoding TopLevelElement.created_at"}
 
+  def decode_description(value) when is_nil(value), do: value
+  def decode_description(value) when is_binary(value), do: value
+  def decode_description(_), do: {:error, "Unexpected type when decoding TopLevelElement.description"}
+
+  def encode_description(value) when is_nil(value), do: value
+  def encode_description(value) when is_binary(value), do: value
+  def encode_description(_), do: {:error, "Unexpected type when encoding TopLevelElement.description"}
+
   def decode_forks_url(value) when is_binary(value), do: value
   def decode_forks_url(_), do: {:error, "Unexpected type when decoding TopLevelElement.forks_url"}
 
@@ -271,7 +279,7 @@ defmodule TopLevelElement do
       comments_url: decode_comments_url(m["comments_url"]),
       commits_url: decode_commits_url(m["commits_url"]),
       created_at: decode_created_at(m["created_at"]),
-      description: Map.fetch!(m, "description"),
+      description: decode_description(Map.fetch!(m, "description")),
       files: m["files"]
       |> Map.new(fn {key, value} -> {key, FileValue.from_map(value)} end),
       forks_url: decode_forks_url(m["forks_url"]),
diff --git a/base/elixir/test/inputs/json/misc/80aff.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/80aff.json/default/QuickType.ex
index 24d5912..275db30 100644
--- a/base/elixir/test/inputs/json/misc/80aff.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/80aff.json/default/QuickType.ex
@@ -72,6 +72,14 @@ defmodule Result do
   def encode_name(value) when is_binary(value), do: value
   def encode_name(_), do: {:error, "Unexpected type when encoding Result.name"}
 
+  def decode_parent(value) when is_integer(value), do: value
+  def decode_parent(value) when is_nil(value), do: value
+  def decode_parent(_), do: {:error, "Unexpected type when decoding Result.parent"}
+
+  def encode_parent(value) when is_integer(value), do: value
+  def encode_parent(value) when is_nil(value), do: value
+  def encode_parent(_), do: {:error, "Unexpected type when encoding Result.parent"}
+
   def decode_updated_at(value) when is_binary(value), do: value
   def decode_updated_at(_), do: {:error, "Unexpected type when decoding Result.updated_at"}
 
@@ -90,7 +98,7 @@ defmodule Result do
       id: decode_id(m["id"]),
       items: decode_items(m["items"]),
       name: decode_name(m["name"]),
-      parent: Map.fetch!(m, "parent"),
+      parent: decode_parent(Map.fetch!(m, "parent")),
       updated_at: decode_updated_at(m["updated_at"]),
       uri: decode_uri(m["uri"]),
     }
diff --git a/base/elixir/test/inputs/json/misc/8592b.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/8592b.json/default/QuickType.ex
index 71a635e..4654de4 100644
--- a/base/elixir/test/inputs/json/misc/8592b.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/8592b.json/default/QuickType.ex
@@ -559,6 +559,22 @@ defmodule ChildData do
   def encode_author(value) when is_binary(value), do: value
   def encode_author(_), do: {:error, "Unexpected type when encoding ChildData.author"}
 
+  def decode_author_flair_css_class(value) when is_nil(value), do: value
+  def decode_author_flair_css_class(value) when is_binary(value), do: value
+  def decode_author_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_css_class"}
+
+  def encode_author_flair_css_class(value) when is_nil(value), do: value
+  def encode_author_flair_css_class(value) when is_binary(value), do: value
+  def encode_author_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_css_class"}
+
+  def decode_author_flair_text(value) when is_nil(value), do: value
+  def decode_author_flair_text(value) when is_binary(value), do: value
+  def decode_author_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_text"}
+
+  def encode_author_flair_text(value) when is_nil(value), do: value
+  def encode_author_flair_text(value) when is_binary(value), do: value
+  def encode_author_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_text"}
+
   def decode_banned_at_utc(value) when is_nil(value), do: value
   def decode_banned_at_utc(_), do: {:error, "Unexpected type when decoding ChildData.banned_at_utc"}
 
@@ -785,6 +801,14 @@ defmodule ChildData do
   def encode_selftext(value) when is_binary(value), do: value
   def encode_selftext(_), do: {:error, "Unexpected type when encoding ChildData.selftext"}
 
+  def decode_selftext_html(value) when is_nil(value), do: value
+  def decode_selftext_html(value) when is_binary(value), do: value
+  def decode_selftext_html(_), do: {:error, "Unexpected type when decoding ChildData.selftext_html"}
+
+  def encode_selftext_html(value) when is_nil(value), do: value
+  def encode_selftext_html(value) when is_binary(value), do: value
+  def encode_selftext_html(_), do: {:error, "Unexpected type when encoding ChildData.selftext_html"}
+
   def decode_spoiler(value) when is_boolean(value), do: value
   def decode_spoiler(_), do: {:error, "Unexpected type when decoding ChildData.spoiler"}
 
@@ -803,6 +827,22 @@ defmodule ChildData do
   def encode_thumbnail(value) when is_binary(value), do: value
   def encode_thumbnail(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail"}
 
+  def decode_thumbnail_height(value) when is_integer(value), do: value
+  def decode_thumbnail_height(value) when is_nil(value), do: value
+  def decode_thumbnail_height(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_height"}
+
+  def encode_thumbnail_height(value) when is_integer(value), do: value
+  def encode_thumbnail_height(value) when is_nil(value), do: value
+  def encode_thumbnail_height(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_height"}
+
+  def decode_thumbnail_width(value) when is_integer(value), do: value
+  def decode_thumbnail_width(value) when is_nil(value), do: value
+  def decode_thumbnail_width(_), do: {:error, "Unexpected type when decoding ChildData.thumbnail_width"}
+
+  def encode_thumbnail_width(value) when is_integer(value), do: value
+  def encode_thumbnail_width(value) when is_nil(value), do: value
+  def encode_thumbnail_width(_), do: {:error, "Unexpected type when encoding ChildData.thumbnail_width"}
+
   def decode_title(value) when is_binary(value), do: value
   def decode_title(_), do: {:error, "Unexpected type when decoding ChildData.title"}
 
@@ -845,8 +885,8 @@ defmodule ChildData do
       approved_by: decode_approved_by(m["approved_by"]),
       archived: decode_archived(m["archived"]),
       author: decode_author(m["author"]),
-      author_flair_css_class: Map.fetch!(m, "author_flair_css_class"),
-      author_flair_text: Map.fetch!(m, "author_flair_text"),
+      author_flair_css_class: decode_author_flair_css_class(Map.fetch!(m, "author_flair_css_class")),
+      author_flair_text: decode_author_flair_text(Map.fetch!(m, "author_flair_text")),
       banned_at_utc: decode_banned_at_utc(m["banned_at_utc"]),
       banned_by: decode_banned_by(m["banned_by"]),
       brand_safe: decode_brand_safe(m["brand_safe"]),
@@ -888,7 +928,7 @@ defmodule ChildData do
       secure_media: decode_secure_media(m["secure_media"]),
       secure_media_embed: MediaEmbed.from_map(m["secure_media_embed"]),
       selftext: decode_selftext(m["selftext"]),
-      selftext_html: Map.fetch!(m, "selftext_html"),
+      selftext_html: decode_selftext_html(Map.fetch!(m, "selftext_html")),
       spoiler: decode_spoiler(m["spoiler"]),
       stickied: decode_stickied(m["stickied"]),
       subreddit: Subreddit.decode(m["subreddit"]),
@@ -897,8 +937,8 @@ defmodule ChildData do
       subreddit_type: SubredditType.decode(m["subreddit_type"]),
       suggested_sort: SuggestedSort.decode(m["suggested_sort"]),
       thumbnail: decode_thumbnail(m["thumbnail"]),
-      thumbnail_height: Map.fetch!(m, "thumbnail_height"),
-      thumbnail_width: Map.fetch!(m, "thumbnail_width"),
+      thumbnail_height: decode_thumbnail_height(Map.fetch!(m, "thumbnail_height")),
+      thumbnail_width: decode_thumbnail_width(Map.fetch!(m, "thumbnail_width")),
       title: decode_title(m["title"]),
       ups: decode_ups(m["ups"]),
       url: decode_url(m["url"]),
diff --git a/base/elixir/test/inputs/json/misc/996bd.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/996bd.json/default/QuickType.ex
index 66160ac..ff0a575 100644
--- a/base/elixir/test/inputs/json/misc/996bd.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/996bd.json/default/QuickType.ex
@@ -378,6 +378,14 @@ defmodule TopLevelElement do
   def encode_other_names(value) when is_list(value), do: value
   def encode_other_names(_), do: {:error, "Unexpected type when encoding TopLevelElement.other_names"}
 
+  def decode_superseded_by(value) when is_nil(value), do: value
+  def decode_superseded_by(value) when is_binary(value), do: value
+  def decode_superseded_by(_), do: {:error, "Unexpected type when decoding TopLevelElement.superseded_by"}
+
+  def encode_superseded_by(value) when is_nil(value), do: value
+  def encode_superseded_by(value) when is_binary(value), do: value
+  def encode_superseded_by(_), do: {:error, "Unexpected type when encoding TopLevelElement.superseded_by"}
+
   def decode_text(value) when is_list(value), do: value
   def decode_text(_), do: {:error, "Unexpected type when decoding TopLevelElement.text"}
 
@@ -392,7 +400,7 @@ defmodule TopLevelElement do
       links: Enum.map(m["links"], &Link.from_map/1),
       name: decode_name(m["name"]),
       other_names: decode_other_names(m["other_names"]),
-      superseded_by: Map.fetch!(m, "superseded_by"),
+      superseded_by: decode_superseded_by(Map.fetch!(m, "superseded_by")),
       text: Enum.map(m["text"], &Text.from_map/1),
     }
   end
diff --git a/base/elixir/test/inputs/json/misc/9ac3b.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/9ac3b.json/default/QuickType.ex
index 413c235..dcc711b 100644
--- a/base/elixir/test/inputs/json/misc/9ac3b.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/9ac3b.json/default/QuickType.ex
@@ -180,6 +180,14 @@ defmodule Result do
   def encode_name(value) when is_binary(value), do: value
   def encode_name(_), do: {:error, "Unexpected type when encoding Result.name"}
 
+  def decode_position(value) when is_nil(value), do: value
+  def decode_position(value) when is_binary(value), do: value
+  def decode_position(_), do: {:error, "Unexpected type when decoding Result.position"}
+
+  def encode_position(value) when is_nil(value), do: value
+  def encode_position(value) when is_binary(value), do: value
+  def encode_position(_), do: {:error, "Unexpected type when encoding Result.position"}
+
   def decode_updated_at(value) when is_binary(value), do: value
   def decode_updated_at(_), do: {:error, "Unexpected type when decoding Result.updated_at"}
 
@@ -200,7 +208,7 @@ defmodule Result do
       id: decode_id(m["id"]),
       last_name: decode_last_name(m["last_name"]),
       name: decode_name(m["name"]),
-      position: Map.fetch!(m, "position"),
+      position: decode_position(Map.fetch!(m, "position")),
       status: Status.decode(m["status"]),
       title: m["title"] && Title.decode(m["title"]),
       updated_at: decode_updated_at(m["updated_at"]),
diff --git a/base/elixir/test/inputs/json/misc/ad8be.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/ad8be.json/default/QuickType.ex
index 9425aaf..c51f20c 100644
--- a/base/elixir/test/inputs/json/misc/ad8be.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/ad8be.json/default/QuickType.ex
@@ -257,10 +257,18 @@ defmodule OtherName do
   def encode_name(value) when is_binary(value), do: value
   def encode_name(_), do: {:error, "Unexpected type when encoding OtherName.name"}
 
+  def decode_note(value) when is_nil(value), do: value
+  def decode_note(value) when is_binary(value), do: value
+  def decode_note(_), do: {:error, "Unexpected type when decoding OtherName.note"}
+
+  def encode_note(value) when is_nil(value), do: value
+  def encode_note(value) when is_binary(value), do: value
+  def encode_note(_), do: {:error, "Unexpected type when encoding OtherName.note"}
+
   def from_map(m) do
     %OtherName{
       name: decode_name(m["name"]),
-      note: Map.fetch!(m, "note"),
+      note: decode_note(Map.fetch!(m, "note")),
     }
   end
 
@@ -474,6 +482,14 @@ defmodule TopLevelElement do
   def encode_other_names(value) when is_list(value), do: value
   def encode_other_names(_), do: {:error, "Unexpected type when encoding TopLevelElement.other_names"}
 
+  def decode_superseded_by(value) when is_nil(value), do: value
+  def decode_superseded_by(value) when is_binary(value), do: value
+  def decode_superseded_by(_), do: {:error, "Unexpected type when decoding TopLevelElement.superseded_by"}
+
+  def encode_superseded_by(value) when is_nil(value), do: value
+  def encode_superseded_by(value) when is_binary(value), do: value
+  def encode_superseded_by(_), do: {:error, "Unexpected type when encoding TopLevelElement.superseded_by"}
+
   def decode_text(value) when is_list(value), do: value
   def decode_text(_), do: {:error, "Unexpected type when decoding TopLevelElement.text"}
 
@@ -488,7 +504,7 @@ defmodule TopLevelElement do
       links: Enum.map(m["links"], &Link.from_map/1),
       name: decode_name(m["name"]),
       other_names: Enum.map(m["other_names"], &OtherName.from_map/1),
-      superseded_by: Map.fetch!(m, "superseded_by"),
+      superseded_by: decode_superseded_by(Map.fetch!(m, "superseded_by")),
       text: Enum.map(m["text"], &Text.from_map/1),
     }
   end
diff --git a/base/elixir/test/inputs/json/misc/ae7f0.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/ae7f0.json/default/QuickType.ex
index 06dc563..fa47eb5 100644
--- a/base/elixir/test/inputs/json/misc/ae7f0.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/ae7f0.json/default/QuickType.ex
@@ -480,6 +480,22 @@ defmodule ChildData do
   def encode_likes(value) when is_nil(value), do: value
   def encode_likes(_), do: {:error, "Unexpected type when encoding ChildData.likes"}
 
+  def decode_link_flair_css_class(value) when is_nil(value), do: value
+  def decode_link_flair_css_class(value) when is_binary(value), do: value
+  def decode_link_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_css_class"}
+
+  def encode_link_flair_css_class(value) when is_nil(value), do: value
+  def encode_link_flair_css_class(value) when is_binary(value), do: value
+  def encode_link_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_css_class"}
+
+  def decode_link_flair_text(value) when is_nil(value), do: value
+  def decode_link_flair_text(value) when is_binary(value), do: value
+  def decode_link_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_text"}
+
+  def encode_link_flair_text(value) when is_nil(value), do: value
+  def encode_link_flair_text(value) when is_binary(value), do: value
+  def encode_link_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_text"}
+
   def decode_locked(value) when is_boolean(value), do: value
   def decode_locked(_), do: {:error, "Unexpected type when decoding ChildData.locked"}
 
@@ -664,8 +680,8 @@ defmodule ChildData do
       is_self: decode_is_self(m["is_self"]),
       is_video: decode_is_video(m["is_video"]),
       likes: decode_likes(m["likes"]),
-      link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
-      link_flair_text: Map.fetch!(m, "link_flair_text"),
+      link_flair_css_class: decode_link_flair_css_class(Map.fetch!(m, "link_flair_css_class")),
+      link_flair_text: decode_link_flair_text(Map.fetch!(m, "link_flair_text")),
       locked: decode_locked(m["locked"]),
       media: decode_media(m["media"]),
       media_embed: MediaEmbed.from_map(m["media_embed"]),
diff --git a/base/elixir/test/inputs/json/misc/af2d1.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/af2d1.json/default/QuickType.ex
index 6f929ca..bf5071b 100644
--- a/base/elixir/test/inputs/json/misc/af2d1.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/af2d1.json/default/QuickType.ex
@@ -604,12 +604,28 @@ defmodule FeatureProperties do
   def encode_asset_numb(value) when is_binary(value), do: value
   def encode_asset_numb(_), do: {:error, "Unexpected type when encoding FeatureProperties.asset_numb"}
 
+  def decode_comments(value) when is_nil(value), do: value
+  def decode_comments(value) when is_binary(value), do: value
+  def decode_comments(_), do: {:error, "Unexpected type when decoding FeatureProperties.comments"}
+
+  def encode_comments(value) when is_nil(value), do: value
+  def encode_comments(value) when is_binary(value), do: value
+  def encode_comments(_), do: {:error, "Unexpected type when encoding FeatureProperties.comments"}
+
   def decode_condition(value) when is_integer(value), do: value
   def decode_condition(_), do: {:error, "Unexpected type when decoding FeatureProperties.condition"}
 
   def encode_condition(value) when is_integer(value), do: value
   def encode_condition(_), do: {:error, "Unexpected type when encoding FeatureProperties.condition"}
 
+  def decode_constructi(value) when is_nil(value), do: value
+  def decode_constructi(value) when is_binary(value), do: value
+  def decode_constructi(_), do: {:error, "Unexpected type when decoding FeatureProperties.constructi"}
+
+  def encode_constructi(value) when is_nil(value), do: value
+  def encode_constructi(value) when is_binary(value), do: value
+  def encode_constructi(_), do: {:error, "Unexpected type when encoding FeatureProperties.constructi"}
+
   def decode_createdate(value) when is_nil(value), do: value
   def decode_createdate(_), do: {:error, "Unexpected type when decoding FeatureProperties.createdate"}
 
@@ -634,6 +650,30 @@ defmodule FeatureProperties do
   def encode_documents(value) when is_binary(value), do: value
   def encode_documents(_), do: {:error, "Unexpected type when encoding FeatureProperties.documents"}
 
+  def decode_drawing_nu(value) when is_nil(value), do: value
+  def decode_drawing_nu(value) when is_binary(value), do: value
+  def decode_drawing_nu(_), do: {:error, "Unexpected type when decoding FeatureProperties.drawing_nu"}
+
+  def encode_drawing_nu(value) when is_nil(value), do: value
+  def encode_drawing_nu(value) when is_binary(value), do: value
+  def encode_drawing_nu(_), do: {:error, "Unexpected type when encoding FeatureProperties.drawing_nu"}
+
+  def decode_file_numbe(value) when is_nil(value), do: value
+  def decode_file_numbe(value) when is_binary(value), do: value
+  def decode_file_numbe(_), do: {:error, "Unexpected type when decoding FeatureProperties.file_numbe"}
+
+  def encode_file_numbe(value) when is_nil(value), do: value
+  def encode_file_numbe(value) when is_binary(value), do: value
+  def encode_file_numbe(_), do: {:error, "Unexpected type when encoding FeatureProperties.file_numbe"}
+
+  def decode_folder_num(value) when is_nil(value), do: value
+  def decode_folder_num(value) when is_binary(value), do: value
+  def decode_folder_num(_), do: {:error, "Unexpected type when decoding FeatureProperties.folder_num"}
+
+  def encode_folder_num(value) when is_nil(value), do: value
+  def encode_folder_num(value) when is_binary(value), do: value
+  def encode_folder_num(_), do: {:error, "Unexpected type when encoding FeatureProperties.folder_num"}
+
   def decode_historic_c(value) when is_integer(value), do: value
   def decode_historic_c(_), do: {:error, "Unexpected type when decoding FeatureProperties.historic_c"}
 
@@ -670,12 +710,36 @@ defmodule FeatureProperties do
   def encode_number_lan(value) when is_integer(value), do: value
   def encode_number_lan(_), do: {:error, "Unexpected type when encoding FeatureProperties.number_lan"}
 
+  def decode_owner(value) when is_nil(value), do: value
+  def decode_owner(value) when is_binary(value), do: value
+  def decode_owner(_), do: {:error, "Unexpected type when decoding FeatureProperties.owner"}
+
+  def encode_owner(value) when is_nil(value), do: value
+  def encode_owner(value) when is_binary(value), do: value
+  def encode_owner(_), do: {:error, "Unexpected type when encoding FeatureProperties.owner"}
+
+  def decode_project_nu(value) when is_nil(value), do: value
+  def decode_project_nu(value) when is_binary(value), do: value
+  def decode_project_nu(_), do: {:error, "Unexpected type when decoding FeatureProperties.project_nu"}
+
+  def encode_project_nu(value) when is_nil(value), do: value
+  def encode_project_nu(value) when is_binary(value), do: value
+  def encode_project_nu(_), do: {:error, "Unexpected type when encoding FeatureProperties.project_nu"}
+
   def decode_rec_id(value) when is_integer(value), do: value
   def decode_rec_id(_), do: {:error, "Unexpected type when decoding FeatureProperties.rec_id"}
 
   def encode_rec_id(value) when is_integer(value), do: value
   def encode_rec_id(_), do: {:error, "Unexpected type when encoding FeatureProperties.rec_id"}
 
+  def decode_record_cre(value) when is_nil(value), do: value
+  def decode_record_cre(value) when is_binary(value), do: value
+  def decode_record_cre(_), do: {:error, "Unexpected type when decoding FeatureProperties.record_cre"}
+
+  def encode_record_cre(value) when is_nil(value), do: value
+  def encode_record_cre(value) when is_binary(value), do: value
+  def encode_record_cre(_), do: {:error, "Unexpected type when encoding FeatureProperties.record_cre"}
+
   def decode_shape_area(value) when is_float(value), do: value
   def decode_shape_area(value) when is_integer(value), do: value
   def decode_shape_area(_), do: {:error, "Unexpected type when decoding FeatureProperties.shape_area"}
@@ -737,16 +801,16 @@ defmodule FeatureProperties do
       add_improv: m["add_improv"] && AddImprov.decode(m["add_improv"]),
       area: decode_area(m["area_"]),
       asset_numb: decode_asset_numb(m["asset_numb"]),
-      comments: Map.fetch!(m, "comments"),
+      comments: decode_comments(Map.fetch!(m, "comments")),
       condition: decode_condition(m["condition"]),
-      constructi: Map.fetch!(m, "constructi"),
+      constructi: decode_constructi(Map.fetch!(m, "constructi")),
       createdate: decode_createdate(m["createdate"]),
       createuser: decode_createuser(m["createuser"]),
       disposal_d: decode_disposal_d(m["disposal_d"]),
       documents: decode_documents(m["documents"]),
-      drawing_nu: Map.fetch!(m, "drawing_nu"),
-      file_numbe: Map.fetch!(m, "file_numbe"),
-      folder_num: Map.fetch!(m, "folder_num"),
+      drawing_nu: decode_drawing_nu(Map.fetch!(m, "drawing_nu")),
+      file_numbe: decode_file_numbe(Map.fetch!(m, "file_numbe")),
+      folder_num: decode_folder_num(Map.fetch!(m, "folder_num")),
       funding_ba: m["funding_ba"] && FundingBa.decode(m["funding_ba"]),
       historic_c: decode_historic_c(m["historic_c"]),
       inspection: decode_inspection(m["inspection"]),
@@ -757,11 +821,11 @@ defmodule FeatureProperties do
       mi_prinx: decode_mi_prinx(m["mi_prinx"]),
       mi_symbolo: MiSymbolo.decode(m["mi_symbolo"]),
       number_lan: decode_number_lan(m["number_lan"]),
-      owner: Map.fetch!(m, "owner"),
+      owner: decode_owner(Map.fetch!(m, "owner")),
       positional: m["positional"] && LevelAccu.decode(m["positional"]),
-      project_nu: Map.fetch!(m, "project_nu"),
+      project_nu: decode_project_nu(Map.fetch!(m, "project_nu")),
       rec_id: decode_rec_id(m["rec_id"]),
-      record_cre: Map.fetch!(m, "record_cre"),
+      record_cre: decode_record_cre(Map.fetch!(m, "record_cre")),
       shape_area: decode_shape_area(m["shape_area"]),
       shape_leng: decode_shape_leng(m["shape_leng"]),
       status: Status.decode(m["status"]),
diff --git a/base/elixir/test/inputs/json/misc/be234.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/be234.json/default/QuickType.ex
index 5949263..00db733 100644
--- a/base/elixir/test/inputs/json/misc/be234.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/be234.json/default/QuickType.ex
@@ -833,6 +833,14 @@ defmodule ChildData do
   def encode_author_flair_css_class(value) when is_nil(value), do: value
   def encode_author_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_css_class"}
 
+  def decode_author_flair_text(value) when is_nil(value), do: value
+  def decode_author_flair_text(value) when is_binary(value), do: value
+  def decode_author_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_text"}
+
+  def encode_author_flair_text(value) when is_nil(value), do: value
+  def encode_author_flair_text(value) when is_binary(value), do: value
+  def encode_author_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_text"}
+
   def decode_banned_at_utc(value) when is_nil(value), do: value
   def decode_banned_at_utc(_), do: {:error, "Unexpected type when decoding ChildData.banned_at_utc"}
 
@@ -891,6 +899,14 @@ defmodule ChildData do
   def encode_created_utc(value) when is_integer(value), do: value
   def encode_created_utc(_), do: {:error, "Unexpected type when encoding ChildData.created_utc"}
 
+  def decode_distinguished(value) when is_nil(value), do: value
+  def decode_distinguished(value) when is_binary(value), do: value
+  def decode_distinguished(_), do: {:error, "Unexpected type when decoding ChildData.distinguished"}
+
+  def encode_distinguished(value) when is_nil(value), do: value
+  def encode_distinguished(value) when is_binary(value), do: value
+  def encode_distinguished(_), do: {:error, "Unexpected type when encoding ChildData.distinguished"}
+
   def decode_downs(value) when is_integer(value), do: value
   def decode_downs(_), do: {:error, "Unexpected type when decoding ChildData.downs"}
 
@@ -1120,7 +1136,7 @@ defmodule ChildData do
       archived: decode_archived(m["archived"]),
       author: decode_author(m["author"]),
       author_flair_css_class: decode_author_flair_css_class(m["author_flair_css_class"]),
-      author_flair_text: Map.fetch!(m, "author_flair_text"),
+      author_flair_text: decode_author_flair_text(Map.fetch!(m, "author_flair_text")),
       banned_at_utc: decode_banned_at_utc(m["banned_at_utc"]),
       banned_by: decode_banned_by(m["banned_by"]),
       brand_safe: decode_brand_safe(m["brand_safe"]),
@@ -1130,7 +1146,7 @@ defmodule ChildData do
       contest_mode: decode_contest_mode(m["contest_mode"]),
       created: decode_created(m["created"]),
       created_utc: decode_created_utc(m["created_utc"]),
-      distinguished: Map.fetch!(m, "distinguished"),
+      distinguished: decode_distinguished(Map.fetch!(m, "distinguished")),
       domain: Domain.decode(m["domain"]),
       downs: decode_downs(m["downs"]),
       edited: decode_edited(m["edited"]),
diff --git a/base/elixir/test/inputs/json/misc/d23d5.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/d23d5.json/default/QuickType.ex
index 4bb8768..76ff384 100644
--- a/base/elixir/test/inputs/json/misc/d23d5.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/d23d5.json/default/QuickType.ex
@@ -47,6 +47,14 @@ defmodule Result do
           uri: String.t()
         }
 
+  def decode_acronym(value) when is_nil(value), do: value
+  def decode_acronym(value) when is_binary(value), do: value
+  def decode_acronym(_), do: {:error, "Unexpected type when decoding Result.acronym"}
+
+  def encode_acronym(value) when is_nil(value), do: value
+  def encode_acronym(value) when is_binary(value), do: value
+  def encode_acronym(_), do: {:error, "Unexpected type when encoding Result.acronym"}
+
   def decode_created_at(value) when is_binary(value), do: value
   def decode_created_at(_), do: {:error, "Unexpected type when decoding Result.created_at"}
 
@@ -79,7 +87,7 @@ defmodule Result do
 
   def from_map(m) do
     %Result{
-      acronym: Map.fetch!(m, "acronym"),
+      acronym: decode_acronym(Map.fetch!(m, "acronym")),
       created_at: decode_created_at(m["created_at"]),
       id: decode_id(m["id"]),
       name: decode_name(m["name"]),
diff --git a/base/elixir/test/inputs/json/misc/f22f5.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/f22f5.json/default/QuickType.ex
index 51f4559..570993d 100644
--- a/base/elixir/test/inputs/json/misc/f22f5.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/f22f5.json/default/QuickType.ex
@@ -441,6 +441,22 @@ defmodule ChildData do
   def encode_likes(value) when is_nil(value), do: value
   def encode_likes(_), do: {:error, "Unexpected type when encoding ChildData.likes"}
 
+  def decode_link_flair_css_class(value) when is_nil(value), do: value
+  def decode_link_flair_css_class(value) when is_binary(value), do: value
+  def decode_link_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_css_class"}
+
+  def encode_link_flair_css_class(value) when is_nil(value), do: value
+  def encode_link_flair_css_class(value) when is_binary(value), do: value
+  def encode_link_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_css_class"}
+
+  def decode_link_flair_text(value) when is_nil(value), do: value
+  def decode_link_flair_text(value) when is_binary(value), do: value
+  def decode_link_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_text"}
+
+  def encode_link_flair_text(value) when is_nil(value), do: value
+  def encode_link_flair_text(value) when is_binary(value), do: value
+  def encode_link_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_text"}
+
   def decode_locked(value) when is_boolean(value), do: value
   def decode_locked(_), do: {:error, "Unexpected type when decoding ChildData.locked"}
 
@@ -625,8 +641,8 @@ defmodule ChildData do
       is_self: decode_is_self(m["is_self"]),
       is_video: decode_is_video(m["is_video"]),
       likes: decode_likes(m["likes"]),
-      link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
-      link_flair_text: Map.fetch!(m, "link_flair_text"),
+      link_flair_css_class: decode_link_flair_css_class(Map.fetch!(m, "link_flair_css_class")),
+      link_flair_text: decode_link_flair_text(Map.fetch!(m, "link_flair_text")),
       locked: decode_locked(m["locked"]),
       media: decode_media(m["media"]),
       media_embed: MediaEmbed.from_map(m["media_embed"]),
diff --git a/base/elixir/test/inputs/json/priority/bug2590.json/default/QuickType.ex b/head/elixir/test/inputs/json/priority/bug2590.json/default/QuickType.ex
index cc360f3..3ac1884 100644
--- a/base/elixir/test/inputs/json/priority/bug2590.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/priority/bug2590.json/default/QuickType.ex
@@ -15,6 +15,22 @@ defmodule Invoice do
           name: String.t()
         }
 
+  def decode_created_at(value) when is_nil(value), do: value
+  def decode_created_at(value) when is_binary(value), do: value
+  def decode_created_at(_), do: {:error, "Unexpected type when decoding Invoice.created_at"}
+
+  def encode_created_at(value) when is_nil(value), do: value
+  def encode_created_at(value) when is_binary(value), do: value
+  def encode_created_at(_), do: {:error, "Unexpected type when encoding Invoice.created_at"}
+
+  def decode_due_date(value) when is_nil(value), do: value
+  def decode_due_date(value) when is_binary(value), do: value
+  def decode_due_date(_), do: {:error, "Unexpected type when decoding Invoice.due_date"}
+
+  def encode_due_date(value) when is_nil(value), do: value
+  def encode_due_date(value) when is_binary(value), do: value
+  def encode_due_date(_), do: {:error, "Unexpected type when encoding Invoice.due_date"}
+
   def decode_name(value) when is_binary(value), do: value
   def decode_name(_), do: {:error, "Unexpected type when decoding Invoice.name"}
 
@@ -23,8 +39,8 @@ defmodule Invoice do
 
   def from_map(m) do
     %Invoice{
-      created_at: Map.fetch!(m, "createdAt"),
-      due_date: Map.fetch!(m, "dueDate"),
+      created_at: decode_created_at(Map.fetch!(m, "createdAt")),
+      due_date: decode_due_date(Map.fetch!(m, "dueDate")),
       name: decode_name(m["name"]),
     }
   end
diff --git a/base/elixir/test/inputs/json/priority/nbl-stats.json/default/QuickType.ex b/head/elixir/test/inputs/json/priority/nbl-stats.json/default/QuickType.ex
index 2578a48..828cb4e 100644
--- a/base/elixir/test/inputs/json/priority/nbl-stats.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/priority/nbl-stats.json/default/QuickType.ex
@@ -1206,6 +1206,14 @@ defmodule Pl do
   def encode_s_free_throws_percentage(value) when is_integer(value), do: value
   def encode_s_free_throws_percentage(_), do: {:error, "Unexpected type when encoding Pl.s_free_throws_percentage"}
 
+  def decode_s_minutes(value) when is_integer(value), do: value
+  def decode_s_minutes(value) when is_binary(value), do: value
+  def decode_s_minutes(_), do: {:error, "Unexpected type when decoding Pl.s_minutes"}
+
+  def encode_s_minutes(value) when is_integer(value), do: value
+  def encode_s_minutes(value) when is_binary(value), do: value
+  def encode_s_minutes(_), do: {:error, "Unexpected type when encoding Pl.s_minutes"}
+
   def decode_s_plus_minus_points(value) when is_integer(value), do: value
   def decode_s_plus_minus_points(_), do: {:error, "Unexpected type when decoding Pl.s_plus_minus_points"}
 
@@ -1347,7 +1355,7 @@ defmodule Pl do
       s_free_throws_attempted: decode_s_free_throws_attempted(m["sFreeThrowsAttempted"]),
       s_free_throws_made: decode_s_free_throws_made(m["sFreeThrowsMade"]),
       s_free_throws_percentage: decode_s_free_throws_percentage(m["sFreeThrowsPercentage"]),
-      s_minutes: Map.fetch!(m, "sMinutes"),
+      s_minutes: decode_s_minutes(Map.fetch!(m, "sMinutes")),
       s_plus_minus_points: decode_s_plus_minus_points(m["sPlusMinusPoints"]),
       s_points: decode_s_points(m["sPoints"]),
       s_points_fast_break: decode_s_points_fast_break(m["sPointsFastBreak"]),
diff --git a/base/elixir/test/inputs/json/priority/optional-union.json/default/QuickType.ex b/head/elixir/test/inputs/json/priority/optional-union.json/default/QuickType.ex
index ad24bc5..2f1d7c6 100644
--- a/base/elixir/test/inputs/json/priority/optional-union.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/priority/optional-union.json/default/QuickType.ex
@@ -12,9 +12,17 @@ defmodule TopLevelElement do
           a: integer() | String.t() | nil
         }
 
+  def decode_a(value) when is_integer(value), do: value
+  def decode_a(value) when is_binary(value), do: value
+  def decode_a(_), do: {:error, "Unexpected type when decoding TopLevelElement.a"}
+
+  def encode_a(value) when is_integer(value), do: value
+  def encode_a(value) when is_binary(value), do: value
+  def encode_a(_), do: {:error, "Unexpected type when encoding TopLevelElement.a"}
+
   def from_map(m) do
     %TopLevelElement{
-      a: m["a"],
+      a: m["a"] && decode_a(m["a"]),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/samples/github-events.json/default/QuickType.ex b/head/elixir/test/inputs/json/samples/github-events.json/default/QuickType.ex
index 1b3e6b2..26a7a44 100644
--- a/base/elixir/test/inputs/json/samples/github-events.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/samples/github-events.json/default/QuickType.ex
@@ -640,6 +640,14 @@ defmodule Milestone do
   def encode_description(value) when is_binary(value), do: value
   def encode_description(_), do: {:error, "Unexpected type when encoding Milestone.description"}
 
+  def decode_due_on(value) when is_nil(value), do: value
+  def decode_due_on(value) when is_binary(value), do: value
+  def decode_due_on(_), do: {:error, "Unexpected type when decoding Milestone.due_on"}
+
+  def encode_due_on(value) when is_nil(value), do: value
+  def encode_due_on(value) when is_binary(value), do: value
+  def encode_due_on(_), do: {:error, "Unexpected type when encoding Milestone.due_on"}
+
   def decode_html_url(value) when is_binary(value), do: value
   def decode_html_url(_), do: {:error, "Unexpected type when decoding Milestone.html_url"}
 
@@ -701,7 +709,7 @@ defmodule Milestone do
       created_at: decode_created_at(m["created_at"]),
       creator: User.from_map(m["creator"]),
       description: decode_description(m["description"]),
-      due_on: Map.fetch!(m, "due_on"),
+      due_on: decode_due_on(Map.fetch!(m, "due_on")),
       html_url: decode_html_url(m["html_url"]),
       id: decode_id(m["id"]),
       labels_url: decode_labels_url(m["labels_url"]),
@@ -860,6 +868,14 @@ defmodule Issue do
   def encode_body(value) when is_binary(value), do: value
   def encode_body(_), do: {:error, "Unexpected type when encoding Issue.body"}
 
+  def decode_closed_at(value) when is_nil(value), do: value
+  def decode_closed_at(value) when is_binary(value), do: value
+  def decode_closed_at(_), do: {:error, "Unexpected type when decoding Issue.closed_at"}
+
+  def encode_closed_at(value) when is_nil(value), do: value
+  def encode_closed_at(value) when is_binary(value), do: value
+  def encode_closed_at(_), do: {:error, "Unexpected type when encoding Issue.closed_at"}
+
   def decode_comments(value) when is_integer(value), do: value
   def decode_comments(_), do: {:error, "Unexpected type when decoding Issue.comments"}
 
@@ -955,7 +971,7 @@ defmodule Issue do
       assignee: decode_assignee(m["assignee"]),
       assignees: decode_assignees(m["assignees"]),
       body: decode_body(m["body"]),
-      closed_at: Map.fetch!(m, "closed_at"),
+      closed_at: decode_closed_at(Map.fetch!(m, "closed_at")),
       comments: decode_comments(m["comments"]),
       comments_url: decode_comments_url(m["comments_url"]),
       created_at: decode_created_at(m["created_at"]),
diff --git a/base/elixir/test/inputs/json/samples/kitchen-sink.json/default/QuickType.ex b/head/elixir/test/inputs/json/samples/kitchen-sink.json/default/QuickType.ex
index 0a73a87..8246f65 100644
--- a/base/elixir/test/inputs/json/samples/kitchen-sink.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/samples/kitchen-sink.json/default/QuickType.ex
@@ -54,6 +54,14 @@ defmodule PersonElement do
           optional_value: boolean() | nil
         }
 
+  def decode_int_or_string(value) when is_integer(value), do: value
+  def decode_int_or_string(value) when is_binary(value), do: value
+  def decode_int_or_string(_), do: {:error, "Unexpected type when decoding PersonElement.int_or_string"}
+
+  def encode_int_or_string(value) when is_integer(value), do: value
+  def encode_int_or_string(value) when is_binary(value), do: value
+  def encode_int_or_string(_), do: {:error, "Unexpected type when encoding PersonElement.int_or_string"}
+
   def decode_name(value) when is_binary(value), do: value
   def decode_name(_), do: {:error, "Unexpected type when decoding PersonElement.name"}
 
@@ -62,7 +70,7 @@ defmodule PersonElement do
 
   def from_map(m) do
     %PersonElement{
-      int_or_string: Map.fetch!(m, "intOrString"),
+      int_or_string: decode_int_or_string(Map.fetch!(m, "intOrString")),
       name: decode_name(m["name"]),
       optional_value: m["optionalValue"],
     }
diff --git a/base/elixir/test/inputs/json/samples/null-safe.json/default/QuickType.ex b/head/elixir/test/inputs/json/samples/null-safe.json/default/QuickType.ex
index 2cf6821..eeb7fa7 100644
--- a/base/elixir/test/inputs/json/samples/null-safe.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/samples/null-safe.json/default/QuickType.ex
@@ -79,12 +79,20 @@ defmodule Item do
   def encode_name(value) when is_binary(value), do: value
   def encode_name(_), do: {:error, "Unexpected type when encoding Item.name"}
 
+  def decode_sex(value) when is_integer(value), do: value
+  def decode_sex(value) when is_nil(value), do: value
+  def decode_sex(_), do: {:error, "Unexpected type when decoding Item.sex"}
+
+  def encode_sex(value) when is_integer(value), do: value
+  def encode_sex(value) when is_nil(value), do: value
+  def encode_sex(_), do: {:error, "Unexpected type when encoding Item.sex"}
+
   def from_map(m) do
     %Item{
       address: m["address"] && Address.from_map(m["address"]),
       created_at: m["created_at"],
       name: decode_name(m["name"]),
-      sex: Map.fetch!(m, "sex"),
+      sex: decode_sex(Map.fetch!(m, "sex")),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/samples/reddit.json/default/QuickType.ex b/head/elixir/test/inputs/json/samples/reddit.json/default/QuickType.ex
index e3a9c35..0707083 100644
--- a/base/elixir/test/inputs/json/samples/reddit.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/samples/reddit.json/default/QuickType.ex
@@ -686,6 +686,22 @@ defmodule ChildData do
   def encode_author(value) when is_binary(value), do: value
   def encode_author(_), do: {:error, "Unexpected type when encoding ChildData.author"}
 
+  def decode_author_flair_css_class(value) when is_nil(value), do: value
+  def decode_author_flair_css_class(value) when is_binary(value), do: value
+  def decode_author_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_css_class"}
+
+  def encode_author_flair_css_class(value) when is_nil(value), do: value
+  def encode_author_flair_css_class(value) when is_binary(value), do: value
+  def encode_author_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_css_class"}
+
+  def decode_author_flair_text(value) when is_nil(value), do: value
+  def decode_author_flair_text(value) when is_binary(value), do: value
+  def decode_author_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.author_flair_text"}
+
+  def encode_author_flair_text(value) when is_nil(value), do: value
+  def encode_author_flair_text(value) when is_binary(value), do: value
+  def encode_author_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.author_flair_text"}
+
   def decode_banned_at_utc(value) when is_nil(value), do: value
   def decode_banned_at_utc(_), do: {:error, "Unexpected type when decoding ChildData.banned_at_utc"}
 
@@ -740,6 +756,14 @@ defmodule ChildData do
   def encode_created_utc(value) when is_integer(value), do: value
   def encode_created_utc(_), do: {:error, "Unexpected type when encoding ChildData.created_utc"}
 
+  def decode_distinguished(value) when is_nil(value), do: value
+  def decode_distinguished(value) when is_binary(value), do: value
+  def decode_distinguished(_), do: {:error, "Unexpected type when decoding ChildData.distinguished"}
+
+  def encode_distinguished(value) when is_nil(value), do: value
+  def encode_distinguished(value) when is_binary(value), do: value
+  def encode_distinguished(_), do: {:error, "Unexpected type when encoding ChildData.distinguished"}
+
   def decode_downs(value) when is_integer(value), do: value
   def decode_downs(_), do: {:error, "Unexpected type when decoding ChildData.downs"}
 
@@ -794,6 +818,22 @@ defmodule ChildData do
   def encode_likes(value) when is_nil(value), do: value
   def encode_likes(_), do: {:error, "Unexpected type when encoding ChildData.likes"}
 
+  def decode_link_flair_css_class(value) when is_nil(value), do: value
+  def decode_link_flair_css_class(value) when is_binary(value), do: value
+  def decode_link_flair_css_class(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_css_class"}
+
+  def encode_link_flair_css_class(value) when is_nil(value), do: value
+  def encode_link_flair_css_class(value) when is_binary(value), do: value
+  def encode_link_flair_css_class(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_css_class"}
+
+  def decode_link_flair_text(value) when is_nil(value), do: value
+  def decode_link_flair_text(value) when is_binary(value), do: value
+  def decode_link_flair_text(_), do: {:error, "Unexpected type when decoding ChildData.link_flair_text"}
+
+  def encode_link_flair_text(value) when is_nil(value), do: value
+  def encode_link_flair_text(value) when is_binary(value), do: value
+  def encode_link_flair_text(_), do: {:error, "Unexpected type when encoding ChildData.link_flair_text"}
+
   def decode_locked(value) when is_boolean(value), do: value
   def decode_locked(_), do: {:error, "Unexpected type when decoding ChildData.locked"}
 
@@ -968,8 +1008,8 @@ defmodule ChildData do
       approved_by: decode_approved_by(m["approved_by"]),
       archived: decode_archived(m["archived"]),
       author: decode_author(m["author"]),
-      author_flair_css_class: Map.fetch!(m, "author_flair_css_class"),
-      author_flair_text: Map.fetch!(m, "author_flair_text"),
+      author_flair_css_class: decode_author_flair_css_class(Map.fetch!(m, "author_flair_css_class")),
+      author_flair_text: decode_author_flair_text(Map.fetch!(m, "author_flair_text")),
       banned_at_utc: decode_banned_at_utc(m["banned_at_utc"]),
       banned_by: decode_banned_by(m["banned_by"]),
       brand_safe: decode_brand_safe(m["brand_safe"]),
@@ -979,7 +1019,7 @@ defmodule ChildData do
       contest_mode: decode_contest_mode(m["contest_mode"]),
       created: decode_created(m["created"]),
       created_utc: decode_created_utc(m["created_utc"]),
-      distinguished: Map.fetch!(m, "distinguished"),
+      distinguished: decode_distinguished(Map.fetch!(m, "distinguished")),
       domain: Domain.decode(m["domain"]),
       downs: decode_downs(m["downs"]),
       edited: decode_edited(m["edited"]),
@@ -990,8 +1030,8 @@ defmodule ChildData do
       is_self: decode_is_self(m["is_self"]),
       is_video: decode_is_video(m["is_video"]),
       likes: decode_likes(m["likes"]),
-      link_flair_css_class: Map.fetch!(m, "link_flair_css_class"),
-      link_flair_text: Map.fetch!(m, "link_flair_text"),
+      link_flair_css_class: decode_link_flair_css_class(Map.fetch!(m, "link_flair_css_class")),
+      link_flair_text: decode_link_flair_text(Map.fetch!(m, "link_flair_text")),
       locked: decode_locked(m["locked"]),
       media: decode_media(m["media"]),
       media_embed: MediaEmbed.from_map(m["media_embed"]),
diff --git a/base/elixir/test/inputs/json/samples/us-senators.json/default/QuickType.ex b/head/elixir/test/inputs/json/samples/us-senators.json/default/QuickType.ex
index 7afc185..871c248 100644
--- a/base/elixir/test/inputs/json/samples/us-senators.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/samples/us-senators.json/default/QuickType.ex
@@ -407,6 +407,22 @@ defmodule Person do
   def encode_sortname(value) when is_binary(value), do: value
   def encode_sortname(_), do: {:error, "Unexpected type when encoding Person.sortname"}
 
+  def decode_twitterid(value) when is_nil(value), do: value
+  def decode_twitterid(value) when is_binary(value), do: value
+  def decode_twitterid(_), do: {:error, "Unexpected type when decoding Person.twitterid"}
+
+  def encode_twitterid(value) when is_nil(value), do: value
+  def encode_twitterid(value) when is_binary(value), do: value
+  def encode_twitterid(_), do: {:error, "Unexpected type when encoding Person.twitterid"}
+
+  def decode_youtubeid(value) when is_nil(value), do: value
+  def decode_youtubeid(value) when is_binary(value), do: value
+  def decode_youtubeid(_), do: {:error, "Unexpected type when decoding Person.youtubeid"}
+
+  def encode_youtubeid(value) when is_nil(value), do: value
+  def encode_youtubeid(value) when is_binary(value), do: value
+  def encode_youtubeid(_), do: {:error, "Unexpected type when encoding Person.youtubeid"}
+
   def from_map(m) do
     %Person{
       bioguideid: decode_bioguideid(m["bioguideid"]),
@@ -424,8 +440,8 @@ defmodule Person do
       osid: decode_osid(m["osid"]),
       pvsid: decode_pvsid(m["pvsid"]),
       sortname: decode_sortname(m["sortname"]),
-      twitterid: Map.fetch!(m, "twitterid"),
-      youtubeid: Map.fetch!(m, "youtubeid"),
+      twitterid: decode_twitterid(Map.fetch!(m, "twitterid")),
+      youtubeid: decode_youtubeid(Map.fetch!(m, "youtubeid")),
     }
   end
 
@@ -844,6 +860,14 @@ defmodule Object do
   def encode_enddate(value) when is_binary(value), do: value
   def encode_enddate(_), do: {:error, "Unexpected type when encoding Object.enddate"}
 
+  def decode_leadership_title(value) when is_nil(value), do: value
+  def decode_leadership_title(value) when is_binary(value), do: value
+  def decode_leadership_title(_), do: {:error, "Unexpected type when decoding Object.leadership_title"}
+
+  def encode_leadership_title(value) when is_nil(value), do: value
+  def encode_leadership_title(value) when is_binary(value), do: value
+  def encode_leadership_title(_), do: {:error, "Unexpected type when encoding Object.leadership_title"}
+
   def decode_phone(value) when is_binary(value), do: value
   def decode_phone(_), do: {:error, "Unexpected type when decoding Object.phone"}
 
@@ -877,7 +901,7 @@ defmodule Object do
       district: decode_district(m["district"]),
       enddate: decode_enddate(m["enddate"]),
       extra: Extra.from_map(m["extra"]),
-      leadership_title: Map.fetch!(m, "leadership_title"),
+      leadership_title: decode_leadership_title(Map.fetch!(m, "leadership_title")),
       party: Party.decode(m["party"]),
       person: Person.from_map(m["person"]),
       phone: decode_phone(m["phone"]),
diff --git a/base/graphql-elixir/test/inputs/graphql/github1.graphql/default/QuickType.ex b/head/graphql-elixir/test/inputs/graphql/github1.graphql/default/QuickType.ex
index 9b1febb..41253e9 100644
--- a/base/graphql-elixir/test/inputs/graphql/github1.graphql/default/QuickType.ex
+++ b/head/graphql-elixir/test/inputs/graphql/github1.graphql/default/QuickType.ex
@@ -20,10 +20,18 @@ defmodule User do
   def encode_login(value) when is_binary(value), do: value
   def encode_login(_), do: {:error, "Unexpected type when encoding User.login"}
 
+  def decode_real_name(value) when is_nil(value), do: value
+  def decode_real_name(value) when is_binary(value), do: value
+  def decode_real_name(_), do: {:error, "Unexpected type when decoding User.real_name"}
+
+  def encode_real_name(value) when is_nil(value), do: value
+  def encode_real_name(value) when is_binary(value), do: value
+  def encode_real_name(_), do: {:error, "Unexpected type when encoding User.real_name"}
+
   def from_map(m) do
     %User{
       login: decode_login(m["login"]),
-      real_name: Map.fetch!(m, "realName"),
+      real_name: decode_real_name(Map.fetch!(m, "realName")),
     }
   end
 
diff --git a/base/graphql-elixir/test/inputs/graphql/github4.graphql/default/QuickType.ex b/head/graphql-elixir/test/inputs/graphql/github4.graphql/default/QuickType.ex
index f6a49d1..cb6585e 100644
--- a/base/graphql-elixir/test/inputs/graphql/github4.graphql/default/QuickType.ex
+++ b/head/graphql-elixir/test/inputs/graphql/github4.graphql/default/QuickType.ex
@@ -175,10 +175,18 @@ defmodule User do
   def encode_login(value) when is_binary(value), do: value
   def encode_login(_), do: {:error, "Unexpected type when encoding User.login"}
 
+  def decode_name(value) when is_nil(value), do: value
+  def decode_name(value) when is_binary(value), do: value
+  def decode_name(_), do: {:error, "Unexpected type when decoding User.name"}
+
+  def encode_name(value) when is_nil(value), do: value
+  def encode_name(value) when is_binary(value), do: value
+  def encode_name(_), do: {:error, "Unexpected type when encoding User.name"}
+
   def from_map(m) do
     %User{
       login: decode_login(m["login"]),
-      name: Map.fetch!(m, "name"),
+      name: decode_name(Map.fetch!(m, "name")),
       repository: m["repository"] && Repository.from_map(m["repository"]),
     }
   end
diff --git a/base/graphql-elixir/test/inputs/graphql/github5.graphql/default/QuickType.ex b/head/graphql-elixir/test/inputs/graphql/github5.graphql/default/QuickType.ex
index 5325506..49bdfc6 100644
--- a/base/graphql-elixir/test/inputs/graphql/github5.graphql/default/QuickType.ex
+++ b/head/graphql-elixir/test/inputs/graphql/github5.graphql/default/QuickType.ex
@@ -20,10 +20,18 @@ defmodule User do
   def encode_login(value) when is_binary(value), do: value
   def encode_login(_), do: {:error, "Unexpected type when encoding User.login"}
 
+  def decode_name(value) when is_nil(value), do: value
+  def decode_name(value) when is_binary(value), do: value
+  def decode_name(_), do: {:error, "Unexpected type when decoding User.name"}
+
+  def encode_name(value) when is_nil(value), do: value
+  def encode_name(value) when is_binary(value), do: value
+  def encode_name(_), do: {:error, "Unexpected type when encoding User.name"}
+
   def from_map(m) do
     %User{
       login: decode_login(m["login"]),
-      name: m["name"],
+      name: m["name"] && decode_name(m["name"]),
     }
   end
 
diff --git a/base/graphql-elixir/test/inputs/graphql/github9.graphql/default/QuickType.ex b/head/graphql-elixir/test/inputs/graphql/github9.graphql/default/QuickType.ex
index fd8f02a..2aba09e 100644
--- a/base/graphql-elixir/test/inputs/graphql/github9.graphql/default/QuickType.ex
+++ b/head/graphql-elixir/test/inputs/graphql/github9.graphql/default/QuickType.ex
@@ -146,9 +146,17 @@ defmodule AddReactionPayload do
           subject: Reactable.t()
         }
 
+  def decode_client_mutation_id(value) when is_nil(value), do: value
+  def decode_client_mutation_id(value) when is_binary(value), do: value
+  def decode_client_mutation_id(_), do: {:error, "Unexpected type when decoding AddReactionPayload.client_mutation_id"}
+
+  def encode_client_mutation_id(value) when is_nil(value), do: value
+  def encode_client_mutation_id(value) when is_binary(value), do: value
+  def encode_client_mutation_id(_), do: {:error, "Unexpected type when encoding AddReactionPayload.client_mutation_id"}
+
   def from_map(m) do
     %AddReactionPayload{
-      client_mutation_id: Map.fetch!(m, "clientMutationId"),
+      client_mutation_id: decode_client_mutation_id(Map.fetch!(m, "clientMutationId")),
       reaction: Reaction.from_map(m["reaction"]),
       subject: Reactable.from_map(m["subject"]),
     }
diff --git a/base/schema-elixir/test/inputs/schema/accessors.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/accessors.schema/default/QuickType.ex
index 6280926..bddcae6 100644
--- a/base/schema-elixir/test/inputs/schema/accessors.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/accessors.schema/default/QuickType.ex
@@ -75,12 +75,22 @@ defmodule TopLevel do
   def encode_foo(value) when is_binary(value), do: value
   def encode_foo(_), do: {:error, "Unexpected type when encoding TopLevel.foo"}
 
+  def decode_unionization(value) when is_boolean(value), do: value
+  def decode_unionization(value) when is_float(value), do: value
+  def decode_unionization(value) when is_integer(value), do: value
+  def decode_unionization(_), do: {:error, "Unexpected type when decoding TopLevel.unionization"}
+
+  def encode_unionization(value) when is_boolean(value), do: value
+  def encode_unionization(value) when is_float(value), do: value
+  def encode_unionization(value) when is_integer(value), do: value
+  def encode_unionization(_), do: {:error, "Unexpected type when encoding TopLevel.unionization"}
+
   def from_map(m) do
     %TopLevel{
       barre: decode_barre(m["bar"]),
       enumerification: EnumEnum.decode(m["enum"]),
       foo: decode_foo(m["foo"]),
-      unionization: Map.fetch!(m, "union"),
+      unionization: decode_unionization(Map.fetch!(m, "union")),
     }
   end
 
diff --git a/base/schema-elixir/test/inputs/schema/bool-string.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/bool-string.schema/default/QuickType.ex
index 63cb009..ac58f53 100644
--- a/base/schema-elixir/test/inputs/schema/bool-string.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/bool-string.schema/default/QuickType.ex
@@ -27,21 +27,45 @@ defmodule TopLevel do
   def encode_arr_nullable_element(value) when is_binary(value), do: value
   def encode_arr_nullable_element(_), do: {:error, "Unexpected type when encoding TopLevel.arr_nullable"}
 
+  def decode_nullable(value) when is_nil(value), do: value
+  def decode_nullable(value) when is_binary(value), do: value
+  def decode_nullable(_), do: {:error, "Unexpected type when decoding TopLevel.nullable"}
+
+  def encode_nullable(value) when is_nil(value), do: value
+  def encode_nullable(value) when is_binary(value), do: value
+  def encode_nullable(_), do: {:error, "Unexpected type when encoding TopLevel.nullable"}
+
   def decode_one(value) when is_binary(value), do: value
   def decode_one(_), do: {:error, "Unexpected type when decoding TopLevel.one"}
 
   def encode_one(value) when is_binary(value), do: value
   def encode_one(_), do: {:error, "Unexpected type when encoding TopLevel.one"}
 
+  def decode_union_with_bool(value) when is_boolean(value), do: value
+  def decode_union_with_bool(value) when is_binary(value), do: value
+  def decode_union_with_bool(_), do: {:error, "Unexpected type when decoding TopLevel.union_with_bool"}
+
+  def encode_union_with_bool(value) when is_boolean(value), do: value
+  def encode_union_with_bool(value) when is_binary(value), do: value
+  def encode_union_with_bool(_), do: {:error, "Unexpected type when encoding TopLevel.union_with_bool"}
+
+  def decode_union_with_bool_and_enum(value) when is_boolean(value), do: value
+  def decode_union_with_bool_and_enum(value) when is_binary(value), do: value
+  def decode_union_with_bool_and_enum(_), do: {:error, "Unexpected type when decoding TopLevel.union_with_bool_and_enum"}
+
+  def encode_union_with_bool_and_enum(value) when is_boolean(value), do: value
+  def encode_union_with_bool_and_enum(value) when is_binary(value), do: value
+  def encode_union_with_bool_and_enum(_), do: {:error, "Unexpected type when encoding TopLevel.union_with_bool_and_enum"}
+
   def from_map(m) do
     %TopLevel{
       arr_nullable: m["arrNullable"] && Enum.map(m["arrNullable"], &decode_arr_nullable_element/1),
       arr_one: m["arrOne"],
-      nullable: Map.fetch!(m, "nullable"),
+      nullable: decode_nullable(Map.fetch!(m, "nullable")),
       one: decode_one(m["one"]),
       optional: m["optional"],
-      union_with_bool: Map.fetch!(m, "unionWithBool"),
-      union_with_bool_and_enum: Map.fetch!(m, "unionWithBoolAndEnum"),
+      union_with_bool: decode_union_with_bool(Map.fetch!(m, "unionWithBool")),
+      union_with_bool_and_enum: decode_union_with_bool_and_enum(Map.fetch!(m, "unionWithBoolAndEnum")),
     }
   end
 
diff --git a/base/schema-elixir/test/inputs/schema/class-map-union.schema/default/QuickType.ex b/base/schema-elixir/test/inputs/schema/class-map-union.schema/default/QuickType.ex
deleted file mode 100644
index fd71797..0000000
--- a/base/schema-elixir/test/inputs/schema/class-map-union.schema/default/QuickType.ex
+++ /dev/null
@@ -1,86 +0,0 @@
-# This file was autogenerated using quicktype https://github.com/quicktype/quicktype
-#
-# Add Jason to your mix.exs
-#
-# Decode a JSON string: TopLevel.from_json(data)
-# Encode into a JSON string: TopLevel.to_json(struct)
-
-defmodule UnionClass do
-  defstruct [:quux]
-
-  @type t :: %__MODULE__{
-          quux: integer() | nil
-        }
-
-  def from_map(m) do
-    %UnionClass{
-      quux: m["quux"],
-    }
-  end
-
-  def from_json(json) do
-    json
-          |> Jason.decode!()
-          |> from_map()
-  end
-
-  def to_map(struct) do
-    %{
-      "quux" => struct.quux,
-    }
-  end
-
-  def to_json(struct) do
-    struct
-          |> to_map()
-          |> Jason.encode!()
-  end
-end
-
-defmodule TopLevel do
-  defstruct [:union]
-
-  @type t :: %__MODULE__{
-          union: %{String.t() => boolean() | UnionClass.t() | float() | String.t()} | nil
-        }
-
-  def decode_union_value(%{} = value), do: UnionClass.from_map(value)
-  def decode_union_value(value) when is_boolean(value), do: value
-  def decode_union_value(value) when is_float(value), do: value
-  def decode_union_value(value) when is_integer(value), do: value
-  def decode_union_value(value) when is_binary(value), do: value
-  def decode_union_value(_), do: {:error, "Unexpected type when decoding TopLevel.union"}
-
-  def encode_union_value(%UnionClass{} = value), do: UnionClass.to_map(value)
-  def encode_union_value(value) when is_boolean(value), do: value
-  def encode_union_value(value) when is_float(value), do: value
-  def encode_union_value(value) when is_integer(value), do: value
-  def encode_union_value(value) when is_binary(value), do: value
-  def encode_union_value(_), do: {:error, "Unexpected type when encoding TopLevel.union"}
-
-  def from_map(m) do
-    %TopLevel{
-      union: m["union"]
-      |> Map.new(fn {key, value} -> {key, decode_union_value(value)} end),
-    }
-  end
-
-  def from_json(json) do
-    json
-          |> Jason.decode!()
-          |> from_map()
-  end
-
-  def to_map(struct) do
-    %{
-      "union" => struct.union
-      |> Map.new(fn {key, value} -> {key, encode_union_value(value)} end),
-    }
-  end
-
-  def to_json(struct) do
-    struct
-          |> to_map()
-          |> Jason.encode!()
-  end
-end
diff --git a/base/schema-elixir/test/inputs/schema/description.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/description.schema/default/QuickType.ex
index 9f4fd44..1770949 100644
--- a/base/schema-elixir/test/inputs/schema/description.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/description.schema/default/QuickType.ex
@@ -127,13 +127,23 @@ defmodule TopLevel do
   def encode_object_or_string(value) when is_binary(value), do: value
   def encode_object_or_string(_), do: {:error, "Unexpected type when encoding TopLevel.object_or_string"}
 
+  def decode_union(value) when is_float(value), do: value
+  def decode_union(value) when is_integer(value), do: value
+  def decode_union(value) when is_binary(value), do: value
+  def decode_union(_), do: {:error, "Unexpected type when decoding TopLevel.union"}
+
+  def encode_union(value) when is_float(value), do: value
+  def encode_union(value) when is_integer(value), do: value
+  def encode_union(value) when is_binary(value), do: value
+  def encode_union(_), do: {:error, "Unexpected type when encoding TopLevel.union"}
+
   def from_map(m) do
     %TopLevel{
       bar: m["bar"],
       enum: EnumEnum.decode(m["enum"]),
       foo: m["foo"],
       object_or_string: decode_object_or_string(m["object-or-string"]),
-      union: Map.fetch!(m, "union"),
+      union: decode_union(Map.fetch!(m, "union")),
     }
   end
 
diff --git a/base/schema-elixir/test/inputs/schema/implicit-class-array-union.schema/default/QuickType.ex b/base/schema-elixir/test/inputs/schema/implicit-class-array-union.schema/default/QuickType.ex
deleted file mode 100644
index c6dedb0..0000000
--- a/base/schema-elixir/test/inputs/schema/implicit-class-array-union.schema/default/QuickType.ex
+++ /dev/null
@@ -1,96 +0,0 @@
-# This file was autogenerated using quicktype https://github.com/quicktype/quicktype
-#
-# Add Jason to your mix.exs
-#
-# Decode a JSON string: TopLevel.from_json(data)
-# Encode into a JSON string: TopLevel.to_json(struct)
-
-defmodule FooClass do
-  @enforce_keys [:bar]
-  defstruct [:bar]
-
-  @type t :: %__MODULE__{
-          bar: integer()
-        }
-
-  def decode_bar(value) when is_integer(value), do: value
-  def decode_bar(_), do: {:error, "Unexpected type when decoding FooClass.bar"}
-
-  def encode_bar(value) when is_integer(value), do: value
-  def encode_bar(_), do: {:error, "Unexpected type when encoding FooClass.bar"}
-
-  def from_map(m) do
-    %FooClass{
-      bar: decode_bar(m["bar"]),
-    }
-  end
-
-  def from_json(json) do
-    json
-          |> Jason.decode!()
-          |> from_map()
-  end
-
-  def to_map(struct) do
-    %{
-      "bar" => struct.bar,
-    }
-  end
-
-  def to_json(struct) do
-    struct
-          |> to_map()
-          |> Jason.encode!()
-  end
-end
-
-defmodule TopLevel do
-  @enforce_keys [:foo]
-  defstruct [:foo]
-
-  @type t :: %__MODULE__{
-          foo: [integer()] | boolean() | FooClass.t() | float() | integer() | nil | String.t()
-        }
-
-  def decode_foo(%{"bar" => _,} = value), do: FooClass.from_map(value)
-  def decode_foo(value) when is_boolean(value), do: value
-  def decode_foo(value) when is_float(value), do: value
-  def decode_foo(value) when is_integer(value), do: value
-  def decode_foo(value) when is_nil(value), do: value
-  def decode_foo(value) when is_binary(value), do: value
-  def decode_foo(value) when is_list(value), do: value
-  def decode_foo(_), do: {:error, "Unexpected type when decoding TopLevel.foo"}
-
-  def encode_foo(%FooClass{} = value), do: FooClass.to_map(value)
-  def encode_foo(value) when is_boolean(value), do: value
-  def encode_foo(value) when is_float(value), do: value
-  def encode_foo(value) when is_integer(value), do: value
-  def encode_foo(value) when is_nil(value), do: value
-  def encode_foo(value) when is_binary(value), do: value
-  def encode_foo(value) when is_list(value), do: value
-  def encode_foo(_), do: {:error, "Unexpected type when encoding TopLevel.foo"}
-
-  def from_map(m) do
-    %TopLevel{
-      foo: decode_foo(m["foo"]),
-    }
-  end
-
-  def from_json(json) do
-    json
-          |> Jason.decode!()
-          |> from_map()
-  end
-
-  def to_map(struct) do
-    %{
-      "foo" => encode_foo(struct.foo),
-    }
-  end
-
-  def to_json(struct) do
-    struct
-          |> to_map()
-          |> Jason.encode!()
-  end
-end
diff --git a/base/schema-elixir/test/inputs/schema/integer-string.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/integer-string.schema/default/QuickType.ex
index c5b4a64..80fa22f 100644
--- a/base/schema-elixir/test/inputs/schema/integer-string.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/integer-string.schema/default/QuickType.ex
@@ -27,21 +27,45 @@ defmodule TopLevel do
   def encode_arr_nullable_element(value) when is_binary(value), do: value
   def encode_arr_nullable_element(_), do: {:error, "Unexpected type when encoding TopLevel.arr_nullable"}
 
+  def decode_nullable(value) when is_nil(value), do: value
+  def decode_nullable(value) when is_binary(value), do: value
+  def decode_nullable(_), do: {:error, "Unexpected type when decoding TopLevel.nullable"}
+
+  def encode_nullable(value) when is_nil(value), do: value
+  def encode_nullable(value) when is_binary(value), do: value
+  def encode_nullable(_), do: {:error, "Unexpected type when encoding TopLevel.nullable"}
+
   def decode_one(value) when is_binary(value), do: value
   def decode_one(_), do: {:error, "Unexpected type when decoding TopLevel.one"}
 
   def encode_one(value) when is_binary(value), do: value
   def encode_one(_), do: {:error, "Unexpected type when encoding TopLevel.one"}
 
+  def decode_union_with_int(value) when is_integer(value), do: value
+  def decode_union_with_int(value) when is_binary(value), do: value
+  def decode_union_with_int(_), do: {:error, "Unexpected type when decoding TopLevel.union_with_int"}
+
+  def encode_union_with_int(value) when is_integer(value), do: value
+  def encode_union_with_int(value) when is_binary(value), do: value
+  def encode_union_with_int(_), do: {:error, "Unexpected type when encoding TopLevel.union_with_int"}
+
+  def decode_union_with_int_and_enum(value) when is_integer(value), do: value
+  def decode_union_with_int_and_enum(value) when is_binary(value), do: value
+  def decode_union_with_int_and_enum(_), do: {:error, "Unexpected type when decoding TopLevel.union_with_int_and_enum"}
+
+  def encode_union_with_int_and_enum(value) when is_integer(value), do: value
+  def encode_union_with_int_and_enum(value) when is_binary(value), do: value
+  def encode_union_with_int_and_enum(_), do: {:error, "Unexpected type when encoding TopLevel.union_with_int_and_enum"}
+
   def from_map(m) do
     %TopLevel{
       arr_nullable: m["arrNullable"] && Enum.map(m["arrNullable"], &decode_arr_nullable_element/1),
       arr_one: m["arrOne"],
-      nullable: Map.fetch!(m, "nullable"),
+      nullable: decode_nullable(Map.fetch!(m, "nullable")),
       one: decode_one(m["one"]),
       optional: m["optional"],
-      union_with_int: Map.fetch!(m, "unionWithInt"),
-      union_with_int_and_enum: Map.fetch!(m, "unionWithIntAndEnum"),
+      union_with_int: decode_union_with_int(Map.fetch!(m, "unionWithInt")),
+      union_with_int_and_enum: decode_union_with_int_and_enum(Map.fetch!(m, "unionWithIntAndEnum")),
     }
   end
 
diff --git a/base/schema-elixir/test/inputs/schema/minmaxlength.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/minmaxlength.schema/default/QuickType.ex
index 07bbd65..4e17644 100644
--- a/base/schema-elixir/test/inputs/schema/minmaxlength.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/minmaxlength.schema/default/QuickType.ex
@@ -26,6 +26,16 @@ defmodule TopLevel do
   def encode_intersection(value) when is_binary(value), do: value
   def encode_intersection(_), do: {:error, "Unexpected type when encoding TopLevel.intersection"}
 
+  def decode_in_union(value) when is_float(value), do: value
+  def decode_in_union(value) when is_integer(value), do: value
+  def decode_in_union(value) when is_binary(value), do: value
+  def decode_in_union(_), do: {:error, "Unexpected type when decoding TopLevel.in_union"}
+
+  def encode_in_union(value) when is_float(value), do: value
+  def encode_in_union(value) when is_integer(value), do: value
+  def encode_in_union(value) when is_binary(value), do: value
+  def encode_in_union(_), do: {:error, "Unexpected type when encoding TopLevel.in_union"}
+
   def decode_maxlength(value) when is_binary(value), do: value
   def decode_maxlength(_), do: {:error, "Unexpected type when decoding TopLevel.maxlength"}
 
@@ -65,7 +75,7 @@ defmodule TopLevel do
   def from_map(m) do
     %TopLevel{
       intersection: decode_intersection(m["intersection"]),
-      in_union: Map.fetch!(m, "inUnion"),
+      in_union: decode_in_union(Map.fetch!(m, "inUnion")),
       maxlength: decode_maxlength(m["maxlength"]),
       minlength: decode_minlength(m["minlength"]),
       min_max_intersection: decode_min_max_intersection(m["minMaxIntersection"]),
diff --git a/base/schema-elixir/test/inputs/schema/nullable-optional-one-of.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/nullable-optional-one-of.schema/default/QuickType.ex
index 64df667..395f58a 100644
--- a/base/schema-elixir/test/inputs/schema/nullable-optional-one-of.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/nullable-optional-one-of.schema/default/QuickType.ex
@@ -60,9 +60,17 @@ defmodule TopLevel do
           kind: Kind.t()
         }
 
+  def decode_b(value) when is_nil(value), do: value
+  def decode_b(value) when is_binary(value), do: value
+  def decode_b(_), do: {:error, "Unexpected type when decoding TopLevel.b"}
+
+  def encode_b(value) when is_nil(value), do: value
+  def encode_b(value) when is_binary(value), do: value
+  def encode_b(_), do: {:error, "Unexpected type when encoding TopLevel.b"}
+
   def from_map(m) do
     %TopLevel{
-      b: m["b"],
+      b: m["b"] && decode_b(m["b"]),
       kind: Kind.decode(m["kind"]),
     }
   end
diff --git a/base/schema-elixir/test/inputs/schema/strict-optional.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/strict-optional.schema/default/QuickType.ex
index 0961fd1..b7ed7db 100644
--- a/base/schema-elixir/test/inputs/schema/strict-optional.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/strict-optional.schema/default/QuickType.ex
@@ -13,9 +13,19 @@ defmodule TopLevel do
           foo: float() | nil
         }
 
+  def decode_foo(value) when is_float(value), do: value
+  def decode_foo(value) when is_integer(value), do: value
+  def decode_foo(value) when is_nil(value), do: value
+  def decode_foo(_), do: {:error, "Unexpected type when decoding TopLevel.foo"}
+
+  def encode_foo(value) when is_float(value), do: value
+  def encode_foo(value) when is_integer(value), do: value
+  def encode_foo(value) when is_nil(value), do: value
+  def encode_foo(_), do: {:error, "Unexpected type when encoding TopLevel.foo"}
+
   def from_map(m) do
     %TopLevel{
-      foo: Map.fetch!(m, "foo"),
+      foo: decode_foo(Map.fetch!(m, "foo")),
     }
   end
 
diff --git a/base/schema-elixir/test/inputs/schema/union-int-double.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/union-int-double.schema/default/QuickType.ex
index bf1832c..02f3c84 100644
--- a/base/schema-elixir/test/inputs/schema/union-int-double.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/union-int-double.schema/default/QuickType.ex
@@ -13,9 +13,19 @@ defmodule TopLevel do
           value: float() | String.t()
         }
 
+  def decode_value(value) when is_float(value), do: value
+  def decode_value(value) when is_integer(value), do: value
+  def decode_value(value) when is_binary(value), do: value
+  def decode_value(_), do: {:error, "Unexpected type when decoding TopLevel.value"}
+
+  def encode_value(value) when is_float(value), do: value
+  def encode_value(value) when is_integer(value), do: value
+  def encode_value(value) when is_binary(value), do: value
+  def encode_value(_), do: {:error, "Unexpected type when encoding TopLevel.value"}
+
   def from_map(m) do
     %TopLevel{
-      value: Map.fetch!(m, "value"),
+      value: decode_value(Map.fetch!(m, "value")),
     }
   end
 
diff --git a/base/schema-elixir/test/inputs/schema/uuid.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/uuid.schema/default/QuickType.ex
index 1ea6e51..752b0f7 100644
--- a/base/schema-elixir/test/inputs/schema/uuid.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/uuid.schema/default/QuickType.ex
@@ -26,6 +26,14 @@ defmodule TopLevel do
   def encode_arr_nullable_element(value) when is_binary(value), do: value
   def encode_arr_nullable_element(_), do: {:error, "Unexpected type when encoding TopLevel.arr_nullable"}
 
+  def decode_nullable(value) when is_nil(value), do: value
+  def decode_nullable(value) when is_binary(value), do: value
+  def decode_nullable(_), do: {:error, "Unexpected type when decoding TopLevel.nullable"}
+
+  def encode_nullable(value) when is_nil(value), do: value
+  def encode_nullable(value) when is_binary(value), do: value
+  def encode_nullable(_), do: {:error, "Unexpected type when encoding TopLevel.nullable"}
+
   def decode_one(value) when is_binary(value), do: value
   def decode_one(_), do: {:error, "Unexpected type when decoding TopLevel.one"}
 
@@ -42,7 +50,7 @@ defmodule TopLevel do
     %TopLevel{
       arr_nullable: m["arrNullable"] && Enum.map(m["arrNullable"], &decode_arr_nullable_element/1),
       arr_one: m["arrOne"],
-      nullable: Map.fetch!(m, "nullable"),
+      nullable: decode_nullable(Map.fetch!(m, "nullable")),
       one: decode_one(m["one"]),
       optional: m["optional"],
       union_with_enum: decode_union_with_enum(m["unionWithEnum"]),
diff --git a/base/schema-elixir/test/inputs/schema/vega-lite.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/vega-lite.schema/default/QuickType.ex
index ea48c77..37f3301 100644
--- a/base/schema-elixir/test/inputs/schema/vega-lite.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/vega-lite.schema/default/QuickType.ex
@@ -892,6 +892,26 @@ defmodule AxisConfig do
           title_y: float() | nil
         }
 
+  def decode_label_bound(value) when is_boolean(value), do: value
+  def decode_label_bound(value) when is_float(value), do: value
+  def decode_label_bound(value) when is_integer(value), do: value
+  def decode_label_bound(_), do: {:error, "Unexpected type when decoding AxisConfig.label_bound"}
+
+  def encode_label_bound(value) when is_boolean(value), do: value
+  def encode_label_bound(value) when is_float(value), do: value
+  def encode_label_bound(value) when is_integer(value), do: value
+  def encode_label_bound(_), do: {:error, "Unexpected type when encoding AxisConfig.label_bound"}
+
+  def decode_label_flush(value) when is_boolean(value), do: value
+  def decode_label_flush(value) when is_float(value), do: value
+  def decode_label_flush(value) when is_integer(value), do: value
+  def decode_label_flush(_), do: {:error, "Unexpected type when decoding AxisConfig.label_flush"}
+
+  def encode_label_flush(value) when is_boolean(value), do: value
+  def encode_label_flush(value) when is_float(value), do: value
+  def encode_label_flush(value) when is_integer(value), do: value
+  def encode_label_flush(_), do: {:error, "Unexpected type when encoding AxisConfig.label_flush"}
+
   def decode_label_overlap(value) when is_boolean(value), do: value
   def decode_label_overlap(value) when is_binary(value), do: LabelOverlapEnum.decode(value)
   def decode_label_overlap(value) when is_nil(value), do: value
@@ -902,6 +922,16 @@ defmodule AxisConfig do
   def encode_label_overlap(value) when is_nil(value), do: value
   def encode_label_overlap(_), do: {:error, "Unexpected type when encoding AxisConfig.label_overlap"}
 
+  def decode_title_font_weight(value) when is_float(value), do: value
+  def decode_title_font_weight(value) when is_integer(value), do: value
+  def decode_title_font_weight(value) when is_binary(value), do: value
+  def decode_title_font_weight(_), do: {:error, "Unexpected type when decoding AxisConfig.title_font_weight"}
+
+  def encode_title_font_weight(value) when is_float(value), do: value
+  def encode_title_font_weight(value) when is_integer(value), do: value
+  def encode_title_font_weight(value) when is_binary(value), do: value
+  def encode_title_font_weight(_), do: {:error, "Unexpected type when encoding AxisConfig.title_font_weight"}
+
   def from_map(m) do
     %AxisConfig{
       band_position: m["bandPosition"],
@@ -914,9 +944,9 @@ defmodule AxisConfig do
       grid_opacity: m["gridOpacity"],
       grid_width: m["gridWidth"],
       label_angle: m["labelAngle"],
-      label_bound: m["labelBound"],
+      label_bound: m["labelBound"] && decode_label_bound(m["labelBound"]),
       label_color: m["labelColor"],
-      label_flush: m["labelFlush"],
+      label_flush: m["labelFlush"] && decode_label_flush(m["labelFlush"]),
       label_font: m["labelFont"],
       label_font_size: m["labelFontSize"],
       label_limit: m["labelLimit"],
@@ -937,7 +967,7 @@ defmodule AxisConfig do
       title_color: m["titleColor"],
       title_font: m["titleFont"],
       title_font_size: m["titleFontSize"],
-      title_font_weight: m["titleFontWeight"],
+      title_font_weight: m["titleFontWeight"] && decode_title_font_weight(m["titleFontWeight"]),
       title_limit: m["titleLimit"],
       title_max_length: m["titleMaxLength"],
       title_padding: m["titlePadding"],
@@ -1101,6 +1131,26 @@ defmodule VGAxisConfig do
           title_y: float() | nil
         }
 
+  def decode_label_bound(value) when is_boolean(value), do: value
+  def decode_label_bound(value) when is_float(value), do: value
+  def decode_label_bound(value) when is_integer(value), do: value
+  def decode_label_bound(_), do: {:error, "Unexpected type when decoding VGAxisConfig.label_bound"}
+
+  def encode_label_bound(value) when is_boolean(value), do: value
+  def encode_label_bound(value) when is_float(value), do: value
+  def encode_label_bound(value) when is_integer(value), do: value
+  def encode_label_bound(_), do: {:error, "Unexpected type when encoding VGAxisConfig.label_bound"}
+
+  def decode_label_flush(value) when is_boolean(value), do: value
+  def decode_label_flush(value) when is_float(value), do: value
+  def decode_label_flush(value) when is_integer(value), do: value
+  def decode_label_flush(_), do: {:error, "Unexpected type when decoding VGAxisConfig.label_flush"}
+
+  def encode_label_flush(value) when is_boolean(value), do: value
+  def encode_label_flush(value) when is_float(value), do: value
+  def encode_label_flush(value) when is_integer(value), do: value
+  def encode_label_flush(_), do: {:error, "Unexpected type when encoding VGAxisConfig.label_flush"}
+
   def decode_label_overlap(value) when is_boolean(value), do: value
   def decode_label_overlap(value) when is_binary(value), do: LabelOverlapEnum.decode(value)
   def decode_label_overlap(value) when is_nil(value), do: value
@@ -1111,6 +1161,16 @@ defmodule VGAxisConfig do
   def encode_label_overlap(value) when is_nil(value), do: value
   def encode_label_overlap(_), do: {:error, "Unexpected type when encoding VGAxisConfig.label_overlap"}
 
+  def decode_title_font_weight(value) when is_float(value), do: value
+  def decode_title_font_weight(value) when is_integer(value), do: value
+  def decode_title_font_weight(value) when is_binary(value), do: value
+  def decode_title_font_weight(_), do: {:error, "Unexpected type when decoding VGAxisConfig.title_font_weight"}
+
+  def encode_title_font_weight(value) when is_float(value), do: value
+  def encode_title_font_weight(value) when is_integer(value), do: value
+  def encode_title_font_weight(value) when is_binary(value), do: value
+  def encode_title_font_weight(_), do: {:error, "Unexpected type when encoding VGAxisConfig.title_font_weight"}
+
   def from_map(m) do
     %VGAxisConfig{
       band_position: m["bandPosition"],
@@ -1123,9 +1183,9 @@ defmodule VGAxisConfig do
       grid_opacity: m["gridOpacity"],
       grid_width: m["gridWidth"],
       label_angle: m["labelAngle"],
-      label_bound: m["labelBound"],
+      label_bound: m["labelBound"] && decode_label_bound(m["labelBound"]),
       label_color: m["labelColor"],
-      label_flush: m["labelFlush"],
+      label_flush: m["labelFlush"] && decode_label_flush(m["labelFlush"]),
       label_font: m["labelFont"],
       label_font_size: m["labelFontSize"],
       label_limit: m["labelLimit"],
@@ -1145,7 +1205,7 @@ defmodule VGAxisConfig do
       title_color: m["titleColor"],
       title_font: m["titleFont"],
       title_font_size: m["titleFontSize"],
-      title_font_weight: m["titleFontWeight"],
+      title_font_weight: m["titleFontWeight"] && decode_title_font_weight(m["titleFontWeight"]),
       title_limit: m["titleLimit"],
       title_max_length: m["titleMaxLength"],
       title_padding: m["titlePadding"],
@@ -1637,6 +1697,16 @@ defmodule LegendConfig do
           title_padding: float() | nil
         }
 
+  def decode_title_font_weight(value) when is_float(value), do: value
+  def decode_title_font_weight(value) when is_integer(value), do: value
+  def decode_title_font_weight(value) when is_binary(value), do: value
+  def decode_title_font_weight(_), do: {:error, "Unexpected type when decoding LegendConfig.title_font_weight"}
+
+  def encode_title_font_weight(value) when is_float(value), do: value
+  def encode_title_font_weight(value) when is_integer(value), do: value
+  def encode_title_font_weight(value) when is_binary(value), do: value
+  def encode_title_font_weight(_), do: {:error, "Unexpected type when encoding LegendConfig.title_font_weight"}
+
   def from_map(m) do
     %LegendConfig{
       corner_radius: m["cornerRadius"],
@@ -1672,7 +1742,7 @@ defmodule LegendConfig do
       title_color: m["titleColor"],
       title_font: m["titleFont"],
       title_font_size: m["titleFontSize"],
-      title_font_weight: m["titleFontWeight"],
+      title_font_weight: m["titleFontWeight"] && decode_title_font_weight(m["titleFontWeight"]),
       title_limit: m["titleLimit"],
       title_padding: m["titlePadding"],
     }
@@ -2030,6 +2100,16 @@ defmodule ScaleConfig do
           use_unaggregated_domain: boolean() | nil
         }
 
+  def decode_range_step(value) when is_float(value), do: value
+  def decode_range_step(value) when is_integer(value), do: value
+  def decode_range_step(value) when is_nil(value), do: value
+  def decode_range_step(_), do: {:error, "Unexpected type when decoding ScaleConfig.range_step"}
+
+  def encode_range_step(value) when is_float(value), do: value
+  def encode_range_step(value) when is_integer(value), do: value
+  def encode_range_step(value) when is_nil(value), do: value
+  def encode_range_step(_), do: {:error, "Unexpected type when encoding ScaleConfig.range_step"}
+
   def from_map(m) do
     %ScaleConfig{
       band_padding_inner: m["bandPaddingInner"],
@@ -2047,7 +2127,7 @@ defmodule ScaleConfig do
       min_size: m["minSize"],
       min_stroke_width: m["minStrokeWidth"],
       point_padding: m["pointPadding"],
-      range_step: m["rangeStep"],
+      range_step: m["rangeStep"] && decode_range_step(m["rangeStep"]),
       round: m["round"],
       text_x_range_step: m["textXRangeStep"],
       use_unaggregated_domain: m["useUnaggregatedDomain"],
@@ -2396,6 +2476,22 @@ defmodule IntervalSelectionConfig do
           zoom: boolean() | String.t() | nil
         }
 
+  def decode_translate(value) when is_boolean(value), do: value
+  def decode_translate(value) when is_binary(value), do: value
+  def decode_translate(_), do: {:error, "Unexpected type when decoding IntervalSelectionConfig.translate"}
+
+  def encode_translate(value) when is_boolean(value), do: value
+  def encode_translate(value) when is_binary(value), do: value
+  def encode_translate(_), do: {:error, "Unexpected type when encoding IntervalSelectionConfig.translate"}
+
+  def decode_zoom(value) when is_boolean(value), do: value
+  def decode_zoom(value) when is_binary(value), do: value
+  def decode_zoom(_), do: {:error, "Unexpected type when decoding IntervalSelectionConfig.zoom"}
+
+  def encode_zoom(value) when is_boolean(value), do: value
+  def encode_zoom(value) when is_binary(value), do: value
+  def encode_zoom(_), do: {:error, "Unexpected type when encoding IntervalSelectionConfig.zoom"}
+
   def from_map(m) do
     %IntervalSelectionConfig{
       bind: m["bind"] && BindEnum.decode(m["bind"]),
@@ -2405,8 +2501,8 @@ defmodule IntervalSelectionConfig do
       mark: m["mark"] && BrushConfig.from_map(m["mark"]),
       on: m["on"],
       resolve: m["resolve"] && SelectionResolution.decode(m["resolve"]),
-      translate: m["translate"],
-      zoom: m["zoom"],
+      translate: m["translate"] && decode_translate(m["translate"]),
+      zoom: m["zoom"] && decode_zoom(m["zoom"]),
     }
   end
 
@@ -2466,6 +2562,14 @@ defmodule MultiSelectionConfig do
           toggle: boolean() | String.t() | nil
         }
 
+  def decode_toggle(value) when is_boolean(value), do: value
+  def decode_toggle(value) when is_binary(value), do: value
+  def decode_toggle(_), do: {:error, "Unexpected type when decoding MultiSelectionConfig.toggle"}
+
+  def encode_toggle(value) when is_boolean(value), do: value
+  def encode_toggle(value) when is_binary(value), do: value
+  def encode_toggle(_), do: {:error, "Unexpected type when encoding MultiSelectionConfig.toggle"}
+
   def from_map(m) do
     %MultiSelectionConfig{
       empty: m["empty"] && Empty.decode(m["empty"]),
@@ -2474,7 +2578,7 @@ defmodule MultiSelectionConfig do
       nearest: m["nearest"],
       on: m["on"],
       resolve: m["resolve"] && SelectionResolution.decode(m["resolve"]),
-      toggle: m["toggle"],
+      toggle: m["toggle"] && decode_toggle(m["toggle"]),
     }
   end
 
@@ -4188,14 +4292,34 @@ defmodule DateTimeClass do
           year: float() | nil
         }
 
+  def decode_day(value) when is_float(value), do: value
+  def decode_day(value) when is_integer(value), do: value
+  def decode_day(value) when is_binary(value), do: value
+  def decode_day(_), do: {:error, "Unexpected type when decoding DateTimeClass.day"}
+
+  def encode_day(value) when is_float(value), do: value
+  def encode_day(value) when is_integer(value), do: value
+  def encode_day(value) when is_binary(value), do: value
+  def encode_day(_), do: {:error, "Unexpected type when encoding DateTimeClass.day"}
+
+  def decode_month(value) when is_float(value), do: value
+  def decode_month(value) when is_integer(value), do: value
+  def decode_month(value) when is_binary(value), do: value
+  def decode_month(_), do: {:error, "Unexpected type when decoding DateTimeClass.month"}
+
+  def encode_month(value) when is_float(value), do: value
+  def encode_month(value) when is_integer(value), do: value
+  def encode_month(value) when is_binary(value), do: value
+  def encode_month(_), do: {:error, "Unexpected type when encoding DateTimeClass.month"}
+
   def from_map(m) do
     %DateTimeClass{
       date: m["date"],
-      day: m["day"],
+      day: m["day"] && decode_day(m["day"]),
       hours: m["hours"],
       milliseconds: m["milliseconds"],
       minutes: m["minutes"],
-      month: m["month"],
+      month: m["month"] && decode_month(m["month"]),
       quarter: m["quarter"],
       seconds: m["seconds"],
       utc: m["utc"],
@@ -4499,6 +4623,18 @@ defmodule ConditionalValueDef do
   def encode_test(value) when is_nil(value), do: value
   def encode_test(_), do: {:error, "Unexpected type when encoding ConditionalValueDef.test"}
 
+  def decode_value(value) when is_boolean(value), do: value
+  def decode_value(value) when is_float(value), do: value
+  def decode_value(value) when is_integer(value), do: value
+  def decode_value(value) when is_binary(value), do: value
+  def decode_value(_), do: {:error, "Unexpected type when decoding ConditionalValueDef.value"}
+
+  def encode_value(value) when is_boolean(value), do: value
+  def encode_value(value) when is_float(value), do: value
+  def encode_value(value) when is_integer(value), do: value
+  def encode_value(value) when is_binary(value), do: value
+  def encode_value(_), do: {:error, "Unexpected type when encoding ConditionalValueDef.value"}
+
   def decode_selection(%{} = value), do: Selection.from_map(value)
   def decode_selection(value) when is_binary(value), do: value
   def decode_selection(value) when is_nil(value), do: value
@@ -4512,7 +4648,7 @@ defmodule ConditionalValueDef do
   def from_map(m) do
     %ConditionalValueDef{
       test: decode_test(m["test"]),
-      value: Map.fetch!(m, "value"),
+      value: decode_value(Map.fetch!(m, "value")),
       selection: decode_selection(m["selection"]),
     }
   end
@@ -4704,6 +4840,14 @@ defmodule Legend do
           zindex: float() | nil
         }
 
+  def decode_title(value) when is_nil(value), do: value
+  def decode_title(value) when is_binary(value), do: value
+  def decode_title(_), do: {:error, "Unexpected type when decoding Legend.title"}
+
+  def encode_title(value) when is_nil(value), do: value
+  def encode_title(value) when is_binary(value), do: value
+  def encode_title(_), do: {:error, "Unexpected type when encoding Legend.title"}
+
   def decode_values_element(%{} = value), do: DateTimeClass.from_map(value)
   def decode_values_element(value) when is_float(value), do: value
   def decode_values_element(value) when is_integer(value), do: value
@@ -4724,7 +4868,7 @@ defmodule Legend do
       orient: m["orient"] && LegendOrient.decode(m["orient"]),
       padding: m["padding"],
       tick_count: m["tickCount"],
-      title: m["title"],
+      title: m["title"] && decode_title(m["title"]),
       type: m["type"] && LegendType.decode(m["type"]),
       values: m["values"] && Enum.map(m["values"], &decode_values_element/1),
       zindex: m["zindex"],
@@ -5252,6 +5396,16 @@ defmodule Scale do
   def encode_range(value) when is_nil(value), do: value
   def encode_range(_), do: {:error, "Unexpected type when encoding Scale.range"}
 
+  def decode_range_step(value) when is_float(value), do: value
+  def decode_range_step(value) when is_integer(value), do: value
+  def decode_range_step(value) when is_nil(value), do: value
+  def decode_range_step(_), do: {:error, "Unexpected type when decoding Scale.range_step"}
+
+  def encode_range_step(value) when is_float(value), do: value
+  def encode_range_step(value) when is_integer(value), do: value
+  def encode_range_step(value) when is_nil(value), do: value
+  def encode_range_step(_), do: {:error, "Unexpected type when encoding Scale.range_step"}
+
   def decode_scheme(%{"name" => _,} = value), do: SchemeParams.from_map(value)
   def decode_scheme(value) when is_binary(value), do: value
   def decode_scheme(value) when is_nil(value), do: value
@@ -5274,7 +5428,7 @@ defmodule Scale do
       padding_inner: m["paddingInner"],
       padding_outer: m["paddingOuter"],
       range: decode_range(m["range"]),
-      range_step: m["rangeStep"],
+      range_step: m["rangeStep"] && decode_range_step(m["rangeStep"]),
       round: m["round"],
       scheme: decode_scheme(m["scheme"]),
       type: m["type"] && ScaleType.decode(m["type"]),
@@ -5516,6 +5670,18 @@ defmodule ConditionalPredicateMarkPropFieldDefClass do
   def encode_test(value) when is_nil(value), do: value
   def encode_test(_), do: {:error, "Unexpected type when encoding ConditionalPredicateMarkPropFieldDefClass.test"}
 
+  def decode_value(value) when is_boolean(value), do: value
+  def decode_value(value) when is_float(value), do: value
+  def decode_value(value) when is_integer(value), do: value
+  def decode_value(value) when is_binary(value), do: value
+  def decode_value(_), do: {:error, "Unexpected type when decoding ConditionalPredicateMarkPropFieldDefClass.value"}
+
+  def encode_value(value) when is_boolean(value), do: value
+  def encode_value(value) when is_float(value), do: value
+  def encode_value(value) when is_integer(value), do: value
+  def encode_value(value) when is_binary(value), do: value
+  def encode_value(_), do: {:error, "Unexpected type when encoding ConditionalPredicateMarkPropFieldDefClass.value"}
+
   def decode_selection(%{} = value), do: Selection.from_map(value)
   def decode_selection(value) when is_binary(value), do: value
   def decode_selection(value) when is_nil(value), do: value
@@ -5559,7 +5725,7 @@ defmodule ConditionalPredicateMarkPropFieldDefClass do
   def from_map(m) do
     %ConditionalPredicateMarkPropFieldDefClass{
       test: decode_test(m["test"]),
-      value: m["value"],
+      value: m["value"] && decode_value(m["value"]),
       selection: decode_selection(m["selection"]),
       aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
       bin: decode_bin(m["bin"]),
@@ -5711,6 +5877,18 @@ defmodule MarkPropDefWithCondition do
   def encode_sort(value) when is_nil(value), do: value
   def encode_sort(_), do: {:error, "Unexpected type when encoding MarkPropDefWithCondition.sort"}
 
+  def decode_value(value) when is_boolean(value), do: value
+  def decode_value(value) when is_float(value), do: value
+  def decode_value(value) when is_integer(value), do: value
+  def decode_value(value) when is_binary(value), do: value
+  def decode_value(_), do: {:error, "Unexpected type when decoding MarkPropDefWithCondition.value"}
+
+  def encode_value(value) when is_boolean(value), do: value
+  def encode_value(value) when is_float(value), do: value
+  def encode_value(value) when is_integer(value), do: value
+  def encode_value(value) when is_binary(value), do: value
+  def encode_value(_), do: {:error, "Unexpected type when encoding MarkPropDefWithCondition.value"}
+
   def from_map(m) do
     %MarkPropDefWithCondition{
       aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
@@ -5722,7 +5900,7 @@ defmodule MarkPropDefWithCondition do
       sort: decode_sort(m["sort"]),
       time_unit: m["timeUnit"] && TimeUnit.decode(m["timeUnit"]),
       type: m["type"] && Type.decode(m["type"]),
-      value: m["value"],
+      value: m["value"] && decode_value(m["value"]),
     }
   end
 
@@ -5772,11 +5950,19 @@ defmodule Header do
           title: nil | String.t() | nil
         }
 
+  def decode_title(value) when is_nil(value), do: value
+  def decode_title(value) when is_binary(value), do: value
+  def decode_title(_), do: {:error, "Unexpected type when decoding Header.title"}
+
+  def encode_title(value) when is_nil(value), do: value
+  def encode_title(value) when is_binary(value), do: value
+  def encode_title(_), do: {:error, "Unexpected type when encoding Header.title"}
+
   def from_map(m) do
     %Header{
       format: m["format"],
       label_angle: m["labelAngle"],
-      title: m["title"],
+      title: m["title"] && decode_title(m["title"]),
     }
   end
 
@@ -5993,6 +6179,18 @@ defmodule ConditionalPredicateFieldDefClass do
   def encode_test(value) when is_nil(value), do: value
   def encode_test(_), do: {:error, "Unexpected type when encoding ConditionalPredicateFieldDefClass.test"}
 
+  def decode_value(value) when is_boolean(value), do: value
+  def decode_value(value) when is_float(value), do: value
+  def decode_value(value) when is_integer(value), do: value
+  def decode_value(value) when is_binary(value), do: value
+  def decode_value(_), do: {:error, "Unexpected type when decoding ConditionalPredicateFieldDefClass.value"}
+
+  def encode_value(value) when is_boolean(value), do: value
+  def encode_value(value) when is_float(value), do: value
+  def encode_value(value) when is_integer(value), do: value
+  def encode_value(value) when is_binary(value), do: value
+  def encode_value(_), do: {:error, "Unexpected type when encoding ConditionalPredicateFieldDefClass.value"}
+
   def decode_selection(%{} = value), do: Selection.from_map(value)
   def decode_selection(value) when is_binary(value), do: value
   def decode_selection(value) when is_nil(value), do: value
@@ -6026,7 +6224,7 @@ defmodule ConditionalPredicateFieldDefClass do
   def from_map(m) do
     %ConditionalPredicateFieldDefClass{
       test: decode_test(m["test"]),
-      value: m["value"],
+      value: m["value"] && decode_value(m["value"]),
       selection: decode_selection(m["selection"]),
       aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
       bin: decode_bin(m["bin"]),
@@ -6129,6 +6327,18 @@ defmodule DefWithCondition do
   def encode_field(value) when is_nil(value), do: value
   def encode_field(_), do: {:error, "Unexpected type when encoding DefWithCondition.field"}
 
+  def decode_value(value) when is_boolean(value), do: value
+  def decode_value(value) when is_float(value), do: value
+  def decode_value(value) when is_integer(value), do: value
+  def decode_value(value) when is_binary(value), do: value
+  def decode_value(_), do: {:error, "Unexpected type when decoding DefWithCondition.value"}
+
+  def encode_value(value) when is_boolean(value), do: value
+  def encode_value(value) when is_float(value), do: value
+  def encode_value(value) when is_integer(value), do: value
+  def encode_value(value) when is_binary(value), do: value
+  def encode_value(_), do: {:error, "Unexpected type when encoding DefWithCondition.value"}
+
   def from_map(m) do
     %DefWithCondition{
       aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
@@ -6137,7 +6347,7 @@ defmodule DefWithCondition do
       field: decode_field(m["field"]),
       time_unit: m["timeUnit"] && TimeUnit.decode(m["timeUnit"]),
       type: m["type"] && Type.decode(m["type"]),
-      value: m["value"],
+      value: m["value"] && decode_value(m["value"]),
     }
   end
 
@@ -6279,6 +6489,18 @@ defmodule ConditionalPredicateTextFieldDefClass do
   def encode_test(value) when is_nil(value), do: value
   def encode_test(_), do: {:error, "Unexpected type when encoding ConditionalPredicateTextFieldDefClass.test"}
 
+  def decode_value(value) when is_boolean(value), do: value
+  def decode_value(value) when is_float(value), do: value
+  def decode_value(value) when is_integer(value), do: value
+  def decode_value(value) when is_binary(value), do: value
+  def decode_value(_), do: {:error, "Unexpected type when decoding ConditionalPredicateTextFieldDefClass.value"}
+
+  def encode_value(value) when is_boolean(value), do: value
+  def encode_value(value) when is_float(value), do: value
+  def encode_value(value) when is_integer(value), do: value
+  def encode_value(value) when is_binary(value), do: value
+  def encode_value(_), do: {:error, "Unexpected type when encoding ConditionalPredicateTextFieldDefClass.value"}
+
   def decode_selection(%{} = value), do: Selection.from_map(value)
   def decode_selection(value) when is_binary(value), do: value
   def decode_selection(value) when is_nil(value), do: value
@@ -6312,7 +6534,7 @@ defmodule ConditionalPredicateTextFieldDefClass do
   def from_map(m) do
     %ConditionalPredicateTextFieldDefClass{
       test: decode_test(m["test"]),
-      value: m["value"],
+      value: m["value"] && decode_value(m["value"]),
       selection: decode_selection(m["selection"]),
       aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
       bin: decode_bin(m["bin"]),
@@ -6421,6 +6643,18 @@ defmodule TextDefWithCondition do
   def encode_field(value) when is_nil(value), do: value
   def encode_field(_), do: {:error, "Unexpected type when encoding TextDefWithCondition.field"}
 
+  def decode_value(value) when is_boolean(value), do: value
+  def decode_value(value) when is_float(value), do: value
+  def decode_value(value) when is_integer(value), do: value
+  def decode_value(value) when is_binary(value), do: value
+  def decode_value(_), do: {:error, "Unexpected type when decoding TextDefWithCondition.value"}
+
+  def encode_value(value) when is_boolean(value), do: value
+  def encode_value(value) when is_float(value), do: value
+  def encode_value(value) when is_integer(value), do: value
+  def encode_value(value) when is_binary(value), do: value
+  def encode_value(_), do: {:error, "Unexpected type when encoding TextDefWithCondition.value"}
+
   def from_map(m) do
     %TextDefWithCondition{
       aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
@@ -6430,7 +6664,7 @@ defmodule TextDefWithCondition do
       format: m["format"],
       time_unit: m["timeUnit"] && TimeUnit.decode(m["timeUnit"]),
       type: m["type"] && Type.decode(m["type"]),
-      value: m["value"],
+      value: m["value"] && decode_value(m["value"]),
     }
   end
 
@@ -6513,6 +6747,26 @@ defmodule Axis do
           zindex: float() | nil
         }
 
+  def decode_label_bound(value) when is_boolean(value), do: value
+  def decode_label_bound(value) when is_float(value), do: value
+  def decode_label_bound(value) when is_integer(value), do: value
+  def decode_label_bound(_), do: {:error, "Unexpected type when decoding Axis.label_bound"}
+
+  def encode_label_bound(value) when is_boolean(value), do: value
+  def encode_label_bound(value) when is_float(value), do: value
+  def encode_label_bound(value) when is_integer(value), do: value
+  def encode_label_bound(_), do: {:error, "Unexpected type when encoding Axis.label_bound"}
+
+  def decode_label_flush(value) when is_boolean(value), do: value
+  def decode_label_flush(value) when is_float(value), do: value
+  def decode_label_flush(value) when is_integer(value), do: value
+  def decode_label_flush(_), do: {:error, "Unexpected type when decoding Axis.label_flush"}
+
+  def encode_label_flush(value) when is_boolean(value), do: value
+  def encode_label_flush(value) when is_float(value), do: value
+  def encode_label_flush(value) when is_integer(value), do: value
+  def encode_label_flush(_), do: {:error, "Unexpected type when encoding Axis.label_flush"}
+
   def decode_label_overlap(value) when is_boolean(value), do: value
   def decode_label_overlap(value) when is_binary(value), do: LabelOverlapEnum.decode(value)
   def decode_label_overlap(value) when is_nil(value), do: value
@@ -6523,6 +6777,14 @@ defmodule Axis do
   def encode_label_overlap(value) when is_nil(value), do: value
   def encode_label_overlap(_), do: {:error, "Unexpected type when encoding Axis.label_overlap"}
 
+  def decode_title(value) when is_nil(value), do: value
+  def decode_title(value) when is_binary(value), do: value
+  def decode_title(_), do: {:error, "Unexpected type when decoding Axis.title"}
+
+  def encode_title(value) when is_nil(value), do: value
+  def encode_title(value) when is_binary(value), do: value
+  def encode_title(_), do: {:error, "Unexpected type when encoding Axis.title"}
+
   def decode_values_element(%{} = value), do: DateTimeClass.from_map(value)
   def decode_values_element(value) when is_float(value), do: value
   def decode_values_element(value) when is_integer(value), do: value
@@ -6539,8 +6801,8 @@ defmodule Axis do
       format: m["format"],
       grid: m["grid"],
       label_angle: m["labelAngle"],
-      label_bound: m["labelBound"],
-      label_flush: m["labelFlush"],
+      label_bound: m["labelBound"] && decode_label_bound(m["labelBound"]),
+      label_flush: m["labelFlush"] && decode_label_flush(m["labelFlush"]),
       label_overlap: decode_label_overlap(m["labelOverlap"]),
       label_padding: m["labelPadding"],
       labels: m["labels"],
@@ -6552,7 +6814,7 @@ defmodule Axis do
       tick_count: m["tickCount"],
       ticks: m["ticks"],
       tick_size: m["tickSize"],
-      title: m["title"],
+      title: m["title"] && decode_title(m["title"]),
       title_max_length: m["titleMaxLength"],
       title_padding: m["titlePadding"],
       values: m["values"] && Enum.map(m["values"], &decode_values_element/1),
@@ -6664,6 +6926,18 @@ defmodule XClass do
   def encode_sort(value) when is_nil(value), do: value
   def encode_sort(_), do: {:error, "Unexpected type when encoding XClass.sort"}
 
+  def decode_value(value) when is_boolean(value), do: value
+  def decode_value(value) when is_float(value), do: value
+  def decode_value(value) when is_integer(value), do: value
+  def decode_value(value) when is_binary(value), do: value
+  def decode_value(_), do: {:error, "Unexpected type when decoding XClass.value"}
+
+  def encode_value(value) when is_boolean(value), do: value
+  def encode_value(value) when is_float(value), do: value
+  def encode_value(value) when is_integer(value), do: value
+  def encode_value(value) when is_binary(value), do: value
+  def encode_value(_), do: {:error, "Unexpected type when encoding XClass.value"}
+
   def from_map(m) do
     %XClass{
       aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
@@ -6675,7 +6949,7 @@ defmodule XClass do
       stack: m["stack"] && StackOffset.decode(m["stack"]),
       time_unit: m["timeUnit"] && TimeUnit.decode(m["timeUnit"]),
       type: m["type"] && Type.decode(m["type"]),
-      value: m["value"],
+      value: m["value"] && decode_value(m["value"]),
     }
   end
 
@@ -6755,6 +7029,18 @@ defmodule X2Class do
   def encode_field(value) when is_nil(value), do: value
   def encode_field(_), do: {:error, "Unexpected type when encoding X2Class.field"}
 
+  def decode_value(value) when is_boolean(value), do: value
+  def decode_value(value) when is_float(value), do: value
+  def decode_value(value) when is_integer(value), do: value
+  def decode_value(value) when is_binary(value), do: value
+  def decode_value(_), do: {:error, "Unexpected type when decoding X2Class.value"}
+
+  def encode_value(value) when is_boolean(value), do: value
+  def encode_value(value) when is_float(value), do: value
+  def encode_value(value) when is_integer(value), do: value
+  def encode_value(value) when is_binary(value), do: value
+  def encode_value(_), do: {:error, "Unexpected type when encoding X2Class.value"}
+
   def from_map(m) do
     %X2Class{
       aggregate: m["aggregate"] && AggregateOp.decode(m["aggregate"]),
@@ -6762,7 +7048,7 @@ defmodule X2Class do
       field: decode_field(m["field"]),
       time_unit: m["timeUnit"] && TimeUnit.decode(m["timeUnit"]),
       type: m["type"] && Type.decode(m["type"]),
-      value: m["value"],
+      value: m["value"] && decode_value(m["value"]),
     }
   end
 
@@ -7710,6 +7996,30 @@ defmodule SelectionDef do
   def encode_bind(value) when is_nil(value), do: value
   def encode_bind(_), do: {:error, "Unexpected type when encoding SelectionDef.bind"}
 
+  def decode_toggle(value) when is_boolean(value), do: value
+  def decode_toggle(value) when is_binary(value), do: value
+  def decode_toggle(_), do: {:error, "Unexpected type when decoding SelectionDef.toggle"}
+
+  def encode_toggle(value) when is_boolean(value), do: value
+  def encode_toggle(value) when is_binary(value), do: value
+  def encode_toggle(_), do: {:error, "Unexpected type when encoding SelectionDef.toggle"}
+
+  def decode_translate(value) when is_boolean(value), do: value
+  def decode_translate(value) when is_binary(value), do: value
+  def decode_translate(_), do: {:error, "Unexpected type when decoding SelectionDef.translate"}
+
+  def encode_translate(value) when is_boolean(value), do: value
+  def encode_translate(value) when is_binary(value), do: value
+  def encode_translate(_), do: {:error, "Unexpected type when encoding SelectionDef.translate"}
+
+  def decode_zoom(value) when is_boolean(value), do: value
+  def decode_zoom(value) when is_binary(value), do: value
+  def decode_zoom(_), do: {:error, "Unexpected type when decoding SelectionDef.zoom"}
+
+  def encode_zoom(value) when is_boolean(value), do: value
+  def encode_zoom(value) when is_binary(value), do: value
+  def encode_zoom(_), do: {:error, "Unexpected type when encoding SelectionDef.zoom"}
+
   def from_map(m) do
     %SelectionDef{
       bind: decode_bind(m["bind"]),
@@ -7720,10 +8030,10 @@ defmodule SelectionDef do
       on: m["on"],
       resolve: m["resolve"] && SelectionResolution.decode(m["resolve"]),
       type: SelectionDefType.decode(m["type"]),
-      toggle: m["toggle"],
+      toggle: m["toggle"] && decode_toggle(m["toggle"]),
       mark: m["mark"] && BrushConfig.from_map(m["mark"]),
-      translate: m["translate"],
-      zoom: m["zoom"],
+      translate: m["translate"] && decode_translate(m["translate"]),
+      zoom: m["zoom"] && decode_zoom(m["zoom"]),
     }
   end