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 eb10b18..cc66c89 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
@@ -1591,6 +1591,12 @@ defmodule Payload do
   def encode_before(value) when is_binary(value), do: value
   def encode_before(_), do: {:error, "Unexpected type when encoding Payload.before"}
 
+  def decode_distinct_size(value) when is_integer(value), do: value
+  def decode_distinct_size(_), do: {:error, "Unexpected type when decoding Payload.distinct_size"}
+
+  def encode_distinct_size(value) when is_integer(value), do: value
+  def encode_distinct_size(_), do: {:error, "Unexpected type when encoding Payload.distinct_size"}
+
   def decode_head(value) when is_binary(value), do: value
   def decode_head(_), do: {:error, "Unexpected type when decoding Payload.head"}
 
@@ -1603,6 +1609,18 @@ defmodule Payload do
   def encode_master_branch(value) when is_binary(value), do: value
   def encode_master_branch(_), do: {:error, "Unexpected type when encoding Payload.master_branch"}
 
+  def decode_number(value) when is_integer(value), do: value
+  def decode_number(_), do: {:error, "Unexpected type when decoding Payload.number"}
+
+  def encode_number(value) when is_integer(value), do: value
+  def encode_number(_), do: {:error, "Unexpected type when encoding Payload.number"}
+
+  def decode_push_id(value) when is_integer(value), do: value
+  def decode_push_id(_), do: {:error, "Unexpected type when decoding Payload.push_id"}
+
+  def encode_push_id(value) when is_integer(value), do: value
+  def encode_push_id(_), do: {:error, "Unexpected type when encoding Payload.push_id"}
+
   def decode_pusher_type(value) when is_binary(value), do: value
   def decode_pusher_type(_), do: {:error, "Unexpected type when decoding Payload.pusher_type"}
 
@@ -1621,22 +1639,28 @@ defmodule Payload do
   def encode_ref_type(value) when is_binary(value), do: value
   def encode_ref_type(_), do: {:error, "Unexpected type when encoding Payload.ref_type"}
 
+  def decode_size(value) when is_integer(value), do: value
+  def decode_size(_), do: {:error, "Unexpected type when decoding Payload.size"}
+
+  def encode_size(value) when is_integer(value), do: value
+  def encode_size(_), do: {:error, "Unexpected type when encoding Payload.size"}
+
   def from_map(m) do
     %Payload{
       action: m["action"] && decode_action(m["action"]),
       before: m["before"] && decode_before(m["before"]),
       commits: m["commits"] && Enum.map(m["commits"], &Commit.from_map/1),
       description: m["description"],
-      distinct_size: m["distinct_size"],
+      distinct_size: m["distinct_size"] && decode_distinct_size(m["distinct_size"]),
       head: m["head"] && decode_head(m["head"]),
       master_branch: m["master_branch"] && decode_master_branch(m["master_branch"]),
-      number: m["number"],
+      number: m["number"] && decode_number(m["number"]),
       pull_request: m["pull_request"] && PullRequest.from_map(m["pull_request"]),
-      push_id: m["push_id"],
+      push_id: m["push_id"] && decode_push_id(m["push_id"]),
       pusher_type: m["pusher_type"] && decode_pusher_type(m["pusher_type"]),
       ref: m["ref"] && decode_ref(m["ref"]),
       ref_type: m["ref_type"] && decode_ref_type(m["ref_type"]),
-      size: m["size"],
+      size: m["size"] && decode_size(m["size"]),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/misc/26c9c.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/26c9c.json/default/QuickType.ex
index f9bd201..418201b 100644
--- a/base/elixir/test/inputs/json/misc/26c9c.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/26c9c.json/default/QuickType.ex
@@ -265,6 +265,18 @@ defmodule Column do
   def encode_render_type_name(value) when is_binary(value), do: value
   def encode_render_type_name(_), do: {:error, "Unexpected type when encoding Column.render_type_name"}
 
+  def decode_table_column_id(value) when is_integer(value), do: value
+  def decode_table_column_id(_), do: {:error, "Unexpected type when decoding Column.table_column_id"}
+
+  def encode_table_column_id(value) when is_integer(value), do: value
+  def encode_table_column_id(_), do: {:error, "Unexpected type when encoding Column.table_column_id"}
+
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding Column.width"}
+
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding Column.width"}
+
   def from_map(m) do
     %Column{
       cached_contents: m["cachedContents"] && CachedContents.from_map(m["cachedContents"]),
@@ -276,8 +288,8 @@ defmodule Column do
       name: decode_name(m["name"]),
       position: decode_position(m["position"]),
       render_type_name: decode_render_type_name(m["renderTypeName"]),
-      table_column_id: m["tableColumnId"],
-      width: m["width"],
+      table_column_id: m["tableColumnId"] && decode_table_column_id(m["tableColumnId"]),
+      width: m["width"] && decode_width(m["width"]),
     }
   end
 
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 30588b1..90238c3 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
@@ -243,12 +243,24 @@ defmodule MediaEmbed do
   def encode_content(value) when is_binary(value), do: value
   def encode_content(_), do: {:error, "Unexpected type when encoding MediaEmbed.content"}
 
+  def decode_height(value) when is_integer(value), do: value
+  def decode_height(_), do: {:error, "Unexpected type when decoding MediaEmbed.height"}
+
+  def encode_height(value) when is_integer(value), do: value
+  def encode_height(_), do: {:error, "Unexpected type when encoding MediaEmbed.height"}
+
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding MediaEmbed.width"}
+
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding MediaEmbed.width"}
+
   def from_map(m) do
     %MediaEmbed{
       content: m["content"] && decode_content(m["content"]),
-      height: m["height"],
+      height: m["height"] && decode_height(m["height"]),
       scrolling: m["scrolling"],
-      width: m["width"],
+      width: m["width"] && decode_width(m["width"]),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/misc/31189.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/31189.json/default/QuickType.ex
index cadf6d3..94e3df4 100644
--- a/base/elixir/test/inputs/json/misc/31189.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/31189.json/default/QuickType.ex
@@ -18,6 +18,38 @@ defmodule Rates do
           super_reduced: float() | nil
         }
 
+  def decode_parking(value) when is_float(value), do: value
+  def decode_parking(value) when is_integer(value), do: value
+  def decode_parking(_), do: {:error, "Unexpected type when decoding Rates.parking"}
+
+  def encode_parking(value) when is_float(value), do: value
+  def encode_parking(value) when is_integer(value), do: value
+  def encode_parking(_), do: {:error, "Unexpected type when encoding Rates.parking"}
+
+  def decode_reduced(value) when is_float(value), do: value
+  def decode_reduced(value) when is_integer(value), do: value
+  def decode_reduced(_), do: {:error, "Unexpected type when decoding Rates.reduced"}
+
+  def encode_reduced(value) when is_float(value), do: value
+  def encode_reduced(value) when is_integer(value), do: value
+  def encode_reduced(_), do: {:error, "Unexpected type when encoding Rates.reduced"}
+
+  def decode_reduced1(value) when is_float(value), do: value
+  def decode_reduced1(value) when is_integer(value), do: value
+  def decode_reduced1(_), do: {:error, "Unexpected type when decoding Rates.reduced1"}
+
+  def encode_reduced1(value) when is_float(value), do: value
+  def encode_reduced1(value) when is_integer(value), do: value
+  def encode_reduced1(_), do: {:error, "Unexpected type when encoding Rates.reduced1"}
+
+  def decode_reduced2(value) when is_float(value), do: value
+  def decode_reduced2(value) when is_integer(value), do: value
+  def decode_reduced2(_), do: {:error, "Unexpected type when decoding Rates.reduced2"}
+
+  def encode_reduced2(value) when is_float(value), do: value
+  def encode_reduced2(value) when is_integer(value), do: value
+  def encode_reduced2(_), do: {:error, "Unexpected type when encoding Rates.reduced2"}
+
   def decode_standard(value) when is_float(value), do: value
   def decode_standard(value) when is_integer(value), do: value
   def decode_standard(_), do: {:error, "Unexpected type when decoding Rates.standard"}
@@ -26,14 +58,22 @@ defmodule Rates do
   def encode_standard(value) when is_integer(value), do: value
   def encode_standard(_), do: {:error, "Unexpected type when encoding Rates.standard"}
 
+  def decode_super_reduced(value) when is_float(value), do: value
+  def decode_super_reduced(value) when is_integer(value), do: value
+  def decode_super_reduced(_), do: {:error, "Unexpected type when decoding Rates.super_reduced"}
+
+  def encode_super_reduced(value) when is_float(value), do: value
+  def encode_super_reduced(value) when is_integer(value), do: value
+  def encode_super_reduced(_), do: {:error, "Unexpected type when encoding Rates.super_reduced"}
+
   def from_map(m) do
     %Rates{
-      parking: m["parking"],
-      reduced: m["reduced"],
-      reduced1: m["reduced1"],
-      reduced2: m["reduced2"],
+      parking: m["parking"] && decode_parking(m["parking"]),
+      reduced: m["reduced"] && decode_reduced(m["reduced"]),
+      reduced1: m["reduced1"] && decode_reduced1(m["reduced1"]),
+      reduced2: m["reduced2"] && decode_reduced2(m["reduced2"]),
       standard: decode_standard(m["standard"]),
-      super_reduced: m["super_reduced"],
+      super_reduced: m["super_reduced"] && decode_super_reduced(m["super_reduced"]),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/misc/421d4.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/421d4.json/default/QuickType.ex
index 939160d..bf90451 100644
--- a/base/elixir/test/inputs/json/misc/421d4.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/421d4.json/default/QuickType.ex
@@ -223,6 +223,18 @@ defmodule Column do
   def encode_render_type_name(value) when is_binary(value), do: value
   def encode_render_type_name(_), do: {:error, "Unexpected type when encoding Column.render_type_name"}
 
+  def decode_table_column_id(value) when is_integer(value), do: value
+  def decode_table_column_id(_), do: {:error, "Unexpected type when decoding Column.table_column_id"}
+
+  def encode_table_column_id(value) when is_integer(value), do: value
+  def encode_table_column_id(_), do: {:error, "Unexpected type when encoding Column.table_column_id"}
+
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding Column.width"}
+
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding Column.width"}
+
   def from_map(m) do
     %Column{
       cached_contents: m["cachedContents"] && CachedContents.from_map(m["cachedContents"]),
@@ -234,8 +246,8 @@ defmodule Column do
       name: decode_name(m["name"]),
       position: decode_position(m["position"]),
       render_type_name: decode_render_type_name(m["renderTypeName"]),
-      table_column_id: m["tableColumnId"],
-      width: m["width"],
+      table_column_id: m["tableColumnId"] && decode_table_column_id(m["tableColumnId"]),
+      width: m["width"] && decode_width(m["width"]),
     }
   end
 
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 22cc61d..3ed69c2 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
@@ -210,12 +210,24 @@ defmodule MediaEmbed do
   def encode_content(value) when is_binary(value), do: value
   def encode_content(_), do: {:error, "Unexpected type when encoding MediaEmbed.content"}
 
+  def decode_height(value) when is_integer(value), do: value
+  def decode_height(_), do: {:error, "Unexpected type when decoding MediaEmbed.height"}
+
+  def encode_height(value) when is_integer(value), do: value
+  def encode_height(_), do: {:error, "Unexpected type when encoding MediaEmbed.height"}
+
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding MediaEmbed.width"}
+
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding MediaEmbed.width"}
+
   def from_map(m) do
     %MediaEmbed{
       content: m["content"] && decode_content(m["content"]),
-      height: m["height"],
+      height: m["height"] && decode_height(m["height"]),
       scrolling: m["scrolling"],
-      width: m["width"],
+      width: m["width"] && decode_width(m["width"]),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/misc/5f7fe.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/5f7fe.json/default/QuickType.ex
index f5b0703..501b2e7 100644
--- a/base/elixir/test/inputs/json/misc/5f7fe.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/5f7fe.json/default/QuickType.ex
@@ -264,6 +264,18 @@ defmodule Column do
   def encode_position(value) when is_integer(value), do: value
   def encode_position(_), do: {:error, "Unexpected type when encoding Column.position"}
 
+  def decode_table_column_id(value) when is_integer(value), do: value
+  def decode_table_column_id(_), do: {:error, "Unexpected type when decoding Column.table_column_id"}
+
+  def encode_table_column_id(value) when is_integer(value), do: value
+  def encode_table_column_id(_), do: {:error, "Unexpected type when encoding Column.table_column_id"}
+
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding Column.width"}
+
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding Column.width"}
+
   def from_map(m) do
     %Column{
       cached_contents: m["cachedContents"] && CachedContents.from_map(m["cachedContents"]),
@@ -275,8 +287,8 @@ defmodule Column do
       name: decode_name(m["name"]),
       position: decode_position(m["position"]),
       render_type_name: TypeName.decode(m["renderTypeName"]),
-      table_column_id: m["tableColumnId"],
-      width: m["width"],
+      table_column_id: m["tableColumnId"] && decode_table_column_id(m["tableColumnId"]),
+      width: m["width"] && decode_width(m["width"]),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/misc/617e8.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/617e8.json/default/QuickType.ex
index e98e9ab..e3cac7d 100644
--- a/base/elixir/test/inputs/json/misc/617e8.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/617e8.json/default/QuickType.ex
@@ -271,6 +271,18 @@ defmodule Column do
   def encode_position(value) when is_integer(value), do: value
   def encode_position(_), do: {:error, "Unexpected type when encoding Column.position"}
 
+  def decode_table_column_id(value) when is_integer(value), do: value
+  def decode_table_column_id(_), do: {:error, "Unexpected type when decoding Column.table_column_id"}
+
+  def encode_table_column_id(value) when is_integer(value), do: value
+  def encode_table_column_id(_), do: {:error, "Unexpected type when encoding Column.table_column_id"}
+
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding Column.width"}
+
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding Column.width"}
+
   def from_map(m) do
     %Column{
       cached_contents: m["cachedContents"] && CachedContents.from_map(m["cachedContents"]),
@@ -283,8 +295,8 @@ defmodule Column do
       name: decode_name(m["name"]),
       position: decode_position(m["position"]),
       render_type_name: TypeName.decode(m["renderTypeName"]),
-      table_column_id: m["tableColumnId"],
-      width: m["width"],
+      table_column_id: m["tableColumnId"] && decode_table_column_id(m["tableColumnId"]),
+      width: m["width"] && decode_width(m["width"]),
     }
   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 fa35207..334a6fb 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
@@ -201,12 +201,24 @@ defmodule MediaEmbed do
   def encode_content(value) when is_binary(value), do: value
   def encode_content(_), do: {:error, "Unexpected type when encoding MediaEmbed.content"}
 
+  def decode_height(value) when is_integer(value), do: value
+  def decode_height(_), do: {:error, "Unexpected type when decoding MediaEmbed.height"}
+
+  def encode_height(value) when is_integer(value), do: value
+  def encode_height(_), do: {:error, "Unexpected type when encoding MediaEmbed.height"}
+
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding MediaEmbed.width"}
+
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding MediaEmbed.width"}
+
   def from_map(m) do
     %MediaEmbed{
       content: m["content"] && decode_content(m["content"]),
-      height: m["height"],
+      height: m["height"] && decode_height(m["height"]),
       scrolling: m["scrolling"],
-      width: m["width"],
+      width: m["width"] && decode_width(m["width"]),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/misc/a3d8c.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/a3d8c.json/default/QuickType.ex
index c6809b7..2d4c3a5 100644
--- a/base/elixir/test/inputs/json/misc/a3d8c.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/a3d8c.json/default/QuickType.ex
@@ -264,6 +264,18 @@ defmodule Column do
   def encode_position(value) when is_integer(value), do: value
   def encode_position(_), do: {:error, "Unexpected type when encoding Column.position"}
 
+  def decode_table_column_id(value) when is_integer(value), do: value
+  def decode_table_column_id(_), do: {:error, "Unexpected type when decoding Column.table_column_id"}
+
+  def encode_table_column_id(value) when is_integer(value), do: value
+  def encode_table_column_id(_), do: {:error, "Unexpected type when encoding Column.table_column_id"}
+
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding Column.width"}
+
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding Column.width"}
+
   def from_map(m) do
     %Column{
       cached_contents: m["cachedContents"] && CachedContents.from_map(m["cachedContents"]),
@@ -275,8 +287,8 @@ defmodule Column do
       name: decode_name(m["name"]),
       position: decode_position(m["position"]),
       render_type_name: TypeName.decode(m["renderTypeName"]),
-      table_column_id: m["tableColumnId"],
-      width: m["width"],
+      table_column_id: m["tableColumnId"] && decode_table_column_id(m["tableColumnId"]),
+      width: m["width"] && decode_width(m["width"]),
     }
   end
 
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 8c7e7da..549a642 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
@@ -244,12 +244,24 @@ defmodule MediaEmbed do
   def encode_content(value) when is_binary(value), do: value
   def encode_content(_), do: {:error, "Unexpected type when encoding MediaEmbed.content"}
 
+  def decode_height(value) when is_integer(value), do: value
+  def decode_height(_), do: {:error, "Unexpected type when decoding MediaEmbed.height"}
+
+  def encode_height(value) when is_integer(value), do: value
+  def encode_height(_), do: {:error, "Unexpected type when encoding MediaEmbed.height"}
+
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding MediaEmbed.width"}
+
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding MediaEmbed.width"}
+
   def from_map(m) do
     %MediaEmbed{
       content: m["content"] && decode_content(m["content"]),
-      height: m["height"],
+      height: m["height"] && decode_height(m["height"]),
       scrolling: m["scrolling"],
-      width: m["width"],
+      width: m["width"] && decode_width(m["width"]),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/misc/e8b04.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/e8b04.json/default/QuickType.ex
index d4ed30a..e413f2e 100644
--- a/base/elixir/test/inputs/json/misc/e8b04.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/e8b04.json/default/QuickType.ex
@@ -634,14 +634,26 @@ defmodule ChildMetadata do
           unified_version: integer() | nil
         }
 
+  def decode_include_auto(value) when is_integer(value), do: value
+  def decode_include_auto(_), do: {:error, "Unexpected type when decoding ChildMetadata.include_auto"}
+
+  def encode_include_auto(value) when is_integer(value), do: value
+  def encode_include_auto(_), do: {:error, "Unexpected type when encoding ChildMetadata.include_auto"}
+
+  def decode_unified_version(value) when is_integer(value), do: value
+  def decode_unified_version(_), do: {:error, "Unexpected type when decoding ChildMetadata.unified_version"}
+
+  def encode_unified_version(value) when is_integer(value), do: value
+  def encode_unified_version(_), do: {:error, "Unexpected type when encoding ChildMetadata.unified_version"}
+
   def from_map(m) do
     %ChildMetadata{
       custom_values: m["customValues"],
       freeform: m["freeform"],
-      include_auto: m["includeAuto"],
+      include_auto: m["includeAuto"] && decode_include_auto(m["includeAuto"]),
       operator: m["operator"] && MetadataOperator.decode(m["operator"]),
       table_column_id: m["tableColumnId"] && TableColumnID.from_map(m["tableColumnId"]),
-      unified_version: m["unifiedVersion"],
+      unified_version: m["unifiedVersion"] && decode_unified_version(m["unifiedVersion"]),
     }
   end
 
@@ -1650,6 +1662,12 @@ defmodule Owner do
   def encode_id(value) when is_binary(value), do: value
   def encode_id(_), do: {:error, "Unexpected type when encoding Owner.id"}
 
+  def decode_last_notification_seen_at(value) when is_integer(value), do: value
+  def decode_last_notification_seen_at(_), do: {:error, "Unexpected type when decoding Owner.last_notification_seen_at"}
+
+  def encode_last_notification_seen_at(value) when is_integer(value), do: value
+  def encode_last_notification_seen_at(_), do: {:error, "Unexpected type when encoding Owner.last_notification_seen_at"}
+
   def decode_profile_image_url_large(value) when is_binary(value), do: value
   def decode_profile_image_url_large(_), do: {:error, "Unexpected type when decoding Owner.profile_image_url_large"}
 
@@ -1679,7 +1697,7 @@ defmodule Owner do
       display_name: decode_display_name(m["displayName"]),
       flags: m["flags"],
       id: decode_id(m["id"]),
-      last_notification_seen_at: m["lastNotificationSeenAt"],
+      last_notification_seen_at: m["lastNotificationSeenAt"] && decode_last_notification_seen_at(m["lastNotificationSeenAt"]),
       profile_image_url_large: m["profileImageUrlLarge"] && decode_profile_image_url_large(m["profileImageUrlLarge"]),
       profile_image_url_medium: m["profileImageUrlMedium"] && decode_profile_image_url_medium(m["profileImageUrlMedium"]),
       profile_image_url_small: m["profileImageUrlSmall"] && decode_profile_image_url_small(m["profileImageUrlSmall"]),
@@ -2148,6 +2166,12 @@ defmodule TopLevelElement do
   def encode_id(value) when is_binary(value), do: value
   def encode_id(_), do: {:error, "Unexpected type when encoding TopLevelElement.id"}
 
+  def decode_index_updated_at(value) when is_integer(value), do: value
+  def decode_index_updated_at(_), do: {:error, "Unexpected type when decoding TopLevelElement.index_updated_at"}
+
+  def encode_index_updated_at(value) when is_integer(value), do: value
+  def encode_index_updated_at(_), do: {:error, "Unexpected type when encoding TopLevelElement.index_updated_at"}
+
   def decode_locale(value) when is_binary(value), do: value
   def decode_locale(_), do: {:error, "Unexpected type when decoding TopLevelElement.locale"}
 
@@ -2184,6 +2208,12 @@ defmodule TopLevelElement do
   def encode_publication_append_enabled(value) when is_boolean(value), do: value
   def encode_publication_append_enabled(_), do: {:error, "Unexpected type when encoding TopLevelElement.publication_append_enabled"}
 
+  def decode_publication_date(value) when is_integer(value), do: value
+  def decode_publication_date(_), do: {:error, "Unexpected type when decoding TopLevelElement.publication_date"}
+
+  def encode_publication_date(value) when is_integer(value), do: value
+  def encode_publication_date(_), do: {:error, "Unexpected type when encoding TopLevelElement.publication_date"}
+
   def decode_publication_group(value) when is_integer(value), do: value
   def decode_publication_group(_), do: {:error, "Unexpected type when decoding TopLevelElement.publication_group"}
 
@@ -2208,6 +2238,18 @@ defmodule TopLevelElement do
   def encode_row_class(value) when is_binary(value), do: value
   def encode_row_class(_), do: {:error, "Unexpected type when encoding TopLevelElement.row_class"}
 
+  def decode_row_identifier_column_id(value) when is_integer(value), do: value
+  def decode_row_identifier_column_id(_), do: {:error, "Unexpected type when decoding TopLevelElement.row_identifier_column_id"}
+
+  def encode_row_identifier_column_id(value) when is_integer(value), do: value
+  def encode_row_identifier_column_id(_), do: {:error, "Unexpected type when encoding TopLevelElement.row_identifier_column_id"}
+
+  def decode_rows_updated_at(value) when is_integer(value), do: value
+  def decode_rows_updated_at(_), do: {:error, "Unexpected type when decoding TopLevelElement.rows_updated_at"}
+
+  def encode_rows_updated_at(value) when is_integer(value), do: value
+  def encode_rows_updated_at(_), do: {:error, "Unexpected type when encoding TopLevelElement.rows_updated_at"}
+
   def decode_table_id(value) when is_integer(value), do: value
   def decode_table_id(_), do: {:error, "Unexpected type when decoding TopLevelElement.table_id"}
 
@@ -2245,7 +2287,7 @@ defmodule TopLevelElement do
       hide_from_catalog: decode_hide_from_catalog(m["hideFromCatalog"]),
       hide_from_data_json: decode_hide_from_data_json(m["hideFromDataJson"]),
       id: decode_id(m["id"]),
-      index_updated_at: m["indexUpdatedAt"],
+      index_updated_at: m["indexUpdatedAt"] && decode_index_updated_at(m["indexUpdatedAt"]),
       locale: decode_locale(m["locale"]),
       metadata: TopLevelMetadata.from_map(m["metadata"]),
       moderation_status: m["moderationStatus"],
@@ -2257,15 +2299,15 @@ defmodule TopLevelElement do
       owner: Owner.from_map(m["owner"]),
       provenance: Provenance.decode(m["provenance"]),
       publication_append_enabled: decode_publication_append_enabled(m["publicationAppendEnabled"]),
-      publication_date: m["publicationDate"],
+      publication_date: m["publicationDate"] && decode_publication_date(m["publicationDate"]),
       publication_group: decode_publication_group(m["publicationGroup"]),
       publication_stage: PublicationStage.decode(m["publicationStage"]),
       ratings: m["ratings"] && Ratings.from_map(m["ratings"]),
       resource_name: m["resourceName"] && decode_resource_name(m["resourceName"]),
       rights: Enum.map(m["rights"], &Right.decode/1),
       row_class: m["rowClass"] && decode_row_class(m["rowClass"]),
-      row_identifier_column_id: m["rowIdentifierColumnId"],
-      rows_updated_at: m["rowsUpdatedAt"],
+      row_identifier_column_id: m["rowIdentifierColumnId"] && decode_row_identifier_column_id(m["rowIdentifierColumnId"]),
+      rows_updated_at: m["rowsUpdatedAt"] && decode_rows_updated_at(m["rowsUpdatedAt"]),
       rows_updated_by: m["rowsUpdatedBy"] && RowsUpdatedBy.decode(m["rowsUpdatedBy"]),
       table_author: TableAuthor.from_map(m["tableAuthor"]),
       table_id: decode_table_id(m["tableId"]),
diff --git a/base/elixir/test/inputs/json/misc/f74d5.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/f74d5.json/default/QuickType.ex
index 8ab9125..2e67de1 100644
--- a/base/elixir/test/inputs/json/misc/f74d5.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/f74d5.json/default/QuickType.ex
@@ -264,6 +264,18 @@ defmodule Column do
   def encode_position(value) when is_integer(value), do: value
   def encode_position(_), do: {:error, "Unexpected type when encoding Column.position"}
 
+  def decode_table_column_id(value) when is_integer(value), do: value
+  def decode_table_column_id(_), do: {:error, "Unexpected type when decoding Column.table_column_id"}
+
+  def encode_table_column_id(value) when is_integer(value), do: value
+  def encode_table_column_id(_), do: {:error, "Unexpected type when encoding Column.table_column_id"}
+
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding Column.width"}
+
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding Column.width"}
+
   def from_map(m) do
     %Column{
       cached_contents: m["cachedContents"] && CachedContents.from_map(m["cachedContents"]),
@@ -275,8 +287,8 @@ defmodule Column do
       name: decode_name(m["name"]),
       position: decode_position(m["position"]),
       render_type_name: TypeName.decode(m["renderTypeName"]),
-      table_column_id: m["tableColumnId"],
-      width: m["width"],
+      table_column_id: m["tableColumnId"] && decode_table_column_id(m["tableColumnId"]),
+      width: m["width"] && decode_width(m["width"]),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/misc/fcca3.json/default/QuickType.ex b/head/elixir/test/inputs/json/misc/fcca3.json/default/QuickType.ex
index 2be7d94..4f3f0fa 100644
--- a/base/elixir/test/inputs/json/misc/fcca3.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/misc/fcca3.json/default/QuickType.ex
@@ -298,6 +298,18 @@ defmodule Column do
   def encode_position(value) when is_integer(value), do: value
   def encode_position(_), do: {:error, "Unexpected type when encoding Column.position"}
 
+  def decode_table_column_id(value) when is_integer(value), do: value
+  def decode_table_column_id(_), do: {:error, "Unexpected type when decoding Column.table_column_id"}
+
+  def encode_table_column_id(value) when is_integer(value), do: value
+  def encode_table_column_id(_), do: {:error, "Unexpected type when encoding Column.table_column_id"}
+
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding Column.width"}
+
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding Column.width"}
+
   def from_map(m) do
     %Column{
       cached_contents: m["cachedContents"] && CachedContents.from_map(m["cachedContents"]),
@@ -310,8 +322,8 @@ defmodule Column do
       name: decode_name(m["name"]),
       position: decode_position(m["position"]),
       render_type_name: TypeName.decode(m["renderTypeName"]),
-      table_column_id: m["tableColumnId"],
-      width: m["width"],
+      table_column_id: m["tableColumnId"] && decode_table_column_id(m["tableColumnId"]),
+      width: m["width"] && decode_width(m["width"]),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/priority/bug427.json/default/QuickType.ex b/head/elixir/test/inputs/json/priority/bug427.json/default/QuickType.ex
index c2835ca..3589088 100644
--- a/base/elixir/test/inputs/json/priority/bug427.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/priority/bug427.json/default/QuickType.ex
@@ -1719,6 +1719,12 @@ defmodule ExtendedBy do
           type_arguments: [ExtendedBy.t()] | nil
         }
 
+  def decode_id(value) when is_integer(value), do: value
+  def decode_id(_), do: {:error, "Unexpected type when decoding ExtendedBy.id"}
+
+  def encode_id(value) when is_integer(value), do: value
+  def encode_id(_), do: {:error, "Unexpected type when encoding ExtendedBy.id"}
+
   def decode_name(value) when is_binary(value), do: value
   def decode_name(_), do: {:error, "Unexpected type when decoding ExtendedBy.name"}
 
@@ -1728,7 +1734,7 @@ defmodule ExtendedBy do
   def from_map(m) do
     %ExtendedBy{
       constraint: m["constraint"] && ExtendedBy.from_map(m["constraint"]),
-      id: m["id"],
+      id: m["id"] && decode_id(m["id"]),
       name: decode_name(m["name"]),
       type: TypeEnum.decode(m["type"]),
       type_arguments: m["typeArguments"] && Enum.map(m["typeArguments"], &ExtendedBy.from_map/1),
@@ -1808,6 +1814,12 @@ defmodule Type4 do
           type_arguments: [ElementType.t()] | nil
         }
 
+  def decode_id(value) when is_integer(value), do: value
+  def decode_id(_), do: {:error, "Unexpected type when decoding Type4.id"}
+
+  def encode_id(value) when is_integer(value), do: value
+  def encode_id(_), do: {:error, "Unexpected type when encoding Type4.id"}
+
   def decode_name(value) when is_binary(value), do: value
   def decode_name(_), do: {:error, "Unexpected type when decoding Type4.name"}
 
@@ -1820,7 +1832,7 @@ defmodule Type4 do
       declaration: m["declaration"] && GetSignature.from_map(m["declaration"]),
       element_type: m["elementType"] && ElementType.from_map(m["elementType"]),
       elements: m["elements"] && Enum.map(m["elements"], &ExtendedBy.from_map/1),
-      id: m["id"],
+      id: m["id"] && decode_id(m["id"]),
       name: m["name"] && decode_name(m["name"]),
       type: TypeEnum.decode(m["type"]),
       type_arguments: m["typeArguments"] && Enum.map(m["typeArguments"], &ElementType.from_map/1),
@@ -2598,6 +2610,12 @@ defmodule Type5 do
           types: [TypeElement.t()] | nil
         }
 
+  def decode_id(value) when is_integer(value), do: value
+  def decode_id(_), do: {:error, "Unexpected type when decoding Type5.id"}
+
+  def encode_id(value) when is_integer(value), do: value
+  def encode_id(_), do: {:error, "Unexpected type when encoding Type5.id"}
+
   def decode_name(value) when is_binary(value), do: value
   def decode_name(_), do: {:error, "Unexpected type when decoding Type5.name"}
 
@@ -2610,7 +2628,7 @@ defmodule Type5 do
       declaration: m["declaration"] && Declaration2.from_map(m["declaration"]),
       element_type: m["elementType"] && ExtendedBy.from_map(m["elementType"]),
       elements: m["elements"] && Enum.map(m["elements"], &ElementType.from_map/1),
-      id: m["id"],
+      id: m["id"] && decode_id(m["id"]),
       name: m["name"] && decode_name(m["name"]),
       type: TypeEnum.decode(m["type"]),
       type_arguments: m["typeArguments"] && Enum.map(m["typeArguments"], &TypeArgument1.from_map/1),
@@ -3048,6 +3066,12 @@ defmodule Type8 do
           type_arguments: [ElementType.t()] | nil
         }
 
+  def decode_id(value) when is_integer(value), do: value
+  def decode_id(_), do: {:error, "Unexpected type when decoding Type8.id"}
+
+  def encode_id(value) when is_integer(value), do: value
+  def encode_id(_), do: {:error, "Unexpected type when encoding Type8.id"}
+
   def decode_name(value) when is_binary(value), do: value
   def decode_name(_), do: {:error, "Unexpected type when decoding Type8.name"}
 
@@ -3058,7 +3082,7 @@ defmodule Type8 do
     %Type8{
       declaration: m["declaration"] && Declaration3.from_map(m["declaration"]),
       element_type: m["elementType"] && ElementType.from_map(m["elementType"]),
-      id: m["id"],
+      id: m["id"] && decode_id(m["id"]),
       name: m["name"] && decode_name(m["name"]),
       type: TypeEnum.decode(m["type"]),
       type_arguments: m["typeArguments"] && Enum.map(m["typeArguments"], &ElementType.from_map/1),
@@ -3188,10 +3212,16 @@ defmodule Type9 do
           type_arguments: [ElementType.t()] | nil
         }
 
+  def decode_id(value) when is_integer(value), do: value
+  def decode_id(_), do: {:error, "Unexpected type when decoding Type9.id"}
+
+  def encode_id(value) when is_integer(value), do: value
+  def encode_id(_), do: {:error, "Unexpected type when encoding Type9.id"}
+
   def from_map(m) do
     %Type9{
       declaration: m["declaration"] && Declaration1.from_map(m["declaration"]),
-      id: m["id"],
+      id: m["id"] && decode_id(m["id"]),
       name: m["name"] && Name.decode(m["name"]),
       type: TypeEnum.decode(m["type"]),
       type_arguments: m["typeArguments"] && Enum.map(m["typeArguments"], &ElementType.from_map/1),
@@ -3648,6 +3678,12 @@ defmodule Type10 do
           value: String.t() | nil
         }
 
+  def decode_id(value) when is_integer(value), do: value
+  def decode_id(_), do: {:error, "Unexpected type when decoding Type10.id"}
+
+  def encode_id(value) when is_integer(value), do: value
+  def encode_id(_), do: {:error, "Unexpected type when encoding Type10.id"}
+
   def decode_name(value) when is_binary(value), do: value
   def decode_name(_), do: {:error, "Unexpected type when decoding Type10.name"}
 
@@ -3665,7 +3701,7 @@ defmodule Type10 do
       declaration: m["declaration"] && Declaration4.from_map(m["declaration"]),
       element_type: m["elementType"] && ElementType.from_map(m["elementType"]),
       elements: m["elements"] && Enum.map(m["elements"], &ExtendedBy.from_map/1),
-      id: m["id"],
+      id: m["id"] && decode_id(m["id"]),
       name: m["name"] && decode_name(m["name"]),
       type: TypeEnum.decode(m["type"]),
       type_arguments: m["typeArguments"] && Enum.map(m["typeArguments"], &TypeArgument2.from_map/1),
@@ -3713,6 +3749,12 @@ defmodule Type12 do
           type: String.t()
         }
 
+  def decode_id(value) when is_integer(value), do: value
+  def decode_id(_), do: {:error, "Unexpected type when decoding Type12.id"}
+
+  def encode_id(value) when is_integer(value), do: value
+  def encode_id(_), do: {:error, "Unexpected type when encoding Type12.id"}
+
   def decode_operator(value) when is_binary(value), do: value
   def decode_operator(_), do: {:error, "Unexpected type when decoding Type12.operator"}
 
@@ -3727,7 +3769,7 @@ defmodule Type12 do
 
   def from_map(m) do
     %Type12{
-      id: m["id"],
+      id: m["id"] && decode_id(m["id"]),
       name: m["name"] && Name.decode(m["name"]),
       operator: m["operator"] && decode_operator(m["operator"]),
       target: m["target"] && ElementType.from_map(m["target"]),
diff --git a/base/elixir/test/inputs/json/priority/combinations1.json/default/QuickType.ex b/head/elixir/test/inputs/json/priority/combinations1.json/default/QuickType.ex
index 1a398a5..c733434 100644
--- a/base/elixir/test/inputs/json/priority/combinations1.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/priority/combinations1.json/default/QuickType.ex
@@ -246,6 +246,20 @@ defmodule ChemotherapeuticClass do
           unshy: nil | nil
         }
 
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding ChemotherapeuticClass.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding ChemotherapeuticClass.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding ChemotherapeuticClass.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding ChemotherapeuticClass.chirotherium"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding ChemotherapeuticClass.disdiapason"}
 
@@ -257,10 +271,10 @@ defmodule ChemotherapeuticClass do
       angioneurotic: m["angioneurotic"],
       availment: m["availment"],
       bladelet: m["bladelet"],
-      catharticalness: m["catharticalness"],
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
       caulis: m["caulis"],
       chalcus: m["chalcus"],
-      chirotherium: m["Chirotherium"],
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
       enteradenological: m["enteradenological"],
       homocerc: m["homocerc"],
@@ -433,6 +447,20 @@ defmodule CoadjustClass do
           unchargeable: nil | nil
         }
 
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding CoadjustClass.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding CoadjustClass.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding CoadjustClass.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding CoadjustClass.chirotherium"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding CoadjustClass.disdiapason"}
 
@@ -443,8 +471,8 @@ defmodule CoadjustClass do
     %CoadjustClass{
       amidosulphonal: m["amidosulphonal"],
       benny: m["Benny"],
-      catharticalness: m["catharticalness"],
-      chirotherium: m["Chirotherium"],
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
       ensnare: m["ensnare"],
       homocerc: m["homocerc"],
@@ -2013,6 +2041,20 @@ defmodule HemocoeleClass do
           walt: nil | nil
         }
 
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding HemocoeleClass.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding HemocoeleClass.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding HemocoeleClass.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding HemocoeleClass.chirotherium"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding HemocoeleClass.disdiapason"}
 
@@ -2025,8 +2067,8 @@ defmodule HemocoeleClass do
       amelification: m["amelification"],
       autobiographic: m["autobiographic"],
       berat: m["berat"],
-      catharticalness: m["catharticalness"],
-      chirotherium: m["Chirotherium"],
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
       disproportionably: m["disproportionably"],
       erythrite: m["erythrite"],
diff --git a/base/elixir/test/inputs/json/priority/combinations2.json/default/QuickType.ex b/head/elixir/test/inputs/json/priority/combinations2.json/default/QuickType.ex
index 93c7d8e..a5ca6e8 100644
--- a/base/elixir/test/inputs/json/priority/combinations2.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/priority/combinations2.json/default/QuickType.ex
@@ -323,39 +323,173 @@ defmodule Amphithyron do
           undecimal: integer() | nil
         }
 
+  def decode_akroasis(value) when is_integer(value), do: value
+  def decode_akroasis(_), do: {:error, "Unexpected type when decoding Amphithyron.akroasis"}
+
+  def encode_akroasis(value) when is_integer(value), do: value
+  def encode_akroasis(_), do: {:error, "Unexpected type when encoding Amphithyron.akroasis"}
+
+  def decode_antiphonical(value) when is_integer(value), do: value
+  def decode_antiphonical(_), do: {:error, "Unexpected type when decoding Amphithyron.antiphonical"}
+
+  def encode_antiphonical(value) when is_integer(value), do: value
+  def encode_antiphonical(_), do: {:error, "Unexpected type when encoding Amphithyron.antiphonical"}
+
+  def decode_basebred(value) when is_integer(value), do: value
+  def decode_basebred(_), do: {:error, "Unexpected type when decoding Amphithyron.basebred"}
+
+  def encode_basebred(value) when is_integer(value), do: value
+  def encode_basebred(_), do: {:error, "Unexpected type when encoding Amphithyron.basebred"}
+
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding Amphithyron.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding Amphithyron.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding Amphithyron.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding Amphithyron.chirotherium"}
+
+  def decode_conductometric(value) when is_integer(value), do: value
+  def decode_conductometric(_), do: {:error, "Unexpected type when decoding Amphithyron.conductometric"}
+
+  def encode_conductometric(value) when is_integer(value), do: value
+  def encode_conductometric(_), do: {:error, "Unexpected type when encoding Amphithyron.conductometric"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding Amphithyron.disdiapason"}
 
   def encode_disdiapason(value) when is_binary(value), do: value
   def encode_disdiapason(_), do: {:error, "Unexpected type when encoding Amphithyron.disdiapason"}
 
+  def decode_ensilation(value) when is_integer(value), do: value
+  def decode_ensilation(_), do: {:error, "Unexpected type when decoding Amphithyron.ensilation"}
+
+  def encode_ensilation(value) when is_integer(value), do: value
+  def encode_ensilation(_), do: {:error, "Unexpected type when encoding Amphithyron.ensilation"}
+
+  def decode_eyebolt(value) when is_integer(value), do: value
+  def decode_eyebolt(_), do: {:error, "Unexpected type when decoding Amphithyron.eyebolt"}
+
+  def encode_eyebolt(value) when is_integer(value), do: value
+  def encode_eyebolt(_), do: {:error, "Unexpected type when encoding Amphithyron.eyebolt"}
+
+  def decode_fistulated(value) when is_integer(value), do: value
+  def decode_fistulated(_), do: {:error, "Unexpected type when decoding Amphithyron.fistulated"}
+
+  def encode_fistulated(value) when is_integer(value), do: value
+  def encode_fistulated(_), do: {:error, "Unexpected type when encoding Amphithyron.fistulated"}
+
+  def decode_heteropod(value) when is_integer(value), do: value
+  def decode_heteropod(_), do: {:error, "Unexpected type when decoding Amphithyron.heteropod"}
+
+  def encode_heteropod(value) when is_integer(value), do: value
+  def encode_heteropod(_), do: {:error, "Unexpected type when encoding Amphithyron.heteropod"}
+
+  def decode_juniperus(value) when is_integer(value), do: value
+  def decode_juniperus(_), do: {:error, "Unexpected type when decoding Amphithyron.juniperus"}
+
+  def encode_juniperus(value) when is_integer(value), do: value
+  def encode_juniperus(_), do: {:error, "Unexpected type when encoding Amphithyron.juniperus"}
+
+  def decode_labyrinthically(value) when is_integer(value), do: value
+  def decode_labyrinthically(_), do: {:error, "Unexpected type when decoding Amphithyron.labyrinthically"}
+
+  def encode_labyrinthically(value) when is_integer(value), do: value
+  def encode_labyrinthically(_), do: {:error, "Unexpected type when encoding Amphithyron.labyrinthically"}
+
+  def decode_martyrization(value) when is_integer(value), do: value
+  def decode_martyrization(_), do: {:error, "Unexpected type when decoding Amphithyron.martyrization"}
+
+  def encode_martyrization(value) when is_integer(value), do: value
+  def encode_martyrization(_), do: {:error, "Unexpected type when encoding Amphithyron.martyrization"}
+
+  def decode_mispolicy(value) when is_integer(value), do: value
+  def decode_mispolicy(_), do: {:error, "Unexpected type when decoding Amphithyron.mispolicy"}
+
+  def encode_mispolicy(value) when is_integer(value), do: value
+  def encode_mispolicy(_), do: {:error, "Unexpected type when encoding Amphithyron.mispolicy"}
+
+  def decode_multipara(value) when is_integer(value), do: value
+  def decode_multipara(_), do: {:error, "Unexpected type when decoding Amphithyron.multipara"}
+
+  def encode_multipara(value) when is_integer(value), do: value
+  def encode_multipara(_), do: {:error, "Unexpected type when encoding Amphithyron.multipara"}
+
+  def decode_nazirite(value) when is_integer(value), do: value
+  def decode_nazirite(_), do: {:error, "Unexpected type when decoding Amphithyron.nazirite"}
+
+  def encode_nazirite(value) when is_integer(value), do: value
+  def encode_nazirite(_), do: {:error, "Unexpected type when encoding Amphithyron.nazirite"}
+
+  def decode_possessorial(value) when is_integer(value), do: value
+  def decode_possessorial(_), do: {:error, "Unexpected type when decoding Amphithyron.possessorial"}
+
+  def encode_possessorial(value) when is_integer(value), do: value
+  def encode_possessorial(_), do: {:error, "Unexpected type when encoding Amphithyron.possessorial"}
+
+  def decode_shamed(value) when is_integer(value), do: value
+  def decode_shamed(_), do: {:error, "Unexpected type when decoding Amphithyron.shamed"}
+
+  def encode_shamed(value) when is_integer(value), do: value
+  def encode_shamed(_), do: {:error, "Unexpected type when encoding Amphithyron.shamed"}
+
+  def decode_shelfworn(value) when is_integer(value), do: value
+  def decode_shelfworn(_), do: {:error, "Unexpected type when decoding Amphithyron.shelfworn"}
+
+  def encode_shelfworn(value) when is_integer(value), do: value
+  def encode_shelfworn(_), do: {:error, "Unexpected type when encoding Amphithyron.shelfworn"}
+
+  def decode_stagnum(value) when is_integer(value), do: value
+  def decode_stagnum(_), do: {:error, "Unexpected type when decoding Amphithyron.stagnum"}
+
+  def encode_stagnum(value) when is_integer(value), do: value
+  def encode_stagnum(_), do: {:error, "Unexpected type when encoding Amphithyron.stagnum"}
+
+  def decode_those(value) when is_integer(value), do: value
+  def decode_those(_), do: {:error, "Unexpected type when decoding Amphithyron.those"}
+
+  def encode_those(value) when is_integer(value), do: value
+  def encode_those(_), do: {:error, "Unexpected type when encoding Amphithyron.those"}
+
+  def decode_undecimal(value) when is_integer(value), do: value
+  def decode_undecimal(_), do: {:error, "Unexpected type when decoding Amphithyron.undecimal"}
+
+  def encode_undecimal(value) when is_integer(value), do: value
+  def encode_undecimal(_), do: {:error, "Unexpected type when encoding Amphithyron.undecimal"}
+
   def from_map(m) do
     %Amphithyron{
-      akroasis: m["akroasis"],
-      antiphonical: m["antiphonical"],
-      basebred: m["basebred"],
-      catharticalness: m["catharticalness"],
-      chirotherium: m["Chirotherium"],
-      conductometric: m["conductometric"],
+      akroasis: m["akroasis"] && decode_akroasis(m["akroasis"]),
+      antiphonical: m["antiphonical"] && decode_antiphonical(m["antiphonical"]),
+      basebred: m["basebred"] && decode_basebred(m["basebred"]),
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
+      conductometric: m["conductometric"] && decode_conductometric(m["conductometric"]),
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
-      ensilation: m["ensilation"],
-      eyebolt: m["eyebolt"],
-      fistulated: m["fistulated"],
-      heteropod: m["heteropod"],
+      ensilation: m["ensilation"] && decode_ensilation(m["ensilation"]),
+      eyebolt: m["eyebolt"] && decode_eyebolt(m["eyebolt"]),
+      fistulated: m["fistulated"] && decode_fistulated(m["fistulated"]),
+      heteropod: m["heteropod"] && decode_heteropod(m["heteropod"]),
       homocerc: m["homocerc"],
-      juniperus: m["Juniperus"],
-      labyrinthically: m["labyrinthically"],
-      martyrization: m["martyrization"],
-      mispolicy: m["mispolicy"],
-      multipara: m["multipara"],
-      nazirite: m["Nazirite"],
+      juniperus: m["Juniperus"] && decode_juniperus(m["Juniperus"]),
+      labyrinthically: m["labyrinthically"] && decode_labyrinthically(m["labyrinthically"]),
+      martyrization: m["martyrization"] && decode_martyrization(m["martyrization"]),
+      mispolicy: m["mispolicy"] && decode_mispolicy(m["mispolicy"]),
+      multipara: m["multipara"] && decode_multipara(m["multipara"]),
+      nazirite: m["Nazirite"] && decode_nazirite(m["Nazirite"]),
       nonbookish: m["nonbookish"],
-      possessorial: m["possessorial"],
-      shamed: m["shamed"],
-      shelfworn: m["shelfworn"],
-      stagnum: m["stagnum"],
-      those: m["Those"],
-      undecimal: m["undecimal"],
+      possessorial: m["possessorial"] && decode_possessorial(m["possessorial"]),
+      shamed: m["shamed"] && decode_shamed(m["shamed"]),
+      shelfworn: m["shelfworn"] && decode_shelfworn(m["shelfworn"]),
+      stagnum: m["stagnum"] && decode_stagnum(m["stagnum"]),
+      those: m["Those"] && decode_those(m["Those"]),
+      undecimal: m["undecimal"] && decode_undecimal(m["undecimal"]),
     }
   end
 
@@ -1063,39 +1197,173 @@ defmodule DiscordiaClass do
           wingle: integer() | nil
         }
 
+  def decode_altaic(value) when is_integer(value), do: value
+  def decode_altaic(_), do: {:error, "Unexpected type when decoding DiscordiaClass.altaic"}
+
+  def encode_altaic(value) when is_integer(value), do: value
+  def encode_altaic(_), do: {:error, "Unexpected type when encoding DiscordiaClass.altaic"}
+
+  def decode_amoristic(value) when is_integer(value), do: value
+  def decode_amoristic(_), do: {:error, "Unexpected type when decoding DiscordiaClass.amoristic"}
+
+  def encode_amoristic(value) when is_integer(value), do: value
+  def encode_amoristic(_), do: {:error, "Unexpected type when encoding DiscordiaClass.amoristic"}
+
+  def decode_blennophthalmia(value) when is_integer(value), do: value
+  def decode_blennophthalmia(_), do: {:error, "Unexpected type when decoding DiscordiaClass.blennophthalmia"}
+
+  def encode_blennophthalmia(value) when is_integer(value), do: value
+  def encode_blennophthalmia(_), do: {:error, "Unexpected type when encoding DiscordiaClass.blennophthalmia"}
+
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding DiscordiaClass.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding DiscordiaClass.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding DiscordiaClass.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding DiscordiaClass.chirotherium"}
+
+  def decode_disciplinability(value) when is_integer(value), do: value
+  def decode_disciplinability(_), do: {:error, "Unexpected type when decoding DiscordiaClass.disciplinability"}
+
+  def encode_disciplinability(value) when is_integer(value), do: value
+  def encode_disciplinability(_), do: {:error, "Unexpected type when encoding DiscordiaClass.disciplinability"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding DiscordiaClass.disdiapason"}
 
   def encode_disdiapason(value) when is_binary(value), do: value
   def encode_disdiapason(_), do: {:error, "Unexpected type when encoding DiscordiaClass.disdiapason"}
 
+  def decode_goofer(value) when is_integer(value), do: value
+  def decode_goofer(_), do: {:error, "Unexpected type when decoding DiscordiaClass.goofer"}
+
+  def encode_goofer(value) when is_integer(value), do: value
+  def encode_goofer(_), do: {:error, "Unexpected type when encoding DiscordiaClass.goofer"}
+
+  def decode_laryngograph(value) when is_integer(value), do: value
+  def decode_laryngograph(_), do: {:error, "Unexpected type when decoding DiscordiaClass.laryngograph"}
+
+  def encode_laryngograph(value) when is_integer(value), do: value
+  def encode_laryngograph(_), do: {:error, "Unexpected type when encoding DiscordiaClass.laryngograph"}
+
+  def decode_leucitis(value) when is_integer(value), do: value
+  def decode_leucitis(_), do: {:error, "Unexpected type when decoding DiscordiaClass.leucitis"}
+
+  def encode_leucitis(value) when is_integer(value), do: value
+  def encode_leucitis(_), do: {:error, "Unexpected type when encoding DiscordiaClass.leucitis"}
+
+  def decode_lymphocyst(value) when is_integer(value), do: value
+  def decode_lymphocyst(_), do: {:error, "Unexpected type when decoding DiscordiaClass.lymphocyst"}
+
+  def encode_lymphocyst(value) when is_integer(value), do: value
+  def encode_lymphocyst(_), do: {:error, "Unexpected type when encoding DiscordiaClass.lymphocyst"}
+
+  def decode_microcosmology(value) when is_integer(value), do: value
+  def decode_microcosmology(_), do: {:error, "Unexpected type when decoding DiscordiaClass.microcosmology"}
+
+  def encode_microcosmology(value) when is_integer(value), do: value
+  def encode_microcosmology(_), do: {:error, "Unexpected type when encoding DiscordiaClass.microcosmology"}
+
+  def decode_nauseation(value) when is_integer(value), do: value
+  def decode_nauseation(_), do: {:error, "Unexpected type when decoding DiscordiaClass.nauseation"}
+
+  def encode_nauseation(value) when is_integer(value), do: value
+  def encode_nauseation(_), do: {:error, "Unexpected type when encoding DiscordiaClass.nauseation"}
+
+  def decode_patarin(value) when is_integer(value), do: value
+  def decode_patarin(_), do: {:error, "Unexpected type when decoding DiscordiaClass.patarin"}
+
+  def encode_patarin(value) when is_integer(value), do: value
+  def encode_patarin(_), do: {:error, "Unexpected type when encoding DiscordiaClass.patarin"}
+
+  def decode_preliberal(value) when is_integer(value), do: value
+  def decode_preliberal(_), do: {:error, "Unexpected type when decoding DiscordiaClass.preliberal"}
+
+  def encode_preliberal(value) when is_integer(value), do: value
+  def encode_preliberal(_), do: {:error, "Unexpected type when encoding DiscordiaClass.preliberal"}
+
+  def decode_prettifier(value) when is_integer(value), do: value
+  def decode_prettifier(_), do: {:error, "Unexpected type when decoding DiscordiaClass.prettifier"}
+
+  def encode_prettifier(value) when is_integer(value), do: value
+  def encode_prettifier(_), do: {:error, "Unexpected type when encoding DiscordiaClass.prettifier"}
+
+  def decode_rangework(value) when is_integer(value), do: value
+  def decode_rangework(_), do: {:error, "Unexpected type when decoding DiscordiaClass.rangework"}
+
+  def encode_rangework(value) when is_integer(value), do: value
+  def encode_rangework(_), do: {:error, "Unexpected type when encoding DiscordiaClass.rangework"}
+
+  def decode_redient(value) when is_integer(value), do: value
+  def decode_redient(_), do: {:error, "Unexpected type when decoding DiscordiaClass.redient"}
+
+  def encode_redient(value) when is_integer(value), do: value
+  def encode_redient(_), do: {:error, "Unexpected type when encoding DiscordiaClass.redient"}
+
+  def decode_subfusiform(value) when is_integer(value), do: value
+  def decode_subfusiform(_), do: {:error, "Unexpected type when decoding DiscordiaClass.subfusiform"}
+
+  def encode_subfusiform(value) when is_integer(value), do: value
+  def encode_subfusiform(_), do: {:error, "Unexpected type when encoding DiscordiaClass.subfusiform"}
+
+  def decode_suicidical(value) when is_integer(value), do: value
+  def decode_suicidical(_), do: {:error, "Unexpected type when decoding DiscordiaClass.suicidical"}
+
+  def encode_suicidical(value) when is_integer(value), do: value
+  def encode_suicidical(_), do: {:error, "Unexpected type when encoding DiscordiaClass.suicidical"}
+
+  def decode_swow(value) when is_integer(value), do: value
+  def decode_swow(_), do: {:error, "Unexpected type when decoding DiscordiaClass.swow"}
+
+  def encode_swow(value) when is_integer(value), do: value
+  def encode_swow(_), do: {:error, "Unexpected type when encoding DiscordiaClass.swow"}
+
+  def decode_wastrel(value) when is_integer(value), do: value
+  def decode_wastrel(_), do: {:error, "Unexpected type when decoding DiscordiaClass.wastrel"}
+
+  def encode_wastrel(value) when is_integer(value), do: value
+  def encode_wastrel(_), do: {:error, "Unexpected type when encoding DiscordiaClass.wastrel"}
+
+  def decode_wingle(value) when is_integer(value), do: value
+  def decode_wingle(_), do: {:error, "Unexpected type when decoding DiscordiaClass.wingle"}
+
+  def encode_wingle(value) when is_integer(value), do: value
+  def encode_wingle(_), do: {:error, "Unexpected type when encoding DiscordiaClass.wingle"}
+
   def from_map(m) do
     %DiscordiaClass{
-      altaic: m["Altaic"],
-      amoristic: m["amoristic"],
-      blennophthalmia: m["blennophthalmia"],
-      catharticalness: m["catharticalness"],
-      chirotherium: m["Chirotherium"],
-      disciplinability: m["disciplinability"],
+      altaic: m["Altaic"] && decode_altaic(m["Altaic"]),
+      amoristic: m["amoristic"] && decode_amoristic(m["amoristic"]),
+      blennophthalmia: m["blennophthalmia"] && decode_blennophthalmia(m["blennophthalmia"]),
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
+      disciplinability: m["disciplinability"] && decode_disciplinability(m["disciplinability"]),
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
-      goofer: m["goofer"],
+      goofer: m["goofer"] && decode_goofer(m["goofer"]),
       homocerc: m["homocerc"],
-      laryngograph: m["laryngograph"],
-      leucitis: m["leucitis"],
-      lymphocyst: m["lymphocyst"],
-      microcosmology: m["microcosmology"],
-      nauseation: m["nauseation"],
+      laryngograph: m["laryngograph"] && decode_laryngograph(m["laryngograph"]),
+      leucitis: m["leucitis"] && decode_leucitis(m["leucitis"]),
+      lymphocyst: m["lymphocyst"] && decode_lymphocyst(m["lymphocyst"]),
+      microcosmology: m["microcosmology"] && decode_microcosmology(m["microcosmology"]),
+      nauseation: m["nauseation"] && decode_nauseation(m["nauseation"]),
       nonbookish: m["nonbookish"],
-      patarin: m["Patarin"],
-      preliberal: m["preliberal"],
-      prettifier: m["prettifier"],
-      rangework: m["rangework"],
-      redient: m["redient"],
-      subfusiform: m["subfusiform"],
-      suicidical: m["suicidical"],
-      swow: m["swow"],
-      wastrel: m["wastrel"],
-      wingle: m["wingle"],
+      patarin: m["Patarin"] && decode_patarin(m["Patarin"]),
+      preliberal: m["preliberal"] && decode_preliberal(m["preliberal"]),
+      prettifier: m["prettifier"] && decode_prettifier(m["prettifier"]),
+      rangework: m["rangework"] && decode_rangework(m["rangework"]),
+      redient: m["redient"] && decode_redient(m["redient"]),
+      subfusiform: m["subfusiform"] && decode_subfusiform(m["subfusiform"]),
+      suicidical: m["suicidical"] && decode_suicidical(m["suicidical"]),
+      swow: m["swow"] && decode_swow(m["swow"]),
+      wastrel: m["wastrel"] && decode_wastrel(m["wastrel"]),
+      wingle: m["wingle"] && decode_wingle(m["wingle"]),
     }
   end
 
@@ -1383,39 +1651,173 @@ defmodule LaviniaClass do
           uproute: integer() | nil
         }
 
+  def decode_agitable(value) when is_integer(value), do: value
+  def decode_agitable(_), do: {:error, "Unexpected type when decoding LaviniaClass.agitable"}
+
+  def encode_agitable(value) when is_integer(value), do: value
+  def encode_agitable(_), do: {:error, "Unexpected type when encoding LaviniaClass.agitable"}
+
+  def decode_asininity(value) when is_integer(value), do: value
+  def decode_asininity(_), do: {:error, "Unexpected type when decoding LaviniaClass.asininity"}
+
+  def encode_asininity(value) when is_integer(value), do: value
+  def encode_asininity(_), do: {:error, "Unexpected type when encoding LaviniaClass.asininity"}
+
+  def decode_benefiter(value) when is_integer(value), do: value
+  def decode_benefiter(_), do: {:error, "Unexpected type when decoding LaviniaClass.benefiter"}
+
+  def encode_benefiter(value) when is_integer(value), do: value
+  def encode_benefiter(_), do: {:error, "Unexpected type when encoding LaviniaClass.benefiter"}
+
+  def decode_bronzelike(value) when is_integer(value), do: value
+  def decode_bronzelike(_), do: {:error, "Unexpected type when decoding LaviniaClass.bronzelike"}
+
+  def encode_bronzelike(value) when is_integer(value), do: value
+  def encode_bronzelike(_), do: {:error, "Unexpected type when encoding LaviniaClass.bronzelike"}
+
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding LaviniaClass.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding LaviniaClass.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding LaviniaClass.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding LaviniaClass.chirotherium"}
+
+  def decode_cholesteatomatous(value) when is_integer(value), do: value
+  def decode_cholesteatomatous(_), do: {:error, "Unexpected type when decoding LaviniaClass.cholesteatomatous"}
+
+  def encode_cholesteatomatous(value) when is_integer(value), do: value
+  def encode_cholesteatomatous(_), do: {:error, "Unexpected type when encoding LaviniaClass.cholesteatomatous"}
+
+  def decode_deprivement(value) when is_integer(value), do: value
+  def decode_deprivement(_), do: {:error, "Unexpected type when decoding LaviniaClass.deprivement"}
+
+  def encode_deprivement(value) when is_integer(value), do: value
+  def encode_deprivement(_), do: {:error, "Unexpected type when encoding LaviniaClass.deprivement"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding LaviniaClass.disdiapason"}
 
   def encode_disdiapason(value) when is_binary(value), do: value
   def encode_disdiapason(_), do: {:error, "Unexpected type when encoding LaviniaClass.disdiapason"}
 
+  def decode_flippantness(value) when is_integer(value), do: value
+  def decode_flippantness(_), do: {:error, "Unexpected type when decoding LaviniaClass.flippantness"}
+
+  def encode_flippantness(value) when is_integer(value), do: value
+  def encode_flippantness(_), do: {:error, "Unexpected type when encoding LaviniaClass.flippantness"}
+
+  def decode_fogproof(value) when is_integer(value), do: value
+  def decode_fogproof(_), do: {:error, "Unexpected type when decoding LaviniaClass.fogproof"}
+
+  def encode_fogproof(value) when is_integer(value), do: value
+  def encode_fogproof(_), do: {:error, "Unexpected type when encoding LaviniaClass.fogproof"}
+
+  def decode_merrymeeting(value) when is_integer(value), do: value
+  def decode_merrymeeting(_), do: {:error, "Unexpected type when decoding LaviniaClass.merrymeeting"}
+
+  def encode_merrymeeting(value) when is_integer(value), do: value
+  def encode_merrymeeting(_), do: {:error, "Unexpected type when encoding LaviniaClass.merrymeeting"}
+
+  def decode_overcareful(value) when is_integer(value), do: value
+  def decode_overcareful(_), do: {:error, "Unexpected type when decoding LaviniaClass.overcareful"}
+
+  def encode_overcareful(value) when is_integer(value), do: value
+  def encode_overcareful(_), do: {:error, "Unexpected type when encoding LaviniaClass.overcareful"}
+
+  def decode_panaris(value) when is_integer(value), do: value
+  def decode_panaris(_), do: {:error, "Unexpected type when decoding LaviniaClass.panaris"}
+
+  def encode_panaris(value) when is_integer(value), do: value
+  def encode_panaris(_), do: {:error, "Unexpected type when encoding LaviniaClass.panaris"}
+
+  def decode_preacceptance(value) when is_integer(value), do: value
+  def decode_preacceptance(_), do: {:error, "Unexpected type when decoding LaviniaClass.preacceptance"}
+
+  def encode_preacceptance(value) when is_integer(value), do: value
+  def encode_preacceptance(_), do: {:error, "Unexpected type when encoding LaviniaClass.preacceptance"}
+
+  def decode_quinoxaline(value) when is_integer(value), do: value
+  def decode_quinoxaline(_), do: {:error, "Unexpected type when decoding LaviniaClass.quinoxaline"}
+
+  def encode_quinoxaline(value) when is_integer(value), do: value
+  def encode_quinoxaline(_), do: {:error, "Unexpected type when encoding LaviniaClass.quinoxaline"}
+
+  def decode_sig(value) when is_integer(value), do: value
+  def decode_sig(_), do: {:error, "Unexpected type when decoding LaviniaClass.sig"}
+
+  def encode_sig(value) when is_integer(value), do: value
+  def encode_sig(_), do: {:error, "Unexpected type when encoding LaviniaClass.sig"}
+
+  def decode_superconfusion(value) when is_integer(value), do: value
+  def decode_superconfusion(_), do: {:error, "Unexpected type when decoding LaviniaClass.superconfusion"}
+
+  def encode_superconfusion(value) when is_integer(value), do: value
+  def encode_superconfusion(_), do: {:error, "Unexpected type when encoding LaviniaClass.superconfusion"}
+
+  def decode_tacana(value) when is_integer(value), do: value
+  def decode_tacana(_), do: {:error, "Unexpected type when decoding LaviniaClass.tacana"}
+
+  def encode_tacana(value) when is_integer(value), do: value
+  def encode_tacana(_), do: {:error, "Unexpected type when encoding LaviniaClass.tacana"}
+
+  def decode_tillotter(value) when is_integer(value), do: value
+  def decode_tillotter(_), do: {:error, "Unexpected type when decoding LaviniaClass.tillotter"}
+
+  def encode_tillotter(value) when is_integer(value), do: value
+  def encode_tillotter(_), do: {:error, "Unexpected type when encoding LaviniaClass.tillotter"}
+
+  def decode_tranquillize(value) when is_integer(value), do: value
+  def decode_tranquillize(_), do: {:error, "Unexpected type when decoding LaviniaClass.tranquillize"}
+
+  def encode_tranquillize(value) when is_integer(value), do: value
+  def encode_tranquillize(_), do: {:error, "Unexpected type when encoding LaviniaClass.tranquillize"}
+
+  def decode_unquestionable(value) when is_integer(value), do: value
+  def decode_unquestionable(_), do: {:error, "Unexpected type when decoding LaviniaClass.unquestionable"}
+
+  def encode_unquestionable(value) when is_integer(value), do: value
+  def encode_unquestionable(_), do: {:error, "Unexpected type when encoding LaviniaClass.unquestionable"}
+
+  def decode_uproute(value) when is_integer(value), do: value
+  def decode_uproute(_), do: {:error, "Unexpected type when decoding LaviniaClass.uproute"}
+
+  def encode_uproute(value) when is_integer(value), do: value
+  def encode_uproute(_), do: {:error, "Unexpected type when encoding LaviniaClass.uproute"}
+
   def from_map(m) do
     %LaviniaClass{
-      agitable: m["agitable"],
-      asininity: m["asininity"],
-      benefiter: m["benefiter"],
-      bronzelike: m["bronzelike"],
-      catharticalness: m["catharticalness"],
-      chirotherium: m["Chirotherium"],
-      cholesteatomatous: m["cholesteatomatous"],
-      deprivement: m["deprivement"],
+      agitable: m["agitable"] && decode_agitable(m["agitable"]),
+      asininity: m["asininity"] && decode_asininity(m["asininity"]),
+      benefiter: m["benefiter"] && decode_benefiter(m["benefiter"]),
+      bronzelike: m["bronzelike"] && decode_bronzelike(m["bronzelike"]),
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
+      cholesteatomatous: m["cholesteatomatous"] && decode_cholesteatomatous(m["cholesteatomatous"]),
+      deprivement: m["deprivement"] && decode_deprivement(m["deprivement"]),
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
-      flippantness: m["flippantness"],
-      fogproof: m["fogproof"],
+      flippantness: m["flippantness"] && decode_flippantness(m["flippantness"]),
+      fogproof: m["fogproof"] && decode_fogproof(m["fogproof"]),
       homocerc: m["homocerc"],
-      merrymeeting: m["merrymeeting"],
+      merrymeeting: m["merrymeeting"] && decode_merrymeeting(m["merrymeeting"]),
       nonbookish: m["nonbookish"],
-      overcareful: m["overcareful"],
-      panaris: m["panaris"],
-      preacceptance: m["preacceptance"],
-      quinoxaline: m["quinoxaline"],
-      sig: m["sig"],
-      superconfusion: m["superconfusion"],
-      tacana: m["Tacana"],
-      tillotter: m["tillotter"],
-      tranquillize: m["tranquillize"],
-      unquestionable: m["unquestionable"],
-      uproute: m["uproute"],
+      overcareful: m["overcareful"] && decode_overcareful(m["overcareful"]),
+      panaris: m["panaris"] && decode_panaris(m["panaris"]),
+      preacceptance: m["preacceptance"] && decode_preacceptance(m["preacceptance"]),
+      quinoxaline: m["quinoxaline"] && decode_quinoxaline(m["quinoxaline"]),
+      sig: m["sig"] && decode_sig(m["sig"]),
+      superconfusion: m["superconfusion"] && decode_superconfusion(m["superconfusion"]),
+      tacana: m["Tacana"] && decode_tacana(m["Tacana"]),
+      tillotter: m["tillotter"] && decode_tillotter(m["tillotter"]),
+      tranquillize: m["tranquillize"] && decode_tranquillize(m["tranquillize"]),
+      unquestionable: m["unquestionable"] && decode_unquestionable(m["unquestionable"]),
+      uproute: m["uproute"] && decode_uproute(m["uproute"]),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/priority/combinations3.json/default/QuickType.ex b/head/elixir/test/inputs/json/priority/combinations3.json/default/QuickType.ex
index 7b155b6..8d0efa8 100644
--- a/base/elixir/test/inputs/json/priority/combinations3.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/priority/combinations3.json/default/QuickType.ex
@@ -666,39 +666,173 @@ defmodule LupusClass do
           vendible: integer() | nil
         }
 
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding LupusClass.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding LupusClass.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding LupusClass.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding LupusClass.chirotherium"}
+
+  def decode_chlorioninae(value) when is_integer(value), do: value
+  def decode_chlorioninae(_), do: {:error, "Unexpected type when decoding LupusClass.chlorioninae"}
+
+  def encode_chlorioninae(value) when is_integer(value), do: value
+  def encode_chlorioninae(_), do: {:error, "Unexpected type when encoding LupusClass.chlorioninae"}
+
+  def decode_corvinae(value) when is_integer(value), do: value
+  def decode_corvinae(_), do: {:error, "Unexpected type when decoding LupusClass.corvinae"}
+
+  def encode_corvinae(value) when is_integer(value), do: value
+  def encode_corvinae(_), do: {:error, "Unexpected type when encoding LupusClass.corvinae"}
+
+  def decode_crassina(value) when is_integer(value), do: value
+  def decode_crassina(_), do: {:error, "Unexpected type when decoding LupusClass.crassina"}
+
+  def encode_crassina(value) when is_integer(value), do: value
+  def encode_crassina(_), do: {:error, "Unexpected type when encoding LupusClass.crassina"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding LupusClass.disdiapason"}
 
   def encode_disdiapason(value) when is_binary(value), do: value
   def encode_disdiapason(_), do: {:error, "Unexpected type when encoding LupusClass.disdiapason"}
 
+  def decode_exiguity(value) when is_integer(value), do: value
+  def decode_exiguity(_), do: {:error, "Unexpected type when decoding LupusClass.exiguity"}
+
+  def encode_exiguity(value) when is_integer(value), do: value
+  def encode_exiguity(_), do: {:error, "Unexpected type when encoding LupusClass.exiguity"}
+
+  def decode_farcist(value) when is_integer(value), do: value
+  def decode_farcist(_), do: {:error, "Unexpected type when decoding LupusClass.farcist"}
+
+  def encode_farcist(value) when is_integer(value), do: value
+  def encode_farcist(_), do: {:error, "Unexpected type when encoding LupusClass.farcist"}
+
+  def decode_holographical(value) when is_integer(value), do: value
+  def decode_holographical(_), do: {:error, "Unexpected type when decoding LupusClass.holographical"}
+
+  def encode_holographical(value) when is_integer(value), do: value
+  def encode_holographical(_), do: {:error, "Unexpected type when encoding LupusClass.holographical"}
+
+  def decode_ichthyophagan(value) when is_integer(value), do: value
+  def decode_ichthyophagan(_), do: {:error, "Unexpected type when decoding LupusClass.ichthyophagan"}
+
+  def encode_ichthyophagan(value) when is_integer(value), do: value
+  def encode_ichthyophagan(_), do: {:error, "Unexpected type when encoding LupusClass.ichthyophagan"}
+
+  def decode_implacable(value) when is_integer(value), do: value
+  def decode_implacable(_), do: {:error, "Unexpected type when decoding LupusClass.implacable"}
+
+  def encode_implacable(value) when is_integer(value), do: value
+  def encode_implacable(_), do: {:error, "Unexpected type when encoding LupusClass.implacable"}
+
+  def decode_outshiner(value) when is_integer(value), do: value
+  def decode_outshiner(_), do: {:error, "Unexpected type when decoding LupusClass.outshiner"}
+
+  def encode_outshiner(value) when is_integer(value), do: value
+  def encode_outshiner(_), do: {:error, "Unexpected type when encoding LupusClass.outshiner"}
+
+  def decode_overweather(value) when is_integer(value), do: value
+  def decode_overweather(_), do: {:error, "Unexpected type when decoding LupusClass.overweather"}
+
+  def encode_overweather(value) when is_integer(value), do: value
+  def encode_overweather(_), do: {:error, "Unexpected type when encoding LupusClass.overweather"}
+
+  def decode_protonegroid(value) when is_integer(value), do: value
+  def decode_protonegroid(_), do: {:error, "Unexpected type when decoding LupusClass.protonegroid"}
+
+  def encode_protonegroid(value) when is_integer(value), do: value
+  def encode_protonegroid(_), do: {:error, "Unexpected type when encoding LupusClass.protonegroid"}
+
+  def decode_shallowish(value) when is_integer(value), do: value
+  def decode_shallowish(_), do: {:error, "Unexpected type when decoding LupusClass.shallowish"}
+
+  def encode_shallowish(value) when is_integer(value), do: value
+  def encode_shallowish(_), do: {:error, "Unexpected type when encoding LupusClass.shallowish"}
+
+  def decode_snoke(value) when is_integer(value), do: value
+  def decode_snoke(_), do: {:error, "Unexpected type when decoding LupusClass.snoke"}
+
+  def encode_snoke(value) when is_integer(value), do: value
+  def encode_snoke(_), do: {:error, "Unexpected type when encoding LupusClass.snoke"}
+
+  def decode_snout(value) when is_integer(value), do: value
+  def decode_snout(_), do: {:error, "Unexpected type when decoding LupusClass.snout"}
+
+  def encode_snout(value) when is_integer(value), do: value
+  def encode_snout(_), do: {:error, "Unexpected type when encoding LupusClass.snout"}
+
+  def decode_surveillance(value) when is_integer(value), do: value
+  def decode_surveillance(_), do: {:error, "Unexpected type when decoding LupusClass.surveillance"}
+
+  def encode_surveillance(value) when is_integer(value), do: value
+  def encode_surveillance(_), do: {:error, "Unexpected type when encoding LupusClass.surveillance"}
+
+  def decode_threshingtime(value) when is_integer(value), do: value
+  def decode_threshingtime(_), do: {:error, "Unexpected type when decoding LupusClass.threshingtime"}
+
+  def encode_threshingtime(value) when is_integer(value), do: value
+  def encode_threshingtime(_), do: {:error, "Unexpected type when encoding LupusClass.threshingtime"}
+
+  def decode_thysanocarpus(value) when is_integer(value), do: value
+  def decode_thysanocarpus(_), do: {:error, "Unexpected type when decoding LupusClass.thysanocarpus"}
+
+  def encode_thysanocarpus(value) when is_integer(value), do: value
+  def encode_thysanocarpus(_), do: {:error, "Unexpected type when encoding LupusClass.thysanocarpus"}
+
+  def decode_unsignificantly(value) when is_integer(value), do: value
+  def decode_unsignificantly(_), do: {:error, "Unexpected type when decoding LupusClass.unsignificantly"}
+
+  def encode_unsignificantly(value) when is_integer(value), do: value
+  def encode_unsignificantly(_), do: {:error, "Unexpected type when encoding LupusClass.unsignificantly"}
+
+  def decode_unsnap(value) when is_integer(value), do: value
+  def decode_unsnap(_), do: {:error, "Unexpected type when decoding LupusClass.unsnap"}
+
+  def encode_unsnap(value) when is_integer(value), do: value
+  def encode_unsnap(_), do: {:error, "Unexpected type when encoding LupusClass.unsnap"}
+
+  def decode_vendible(value) when is_integer(value), do: value
+  def decode_vendible(_), do: {:error, "Unexpected type when decoding LupusClass.vendible"}
+
+  def encode_vendible(value) when is_integer(value), do: value
+  def encode_vendible(_), do: {:error, "Unexpected type when encoding LupusClass.vendible"}
+
   def from_map(m) do
     %LupusClass{
-      catharticalness: m["catharticalness"],
-      chirotherium: m["Chirotherium"],
-      chlorioninae: m["Chlorioninae"],
-      corvinae: m["Corvinae"],
-      crassina: m["Crassina"],
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
+      chlorioninae: m["Chlorioninae"] && decode_chlorioninae(m["Chlorioninae"]),
+      corvinae: m["Corvinae"] && decode_corvinae(m["Corvinae"]),
+      crassina: m["Crassina"] && decode_crassina(m["Crassina"]),
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
-      exiguity: m["exiguity"],
-      farcist: m["farcist"],
-      holographical: m["holographical"],
+      exiguity: m["exiguity"] && decode_exiguity(m["exiguity"]),
+      farcist: m["farcist"] && decode_farcist(m["farcist"]),
+      holographical: m["holographical"] && decode_holographical(m["holographical"]),
       homocerc: m["homocerc"],
-      ichthyophagan: m["ichthyophagan"],
-      implacable: m["implacable"],
+      ichthyophagan: m["ichthyophagan"] && decode_ichthyophagan(m["ichthyophagan"]),
+      implacable: m["implacable"] && decode_implacable(m["implacable"]),
       nonbookish: m["nonbookish"],
-      outshiner: m["outshiner"],
-      overweather: m["overweather"],
-      protonegroid: m["protonegroid"],
-      shallowish: m["shallowish"],
-      snoke: m["snoke"],
-      snout: m["snout"],
-      surveillance: m["surveillance"],
-      threshingtime: m["threshingtime"],
-      thysanocarpus: m["Thysanocarpus"],
-      unsignificantly: m["unsignificantly"],
-      unsnap: m["unsnap"],
-      vendible: m["vendible"],
+      outshiner: m["outshiner"] && decode_outshiner(m["outshiner"]),
+      overweather: m["overweather"] && decode_overweather(m["overweather"]),
+      protonegroid: m["protonegroid"] && decode_protonegroid(m["protonegroid"]),
+      shallowish: m["shallowish"] && decode_shallowish(m["shallowish"]),
+      snoke: m["snoke"] && decode_snoke(m["snoke"]),
+      snout: m["snout"] && decode_snout(m["snout"]),
+      surveillance: m["surveillance"] && decode_surveillance(m["surveillance"]),
+      threshingtime: m["threshingtime"] && decode_threshingtime(m["threshingtime"]),
+      thysanocarpus: m["Thysanocarpus"] && decode_thysanocarpus(m["Thysanocarpus"]),
+      unsignificantly: m["unsignificantly"] && decode_unsignificantly(m["unsignificantly"]),
+      unsnap: m["unsnap"] && decode_unsnap(m["unsnap"]),
+      vendible: m["vendible"] && decode_vendible(m["vendible"]),
     }
   end
 
@@ -796,57 +930,191 @@ defmodule Maslin do
           unjudiciously: nil | nil
         }
 
+  def decode_alicant(value) when is_integer(value), do: value
+  def decode_alicant(_), do: {:error, "Unexpected type when decoding Maslin.alicant"}
+
+  def encode_alicant(value) when is_integer(value), do: value
+  def encode_alicant(_), do: {:error, "Unexpected type when encoding Maslin.alicant"}
+
+  def decode_anticorrosive(value) when is_integer(value), do: value
+  def decode_anticorrosive(_), do: {:error, "Unexpected type when decoding Maslin.anticorrosive"}
+
+  def encode_anticorrosive(value) when is_integer(value), do: value
+  def encode_anticorrosive(_), do: {:error, "Unexpected type when encoding Maslin.anticorrosive"}
+
+  def decode_be(value) when is_integer(value), do: value
+  def decode_be(_), do: {:error, "Unexpected type when decoding Maslin.be"}
+
+  def encode_be(value) when is_integer(value), do: value
+  def encode_be(_), do: {:error, "Unexpected type when encoding Maslin.be"}
+
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding Maslin.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding Maslin.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding Maslin.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding Maslin.chirotherium"}
+
+  def decode_chub(value) when is_integer(value), do: value
+  def decode_chub(_), do: {:error, "Unexpected type when decoding Maslin.chub"}
+
+  def encode_chub(value) when is_integer(value), do: value
+  def encode_chub(_), do: {:error, "Unexpected type when encoding Maslin.chub"}
+
+  def decode_cuprosilicon(value) when is_integer(value), do: value
+  def decode_cuprosilicon(_), do: {:error, "Unexpected type when decoding Maslin.cuprosilicon"}
+
+  def encode_cuprosilicon(value) when is_integer(value), do: value
+  def encode_cuprosilicon(_), do: {:error, "Unexpected type when encoding Maslin.cuprosilicon"}
+
+  def decode_curtailedly(value) when is_integer(value), do: value
+  def decode_curtailedly(_), do: {:error, "Unexpected type when decoding Maslin.curtailedly"}
+
+  def encode_curtailedly(value) when is_integer(value), do: value
+  def encode_curtailedly(_), do: {:error, "Unexpected type when encoding Maslin.curtailedly"}
+
+  def decode_dellenite(value) when is_integer(value), do: value
+  def decode_dellenite(_), do: {:error, "Unexpected type when decoding Maslin.dellenite"}
+
+  def encode_dellenite(value) when is_integer(value), do: value
+  def encode_dellenite(_), do: {:error, "Unexpected type when encoding Maslin.dellenite"}
+
+  def decode_dimitry(value) when is_integer(value), do: value
+  def decode_dimitry(_), do: {:error, "Unexpected type when decoding Maslin.dimitry"}
+
+  def encode_dimitry(value) when is_integer(value), do: value
+  def encode_dimitry(_), do: {:error, "Unexpected type when encoding Maslin.dimitry"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding Maslin.disdiapason"}
 
   def encode_disdiapason(value) when is_binary(value), do: value
   def encode_disdiapason(_), do: {:error, "Unexpected type when encoding Maslin.disdiapason"}
 
+  def decode_ethmoiditis(value) when is_integer(value), do: value
+  def decode_ethmoiditis(_), do: {:error, "Unexpected type when decoding Maslin.ethmoiditis"}
+
+  def encode_ethmoiditis(value) when is_integer(value), do: value
+  def encode_ethmoiditis(_), do: {:error, "Unexpected type when encoding Maslin.ethmoiditis"}
+
+  def decode_goatherd(value) when is_integer(value), do: value
+  def decode_goatherd(_), do: {:error, "Unexpected type when decoding Maslin.goatherd"}
+
+  def encode_goatherd(value) when is_integer(value), do: value
+  def encode_goatherd(_), do: {:error, "Unexpected type when encoding Maslin.goatherd"}
+
+  def decode_hammerdress(value) when is_integer(value), do: value
+  def decode_hammerdress(_), do: {:error, "Unexpected type when decoding Maslin.hammerdress"}
+
+  def encode_hammerdress(value) when is_integer(value), do: value
+  def encode_hammerdress(_), do: {:error, "Unexpected type when encoding Maslin.hammerdress"}
+
+  def decode_lacunosity(value) when is_integer(value), do: value
+  def decode_lacunosity(_), do: {:error, "Unexpected type when decoding Maslin.lacunosity"}
+
+  def encode_lacunosity(value) when is_integer(value), do: value
+  def encode_lacunosity(_), do: {:error, "Unexpected type when encoding Maslin.lacunosity"}
+
+  def decode_mameliere(value) when is_integer(value), do: value
+  def decode_mameliere(_), do: {:error, "Unexpected type when decoding Maslin.mameliere"}
+
+  def encode_mameliere(value) when is_integer(value), do: value
+  def encode_mameliere(_), do: {:error, "Unexpected type when encoding Maslin.mameliere"}
+
+  def decode_oafishly(value) when is_integer(value), do: value
+  def decode_oafishly(_), do: {:error, "Unexpected type when decoding Maslin.oafishly"}
+
+  def encode_oafishly(value) when is_integer(value), do: value
+  def encode_oafishly(_), do: {:error, "Unexpected type when encoding Maslin.oafishly"}
+
+  def decode_saccharulmic(value) when is_integer(value), do: value
+  def decode_saccharulmic(_), do: {:error, "Unexpected type when decoding Maslin.saccharulmic"}
+
+  def encode_saccharulmic(value) when is_integer(value), do: value
+  def encode_saccharulmic(_), do: {:error, "Unexpected type when encoding Maslin.saccharulmic"}
+
+  def decode_scowlful(value) when is_integer(value), do: value
+  def decode_scowlful(_), do: {:error, "Unexpected type when decoding Maslin.scowlful"}
+
+  def encode_scowlful(value) when is_integer(value), do: value
+  def encode_scowlful(_), do: {:error, "Unexpected type when encoding Maslin.scowlful"}
+
+  def decode_sphaeridial(value) when is_integer(value), do: value
+  def decode_sphaeridial(_), do: {:error, "Unexpected type when decoding Maslin.sphaeridial"}
+
+  def encode_sphaeridial(value) when is_integer(value), do: value
+  def encode_sphaeridial(_), do: {:error, "Unexpected type when encoding Maslin.sphaeridial"}
+
+  def decode_subsecive(value) when is_integer(value), do: value
+  def decode_subsecive(_), do: {:error, "Unexpected type when decoding Maslin.subsecive"}
+
+  def encode_subsecive(value) when is_integer(value), do: value
+  def encode_subsecive(_), do: {:error, "Unexpected type when encoding Maslin.subsecive"}
+
+  def decode_trachyglossate(value) when is_integer(value), do: value
+  def decode_trachyglossate(_), do: {:error, "Unexpected type when decoding Maslin.trachyglossate"}
+
+  def encode_trachyglossate(value) when is_integer(value), do: value
+  def encode_trachyglossate(_), do: {:error, "Unexpected type when encoding Maslin.trachyglossate"}
+
+  def decode_unassuaged(value) when is_integer(value), do: value
+  def decode_unassuaged(_), do: {:error, "Unexpected type when decoding Maslin.unassuaged"}
+
+  def encode_unassuaged(value) when is_integer(value), do: value
+  def encode_unassuaged(_), do: {:error, "Unexpected type when encoding Maslin.unassuaged"}
+
   def from_map(m) do
     %Maslin{
-      alicant: m["Alicant"],
+      alicant: m["Alicant"] && decode_alicant(m["Alicant"]),
       antiatonement: m["antiatonement"],
-      anticorrosive: m["anticorrosive"],
+      anticorrosive: m["anticorrosive"] && decode_anticorrosive(m["anticorrosive"]),
       aphidozer: m["aphidozer"],
       bakuninist: m["Bakuninist"],
-      be: m["be"],
-      catharticalness: m["catharticalness"],
-      chirotherium: m["Chirotherium"],
-      chub: m["chub"],
-      cuprosilicon: m["cuprosilicon"],
-      curtailedly: m["curtailedly"],
-      dellenite: m["dellenite"],
-      dimitry: m["Dimitry"],
+      be: m["be"] && decode_be(m["be"]),
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
+      chub: m["chub"] && decode_chub(m["chub"]),
+      cuprosilicon: m["cuprosilicon"] && decode_cuprosilicon(m["cuprosilicon"]),
+      curtailedly: m["curtailedly"] && decode_curtailedly(m["curtailedly"]),
+      dellenite: m["dellenite"] && decode_dellenite(m["dellenite"]),
+      dimitry: m["Dimitry"] && decode_dimitry(m["Dimitry"]),
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
       edifying: m["edifying"],
-      ethmoiditis: m["ethmoiditis"],
+      ethmoiditis: m["ethmoiditis"] && decode_ethmoiditis(m["ethmoiditis"]),
       gastralgy: m["gastralgy"],
-      goatherd: m["goatherd"],
-      hammerdress: m["hammerdress"],
+      goatherd: m["goatherd"] && decode_goatherd(m["goatherd"]),
+      hammerdress: m["hammerdress"] && decode_hammerdress(m["hammerdress"]),
       hangfire: m["hangfire"],
       homocerc: m["homocerc"],
-      lacunosity: m["lacunosity"],
+      lacunosity: m["lacunosity"] && decode_lacunosity(m["lacunosity"]),
       longiloquence: m["longiloquence"],
-      mameliere: m["mameliere"],
+      mameliere: m["mameliere"] && decode_mameliere(m["mameliere"]),
       motherless: m["motherless"],
       nonbookish: m["nonbookish"],
       noncorrodible: m["noncorrodible"],
       nonsensicality: m["nonsensicality"],
-      oafishly: m["oafishly"],
+      oafishly: m["oafishly"] && decode_oafishly(m["oafishly"]),
       pfund: m["pfund"],
       preadvisory: m["preadvisory"],
       retroflexed: m["retroflexed"],
-      saccharulmic: m["saccharulmic"],
-      scowlful: m["scowlful"],
+      saccharulmic: m["saccharulmic"] && decode_saccharulmic(m["saccharulmic"]),
+      scowlful: m["scowlful"] && decode_scowlful(m["scowlful"]),
       secluded: m["secluded"],
       slackage: m["slackage"],
-      sphaeridial: m["sphaeridial"],
+      sphaeridial: m["sphaeridial"] && decode_sphaeridial(m["sphaeridial"]),
       spondulics: m["spondulics"],
-      subsecive: m["subsecive"],
+      subsecive: m["subsecive"] && decode_subsecive(m["subsecive"]),
       swellmobsman: m["swellmobsman"],
-      trachyglossate: m["trachyglossate"],
+      trachyglossate: m["trachyglossate"] && decode_trachyglossate(m["trachyglossate"]),
       trialogue: m["trialogue"],
-      unassuaged: m["unassuaged"],
+      unassuaged: m["unassuaged"] && decode_unassuaged(m["unassuaged"]),
       ungross: m["ungross"],
       unjudiciously: m["unjudiciously"],
     }
@@ -1023,6 +1291,20 @@ defmodule MonotheisticallyClass do
           whitestone: nil | nil
         }
 
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding MonotheisticallyClass.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding MonotheisticallyClass.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding MonotheisticallyClass.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding MonotheisticallyClass.chirotherium"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding MonotheisticallyClass.disdiapason"}
 
@@ -1032,9 +1314,9 @@ defmodule MonotheisticallyClass do
   def from_map(m) do
     %MonotheisticallyClass{
       blaspheme: m["blaspheme"],
-      catharticalness: m["catharticalness"],
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
       celiosalpingectomy: m["celiosalpingectomy"],
-      chirotherium: m["Chirotherium"],
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
       consummativeness: m["consummativeness"],
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
       egestive: m["egestive"],
@@ -1630,39 +1912,173 @@ defmodule PiaculumClass do
           zipper: integer() | nil
         }
 
+  def decode_alada(value) when is_integer(value), do: value
+  def decode_alada(_), do: {:error, "Unexpected type when decoding PiaculumClass.alada"}
+
+  def encode_alada(value) when is_integer(value), do: value
+  def encode_alada(_), do: {:error, "Unexpected type when encoding PiaculumClass.alada"}
+
+  def decode_amphistomous(value) when is_integer(value), do: value
+  def decode_amphistomous(_), do: {:error, "Unexpected type when decoding PiaculumClass.amphistomous"}
+
+  def encode_amphistomous(value) when is_integer(value), do: value
+  def encode_amphistomous(_), do: {:error, "Unexpected type when encoding PiaculumClass.amphistomous"}
+
+  def decode_boysenberry(value) when is_integer(value), do: value
+  def decode_boysenberry(_), do: {:error, "Unexpected type when decoding PiaculumClass.boysenberry"}
+
+  def encode_boysenberry(value) when is_integer(value), do: value
+  def encode_boysenberry(_), do: {:error, "Unexpected type when encoding PiaculumClass.boysenberry"}
+
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding PiaculumClass.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding PiaculumClass.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding PiaculumClass.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding PiaculumClass.chirotherium"}
+
+  def decode_decardinalize(value) when is_integer(value), do: value
+  def decode_decardinalize(_), do: {:error, "Unexpected type when decoding PiaculumClass.decardinalize"}
+
+  def encode_decardinalize(value) when is_integer(value), do: value
+  def encode_decardinalize(_), do: {:error, "Unexpected type when encoding PiaculumClass.decardinalize"}
+
+  def decode_discouragement(value) when is_integer(value), do: value
+  def decode_discouragement(_), do: {:error, "Unexpected type when decoding PiaculumClass.discouragement"}
+
+  def encode_discouragement(value) when is_integer(value), do: value
+  def encode_discouragement(_), do: {:error, "Unexpected type when encoding PiaculumClass.discouragement"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding PiaculumClass.disdiapason"}
 
   def encode_disdiapason(value) when is_binary(value), do: value
   def encode_disdiapason(_), do: {:error, "Unexpected type when encoding PiaculumClass.disdiapason"}
 
+  def decode_doitrified(value) when is_integer(value), do: value
+  def decode_doitrified(_), do: {:error, "Unexpected type when decoding PiaculumClass.doitrified"}
+
+  def encode_doitrified(value) when is_integer(value), do: value
+  def encode_doitrified(_), do: {:error, "Unexpected type when encoding PiaculumClass.doitrified"}
+
+  def decode_hexaspermous(value) when is_integer(value), do: value
+  def decode_hexaspermous(_), do: {:error, "Unexpected type when decoding PiaculumClass.hexaspermous"}
+
+  def encode_hexaspermous(value) when is_integer(value), do: value
+  def encode_hexaspermous(_), do: {:error, "Unexpected type when encoding PiaculumClass.hexaspermous"}
+
+  def decode_insinking(value) when is_integer(value), do: value
+  def decode_insinking(_), do: {:error, "Unexpected type when decoding PiaculumClass.insinking"}
+
+  def encode_insinking(value) when is_integer(value), do: value
+  def encode_insinking(_), do: {:error, "Unexpected type when encoding PiaculumClass.insinking"}
+
+  def decode_loathfulness(value) when is_integer(value), do: value
+  def decode_loathfulness(_), do: {:error, "Unexpected type when decoding PiaculumClass.loathfulness"}
+
+  def encode_loathfulness(value) when is_integer(value), do: value
+  def encode_loathfulness(_), do: {:error, "Unexpected type when encoding PiaculumClass.loathfulness"}
+
+  def decode_miasmatical(value) when is_integer(value), do: value
+  def decode_miasmatical(_), do: {:error, "Unexpected type when decoding PiaculumClass.miasmatical"}
+
+  def encode_miasmatical(value) when is_integer(value), do: value
+  def encode_miasmatical(_), do: {:error, "Unexpected type when encoding PiaculumClass.miasmatical"}
+
+  def decode_neurofibril(value) when is_integer(value), do: value
+  def decode_neurofibril(_), do: {:error, "Unexpected type when decoding PiaculumClass.neurofibril"}
+
+  def encode_neurofibril(value) when is_integer(value), do: value
+  def encode_neurofibril(_), do: {:error, "Unexpected type when encoding PiaculumClass.neurofibril"}
+
+  def decode_phonendoscope(value) when is_integer(value), do: value
+  def decode_phonendoscope(_), do: {:error, "Unexpected type when decoding PiaculumClass.phonendoscope"}
+
+  def encode_phonendoscope(value) when is_integer(value), do: value
+  def encode_phonendoscope(_), do: {:error, "Unexpected type when encoding PiaculumClass.phonendoscope"}
+
+  def decode_pilferment(value) when is_integer(value), do: value
+  def decode_pilferment(_), do: {:error, "Unexpected type when decoding PiaculumClass.pilferment"}
+
+  def encode_pilferment(value) when is_integer(value), do: value
+  def encode_pilferment(_), do: {:error, "Unexpected type when encoding PiaculumClass.pilferment"}
+
+  def decode_predismissory(value) when is_integer(value), do: value
+  def decode_predismissory(_), do: {:error, "Unexpected type when decoding PiaculumClass.predismissory"}
+
+  def encode_predismissory(value) when is_integer(value), do: value
+  def encode_predismissory(_), do: {:error, "Unexpected type when encoding PiaculumClass.predismissory"}
+
+  def decode_preinscription(value) when is_integer(value), do: value
+  def decode_preinscription(_), do: {:error, "Unexpected type when decoding PiaculumClass.preinscription"}
+
+  def encode_preinscription(value) when is_integer(value), do: value
+  def encode_preinscription(_), do: {:error, "Unexpected type when encoding PiaculumClass.preinscription"}
+
+  def decode_quotative(value) when is_integer(value), do: value
+  def decode_quotative(_), do: {:error, "Unexpected type when decoding PiaculumClass.quotative"}
+
+  def encode_quotative(value) when is_integer(value), do: value
+  def encode_quotative(_), do: {:error, "Unexpected type when encoding PiaculumClass.quotative"}
+
+  def decode_sienna(value) when is_integer(value), do: value
+  def decode_sienna(_), do: {:error, "Unexpected type when decoding PiaculumClass.sienna"}
+
+  def encode_sienna(value) when is_integer(value), do: value
+  def encode_sienna(_), do: {:error, "Unexpected type when encoding PiaculumClass.sienna"}
+
+  def decode_thorax(value) when is_integer(value), do: value
+  def decode_thorax(_), do: {:error, "Unexpected type when decoding PiaculumClass.thorax"}
+
+  def encode_thorax(value) when is_integer(value), do: value
+  def encode_thorax(_), do: {:error, "Unexpected type when encoding PiaculumClass.thorax"}
+
+  def decode_yachting(value) when is_integer(value), do: value
+  def decode_yachting(_), do: {:error, "Unexpected type when decoding PiaculumClass.yachting"}
+
+  def encode_yachting(value) when is_integer(value), do: value
+  def encode_yachting(_), do: {:error, "Unexpected type when encoding PiaculumClass.yachting"}
+
+  def decode_zipper(value) when is_integer(value), do: value
+  def decode_zipper(_), do: {:error, "Unexpected type when decoding PiaculumClass.zipper"}
+
+  def encode_zipper(value) when is_integer(value), do: value
+  def encode_zipper(_), do: {:error, "Unexpected type when encoding PiaculumClass.zipper"}
+
   def from_map(m) do
     %PiaculumClass{
-      alada: m["alada"],
-      amphistomous: m["amphistomous"],
-      boysenberry: m["boysenberry"],
-      catharticalness: m["catharticalness"],
-      chirotherium: m["Chirotherium"],
-      decardinalize: m["decardinalize"],
-      discouragement: m["discouragement"],
+      alada: m["alada"] && decode_alada(m["alada"]),
+      amphistomous: m["amphistomous"] && decode_amphistomous(m["amphistomous"]),
+      boysenberry: m["boysenberry"] && decode_boysenberry(m["boysenberry"]),
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
+      decardinalize: m["decardinalize"] && decode_decardinalize(m["decardinalize"]),
+      discouragement: m["discouragement"] && decode_discouragement(m["discouragement"]),
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
-      doitrified: m["doitrified"],
-      hexaspermous: m["hexaspermous"],
+      doitrified: m["doitrified"] && decode_doitrified(m["doitrified"]),
+      hexaspermous: m["hexaspermous"] && decode_hexaspermous(m["hexaspermous"]),
       homocerc: m["homocerc"],
-      insinking: m["insinking"],
-      loathfulness: m["loathfulness"],
-      miasmatical: m["miasmatical"],
-      neurofibril: m["neurofibril"],
+      insinking: m["insinking"] && decode_insinking(m["insinking"]),
+      loathfulness: m["loathfulness"] && decode_loathfulness(m["loathfulness"]),
+      miasmatical: m["miasmatical"] && decode_miasmatical(m["miasmatical"]),
+      neurofibril: m["neurofibril"] && decode_neurofibril(m["neurofibril"]),
       nonbookish: m["nonbookish"],
-      phonendoscope: m["phonendoscope"],
-      pilferment: m["pilferment"],
-      predismissory: m["predismissory"],
-      preinscription: m["preinscription"],
-      quotative: m["quotative"],
-      sienna: m["sienna"],
-      thorax: m["thorax"],
-      yachting: m["yachting"],
-      zipper: m["Zipper"],
+      phonendoscope: m["phonendoscope"] && decode_phonendoscope(m["phonendoscope"]),
+      pilferment: m["pilferment"] && decode_pilferment(m["pilferment"]),
+      predismissory: m["predismissory"] && decode_predismissory(m["predismissory"]),
+      preinscription: m["preinscription"] && decode_preinscription(m["preinscription"]),
+      quotative: m["quotative"] && decode_quotative(m["quotative"]),
+      sienna: m["sienna"] && decode_sienna(m["sienna"]),
+      thorax: m["thorax"] && decode_thorax(m["thorax"]),
+      yachting: m["yachting"] && decode_yachting(m["yachting"]),
+      zipper: m["Zipper"] && decode_zipper(m["Zipper"]),
     }
   end
 
@@ -1740,6 +2156,20 @@ defmodule Pneumocele do
           visitorial: nil | nil
         }
 
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding Pneumocele.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding Pneumocele.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding Pneumocele.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding Pneumocele.chirotherium"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding Pneumocele.disdiapason"}
 
@@ -1749,8 +2179,8 @@ defmodule Pneumocele do
   def from_map(m) do
     %Pneumocele{
       carbonarism: m["Carbonarism"],
-      catharticalness: m["catharticalness"],
-      chirotherium: m["Chirotherium"],
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
       cineolic: m["cineolic"],
       cobbly: m["cobbly"],
       conchyliferous: m["conchyliferous"],
diff --git a/base/elixir/test/inputs/json/priority/combinations4.json/default/QuickType.ex b/head/elixir/test/inputs/json/priority/combinations4.json/default/QuickType.ex
index 323ed8a..16848d2 100644
--- a/base/elixir/test/inputs/json/priority/combinations4.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/priority/combinations4.json/default/QuickType.ex
@@ -533,6 +533,20 @@ defmodule Reimagine do
           waltzlike: nil | nil
         }
 
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding Reimagine.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding Reimagine.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding Reimagine.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding Reimagine.chirotherium"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding Reimagine.disdiapason"}
 
@@ -544,8 +558,8 @@ defmodule Reimagine do
       adducible: m["adducible"],
       anabolin: m["anabolin"],
       brainy: m["brainy"],
-      catharticalness: m["catharticalness"],
-      chirotherium: m["Chirotherium"],
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
       chrysamine: m["chrysamine"],
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
       fluxweed: m["fluxweed"],
@@ -1273,6 +1287,20 @@ defmodule SaxtenClass do
           withdrawnness: nil | nil
         }
 
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding SaxtenClass.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding SaxtenClass.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding SaxtenClass.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding SaxtenClass.chirotherium"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding SaxtenClass.disdiapason"}
 
@@ -1283,9 +1311,9 @@ defmodule SaxtenClass do
     %SaxtenClass{
       algarrobilla: m["algarrobilla"],
       bowgrace: m["bowgrace"],
-      catharticalness: m["catharticalness"],
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
       centaurid: m["Centaurid"],
-      chirotherium: m["Chirotherium"],
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
       flix: m["flix"],
       germanely: m["germanely"],
@@ -1803,39 +1831,173 @@ defmodule Staghunting do
           ungirlish: integer() | nil
         }
 
+  def decode_calorimetric(value) when is_integer(value), do: value
+  def decode_calorimetric(_), do: {:error, "Unexpected type when decoding Staghunting.calorimetric"}
+
+  def encode_calorimetric(value) when is_integer(value), do: value
+  def encode_calorimetric(_), do: {:error, "Unexpected type when encoding Staghunting.calorimetric"}
+
+  def decode_canid(value) when is_integer(value), do: value
+  def decode_canid(_), do: {:error, "Unexpected type when decoding Staghunting.canid"}
+
+  def encode_canid(value) when is_integer(value), do: value
+  def encode_canid(_), do: {:error, "Unexpected type when encoding Staghunting.canid"}
+
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding Staghunting.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding Staghunting.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding Staghunting.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding Staghunting.chirotherium"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding Staghunting.disdiapason"}
 
   def encode_disdiapason(value) when is_binary(value), do: value
   def encode_disdiapason(_), do: {:error, "Unexpected type when encoding Staghunting.disdiapason"}
 
+  def decode_ditriglyphic(value) when is_integer(value), do: value
+  def decode_ditriglyphic(_), do: {:error, "Unexpected type when decoding Staghunting.ditriglyphic"}
+
+  def encode_ditriglyphic(value) when is_integer(value), do: value
+  def encode_ditriglyphic(_), do: {:error, "Unexpected type when encoding Staghunting.ditriglyphic"}
+
+  def decode_floriferousness(value) when is_integer(value), do: value
+  def decode_floriferousness(_), do: {:error, "Unexpected type when decoding Staghunting.floriferousness"}
+
+  def encode_floriferousness(value) when is_integer(value), do: value
+  def encode_floriferousness(_), do: {:error, "Unexpected type when encoding Staghunting.floriferousness"}
+
+  def decode_gamelike(value) when is_integer(value), do: value
+  def decode_gamelike(_), do: {:error, "Unexpected type when decoding Staghunting.gamelike"}
+
+  def encode_gamelike(value) when is_integer(value), do: value
+  def encode_gamelike(_), do: {:error, "Unexpected type when encoding Staghunting.gamelike"}
+
+  def decode_grig(value) when is_integer(value), do: value
+  def decode_grig(_), do: {:error, "Unexpected type when decoding Staghunting.grig"}
+
+  def encode_grig(value) when is_integer(value), do: value
+  def encode_grig(_), do: {:error, "Unexpected type when encoding Staghunting.grig"}
+
+  def decode_interloan(value) when is_integer(value), do: value
+  def decode_interloan(_), do: {:error, "Unexpected type when decoding Staghunting.interloan"}
+
+  def encode_interloan(value) when is_integer(value), do: value
+  def encode_interloan(_), do: {:error, "Unexpected type when encoding Staghunting.interloan"}
+
+  def decode_lithotomy(value) when is_integer(value), do: value
+  def decode_lithotomy(_), do: {:error, "Unexpected type when decoding Staghunting.lithotomy"}
+
+  def encode_lithotomy(value) when is_integer(value), do: value
+  def encode_lithotomy(_), do: {:error, "Unexpected type when encoding Staghunting.lithotomy"}
+
+  def decode_loric(value) when is_integer(value), do: value
+  def decode_loric(_), do: {:error, "Unexpected type when decoding Staghunting.loric"}
+
+  def encode_loric(value) when is_integer(value), do: value
+  def encode_loric(_), do: {:error, "Unexpected type when encoding Staghunting.loric"}
+
+  def decode_membranocoriaceous(value) when is_integer(value), do: value
+  def decode_membranocoriaceous(_), do: {:error, "Unexpected type when decoding Staghunting.membranocoriaceous"}
+
+  def encode_membranocoriaceous(value) when is_integer(value), do: value
+  def encode_membranocoriaceous(_), do: {:error, "Unexpected type when encoding Staghunting.membranocoriaceous"}
+
+  def decode_membranogenic(value) when is_integer(value), do: value
+  def decode_membranogenic(_), do: {:error, "Unexpected type when decoding Staghunting.membranogenic"}
+
+  def encode_membranogenic(value) when is_integer(value), do: value
+  def encode_membranogenic(_), do: {:error, "Unexpected type when encoding Staghunting.membranogenic"}
+
+  def decode_overtrump(value) when is_integer(value), do: value
+  def decode_overtrump(_), do: {:error, "Unexpected type when decoding Staghunting.overtrump"}
+
+  def encode_overtrump(value) when is_integer(value), do: value
+  def encode_overtrump(_), do: {:error, "Unexpected type when encoding Staghunting.overtrump"}
+
+  def decode_scotino(value) when is_integer(value), do: value
+  def decode_scotino(_), do: {:error, "Unexpected type when decoding Staghunting.scotino"}
+
+  def encode_scotino(value) when is_integer(value), do: value
+  def encode_scotino(_), do: {:error, "Unexpected type when encoding Staghunting.scotino"}
+
+  def decode_seasonable(value) when is_integer(value), do: value
+  def decode_seasonable(_), do: {:error, "Unexpected type when decoding Staghunting.seasonable"}
+
+  def encode_seasonable(value) when is_integer(value), do: value
+  def encode_seasonable(_), do: {:error, "Unexpected type when encoding Staghunting.seasonable"}
+
+  def decode_sephen(value) when is_integer(value), do: value
+  def decode_sephen(_), do: {:error, "Unexpected type when decoding Staghunting.sephen"}
+
+  def encode_sephen(value) when is_integer(value), do: value
+  def encode_sephen(_), do: {:error, "Unexpected type when encoding Staghunting.sephen"}
+
+  def decode_stigmarioid(value) when is_integer(value), do: value
+  def decode_stigmarioid(_), do: {:error, "Unexpected type when decoding Staghunting.stigmarioid"}
+
+  def encode_stigmarioid(value) when is_integer(value), do: value
+  def encode_stigmarioid(_), do: {:error, "Unexpected type when encoding Staghunting.stigmarioid"}
+
+  def decode_tired(value) when is_integer(value), do: value
+  def decode_tired(_), do: {:error, "Unexpected type when decoding Staghunting.tired"}
+
+  def encode_tired(value) when is_integer(value), do: value
+  def encode_tired(_), do: {:error, "Unexpected type when encoding Staghunting.tired"}
+
+  def decode_trifid(value) when is_integer(value), do: value
+  def decode_trifid(_), do: {:error, "Unexpected type when decoding Staghunting.trifid"}
+
+  def encode_trifid(value) when is_integer(value), do: value
+  def encode_trifid(_), do: {:error, "Unexpected type when encoding Staghunting.trifid"}
+
+  def decode_undefeatedly(value) when is_integer(value), do: value
+  def decode_undefeatedly(_), do: {:error, "Unexpected type when decoding Staghunting.undefeatedly"}
+
+  def encode_undefeatedly(value) when is_integer(value), do: value
+  def encode_undefeatedly(_), do: {:error, "Unexpected type when encoding Staghunting.undefeatedly"}
+
+  def decode_ungirlish(value) when is_integer(value), do: value
+  def decode_ungirlish(_), do: {:error, "Unexpected type when decoding Staghunting.ungirlish"}
+
+  def encode_ungirlish(value) when is_integer(value), do: value
+  def encode_ungirlish(_), do: {:error, "Unexpected type when encoding Staghunting.ungirlish"}
+
   def from_map(m) do
     %Staghunting{
-      calorimetric: m["calorimetric"],
-      canid: m["canid"],
-      catharticalness: m["catharticalness"],
-      chirotherium: m["Chirotherium"],
+      calorimetric: m["calorimetric"] && decode_calorimetric(m["calorimetric"]),
+      canid: m["canid"] && decode_canid(m["canid"]),
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
-      ditriglyphic: m["ditriglyphic"],
-      floriferousness: m["floriferousness"],
-      gamelike: m["gamelike"],
-      grig: m["grig"],
+      ditriglyphic: m["ditriglyphic"] && decode_ditriglyphic(m["ditriglyphic"]),
+      floriferousness: m["floriferousness"] && decode_floriferousness(m["floriferousness"]),
+      gamelike: m["gamelike"] && decode_gamelike(m["gamelike"]),
+      grig: m["grig"] && decode_grig(m["grig"]),
       homocerc: m["homocerc"],
-      interloan: m["interloan"],
-      lithotomy: m["lithotomy"],
-      loric: m["loric"],
-      membranocoriaceous: m["membranocoriaceous"],
-      membranogenic: m["membranogenic"],
+      interloan: m["interloan"] && decode_interloan(m["interloan"]),
+      lithotomy: m["lithotomy"] && decode_lithotomy(m["lithotomy"]),
+      loric: m["loric"] && decode_loric(m["loric"]),
+      membranocoriaceous: m["membranocoriaceous"] && decode_membranocoriaceous(m["membranocoriaceous"]),
+      membranogenic: m["membranogenic"] && decode_membranogenic(m["membranogenic"]),
       nonbookish: m["nonbookish"],
-      overtrump: m["overtrump"],
-      scotino: m["scotino"],
-      seasonable: m["seasonable"],
-      sephen: m["sephen"],
-      stigmarioid: m["stigmarioid"],
-      tired: m["tired"],
-      trifid: m["trifid"],
-      undefeatedly: m["undefeatedly"],
-      ungirlish: m["ungirlish"],
+      overtrump: m["overtrump"] && decode_overtrump(m["overtrump"]),
+      scotino: m["scotino"] && decode_scotino(m["scotino"]),
+      seasonable: m["seasonable"] && decode_seasonable(m["seasonable"]),
+      sephen: m["sephen"] && decode_sephen(m["sephen"]),
+      stigmarioid: m["stigmarioid"] && decode_stigmarioid(m["stigmarioid"]),
+      tired: m["tired"] && decode_tired(m["tired"]),
+      trifid: m["trifid"] && decode_trifid(m["trifid"]),
+      undefeatedly: m["undefeatedly"] && decode_undefeatedly(m["undefeatedly"]),
+      ungirlish: m["ungirlish"] && decode_ungirlish(m["ungirlish"]),
     }
   end
 
@@ -1913,39 +2075,173 @@ defmodule StrenuosityClass do
           yankeeist: integer() | nil
         }
 
+  def decode_bliss(value) when is_integer(value), do: value
+  def decode_bliss(_), do: {:error, "Unexpected type when decoding StrenuosityClass.bliss"}
+
+  def encode_bliss(value) when is_integer(value), do: value
+  def encode_bliss(_), do: {:error, "Unexpected type when encoding StrenuosityClass.bliss"}
+
+  def decode_buccate(value) when is_integer(value), do: value
+  def decode_buccate(_), do: {:error, "Unexpected type when decoding StrenuosityClass.buccate"}
+
+  def encode_buccate(value) when is_integer(value), do: value
+  def encode_buccate(_), do: {:error, "Unexpected type when encoding StrenuosityClass.buccate"}
+
+  def decode_bulletproof(value) when is_integer(value), do: value
+  def decode_bulletproof(_), do: {:error, "Unexpected type when decoding StrenuosityClass.bulletproof"}
+
+  def encode_bulletproof(value) when is_integer(value), do: value
+  def encode_bulletproof(_), do: {:error, "Unexpected type when encoding StrenuosityClass.bulletproof"}
+
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding StrenuosityClass.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding StrenuosityClass.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding StrenuosityClass.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding StrenuosityClass.chirotherium"}
+
+  def decode_crumblingness(value) when is_integer(value), do: value
+  def decode_crumblingness(_), do: {:error, "Unexpected type when decoding StrenuosityClass.crumblingness"}
+
+  def encode_crumblingness(value) when is_integer(value), do: value
+  def encode_crumblingness(_), do: {:error, "Unexpected type when encoding StrenuosityClass.crumblingness"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding StrenuosityClass.disdiapason"}
 
   def encode_disdiapason(value) when is_binary(value), do: value
   def encode_disdiapason(_), do: {:error, "Unexpected type when encoding StrenuosityClass.disdiapason"}
 
+  def decode_engagedly(value) when is_integer(value), do: value
+  def decode_engagedly(_), do: {:error, "Unexpected type when decoding StrenuosityClass.engagedly"}
+
+  def encode_engagedly(value) when is_integer(value), do: value
+  def encode_engagedly(_), do: {:error, "Unexpected type when encoding StrenuosityClass.engagedly"}
+
+  def decode_fightable(value) when is_integer(value), do: value
+  def decode_fightable(_), do: {:error, "Unexpected type when decoding StrenuosityClass.fightable"}
+
+  def encode_fightable(value) when is_integer(value), do: value
+  def encode_fightable(_), do: {:error, "Unexpected type when encoding StrenuosityClass.fightable"}
+
+  def decode_hoariness(value) when is_integer(value), do: value
+  def decode_hoariness(_), do: {:error, "Unexpected type when decoding StrenuosityClass.hoariness"}
+
+  def encode_hoariness(value) when is_integer(value), do: value
+  def encode_hoariness(_), do: {:error, "Unexpected type when encoding StrenuosityClass.hoariness"}
+
+  def decode_hypopodium(value) when is_integer(value), do: value
+  def decode_hypopodium(_), do: {:error, "Unexpected type when decoding StrenuosityClass.hypopodium"}
+
+  def encode_hypopodium(value) when is_integer(value), do: value
+  def encode_hypopodium(_), do: {:error, "Unexpected type when encoding StrenuosityClass.hypopodium"}
+
+  def decode_luxurist(value) when is_integer(value), do: value
+  def decode_luxurist(_), do: {:error, "Unexpected type when decoding StrenuosityClass.luxurist"}
+
+  def encode_luxurist(value) when is_integer(value), do: value
+  def encode_luxurist(_), do: {:error, "Unexpected type when encoding StrenuosityClass.luxurist"}
+
+  def decode_mechanician(value) when is_integer(value), do: value
+  def decode_mechanician(_), do: {:error, "Unexpected type when decoding StrenuosityClass.mechanician"}
+
+  def encode_mechanician(value) when is_integer(value), do: value
+  def encode_mechanician(_), do: {:error, "Unexpected type when encoding StrenuosityClass.mechanician"}
+
+  def decode_onopordon(value) when is_integer(value), do: value
+  def decode_onopordon(_), do: {:error, "Unexpected type when decoding StrenuosityClass.onopordon"}
+
+  def encode_onopordon(value) when is_integer(value), do: value
+  def encode_onopordon(_), do: {:error, "Unexpected type when encoding StrenuosityClass.onopordon"}
+
+  def decode_podgily(value) when is_integer(value), do: value
+  def decode_podgily(_), do: {:error, "Unexpected type when decoding StrenuosityClass.podgily"}
+
+  def encode_podgily(value) when is_integer(value), do: value
+  def encode_podgily(_), do: {:error, "Unexpected type when encoding StrenuosityClass.podgily"}
+
+  def decode_reformableness(value) when is_integer(value), do: value
+  def decode_reformableness(_), do: {:error, "Unexpected type when decoding StrenuosityClass.reformableness"}
+
+  def encode_reformableness(value) when is_integer(value), do: value
+  def encode_reformableness(_), do: {:error, "Unexpected type when encoding StrenuosityClass.reformableness"}
+
+  def decode_scatterbrains(value) when is_integer(value), do: value
+  def decode_scatterbrains(_), do: {:error, "Unexpected type when decoding StrenuosityClass.scatterbrains"}
+
+  def encode_scatterbrains(value) when is_integer(value), do: value
+  def encode_scatterbrains(_), do: {:error, "Unexpected type when encoding StrenuosityClass.scatterbrains"}
+
+  def decode_seminuria(value) when is_integer(value), do: value
+  def decode_seminuria(_), do: {:error, "Unexpected type when decoding StrenuosityClass.seminuria"}
+
+  def encode_seminuria(value) when is_integer(value), do: value
+  def encode_seminuria(_), do: {:error, "Unexpected type when encoding StrenuosityClass.seminuria"}
+
+  def decode_sodomite(value) when is_integer(value), do: value
+  def decode_sodomite(_), do: {:error, "Unexpected type when decoding StrenuosityClass.sodomite"}
+
+  def encode_sodomite(value) when is_integer(value), do: value
+  def encode_sodomite(_), do: {:error, "Unexpected type when encoding StrenuosityClass.sodomite"}
+
+  def decode_tramp(value) when is_integer(value), do: value
+  def decode_tramp(_), do: {:error, "Unexpected type when decoding StrenuosityClass.tramp"}
+
+  def encode_tramp(value) when is_integer(value), do: value
+  def encode_tramp(_), do: {:error, "Unexpected type when encoding StrenuosityClass.tramp"}
+
+  def decode_undueness(value) when is_integer(value), do: value
+  def decode_undueness(_), do: {:error, "Unexpected type when decoding StrenuosityClass.undueness"}
+
+  def encode_undueness(value) when is_integer(value), do: value
+  def encode_undueness(_), do: {:error, "Unexpected type when encoding StrenuosityClass.undueness"}
+
+  def decode_worthily(value) when is_integer(value), do: value
+  def decode_worthily(_), do: {:error, "Unexpected type when decoding StrenuosityClass.worthily"}
+
+  def encode_worthily(value) when is_integer(value), do: value
+  def encode_worthily(_), do: {:error, "Unexpected type when encoding StrenuosityClass.worthily"}
+
+  def decode_yankeeist(value) when is_integer(value), do: value
+  def decode_yankeeist(_), do: {:error, "Unexpected type when decoding StrenuosityClass.yankeeist"}
+
+  def encode_yankeeist(value) when is_integer(value), do: value
+  def encode_yankeeist(_), do: {:error, "Unexpected type when encoding StrenuosityClass.yankeeist"}
+
   def from_map(m) do
     %StrenuosityClass{
-      bliss: m["bliss"],
-      buccate: m["buccate"],
-      bulletproof: m["bulletproof"],
-      catharticalness: m["catharticalness"],
-      chirotherium: m["Chirotherium"],
-      crumblingness: m["crumblingness"],
+      bliss: m["bliss"] && decode_bliss(m["bliss"]),
+      buccate: m["buccate"] && decode_buccate(m["buccate"]),
+      bulletproof: m["bulletproof"] && decode_bulletproof(m["bulletproof"]),
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
+      crumblingness: m["crumblingness"] && decode_crumblingness(m["crumblingness"]),
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
-      engagedly: m["engagedly"],
-      fightable: m["fightable"],
-      hoariness: m["hoariness"],
+      engagedly: m["engagedly"] && decode_engagedly(m["engagedly"]),
+      fightable: m["fightable"] && decode_fightable(m["fightable"]),
+      hoariness: m["hoariness"] && decode_hoariness(m["hoariness"]),
       homocerc: m["homocerc"],
-      hypopodium: m["hypopodium"],
-      luxurist: m["luxurist"],
-      mechanician: m["mechanician"],
+      hypopodium: m["hypopodium"] && decode_hypopodium(m["hypopodium"]),
+      luxurist: m["luxurist"] && decode_luxurist(m["luxurist"]),
+      mechanician: m["mechanician"] && decode_mechanician(m["mechanician"]),
       nonbookish: m["nonbookish"],
-      onopordon: m["Onopordon"],
-      podgily: m["podgily"],
-      reformableness: m["reformableness"],
-      scatterbrains: m["scatterbrains"],
-      seminuria: m["seminuria"],
-      sodomite: m["Sodomite"],
-      tramp: m["tramp"],
-      undueness: m["undueness"],
-      worthily: m["worthily"],
-      yankeeist: m["Yankeeist"],
+      onopordon: m["Onopordon"] && decode_onopordon(m["Onopordon"]),
+      podgily: m["podgily"] && decode_podgily(m["podgily"]),
+      reformableness: m["reformableness"] && decode_reformableness(m["reformableness"]),
+      scatterbrains: m["scatterbrains"] && decode_scatterbrains(m["scatterbrains"]),
+      seminuria: m["seminuria"] && decode_seminuria(m["seminuria"]),
+      sodomite: m["Sodomite"] && decode_sodomite(m["Sodomite"]),
+      tramp: m["tramp"] && decode_tramp(m["tramp"]),
+      undueness: m["undueness"] && decode_undueness(m["undueness"]),
+      worthily: m["worthily"] && decode_worthily(m["worthily"]),
+      yankeeist: m["Yankeeist"] && decode_yankeeist(m["Yankeeist"]),
     }
   end
 
@@ -2023,6 +2319,20 @@ defmodule TruantcyClass do
           yuman: nil | nil
         }
 
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding TruantcyClass.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding TruantcyClass.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding TruantcyClass.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding TruantcyClass.chirotherium"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding TruantcyClass.disdiapason"}
 
@@ -2034,9 +2344,9 @@ defmodule TruantcyClass do
       alfiona: m["alfiona"],
       ascaridiasis: m["ascaridiasis"],
       bungey: m["bungey"],
-      catharticalness: m["catharticalness"],
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
       ceroxyle: m["ceroxyle"],
-      chirotherium: m["Chirotherium"],
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
       chorology: m["chorology"],
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
       enmarble: m["enmarble"],
@@ -2133,39 +2443,173 @@ defmodule UnimpeachablyClass do
           unsuggestedness: integer() | nil
         }
 
+  def decode_acerin(value) when is_integer(value), do: value
+  def decode_acerin(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.acerin"}
+
+  def encode_acerin(value) when is_integer(value), do: value
+  def encode_acerin(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.acerin"}
+
+  def decode_bobadil(value) when is_integer(value), do: value
+  def decode_bobadil(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.bobadil"}
+
+  def encode_bobadil(value) when is_integer(value), do: value
+  def encode_bobadil(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.bobadil"}
+
+  def decode_catharticalness(value) when is_float(value), do: value
+  def decode_catharticalness(value) when is_integer(value), do: value
+  def decode_catharticalness(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.catharticalness"}
+
+  def encode_catharticalness(value) when is_float(value), do: value
+  def encode_catharticalness(value) when is_integer(value), do: value
+  def encode_catharticalness(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.catharticalness"}
+
+  def decode_chirotherium(value) when is_integer(value), do: value
+  def decode_chirotherium(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.chirotherium"}
+
+  def encode_chirotherium(value) when is_integer(value), do: value
+  def encode_chirotherium(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.chirotherium"}
+
+  def decode_chlorophylligenous(value) when is_integer(value), do: value
+  def decode_chlorophylligenous(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.chlorophylligenous"}
+
+  def encode_chlorophylligenous(value) when is_integer(value), do: value
+  def encode_chlorophylligenous(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.chlorophylligenous"}
+
+  def decode_conversational(value) when is_integer(value), do: value
+  def decode_conversational(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.conversational"}
+
+  def encode_conversational(value) when is_integer(value), do: value
+  def encode_conversational(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.conversational"}
+
+  def decode_demiowl(value) when is_integer(value), do: value
+  def decode_demiowl(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.demiowl"}
+
+  def encode_demiowl(value) when is_integer(value), do: value
+  def encode_demiowl(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.demiowl"}
+
   def decode_disdiapason(value) when is_binary(value), do: value
   def decode_disdiapason(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.disdiapason"}
 
   def encode_disdiapason(value) when is_binary(value), do: value
   def encode_disdiapason(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.disdiapason"}
 
+  def decode_ectorhinal(value) when is_integer(value), do: value
+  def decode_ectorhinal(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.ectorhinal"}
+
+  def encode_ectorhinal(value) when is_integer(value), do: value
+  def encode_ectorhinal(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.ectorhinal"}
+
+  def decode_gamblesomeness(value) when is_integer(value), do: value
+  def decode_gamblesomeness(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.gamblesomeness"}
+
+  def encode_gamblesomeness(value) when is_integer(value), do: value
+  def encode_gamblesomeness(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.gamblesomeness"}
+
+  def decode_irrorate(value) when is_integer(value), do: value
+  def decode_irrorate(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.irrorate"}
+
+  def encode_irrorate(value) when is_integer(value), do: value
+  def encode_irrorate(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.irrorate"}
+
+  def decode_kindergartening(value) when is_integer(value), do: value
+  def decode_kindergartening(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.kindergartening"}
+
+  def encode_kindergartening(value) when is_integer(value), do: value
+  def encode_kindergartening(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.kindergartening"}
+
+  def decode_lateritic(value) when is_integer(value), do: value
+  def decode_lateritic(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.lateritic"}
+
+  def encode_lateritic(value) when is_integer(value), do: value
+  def encode_lateritic(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.lateritic"}
+
+  def decode_mespil(value) when is_integer(value), do: value
+  def decode_mespil(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.mespil"}
+
+  def encode_mespil(value) when is_integer(value), do: value
+  def encode_mespil(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.mespil"}
+
+  def decode_misconfiguration(value) when is_integer(value), do: value
+  def decode_misconfiguration(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.misconfiguration"}
+
+  def encode_misconfiguration(value) when is_integer(value), do: value
+  def encode_misconfiguration(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.misconfiguration"}
+
+  def decode_planometry(value) when is_integer(value), do: value
+  def decode_planometry(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.planometry"}
+
+  def encode_planometry(value) when is_integer(value), do: value
+  def encode_planometry(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.planometry"}
+
+  def decode_quiina(value) when is_integer(value), do: value
+  def decode_quiina(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.quiina"}
+
+  def encode_quiina(value) when is_integer(value), do: value
+  def encode_quiina(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.quiina"}
+
+  def decode_robert(value) when is_integer(value), do: value
+  def decode_robert(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.robert"}
+
+  def encode_robert(value) when is_integer(value), do: value
+  def encode_robert(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.robert"}
+
+  def decode_rot(value) when is_integer(value), do: value
+  def decode_rot(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.rot"}
+
+  def encode_rot(value) when is_integer(value), do: value
+  def encode_rot(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.rot"}
+
+  def decode_subcinctorium(value) when is_integer(value), do: value
+  def decode_subcinctorium(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.subcinctorium"}
+
+  def encode_subcinctorium(value) when is_integer(value), do: value
+  def encode_subcinctorium(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.subcinctorium"}
+
+  def decode_tussocker(value) when is_integer(value), do: value
+  def decode_tussocker(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.tussocker"}
+
+  def encode_tussocker(value) when is_integer(value), do: value
+  def encode_tussocker(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.tussocker"}
+
+  def decode_ultraproud(value) when is_integer(value), do: value
+  def decode_ultraproud(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.ultraproud"}
+
+  def encode_ultraproud(value) when is_integer(value), do: value
+  def encode_ultraproud(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.ultraproud"}
+
+  def decode_unsuggestedness(value) when is_integer(value), do: value
+  def decode_unsuggestedness(_), do: {:error, "Unexpected type when decoding UnimpeachablyClass.unsuggestedness"}
+
+  def encode_unsuggestedness(value) when is_integer(value), do: value
+  def encode_unsuggestedness(_), do: {:error, "Unexpected type when encoding UnimpeachablyClass.unsuggestedness"}
+
   def from_map(m) do
     %UnimpeachablyClass{
-      acerin: m["acerin"],
-      bobadil: m["Bobadil"],
-      catharticalness: m["catharticalness"],
-      chirotherium: m["Chirotherium"],
-      chlorophylligenous: m["chlorophylligenous"],
-      conversational: m["conversational"],
-      demiowl: m["demiowl"],
+      acerin: m["acerin"] && decode_acerin(m["acerin"]),
+      bobadil: m["Bobadil"] && decode_bobadil(m["Bobadil"]),
+      catharticalness: m["catharticalness"] && decode_catharticalness(m["catharticalness"]),
+      chirotherium: m["Chirotherium"] && decode_chirotherium(m["Chirotherium"]),
+      chlorophylligenous: m["chlorophylligenous"] && decode_chlorophylligenous(m["chlorophylligenous"]),
+      conversational: m["conversational"] && decode_conversational(m["conversational"]),
+      demiowl: m["demiowl"] && decode_demiowl(m["demiowl"]),
       disdiapason: m["disdiapason"] && decode_disdiapason(m["disdiapason"]),
-      ectorhinal: m["ectorhinal"],
-      gamblesomeness: m["gamblesomeness"],
+      ectorhinal: m["ectorhinal"] && decode_ectorhinal(m["ectorhinal"]),
+      gamblesomeness: m["gamblesomeness"] && decode_gamblesomeness(m["gamblesomeness"]),
       homocerc: m["homocerc"],
-      irrorate: m["irrorate"],
-      kindergartening: m["kindergartening"],
-      lateritic: m["lateritic"],
-      mespil: m["mespil"],
-      misconfiguration: m["misconfiguration"],
+      irrorate: m["irrorate"] && decode_irrorate(m["irrorate"]),
+      kindergartening: m["kindergartening"] && decode_kindergartening(m["kindergartening"]),
+      lateritic: m["lateritic"] && decode_lateritic(m["lateritic"]),
+      mespil: m["mespil"] && decode_mespil(m["mespil"]),
+      misconfiguration: m["misconfiguration"] && decode_misconfiguration(m["misconfiguration"]),
       nonbookish: m["nonbookish"],
-      planometry: m["planometry"],
-      quiina: m["Quiina"],
-      robert: m["Robert"],
-      rot: m["rot"],
-      subcinctorium: m["subcinctorium"],
-      tussocker: m["tussocker"],
-      ultraproud: m["ultraproud"],
-      unsuggestedness: m["unsuggestedness"],
+      planometry: m["planometry"] && decode_planometry(m["planometry"]),
+      quiina: m["Quiina"] && decode_quiina(m["Quiina"]),
+      robert: m["Robert"] && decode_robert(m["Robert"]),
+      rot: m["rot"] && decode_rot(m["rot"]),
+      subcinctorium: m["subcinctorium"] && decode_subcinctorium(m["subcinctorium"]),
+      tussocker: m["tussocker"] && decode_tussocker(m["tussocker"]),
+      ultraproud: m["ultraproud"] && decode_ultraproud(m["ultraproud"]),
+      unsuggestedness: m["unsuggestedness"] && decode_unsuggestedness(m["unsuggestedness"]),
     }
   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 b9b9eb4..9f670d9 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
@@ -816,6 +816,12 @@ defmodule Scorer do
   def encode_name(value) when is_binary(value), do: value
   def encode_name(_), do: {:error, "Unexpected type when encoding Scorer.name"}
 
+  def decode_per(value) when is_integer(value), do: value
+  def decode_per(_), do: {:error, "Unexpected type when decoding Scorer.per"}
+
+  def encode_per(value) when is_integer(value), do: value
+  def encode_per(_), do: {:error, "Unexpected type when encoding Scorer.per"}
+
   def decode_player(value) when is_binary(value), do: value
   def decode_player(_), do: {:error, "Unexpected type when decoding Scorer.player"}
 
@@ -846,6 +852,12 @@ defmodule Scorer do
   def encode_tno(value) when is_integer(value), do: value
   def encode_tno(_), do: {:error, "Unexpected type when encoding Scorer.tno"}
 
+  def decode_tot(value) when is_integer(value), do: value
+  def decode_tot(_), do: {:error, "Unexpected type when decoding Scorer.tot"}
+
+  def encode_tot(value) when is_integer(value), do: value
+  def encode_tot(_), do: {:error, "Unexpected type when encoding Scorer.tot"}
+
   def from_map(m) do
     %Scorer{
       family_name: m["familyName"] && decode_family_name(m["familyName"]),
@@ -858,7 +870,7 @@ defmodule Scorer do
       international_first_name: m["internationalFirstName"] && decode_international_first_name(m["internationalFirstName"]),
       international_first_name_initial: m["internationalFirstNameInitial"] && FirstNameInitial.decode(m["internationalFirstNameInitial"]),
       name: m["name"] && decode_name(m["name"]),
-      per: m["per"],
+      per: m["per"] && decode_per(m["per"]),
       per_type: m["perType"] && PerType.decode(m["perType"]),
       player: m["player"] && decode_player(m["player"]),
       pno: decode_pno(m["pno"]),
@@ -867,7 +879,7 @@ defmodule Scorer do
       summary: m["summary"] && decode_summary(m["summary"]),
       times: m["times"] && Enum.map(m["times"], &TimeElement.from_map/1),
       tno: decode_tno(m["tno"]),
-      tot: m["tot"],
+      tot: m["tot"] && decode_tot(m["tot"]),
     }
   end
 
@@ -1130,6 +1142,12 @@ defmodule Pl do
   def encode_active(value) when is_integer(value), do: value
   def encode_active(_), do: {:error, "Unexpected type when encoding Pl.active"}
 
+  def decode_captain(value) when is_integer(value), do: value
+  def decode_captain(_), do: {:error, "Unexpected type when decoding Pl.captain"}
+
+  def encode_captain(value) when is_integer(value), do: value
+  def encode_captain(_), do: {:error, "Unexpected type when encoding Pl.captain"}
+
   def decode_eff_1(value) when is_integer(value), do: value
   def decode_eff_1(_), do: {:error, "Unexpected type when decoding Pl.eff_1"}
 
@@ -1389,7 +1407,7 @@ defmodule Pl do
   def from_map(m) do
     %Pl{
       active: decode_active(m["active"]),
-      captain: m["captain"],
+      captain: m["captain"] && decode_captain(m["captain"]),
       comp: m["comp"] && Comp.from_map(m["comp"]),
       eff_1: decode_eff_1(m["eff_1"]),
       eff_2: decode_eff_2(m["eff_2"]),
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 de5128c..cb036e5 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
@@ -2233,6 +2233,12 @@ defmodule Payload do
   def encode_description(value) when is_binary(value), do: value
   def encode_description(_), do: {:error, "Unexpected type when encoding Payload.description"}
 
+  def decode_distinct_size(value) when is_integer(value), do: value
+  def decode_distinct_size(_), do: {:error, "Unexpected type when decoding Payload.distinct_size"}
+
+  def encode_distinct_size(value) when is_integer(value), do: value
+  def encode_distinct_size(_), do: {:error, "Unexpected type when encoding Payload.distinct_size"}
+
   def decode_head(value) when is_binary(value), do: value
   def decode_head(_), do: {:error, "Unexpected type when decoding Payload.head"}
 
@@ -2245,6 +2251,18 @@ defmodule Payload do
   def encode_master_branch(value) when is_binary(value), do: value
   def encode_master_branch(_), do: {:error, "Unexpected type when encoding Payload.master_branch"}
 
+  def decode_number(value) when is_integer(value), do: value
+  def decode_number(_), do: {:error, "Unexpected type when decoding Payload.number"}
+
+  def encode_number(value) when is_integer(value), do: value
+  def encode_number(_), do: {:error, "Unexpected type when encoding Payload.number"}
+
+  def decode_push_id(value) when is_integer(value), do: value
+  def decode_push_id(_), do: {:error, "Unexpected type when decoding Payload.push_id"}
+
+  def encode_push_id(value) when is_integer(value), do: value
+  def encode_push_id(_), do: {:error, "Unexpected type when encoding Payload.push_id"}
+
   def decode_pusher_type(value) when is_binary(value), do: value
   def decode_pusher_type(_), do: {:error, "Unexpected type when decoding Payload.pusher_type"}
 
@@ -2263,6 +2281,12 @@ defmodule Payload do
   def encode_ref_type(value) when is_binary(value), do: value
   def encode_ref_type(_), do: {:error, "Unexpected type when encoding Payload.ref_type"}
 
+  def decode_size(value) when is_integer(value), do: value
+  def decode_size(_), do: {:error, "Unexpected type when decoding Payload.size"}
+
+  def encode_size(value) when is_integer(value), do: value
+  def encode_size(_), do: {:error, "Unexpected type when encoding Payload.size"}
+
   def from_map(m) do
     %Payload{
       action: m["action"] && decode_action(m["action"]),
@@ -2270,17 +2294,17 @@ defmodule Payload do
       comment: m["comment"] && Comment.from_map(m["comment"]),
       commits: m["commits"] && Enum.map(m["commits"], &Commit.from_map/1),
       description: m["description"] && decode_description(m["description"]),
-      distinct_size: m["distinct_size"],
+      distinct_size: m["distinct_size"] && decode_distinct_size(m["distinct_size"]),
       head: m["head"] && decode_head(m["head"]),
       issue: m["issue"] && Issue.from_map(m["issue"]),
       master_branch: m["master_branch"] && decode_master_branch(m["master_branch"]),
-      number: m["number"],
+      number: m["number"] && decode_number(m["number"]),
       pull_request: m["pull_request"] && PayloadPullRequest.from_map(m["pull_request"]),
-      push_id: m["push_id"],
+      push_id: m["push_id"] && decode_push_id(m["push_id"]),
       pusher_type: m["pusher_type"] && decode_pusher_type(m["pusher_type"]),
       ref: m["ref"] && decode_ref(m["ref"]),
       ref_type: m["ref_type"] && decode_ref_type(m["ref_type"]),
-      size: m["size"],
+      size: m["size"] && decode_size(m["size"]),
     }
   end
 
diff --git a/base/elixir/test/inputs/json/samples/pokedex.json/default/QuickType.ex b/head/elixir/test/inputs/json/samples/pokedex.json/default/QuickType.ex
index d78f11b..dd159fb 100644
--- a/base/elixir/test/inputs/json/samples/pokedex.json/default/QuickType.ex
+++ b/head/elixir/test/inputs/json/samples/pokedex.json/default/QuickType.ex
@@ -202,6 +202,12 @@ defmodule Pokemon do
   def encode_candy(value) when is_binary(value), do: value
   def encode_candy(_), do: {:error, "Unexpected type when encoding Pokemon.candy"}
 
+  def decode_candy_count(value) when is_integer(value), do: value
+  def decode_candy_count(_), do: {:error, "Unexpected type when decoding Pokemon.candy_count"}
+
+  def encode_candy_count(value) when is_integer(value), do: value
+  def encode_candy_count(_), do: {:error, "Unexpected type when encoding Pokemon.candy_count"}
+
   def decode_height(value) when is_binary(value), do: value
   def decode_height(_), do: {:error, "Unexpected type when decoding Pokemon.height"}
 
@@ -276,7 +282,7 @@ defmodule Pokemon do
     %Pokemon{
       avg_spawns: decode_avg_spawns(m["avg_spawns"]),
       candy: decode_candy(m["candy"]),
-      candy_count: m["candy_count"],
+      candy_count: m["candy_count"] && decode_candy_count(m["candy_count"]),
       egg: Egg.decode(m["egg"]),
       height: decode_height(m["height"]),
       id: decode_id(m["id"]),
diff --git a/head/schema-dart/test/inputs/dart/object-member-names.schema/default/TopLevel.dart b/head/schema-dart/test/inputs/dart/object-member-names.schema/default/TopLevel.dart
new file mode 100644
index 0000000..9d7c58f
--- /dev/null
+++ b/head/schema-dart/test/inputs/dart/object-member-names.schema/default/TopLevel.dart
@@ -0,0 +1,37 @@
+// To parse this JSON data, do
+//
+//     final topLevel = topLevelFromJson(jsonString);
+
+import 'dart:convert';
+
+TopLevel topLevelFromJson(String str) => TopLevel.fromJson(json.decode(str));
+
+String topLevelToJson(TopLevel data) => json.encode(data.toJson());
+
+class TopLevel {
+    final String topLevelHashCode;
+    final String topLevelNoSuchMethod;
+    final int topLevelRuntimeType;
+    final bool topLevelToString;
+
+    TopLevel({
+        required this.topLevelHashCode,
+        required this.topLevelNoSuchMethod,
+        required this.topLevelRuntimeType,
+        required this.topLevelToString,
+    });
+
+    factory TopLevel.fromJson(Map<String, dynamic> json) => TopLevel(
+        topLevelHashCode: json["hashCode"],
+        topLevelNoSuchMethod: json["noSuchMethod"],
+        topLevelRuntimeType: json["runtimeType"],
+        topLevelToString: json["toString"],
+    );
+
+    Map<String, dynamic> toJson() => {
+        "hashCode": topLevelHashCode,
+        "noSuchMethod": topLevelNoSuchMethod,
+        "runtimeType": topLevelRuntimeType,
+        "toString": topLevelToString,
+    };
+}
diff --git a/base/schema-elixir/test/inputs/schema/class-map-union.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/class-map-union.schema/default/QuickType.ex
index fd71797..fda14ff 100644
--- a/base/schema-elixir/test/inputs/schema/class-map-union.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/class-map-union.schema/default/QuickType.ex
@@ -12,9 +12,15 @@ defmodule UnionClass do
           quux: integer() | nil
         }
 
+  def decode_quux(value) when is_integer(value), do: value
+  def decode_quux(_), do: {:error, "Unexpected type when decoding UnionClass.quux"}
+
+  def encode_quux(value) when is_integer(value), do: value
+  def encode_quux(_), do: {:error, "Unexpected type when encoding UnionClass.quux"}
+
   def from_map(m) do
     %UnionClass{
-      quux: m["quux"],
+      quux: m["quux"] && decode_quux(m["quux"]),
     }
   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..7c0ed78 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
@@ -119,6 +119,14 @@ defmodule TopLevel do
           union: float() | String.t()
         }
 
+  def decode_foo(value) when is_float(value), do: value
+  def decode_foo(value) when is_integer(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(_), do: {:error, "Unexpected type when encoding TopLevel.foo"}
+
   def decode_object_or_string(%{"prop" => _,} = value), do: ObjectOrStringClass.from_map(value)
   def decode_object_or_string(value) when is_binary(value), do: value
   def decode_object_or_string(_), do: {:error, "Unexpected type when decoding TopLevel.object_or_string"}
@@ -131,7 +139,7 @@ defmodule TopLevel do
     %TopLevel{
       bar: m["bar"],
       enum: EnumEnum.decode(m["enum"]),
-      foo: m["foo"],
+      foo: m["foo"] && decode_foo(m["foo"]),
       object_or_string: decode_object_or_string(m["object-or-string"]),
       union: Map.fetch!(m, "union"),
     }
diff --git a/base/schema-elixir/test/inputs/schema/integer-type.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/integer-type.schema/default/QuickType.ex
index 257b3a8..51cd70c 100644
--- a/base/schema-elixir/test/inputs/schema/integer-type.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/integer-type.schema/default/QuickType.ex
@@ -21,49 +21,49 @@ defmodule TopLevel do
           unbounded: integer()
         }
 
-  def decode_above_i32_max(value) when is_integer(value), do: value
+  def decode_above_i32_max(value) when is_integer(value) and value >= 0 and value <= 2147483648, do: value
   def decode_above_i32_max(_), do: {:error, "Unexpected type when decoding TopLevel.above_i32_max"}
 
   def encode_above_i32_max(value) when is_integer(value), do: value
   def encode_above_i32_max(_), do: {:error, "Unexpected type when encoding TopLevel.above_i32_max"}
 
-  def decode_below_i32_min(value) when is_integer(value), do: value
+  def decode_below_i32_min(value) when is_integer(value) and value >= -2147483649 and value <= 0, do: value
   def decode_below_i32_min(_), do: {:error, "Unexpected type when decoding TopLevel.below_i32_min"}
 
   def encode_below_i32_min(value) when is_integer(value), do: value
   def encode_below_i32_min(_), do: {:error, "Unexpected type when encoding TopLevel.below_i32_min"}
 
-  def decode_i32_range(value) when is_integer(value), do: value
+  def decode_i32_range(value) when is_integer(value) and value >= -2147483648 and value <= 2147483647, do: value
   def decode_i32_range(_), do: {:error, "Unexpected type when decoding TopLevel.i32_range"}
 
   def encode_i32_range(value) when is_integer(value), do: value
   def encode_i32_range(_), do: {:error, "Unexpected type when encoding TopLevel.i32_range"}
 
-  def decode_large_bounds(value) when is_integer(value), do: value
+  def decode_large_bounds(value) when is_integer(value) and value >= -9007199254740991 and value <= 9007199254740991, do: value
   def decode_large_bounds(_), do: {:error, "Unexpected type when decoding TopLevel.large_bounds"}
 
   def encode_large_bounds(value) when is_integer(value), do: value
   def encode_large_bounds(_), do: {:error, "Unexpected type when encoding TopLevel.large_bounds"}
 
-  def decode_only_maximum(value) when is_integer(value), do: value
+  def decode_only_maximum(value) when is_integer(value) and value <= 0, do: value
   def decode_only_maximum(_), do: {:error, "Unexpected type when decoding TopLevel.only_maximum"}
 
   def encode_only_maximum(value) when is_integer(value), do: value
   def encode_only_maximum(_), do: {:error, "Unexpected type when encoding TopLevel.only_maximum"}
 
-  def decode_only_minimum(value) when is_integer(value), do: value
+  def decode_only_minimum(value) when is_integer(value) and value >= 0, do: value
   def decode_only_minimum(_), do: {:error, "Unexpected type when decoding TopLevel.only_minimum"}
 
   def encode_only_minimum(value) when is_integer(value), do: value
   def encode_only_minimum(_), do: {:error, "Unexpected type when encoding TopLevel.only_minimum"}
 
-  def decode_small_negative(value) when is_integer(value), do: value
+  def decode_small_negative(value) when is_integer(value) and value >= -100 and value <= 0, do: value
   def decode_small_negative(_), do: {:error, "Unexpected type when decoding TopLevel.small_negative"}
 
   def encode_small_negative(value) when is_integer(value), do: value
   def encode_small_negative(_), do: {:error, "Unexpected type when encoding TopLevel.small_negative"}
 
-  def decode_small_positive(value) when is_integer(value), do: value
+  def decode_small_positive(value) when is_integer(value) and value >= 0 and value <= 100, do: value
   def decode_small_positive(_), do: {:error, "Unexpected type when decoding TopLevel.small_positive"}
 
   def encode_small_positive(value) when is_integer(value), do: value
diff --git a/base/schema-elixir/test/inputs/schema/intersection-nested.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/intersection-nested.schema/default/QuickType.ex
index b63f615..94910eb 100644
--- a/base/schema-elixir/test/inputs/schema/intersection-nested.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/intersection-nested.schema/default/QuickType.ex
@@ -12,9 +12,17 @@ defmodule TopLevel do
           intersection: float() | nil
         }
 
+  def decode_intersection(value) when is_float(value), do: value
+  def decode_intersection(value) when is_integer(value), do: value
+  def decode_intersection(_), do: {:error, "Unexpected type when decoding TopLevel.intersection"}
+
+  def encode_intersection(value) when is_float(value), do: value
+  def encode_intersection(value) when is_integer(value), do: value
+  def encode_intersection(_), do: {:error, "Unexpected type when encoding TopLevel.intersection"}
+
   def from_map(m) do
     %TopLevel{
-      intersection: m["intersection"],
+      intersection: m["intersection"] && decode_intersection(m["intersection"]),
     }
   end
 
diff --git a/base/schema-elixir/test/inputs/schema/keyword-unions.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/keyword-unions.schema/default/QuickType.ex
index 4d138dd..596140d 100644
--- a/base/schema-elixir/test/inputs/schema/keyword-unions.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/keyword-unions.schema/default/QuickType.ex
@@ -9204,6 +9204,14 @@ defmodule TopLevel do
   def encode_double(value) when is_nil(value), do: value
   def encode_double(_), do: {:error, "Unexpected type when encoding TopLevel.double"}
 
+  def decode_dummy(value) when is_float(value), do: value
+  def decode_dummy(value) when is_integer(value), do: value
+  def decode_dummy(_), do: {:error, "Unexpected type when decoding TopLevel.dummy"}
+
+  def encode_dummy(value) when is_float(value), do: value
+  def encode_dummy(value) when is_integer(value), do: value
+  def encode_dummy(_), do: {:error, "Unexpected type when encoding TopLevel.dummy"}
+
   def decode_dynamic(%{} = value), do: Dynamic.from_map(value)
   def decode_dynamic(value) when is_float(value), do: value
   def decode_dynamic(value) when is_integer(value), do: value
@@ -11682,7 +11690,7 @@ defmodule TopLevel do
       did_set: decode_did_set(m["didSet"]),
       top_level_do: decode_top_level_do(m["do"]),
       double: decode_double(m["double"]),
-      dummy: m["dummy"],
+      dummy: m["dummy"] && decode_dummy(m["dummy"]),
       dynamic: decode_dynamic(m["dynamic"]),
       dynamic_cast: decode_dynamic_cast(m["dynamic_cast"]),
       elif: decode_elif(m["elif"]),
diff --git a/base/schema-elixir/test/inputs/schema/minmax-integer.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/minmax-integer.schema/default/QuickType.ex
index 9129fbd..26774ba 100644
--- a/base/schema-elixir/test/inputs/schema/minmax-integer.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/minmax-integer.schema/default/QuickType.ex
@@ -26,31 +26,31 @@ defmodule TopLevel do
   def encode_free(value) when is_integer(value), do: value
   def encode_free(_), do: {:error, "Unexpected type when encoding TopLevel.free"}
 
-  def decode_intersection(value) when is_integer(value), do: value
+  def decode_intersection(value) when is_integer(value) and value >= 4 and value <= 5, do: value
   def decode_intersection(_), do: {:error, "Unexpected type when decoding TopLevel.intersection"}
 
   def encode_intersection(value) when is_integer(value), do: value
   def encode_intersection(_), do: {:error, "Unexpected type when encoding TopLevel.intersection"}
 
-  def decode_max(value) when is_integer(value), do: value
+  def decode_max(value) when is_integer(value) and value <= 5, do: value
   def decode_max(_), do: {:error, "Unexpected type when decoding TopLevel.max"}
 
   def encode_max(value) when is_integer(value), do: value
   def encode_max(_), do: {:error, "Unexpected type when encoding TopLevel.max"}
 
-  def decode_min(value) when is_integer(value), do: value
+  def decode_min(value) when is_integer(value) and value >= 3, do: value
   def decode_min(_), do: {:error, "Unexpected type when decoding TopLevel.min"}
 
   def encode_min(value) when is_integer(value), do: value
   def encode_min(_), do: {:error, "Unexpected type when encoding TopLevel.min"}
 
-  def decode_minmax(value) when is_integer(value), do: value
+  def decode_minmax(value) when is_integer(value) and value >= 3 and value <= 5, do: value
   def decode_minmax(_), do: {:error, "Unexpected type when decoding TopLevel.minmax"}
 
   def encode_minmax(value) when is_integer(value), do: value
   def encode_minmax(_), do: {:error, "Unexpected type when encoding TopLevel.minmax"}
 
-  def decode_min_max_intersection(value) when is_integer(value), do: value
+  def decode_min_max_intersection(value) when is_integer(value) and value >= 3 and value <= 5, do: value
   def decode_min_max_intersection(_), do: {:error, "Unexpected type when decoding TopLevel.min_max_intersection"}
 
   def encode_min_max_intersection(value) when is_integer(value), do: value
@@ -62,7 +62,7 @@ defmodule TopLevel do
   def encode_min_max_union(value) when is_integer(value), do: value
   def encode_min_max_union(_), do: {:error, "Unexpected type when encoding TopLevel.min_max_union"}
 
-  def decode_union(value) when is_integer(value), do: value
+  def decode_union(value) when is_integer(value) and value >= 3 and value <= 6, do: value
   def decode_union(_), do: {:error, "Unexpected type when decoding TopLevel.union"}
 
   def encode_union(value) when is_integer(value), do: value
diff --git a/base/schema-elixir/test/inputs/schema/minmax.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/minmax.schema/default/QuickType.ex
index 3ffe159..2efb8a7 100644
--- a/base/schema-elixir/test/inputs/schema/minmax.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/minmax.schema/default/QuickType.ex
@@ -28,40 +28,40 @@ defmodule TopLevel do
   def encode_free(value) when is_integer(value), do: value
   def encode_free(_), do: {:error, "Unexpected type when encoding TopLevel.free"}
 
-  def decode_intersection(value) when is_float(value), do: value
-  def decode_intersection(value) when is_integer(value), do: value
+  def decode_intersection(value) when is_float(value) and value >= 4 and value <= 5, do: value
+  def decode_intersection(value) when is_integer(value) and value >= 4 and value <= 5, do: value
   def decode_intersection(_), do: {:error, "Unexpected type when decoding TopLevel.intersection"}
 
   def encode_intersection(value) when is_float(value), do: value
   def encode_intersection(value) when is_integer(value), do: value
   def encode_intersection(_), do: {:error, "Unexpected type when encoding TopLevel.intersection"}
 
-  def decode_max(value) when is_float(value), do: value
-  def decode_max(value) when is_integer(value), do: value
+  def decode_max(value) when is_float(value) and value <= 5, do: value
+  def decode_max(value) when is_integer(value) and value <= 5, do: value
   def decode_max(_), do: {:error, "Unexpected type when decoding TopLevel.max"}
 
   def encode_max(value) when is_float(value), do: value
   def encode_max(value) when is_integer(value), do: value
   def encode_max(_), do: {:error, "Unexpected type when encoding TopLevel.max"}
 
-  def decode_min(value) when is_float(value), do: value
-  def decode_min(value) when is_integer(value), do: value
+  def decode_min(value) when is_float(value) and value >= 3, do: value
+  def decode_min(value) when is_integer(value) and value >= 3, do: value
   def decode_min(_), do: {:error, "Unexpected type when decoding TopLevel.min"}
 
   def encode_min(value) when is_float(value), do: value
   def encode_min(value) when is_integer(value), do: value
   def encode_min(_), do: {:error, "Unexpected type when encoding TopLevel.min"}
 
-  def decode_minmax(value) when is_float(value), do: value
-  def decode_minmax(value) when is_integer(value), do: value
+  def decode_minmax(value) when is_float(value) and value >= 3 and value <= 5, do: value
+  def decode_minmax(value) when is_integer(value) and value >= 3 and value <= 5, do: value
   def decode_minmax(_), do: {:error, "Unexpected type when decoding TopLevel.minmax"}
 
   def encode_minmax(value) when is_float(value), do: value
   def encode_minmax(value) when is_integer(value), do: value
   def encode_minmax(_), do: {:error, "Unexpected type when encoding TopLevel.minmax"}
 
-  def decode_min_max_intersection(value) when is_float(value), do: value
-  def decode_min_max_intersection(value) when is_integer(value), do: value
+  def decode_min_max_intersection(value) when is_float(value) and value >= 3 and value <= 5, do: value
+  def decode_min_max_intersection(value) when is_integer(value) and value >= 3 and value <= 5, do: value
   def decode_min_max_intersection(_), do: {:error, "Unexpected type when decoding TopLevel.min_max_intersection"}
 
   def encode_min_max_intersection(value) when is_float(value), do: value
@@ -76,8 +76,8 @@ defmodule TopLevel do
   def encode_min_max_union(value) when is_integer(value), do: value
   def encode_min_max_union(_), do: {:error, "Unexpected type when encoding TopLevel.min_max_union"}
 
-  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_float(value) and value >= 3 and value <= 6, do: value
+  def decode_union(value) when is_integer(value) and value >= 3 and value <= 6, do: value
   def decode_union(_), do: {:error, "Unexpected type when decoding TopLevel.union"}
 
   def encode_union(value) when is_float(value), do: value
diff --git a/base/schema-elixir/test/inputs/schema/optional-const-ref.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/optional-const-ref.schema/default/QuickType.ex
index 145fa38..a3fb21b 100644
--- a/base/schema-elixir/test/inputs/schema/optional-const-ref.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/optional-const-ref.schema/default/QuickType.ex
@@ -71,6 +71,12 @@ defmodule TopLevel do
           weight: float() | nil
         }
 
+  def decode_count(value) when is_integer(value) and value >= 1 and value <= 100, do: value
+  def decode_count(_), do: {:error, "Unexpected type when decoding TopLevel.count"}
+
+  def encode_count(value) when is_integer(value), do: value
+  def encode_count(_), do: {:error, "Unexpected type when encoding TopLevel.count"}
+
   def decode_label(value) when is_binary(value) do
     if String.length(value) >= 2 and String.length(value) <= 16, do: value, else: raise(ArgumentError)
   end
@@ -85,7 +91,7 @@ defmodule TopLevel do
   def encode_required_coordinates(value) when is_list(value), do: value
   def encode_required_coordinates(_), do: {:error, "Unexpected type when encoding TopLevel.required_coordinates"}
 
-  def decode_required_count(value) when is_integer(value), do: value
+  def decode_required_count(value) when is_integer(value) and value >= 1 and value <= 100, do: value
   def decode_required_count(_), do: {:error, "Unexpected type when decoding TopLevel.required_count"}
 
   def encode_required_count(value) when is_integer(value), do: value
@@ -99,15 +105,23 @@ defmodule TopLevel do
   def encode_required_label(value) when is_binary(value), do: value
   def encode_required_label(_), do: {:error, "Unexpected type when encoding TopLevel.required_label"}
 
+  def decode_weight(value) when is_float(value) and value >= 0.5 and value <= 99.5, do: value
+  def decode_weight(value) when is_integer(value) and value >= 0.5 and value <= 99.5, do: value
+  def decode_weight(_), do: {:error, "Unexpected type when decoding TopLevel.weight"}
+
+  def encode_weight(value) when is_float(value), do: value
+  def encode_weight(value) when is_integer(value), do: value
+  def encode_weight(_), do: {:error, "Unexpected type when encoding TopLevel.weight"}
+
   def from_map(m) do
     %TopLevel{
       coordinates: m["coordinates"] && Enum.map(m["coordinates"], &Coordinate.from_map/1),
-      count: m["count"],
+      count: m["count"] && decode_count(m["count"]),
       label: m["label"] && decode_label(m["label"]),
       required_coordinates: Enum.map(m["requiredCoordinates"], &Coordinate.from_map/1),
       required_count: decode_required_count(m["requiredCount"]),
       required_label: decode_required_label(m["requiredLabel"]),
-      weight: m["weight"],
+      weight: m["weight"] && decode_weight(m["weight"]),
     }
   end
 
diff --git a/base/schema-elixir/test/inputs/schema/optional-constraints.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/optional-constraints.schema/default/QuickType.ex
index 18cefc2..81f9584 100644
--- a/base/schema-elixir/test/inputs/schema/optional-constraints.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/optional-constraints.schema/default/QuickType.ex
@@ -17,6 +17,20 @@ defmodule TopLevel do
           req_zero_min: integer()
         }
 
+  def decode_opt_double(value) when is_float(value) and value >= 0.5 and value <= 99.5, do: value
+  def decode_opt_double(value) when is_integer(value) and value >= 0.5 and value <= 99.5, do: value
+  def decode_opt_double(_), do: {:error, "Unexpected type when decoding TopLevel.opt_double"}
+
+  def encode_opt_double(value) when is_float(value), do: value
+  def encode_opt_double(value) when is_integer(value), do: value
+  def encode_opt_double(_), do: {:error, "Unexpected type when encoding TopLevel.opt_double"}
+
+  def decode_opt_int(value) when is_integer(value) and value >= 0 and value <= 100, do: value
+  def decode_opt_int(_), do: {:error, "Unexpected type when decoding TopLevel.opt_int"}
+
+  def encode_opt_int(value) when is_integer(value), do: value
+  def encode_opt_int(_), do: {:error, "Unexpected type when encoding TopLevel.opt_int"}
+
   def decode_opt_pattern(value) when is_binary(value) do
     if Regex.match?(Regex.compile!("^[a-z]+$"), value), do: value, else: raise(ArgumentError)
   end
@@ -33,7 +47,7 @@ defmodule TopLevel do
   def encode_opt_string(value) when is_binary(value), do: value
   def encode_opt_string(_), do: {:error, "Unexpected type when encoding TopLevel.opt_string"}
 
-  def decode_req_zero_min(value) when is_integer(value), do: value
+  def decode_req_zero_min(value) when is_integer(value) and value >= 0 and value <= 100, do: value
   def decode_req_zero_min(_), do: {:error, "Unexpected type when decoding TopLevel.req_zero_min"}
 
   def encode_req_zero_min(value) when is_integer(value), do: value
@@ -41,8 +55,8 @@ defmodule TopLevel do
 
   def from_map(m) do
     %TopLevel{
-      opt_double: m["optDouble"],
-      opt_int: m["optInt"],
+      opt_double: m["optDouble"] && decode_opt_double(m["optDouble"]),
+      opt_int: m["optInt"] && decode_opt_int(m["optInt"]),
       opt_pattern: m["optPattern"] && decode_opt_pattern(m["optPattern"]),
       opt_string: m["optString"] && decode_opt_string(m["optString"]),
       req_zero_min: decode_req_zero_min(m["reqZeroMin"]),
diff --git a/base/schema-elixir/test/inputs/schema/renaming-bug.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/renaming-bug.schema/default/QuickType.ex
index a1db657..8084788 100644
--- a/base/schema-elixir/test/inputs/schema/renaming-bug.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/renaming-bug.schema/default/QuickType.ex
@@ -12,9 +12,17 @@ defmodule Color do
           rgb: float() | nil
         }
 
+  def decode_rgb(value) when is_float(value), do: value
+  def decode_rgb(value) when is_integer(value), do: value
+  def decode_rgb(_), do: {:error, "Unexpected type when decoding Color.rgb"}
+
+  def encode_rgb(value) when is_float(value), do: value
+  def encode_rgb(value) when is_integer(value), do: value
+  def encode_rgb(_), do: {:error, "Unexpected type when encoding Color.rgb"}
+
   def from_map(m) do
     %Color{
-      rgb: m["rgb"],
+      rgb: m["rgb"] && decode_rgb(m["rgb"]),
     }
   end
 
@@ -363,10 +371,26 @@ defmodule Limit do
           minimum: float() | nil
         }
 
+  def decode_maximum(value) when is_float(value), do: value
+  def decode_maximum(value) when is_integer(value), do: value
+  def decode_maximum(_), do: {:error, "Unexpected type when decoding Limit.maximum"}
+
+  def encode_maximum(value) when is_float(value), do: value
+  def encode_maximum(value) when is_integer(value), do: value
+  def encode_maximum(_), do: {:error, "Unexpected type when encoding Limit.maximum"}
+
+  def decode_minimum(value) when is_float(value), do: value
+  def decode_minimum(value) when is_integer(value), do: value
+  def decode_minimum(_), do: {:error, "Unexpected type when decoding Limit.minimum"}
+
+  def encode_minimum(value) when is_float(value), do: value
+  def encode_minimum(value) when is_integer(value), do: value
+  def encode_minimum(_), do: {:error, "Unexpected type when encoding Limit.minimum"}
+
   def from_map(m) do
     %Limit{
-      maximum: m["maximum"],
-      minimum: m["minimum"],
+      maximum: m["maximum"] && decode_maximum(m["maximum"]),
+      minimum: m["minimum"] && decode_minimum(m["minimum"]),
     }
   end
 
diff --git a/base/schema-elixir/test/inputs/schema/schema-constraints.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/schema-constraints.schema/default/QuickType.ex
index 154049c..e8b9e64 100644
--- a/base/schema-elixir/test/inputs/schema/schema-constraints.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/schema-constraints.schema/default/QuickType.ex
@@ -22,8 +22,8 @@ defmodule TopLevel do
   def encode_min_max_length(value) when is_binary(value), do: value
   def encode_min_max_length(_), do: {:error, "Unexpected type when encoding TopLevel.min_max_length"}
 
-  def decode_percent(value) when is_float(value), do: value
-  def decode_percent(value) when is_integer(value), do: value
+  def decode_percent(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_percent(value) when is_integer(value) and value >= 0 and value <= 1, do: value
   def decode_percent(_), do: {:error, "Unexpected type when decoding TopLevel.percent"}
 
   def encode_percent(value) when is_float(value), do: value
diff --git a/base/schema-elixir/test/inputs/schema/union.schema/default/QuickType.ex b/head/schema-elixir/test/inputs/schema/union.schema/default/QuickType.ex
index 3ab5043..0eb30c4 100644
--- a/base/schema-elixir/test/inputs/schema/union.schema/default/QuickType.ex
+++ b/head/schema-elixir/test/inputs/schema/union.schema/default/QuickType.ex
@@ -15,17 +15,31 @@ defmodule TopLevelElement do
           three: float() | nil
         }
 
+  def decode_one(value) when is_integer(value), do: value
+  def decode_one(_), do: {:error, "Unexpected type when decoding TopLevelElement.one"}
+
+  def encode_one(value) when is_integer(value), do: value
+  def encode_one(_), do: {:error, "Unexpected type when encoding TopLevelElement.one"}
+
   def decode_two(value) when is_boolean(value), do: value
   def decode_two(_), do: {:error, "Unexpected type when decoding TopLevelElement.two"}
 
   def encode_two(value) when is_boolean(value), do: value
   def encode_two(_), do: {:error, "Unexpected type when encoding TopLevelElement.two"}
 
+  def decode_three(value) when is_float(value), do: value
+  def decode_three(value) when is_integer(value), do: value
+  def decode_three(_), do: {:error, "Unexpected type when decoding TopLevelElement.three"}
+
+  def encode_three(value) when is_float(value), do: value
+  def encode_three(value) when is_integer(value), do: value
+  def encode_three(_), do: {:error, "Unexpected type when encoding TopLevelElement.three"}
+
   def from_map(m) do
     %TopLevelElement{
-      one: m["one"],
+      one: m["one"] && decode_one(m["one"]),
       two: decode_two(m["two"]),
-      three: m["three"],
+      three: m["three"] && decode_three(m["three"]),
     }
   end
 
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 3785892..b2b0c35 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
@@ -661,27 +661,67 @@ defmodule MarkConfig do
           theta: float() | nil
         }
 
+  def decode_angle(value) when is_float(value) and value >= 0 and value <= 360, do: value
+  def decode_angle(value) when is_integer(value) and value >= 0 and value <= 360, do: value
+  def decode_angle(_), do: {:error, "Unexpected type when decoding MarkConfig.angle"}
+
+  def encode_angle(value) when is_float(value), do: value
+  def encode_angle(value) when is_integer(value), do: value
+  def encode_angle(_), do: {:error, "Unexpected type when encoding MarkConfig.angle"}
+
   def decode_color(value) when is_binary(value), do: value
   def decode_color(_), do: {:error, "Unexpected type when decoding MarkConfig.color"}
 
   def encode_color(value) when is_binary(value), do: value
   def encode_color(_), do: {:error, "Unexpected type when encoding MarkConfig.color"}
 
+  def decode_dx(value) when is_float(value), do: value
+  def decode_dx(value) when is_integer(value), do: value
+  def decode_dx(_), do: {:error, "Unexpected type when decoding MarkConfig.dx"}
+
+  def encode_dx(value) when is_float(value), do: value
+  def encode_dx(value) when is_integer(value), do: value
+  def encode_dx(_), do: {:error, "Unexpected type when encoding MarkConfig.dx"}
+
+  def decode_dy(value) when is_float(value), do: value
+  def decode_dy(value) when is_integer(value), do: value
+  def decode_dy(_), do: {:error, "Unexpected type when decoding MarkConfig.dy"}
+
+  def encode_dy(value) when is_float(value), do: value
+  def encode_dy(value) when is_integer(value), do: value
+  def encode_dy(_), do: {:error, "Unexpected type when encoding MarkConfig.dy"}
+
   def decode_fill(value) when is_binary(value), do: value
   def decode_fill(_), do: {:error, "Unexpected type when decoding MarkConfig.fill"}
 
   def encode_fill(value) when is_binary(value), do: value
   def encode_fill(_), do: {:error, "Unexpected type when encoding MarkConfig.fill"}
 
+  def decode_fill_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_fill_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_fill_opacity(_), do: {:error, "Unexpected type when decoding MarkConfig.fill_opacity"}
+
+  def encode_fill_opacity(value) when is_float(value), do: value
+  def encode_fill_opacity(value) when is_integer(value), do: value
+  def encode_fill_opacity(_), do: {:error, "Unexpected type when encoding MarkConfig.fill_opacity"}
+
   def decode_font(value) when is_binary(value), do: value
   def decode_font(_), do: {:error, "Unexpected type when decoding MarkConfig.font"}
 
   def encode_font(value) when is_binary(value), do: value
   def encode_font(_), do: {:error, "Unexpected type when encoding MarkConfig.font"}
 
+  def decode_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_font_size(_), do: {:error, "Unexpected type when decoding MarkConfig.font_size"}
+
+  def encode_font_size(value) when is_float(value), do: value
+  def encode_font_size(value) when is_integer(value), do: value
+  def encode_font_size(_), do: {:error, "Unexpected type when encoding MarkConfig.font_size"}
+
   def decode_font_weight(value) when is_binary(value), do: FontWeight.decode(value)
-  def decode_font_weight(value) when is_float(value), do: value
-  def decode_font_weight(value) when is_integer(value), do: value
+  def decode_font_weight(value) when is_float(value) and value >= 100 and value <= 900, do: value
+  def decode_font_weight(value) when is_integer(value) and value >= 100 and value <= 900, do: value
   def decode_font_weight(value) when is_nil(value), do: value
   def decode_font_weight(_), do: {:error, "Unexpected type when decoding MarkConfig.font_weight"}
 
@@ -697,56 +737,128 @@ defmodule MarkConfig do
   def encode_href(value) when is_binary(value), do: value
   def encode_href(_), do: {:error, "Unexpected type when encoding MarkConfig.href"}
 
+  def decode_limit(value) when is_float(value), do: value
+  def decode_limit(value) when is_integer(value), do: value
+  def decode_limit(_), do: {:error, "Unexpected type when decoding MarkConfig.limit"}
+
+  def encode_limit(value) when is_float(value), do: value
+  def encode_limit(value) when is_integer(value), do: value
+  def encode_limit(_), do: {:error, "Unexpected type when encoding MarkConfig.limit"}
+
+  def decode_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_opacity(_), do: {:error, "Unexpected type when decoding MarkConfig.opacity"}
+
+  def encode_opacity(value) when is_float(value), do: value
+  def encode_opacity(value) when is_integer(value), do: value
+  def encode_opacity(_), do: {:error, "Unexpected type when encoding MarkConfig.opacity"}
+
+  def decode_radius(value) when is_float(value) and value >= 0, do: value
+  def decode_radius(value) when is_integer(value) and value >= 0, do: value
+  def decode_radius(_), do: {:error, "Unexpected type when decoding MarkConfig.radius"}
+
+  def encode_radius(value) when is_float(value), do: value
+  def encode_radius(value) when is_integer(value), do: value
+  def encode_radius(_), do: {:error, "Unexpected type when encoding MarkConfig.radius"}
+
   def decode_shape(value) when is_binary(value), do: value
   def decode_shape(_), do: {:error, "Unexpected type when decoding MarkConfig.shape"}
 
   def encode_shape(value) when is_binary(value), do: value
   def encode_shape(_), do: {:error, "Unexpected type when encoding MarkConfig.shape"}
 
+  def decode_size(value) when is_float(value) and value >= 0, do: value
+  def decode_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_size(_), do: {:error, "Unexpected type when decoding MarkConfig.size"}
+
+  def encode_size(value) when is_float(value), do: value
+  def encode_size(value) when is_integer(value), do: value
+  def encode_size(_), do: {:error, "Unexpected type when encoding MarkConfig.size"}
+
   def decode_stroke(value) when is_binary(value), do: value
   def decode_stroke(_), do: {:error, "Unexpected type when decoding MarkConfig.stroke"}
 
   def encode_stroke(value) when is_binary(value), do: value
   def encode_stroke(_), do: {:error, "Unexpected type when encoding MarkConfig.stroke"}
 
+  def decode_stroke_dash_offset(value) when is_float(value), do: value
+  def decode_stroke_dash_offset(value) when is_integer(value), do: value
+  def decode_stroke_dash_offset(_), do: {:error, "Unexpected type when decoding MarkConfig.stroke_dash_offset"}
+
+  def encode_stroke_dash_offset(value) when is_float(value), do: value
+  def encode_stroke_dash_offset(value) when is_integer(value), do: value
+  def encode_stroke_dash_offset(_), do: {:error, "Unexpected type when encoding MarkConfig.stroke_dash_offset"}
+
+  def decode_stroke_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_stroke_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_stroke_opacity(_), do: {:error, "Unexpected type when decoding MarkConfig.stroke_opacity"}
+
+  def encode_stroke_opacity(value) when is_float(value), do: value
+  def encode_stroke_opacity(value) when is_integer(value), do: value
+  def encode_stroke_opacity(_), do: {:error, "Unexpected type when encoding MarkConfig.stroke_opacity"}
+
+  def decode_stroke_width(value) when is_float(value) and value >= 0, do: value
+  def decode_stroke_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_stroke_width(_), do: {:error, "Unexpected type when decoding MarkConfig.stroke_width"}
+
+  def encode_stroke_width(value) when is_float(value), do: value
+  def encode_stroke_width(value) when is_integer(value), do: value
+  def encode_stroke_width(_), do: {:error, "Unexpected type when encoding MarkConfig.stroke_width"}
+
+  def decode_tension(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_tension(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_tension(_), do: {:error, "Unexpected type when decoding MarkConfig.tension"}
+
+  def encode_tension(value) when is_float(value), do: value
+  def encode_tension(value) when is_integer(value), do: value
+  def encode_tension(_), do: {:error, "Unexpected type when encoding MarkConfig.tension"}
+
   def decode_text(value) when is_binary(value), do: value
   def decode_text(_), do: {:error, "Unexpected type when decoding MarkConfig.text"}
 
   def encode_text(value) when is_binary(value), do: value
   def encode_text(_), do: {:error, "Unexpected type when encoding MarkConfig.text"}
 
+  def decode_theta(value) when is_float(value), do: value
+  def decode_theta(value) when is_integer(value), do: value
+  def decode_theta(_), do: {:error, "Unexpected type when decoding MarkConfig.theta"}
+
+  def encode_theta(value) when is_float(value), do: value
+  def encode_theta(value) when is_integer(value), do: value
+  def encode_theta(_), do: {:error, "Unexpected type when encoding MarkConfig.theta"}
+
   def from_map(m) do
     %MarkConfig{
       align: m["align"] && HorizontalAlign.decode(m["align"]),
-      angle: m["angle"],
+      angle: m["angle"] && decode_angle(m["angle"]),
       baseline: m["baseline"] && VerticalAlign.decode(m["baseline"]),
       color: m["color"] && decode_color(m["color"]),
       cursor: m["cursor"] && Cursor.decode(m["cursor"]),
-      dx: m["dx"],
-      dy: m["dy"],
+      dx: m["dx"] && decode_dx(m["dx"]),
+      dy: m["dy"] && decode_dy(m["dy"]),
       fill: m["fill"] && decode_fill(m["fill"]),
       filled: m["filled"],
-      fill_opacity: m["fillOpacity"],
+      fill_opacity: m["fillOpacity"] && decode_fill_opacity(m["fillOpacity"]),
       font: m["font"] && decode_font(m["font"]),
-      font_size: m["fontSize"],
+      font_size: m["fontSize"] && decode_font_size(m["fontSize"]),
       font_style: m["fontStyle"] && FontStyle.decode(m["fontStyle"]),
       font_weight: decode_font_weight(m["fontWeight"]),
       href: m["href"] && decode_href(m["href"]),
       interpolate: m["interpolate"] && Interpolate.decode(m["interpolate"]),
-      limit: m["limit"],
-      opacity: m["opacity"],
+      limit: m["limit"] && decode_limit(m["limit"]),
+      opacity: m["opacity"] && decode_opacity(m["opacity"]),
       orient: m["orient"] && Orient.decode(m["orient"]),
-      radius: m["radius"],
+      radius: m["radius"] && decode_radius(m["radius"]),
       shape: m["shape"] && decode_shape(m["shape"]),
-      size: m["size"],
+      size: m["size"] && decode_size(m["size"]),
       stroke: m["stroke"] && decode_stroke(m["stroke"]),
       stroke_dash: m["strokeDash"],
-      stroke_dash_offset: m["strokeDashOffset"],
-      stroke_opacity: m["strokeOpacity"],
-      stroke_width: m["strokeWidth"],
-      tension: m["tension"],
+      stroke_dash_offset: m["strokeDashOffset"] && decode_stroke_dash_offset(m["strokeDashOffset"]),
+      stroke_opacity: m["strokeOpacity"] && decode_stroke_opacity(m["strokeOpacity"]),
+      stroke_width: m["strokeWidth"] && decode_stroke_width(m["strokeWidth"]),
+      tension: m["tension"] && decode_tension(m["tension"]),
       text: m["text"] && decode_text(m["text"]),
-      theta: m["theta"],
+      theta: m["theta"] && decode_theta(m["theta"]),
     }
   end
 
@@ -934,18 +1046,58 @@ defmodule AxisConfig do
           title_y: float() | nil
         }
 
+  def decode_band_position(value) when is_float(value), do: value
+  def decode_band_position(value) when is_integer(value), do: value
+  def decode_band_position(_), do: {:error, "Unexpected type when decoding AxisConfig.band_position"}
+
+  def encode_band_position(value) when is_float(value), do: value
+  def encode_band_position(value) when is_integer(value), do: value
+  def encode_band_position(_), do: {:error, "Unexpected type when encoding AxisConfig.band_position"}
+
   def decode_domain_color(value) when is_binary(value), do: value
   def decode_domain_color(_), do: {:error, "Unexpected type when decoding AxisConfig.domain_color"}
 
   def encode_domain_color(value) when is_binary(value), do: value
   def encode_domain_color(_), do: {:error, "Unexpected type when encoding AxisConfig.domain_color"}
 
+  def decode_domain_width(value) when is_float(value), do: value
+  def decode_domain_width(value) when is_integer(value), do: value
+  def decode_domain_width(_), do: {:error, "Unexpected type when decoding AxisConfig.domain_width"}
+
+  def encode_domain_width(value) when is_float(value), do: value
+  def encode_domain_width(value) when is_integer(value), do: value
+  def encode_domain_width(_), do: {:error, "Unexpected type when encoding AxisConfig.domain_width"}
+
   def decode_grid_color(value) when is_binary(value), do: value
   def decode_grid_color(_), do: {:error, "Unexpected type when decoding AxisConfig.grid_color"}
 
   def encode_grid_color(value) when is_binary(value), do: value
   def encode_grid_color(_), do: {:error, "Unexpected type when encoding AxisConfig.grid_color"}
 
+  def decode_grid_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_grid_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_grid_opacity(_), do: {:error, "Unexpected type when decoding AxisConfig.grid_opacity"}
+
+  def encode_grid_opacity(value) when is_float(value), do: value
+  def encode_grid_opacity(value) when is_integer(value), do: value
+  def encode_grid_opacity(_), do: {:error, "Unexpected type when encoding AxisConfig.grid_opacity"}
+
+  def decode_grid_width(value) when is_float(value) and value >= 0, do: value
+  def decode_grid_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_grid_width(_), do: {:error, "Unexpected type when decoding AxisConfig.grid_width"}
+
+  def encode_grid_width(value) when is_float(value), do: value
+  def encode_grid_width(value) when is_integer(value), do: value
+  def encode_grid_width(_), do: {:error, "Unexpected type when encoding AxisConfig.grid_width"}
+
+  def decode_label_angle(value) when is_float(value) and value >= -360 and value <= 360, do: value
+  def decode_label_angle(value) when is_integer(value) and value >= -360 and value <= 360, do: value
+  def decode_label_angle(_), do: {:error, "Unexpected type when decoding AxisConfig.label_angle"}
+
+  def encode_label_angle(value) when is_float(value), do: value
+  def encode_label_angle(value) when is_integer(value), do: value
+  def encode_label_angle(_), do: {:error, "Unexpected type when encoding AxisConfig.label_angle"}
+
   def decode_label_color(value) when is_binary(value), do: value
   def decode_label_color(_), do: {:error, "Unexpected type when decoding AxisConfig.label_color"}
 
@@ -958,6 +1110,22 @@ defmodule AxisConfig do
   def encode_label_font(value) when is_binary(value), do: value
   def encode_label_font(_), do: {:error, "Unexpected type when encoding AxisConfig.label_font"}
 
+  def decode_label_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_label_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_label_font_size(_), do: {:error, "Unexpected type when decoding AxisConfig.label_font_size"}
+
+  def encode_label_font_size(value) when is_float(value), do: value
+  def encode_label_font_size(value) when is_integer(value), do: value
+  def encode_label_font_size(_), do: {:error, "Unexpected type when encoding AxisConfig.label_font_size"}
+
+  def decode_label_limit(value) when is_float(value), do: value
+  def decode_label_limit(value) when is_integer(value), do: value
+  def decode_label_limit(_), do: {:error, "Unexpected type when decoding AxisConfig.label_limit"}
+
+  def encode_label_limit(value) when is_float(value), do: value
+  def encode_label_limit(value) when is_integer(value), do: value
+  def encode_label_limit(_), do: {:error, "Unexpected type when encoding AxisConfig.label_limit"}
+
   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
@@ -968,18 +1136,66 @@ 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_label_padding(value) when is_float(value), do: value
+  def decode_label_padding(value) when is_integer(value), do: value
+  def decode_label_padding(_), do: {:error, "Unexpected type when decoding AxisConfig.label_padding"}
+
+  def encode_label_padding(value) when is_float(value), do: value
+  def encode_label_padding(value) when is_integer(value), do: value
+  def encode_label_padding(_), do: {:error, "Unexpected type when encoding AxisConfig.label_padding"}
+
+  def decode_max_extent(value) when is_float(value), do: value
+  def decode_max_extent(value) when is_integer(value), do: value
+  def decode_max_extent(_), do: {:error, "Unexpected type when decoding AxisConfig.max_extent"}
+
+  def encode_max_extent(value) when is_float(value), do: value
+  def encode_max_extent(value) when is_integer(value), do: value
+  def encode_max_extent(_), do: {:error, "Unexpected type when encoding AxisConfig.max_extent"}
+
+  def decode_min_extent(value) when is_float(value), do: value
+  def decode_min_extent(value) when is_integer(value), do: value
+  def decode_min_extent(_), do: {:error, "Unexpected type when decoding AxisConfig.min_extent"}
+
+  def encode_min_extent(value) when is_float(value), do: value
+  def encode_min_extent(value) when is_integer(value), do: value
+  def encode_min_extent(_), do: {:error, "Unexpected type when encoding AxisConfig.min_extent"}
+
   def decode_tick_color(value) when is_binary(value), do: value
   def decode_tick_color(_), do: {:error, "Unexpected type when decoding AxisConfig.tick_color"}
 
   def encode_tick_color(value) when is_binary(value), do: value
   def encode_tick_color(_), do: {:error, "Unexpected type when encoding AxisConfig.tick_color"}
 
+  def decode_tick_size(value) when is_float(value) and value >= 0, do: value
+  def decode_tick_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_tick_size(_), do: {:error, "Unexpected type when decoding AxisConfig.tick_size"}
+
+  def encode_tick_size(value) when is_float(value), do: value
+  def encode_tick_size(value) when is_integer(value), do: value
+  def encode_tick_size(_), do: {:error, "Unexpected type when encoding AxisConfig.tick_size"}
+
+  def decode_tick_width(value) when is_float(value) and value >= 0, do: value
+  def decode_tick_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_tick_width(_), do: {:error, "Unexpected type when decoding AxisConfig.tick_width"}
+
+  def encode_tick_width(value) when is_float(value), do: value
+  def encode_tick_width(value) when is_integer(value), do: value
+  def encode_tick_width(_), do: {:error, "Unexpected type when encoding AxisConfig.tick_width"}
+
   def decode_title_align(value) when is_binary(value), do: value
   def decode_title_align(_), do: {:error, "Unexpected type when decoding AxisConfig.title_align"}
 
   def encode_title_align(value) when is_binary(value), do: value
   def encode_title_align(_), do: {:error, "Unexpected type when encoding AxisConfig.title_align"}
 
+  def decode_title_angle(value) when is_float(value), do: value
+  def decode_title_angle(value) when is_integer(value), do: value
+  def decode_title_angle(_), do: {:error, "Unexpected type when decoding AxisConfig.title_angle"}
+
+  def encode_title_angle(value) when is_float(value), do: value
+  def encode_title_angle(value) when is_integer(value), do: value
+  def encode_title_angle(_), do: {:error, "Unexpected type when encoding AxisConfig.title_angle"}
+
   def decode_title_baseline(value) when is_binary(value), do: value
   def decode_title_baseline(_), do: {:error, "Unexpected type when decoding AxisConfig.title_baseline"}
 
@@ -998,47 +1214,95 @@ defmodule AxisConfig do
   def encode_title_font(value) when is_binary(value), do: value
   def encode_title_font(_), do: {:error, "Unexpected type when encoding AxisConfig.title_font"}
 
+  def decode_title_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_title_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_title_font_size(_), do: {:error, "Unexpected type when decoding AxisConfig.title_font_size"}
+
+  def encode_title_font_size(value) when is_float(value), do: value
+  def encode_title_font_size(value) when is_integer(value), do: value
+  def encode_title_font_size(_), do: {:error, "Unexpected type when encoding AxisConfig.title_font_size"}
+
+  def decode_title_limit(value) when is_float(value), do: value
+  def decode_title_limit(value) when is_integer(value), do: value
+  def decode_title_limit(_), do: {:error, "Unexpected type when decoding AxisConfig.title_limit"}
+
+  def encode_title_limit(value) when is_float(value), do: value
+  def encode_title_limit(value) when is_integer(value), do: value
+  def encode_title_limit(_), do: {:error, "Unexpected type when encoding AxisConfig.title_limit"}
+
+  def decode_title_max_length(value) when is_float(value), do: value
+  def decode_title_max_length(value) when is_integer(value), do: value
+  def decode_title_max_length(_), do: {:error, "Unexpected type when decoding AxisConfig.title_max_length"}
+
+  def encode_title_max_length(value) when is_float(value), do: value
+  def encode_title_max_length(value) when is_integer(value), do: value
+  def encode_title_max_length(_), do: {:error, "Unexpected type when encoding AxisConfig.title_max_length"}
+
+  def decode_title_padding(value) when is_float(value), do: value
+  def decode_title_padding(value) when is_integer(value), do: value
+  def decode_title_padding(_), do: {:error, "Unexpected type when decoding AxisConfig.title_padding"}
+
+  def encode_title_padding(value) when is_float(value), do: value
+  def encode_title_padding(value) when is_integer(value), do: value
+  def encode_title_padding(_), do: {:error, "Unexpected type when encoding AxisConfig.title_padding"}
+
+  def decode_title_x(value) when is_float(value), do: value
+  def decode_title_x(value) when is_integer(value), do: value
+  def decode_title_x(_), do: {:error, "Unexpected type when decoding AxisConfig.title_x"}
+
+  def encode_title_x(value) when is_float(value), do: value
+  def encode_title_x(value) when is_integer(value), do: value
+  def encode_title_x(_), do: {:error, "Unexpected type when encoding AxisConfig.title_x"}
+
+  def decode_title_y(value) when is_float(value), do: value
+  def decode_title_y(value) when is_integer(value), do: value
+  def decode_title_y(_), do: {:error, "Unexpected type when decoding AxisConfig.title_y"}
+
+  def encode_title_y(value) when is_float(value), do: value
+  def encode_title_y(value) when is_integer(value), do: value
+  def encode_title_y(_), do: {:error, "Unexpected type when encoding AxisConfig.title_y"}
+
   def from_map(m) do
     %AxisConfig{
-      band_position: m["bandPosition"],
+      band_position: m["bandPosition"] && decode_band_position(m["bandPosition"]),
       domain: m["domain"],
       domain_color: m["domainColor"] && decode_domain_color(m["domainColor"]),
-      domain_width: m["domainWidth"],
+      domain_width: m["domainWidth"] && decode_domain_width(m["domainWidth"]),
       grid: m["grid"],
       grid_color: m["gridColor"] && decode_grid_color(m["gridColor"]),
       grid_dash: m["gridDash"],
-      grid_opacity: m["gridOpacity"],
-      grid_width: m["gridWidth"],
-      label_angle: m["labelAngle"],
+      grid_opacity: m["gridOpacity"] && decode_grid_opacity(m["gridOpacity"]),
+      grid_width: m["gridWidth"] && decode_grid_width(m["gridWidth"]),
+      label_angle: m["labelAngle"] && decode_label_angle(m["labelAngle"]),
       label_bound: m["labelBound"],
       label_color: m["labelColor"] && decode_label_color(m["labelColor"]),
       label_flush: m["labelFlush"],
       label_font: m["labelFont"] && decode_label_font(m["labelFont"]),
-      label_font_size: m["labelFontSize"],
-      label_limit: m["labelLimit"],
+      label_font_size: m["labelFontSize"] && decode_label_font_size(m["labelFontSize"]),
+      label_limit: m["labelLimit"] && decode_label_limit(m["labelLimit"]),
       label_overlap: decode_label_overlap(m["labelOverlap"]),
-      label_padding: m["labelPadding"],
+      label_padding: m["labelPadding"] && decode_label_padding(m["labelPadding"]),
       labels: m["labels"],
-      max_extent: m["maxExtent"],
-      min_extent: m["minExtent"],
+      max_extent: m["maxExtent"] && decode_max_extent(m["maxExtent"]),
+      min_extent: m["minExtent"] && decode_min_extent(m["minExtent"]),
       short_time_labels: m["shortTimeLabels"],
       tick_color: m["tickColor"] && decode_tick_color(m["tickColor"]),
       tick_round: m["tickRound"],
       ticks: m["ticks"],
-      tick_size: m["tickSize"],
-      tick_width: m["tickWidth"],
+      tick_size: m["tickSize"] && decode_tick_size(m["tickSize"]),
+      tick_width: m["tickWidth"] && decode_tick_width(m["tickWidth"]),
       title_align: m["titleAlign"] && decode_title_align(m["titleAlign"]),
-      title_angle: m["titleAngle"],
+      title_angle: m["titleAngle"] && decode_title_angle(m["titleAngle"]),
       title_baseline: m["titleBaseline"] && decode_title_baseline(m["titleBaseline"]),
       title_color: m["titleColor"] && decode_title_color(m["titleColor"]),
       title_font: m["titleFont"] && decode_title_font(m["titleFont"]),
-      title_font_size: m["titleFontSize"],
+      title_font_size: m["titleFontSize"] && decode_title_font_size(m["titleFontSize"]),
       title_font_weight: m["titleFontWeight"],
-      title_limit: m["titleLimit"],
-      title_max_length: m["titleMaxLength"],
-      title_padding: m["titlePadding"],
-      title_x: m["titleX"],
-      title_y: m["titleY"],
+      title_limit: m["titleLimit"] && decode_title_limit(m["titleLimit"]),
+      title_max_length: m["titleMaxLength"] && decode_title_max_length(m["titleMaxLength"]),
+      title_padding: m["titlePadding"] && decode_title_padding(m["titlePadding"]),
+      title_x: m["titleX"] && decode_title_x(m["titleX"]),
+      title_y: m["titleY"] && decode_title_y(m["titleY"]),
     }
   end
 
@@ -1197,18 +1461,58 @@ defmodule VGAxisConfig do
           title_y: float() | nil
         }
 
+  def decode_band_position(value) when is_float(value), do: value
+  def decode_band_position(value) when is_integer(value), do: value
+  def decode_band_position(_), do: {:error, "Unexpected type when decoding VGAxisConfig.band_position"}
+
+  def encode_band_position(value) when is_float(value), do: value
+  def encode_band_position(value) when is_integer(value), do: value
+  def encode_band_position(_), do: {:error, "Unexpected type when encoding VGAxisConfig.band_position"}
+
   def decode_domain_color(value) when is_binary(value), do: value
   def decode_domain_color(_), do: {:error, "Unexpected type when decoding VGAxisConfig.domain_color"}
 
   def encode_domain_color(value) when is_binary(value), do: value
   def encode_domain_color(_), do: {:error, "Unexpected type when encoding VGAxisConfig.domain_color"}
 
+  def decode_domain_width(value) when is_float(value), do: value
+  def decode_domain_width(value) when is_integer(value), do: value
+  def decode_domain_width(_), do: {:error, "Unexpected type when decoding VGAxisConfig.domain_width"}
+
+  def encode_domain_width(value) when is_float(value), do: value
+  def encode_domain_width(value) when is_integer(value), do: value
+  def encode_domain_width(_), do: {:error, "Unexpected type when encoding VGAxisConfig.domain_width"}
+
   def decode_grid_color(value) when is_binary(value), do: value
   def decode_grid_color(_), do: {:error, "Unexpected type when decoding VGAxisConfig.grid_color"}
 
   def encode_grid_color(value) when is_binary(value), do: value
   def encode_grid_color(_), do: {:error, "Unexpected type when encoding VGAxisConfig.grid_color"}
 
+  def decode_grid_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_grid_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_grid_opacity(_), do: {:error, "Unexpected type when decoding VGAxisConfig.grid_opacity"}
+
+  def encode_grid_opacity(value) when is_float(value), do: value
+  def encode_grid_opacity(value) when is_integer(value), do: value
+  def encode_grid_opacity(_), do: {:error, "Unexpected type when encoding VGAxisConfig.grid_opacity"}
+
+  def decode_grid_width(value) when is_float(value) and value >= 0, do: value
+  def decode_grid_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_grid_width(_), do: {:error, "Unexpected type when decoding VGAxisConfig.grid_width"}
+
+  def encode_grid_width(value) when is_float(value), do: value
+  def encode_grid_width(value) when is_integer(value), do: value
+  def encode_grid_width(_), do: {:error, "Unexpected type when encoding VGAxisConfig.grid_width"}
+
+  def decode_label_angle(value) when is_float(value) and value >= -360 and value <= 360, do: value
+  def decode_label_angle(value) when is_integer(value) and value >= -360 and value <= 360, do: value
+  def decode_label_angle(_), do: {:error, "Unexpected type when decoding VGAxisConfig.label_angle"}
+
+  def encode_label_angle(value) when is_float(value), do: value
+  def encode_label_angle(value) when is_integer(value), do: value
+  def encode_label_angle(_), do: {:error, "Unexpected type when encoding VGAxisConfig.label_angle"}
+
   def decode_label_color(value) when is_binary(value), do: value
   def decode_label_color(_), do: {:error, "Unexpected type when decoding VGAxisConfig.label_color"}
 
@@ -1221,6 +1525,22 @@ defmodule VGAxisConfig do
   def encode_label_font(value) when is_binary(value), do: value
   def encode_label_font(_), do: {:error, "Unexpected type when encoding VGAxisConfig.label_font"}
 
+  def decode_label_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_label_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_label_font_size(_), do: {:error, "Unexpected type when decoding VGAxisConfig.label_font_size"}
+
+  def encode_label_font_size(value) when is_float(value), do: value
+  def encode_label_font_size(value) when is_integer(value), do: value
+  def encode_label_font_size(_), do: {:error, "Unexpected type when encoding VGAxisConfig.label_font_size"}
+
+  def decode_label_limit(value) when is_float(value), do: value
+  def decode_label_limit(value) when is_integer(value), do: value
+  def decode_label_limit(_), do: {:error, "Unexpected type when decoding VGAxisConfig.label_limit"}
+
+  def encode_label_limit(value) when is_float(value), do: value
+  def encode_label_limit(value) when is_integer(value), do: value
+  def encode_label_limit(_), do: {:error, "Unexpected type when encoding VGAxisConfig.label_limit"}
+
   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
@@ -1231,18 +1551,66 @@ 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_label_padding(value) when is_float(value), do: value
+  def decode_label_padding(value) when is_integer(value), do: value
+  def decode_label_padding(_), do: {:error, "Unexpected type when decoding VGAxisConfig.label_padding"}
+
+  def encode_label_padding(value) when is_float(value), do: value
+  def encode_label_padding(value) when is_integer(value), do: value
+  def encode_label_padding(_), do: {:error, "Unexpected type when encoding VGAxisConfig.label_padding"}
+
+  def decode_max_extent(value) when is_float(value), do: value
+  def decode_max_extent(value) when is_integer(value), do: value
+  def decode_max_extent(_), do: {:error, "Unexpected type when decoding VGAxisConfig.max_extent"}
+
+  def encode_max_extent(value) when is_float(value), do: value
+  def encode_max_extent(value) when is_integer(value), do: value
+  def encode_max_extent(_), do: {:error, "Unexpected type when encoding VGAxisConfig.max_extent"}
+
+  def decode_min_extent(value) when is_float(value), do: value
+  def decode_min_extent(value) when is_integer(value), do: value
+  def decode_min_extent(_), do: {:error, "Unexpected type when decoding VGAxisConfig.min_extent"}
+
+  def encode_min_extent(value) when is_float(value), do: value
+  def encode_min_extent(value) when is_integer(value), do: value
+  def encode_min_extent(_), do: {:error, "Unexpected type when encoding VGAxisConfig.min_extent"}
+
   def decode_tick_color(value) when is_binary(value), do: value
   def decode_tick_color(_), do: {:error, "Unexpected type when decoding VGAxisConfig.tick_color"}
 
   def encode_tick_color(value) when is_binary(value), do: value
   def encode_tick_color(_), do: {:error, "Unexpected type when encoding VGAxisConfig.tick_color"}
 
+  def decode_tick_size(value) when is_float(value) and value >= 0, do: value
+  def decode_tick_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_tick_size(_), do: {:error, "Unexpected type when decoding VGAxisConfig.tick_size"}
+
+  def encode_tick_size(value) when is_float(value), do: value
+  def encode_tick_size(value) when is_integer(value), do: value
+  def encode_tick_size(_), do: {:error, "Unexpected type when encoding VGAxisConfig.tick_size"}
+
+  def decode_tick_width(value) when is_float(value) and value >= 0, do: value
+  def decode_tick_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_tick_width(_), do: {:error, "Unexpected type when decoding VGAxisConfig.tick_width"}
+
+  def encode_tick_width(value) when is_float(value), do: value
+  def encode_tick_width(value) when is_integer(value), do: value
+  def encode_tick_width(_), do: {:error, "Unexpected type when encoding VGAxisConfig.tick_width"}
+
   def decode_title_align(value) when is_binary(value), do: value
   def decode_title_align(_), do: {:error, "Unexpected type when decoding VGAxisConfig.title_align"}
 
   def encode_title_align(value) when is_binary(value), do: value
   def encode_title_align(_), do: {:error, "Unexpected type when encoding VGAxisConfig.title_align"}
 
+  def decode_title_angle(value) when is_float(value), do: value
+  def decode_title_angle(value) when is_integer(value), do: value
+  def decode_title_angle(_), do: {:error, "Unexpected type when decoding VGAxisConfig.title_angle"}
+
+  def encode_title_angle(value) when is_float(value), do: value
+  def encode_title_angle(value) when is_integer(value), do: value
+  def encode_title_angle(_), do: {:error, "Unexpected type when encoding VGAxisConfig.title_angle"}
+
   def decode_title_baseline(value) when is_binary(value), do: value
   def decode_title_baseline(_), do: {:error, "Unexpected type when decoding VGAxisConfig.title_baseline"}
 
@@ -1261,46 +1629,94 @@ defmodule VGAxisConfig do
   def encode_title_font(value) when is_binary(value), do: value
   def encode_title_font(_), do: {:error, "Unexpected type when encoding VGAxisConfig.title_font"}
 
+  def decode_title_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_title_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_title_font_size(_), do: {:error, "Unexpected type when decoding VGAxisConfig.title_font_size"}
+
+  def encode_title_font_size(value) when is_float(value), do: value
+  def encode_title_font_size(value) when is_integer(value), do: value
+  def encode_title_font_size(_), do: {:error, "Unexpected type when encoding VGAxisConfig.title_font_size"}
+
+  def decode_title_limit(value) when is_float(value), do: value
+  def decode_title_limit(value) when is_integer(value), do: value
+  def decode_title_limit(_), do: {:error, "Unexpected type when decoding VGAxisConfig.title_limit"}
+
+  def encode_title_limit(value) when is_float(value), do: value
+  def encode_title_limit(value) when is_integer(value), do: value
+  def encode_title_limit(_), do: {:error, "Unexpected type when encoding VGAxisConfig.title_limit"}
+
+  def decode_title_max_length(value) when is_float(value), do: value
+  def decode_title_max_length(value) when is_integer(value), do: value
+  def decode_title_max_length(_), do: {:error, "Unexpected type when decoding VGAxisConfig.title_max_length"}
+
+  def encode_title_max_length(value) when is_float(value), do: value
+  def encode_title_max_length(value) when is_integer(value), do: value
+  def encode_title_max_length(_), do: {:error, "Unexpected type when encoding VGAxisConfig.title_max_length"}
+
+  def decode_title_padding(value) when is_float(value), do: value
+  def decode_title_padding(value) when is_integer(value), do: value
+  def decode_title_padding(_), do: {:error, "Unexpected type when decoding VGAxisConfig.title_padding"}
+
+  def encode_title_padding(value) when is_float(value), do: value
+  def encode_title_padding(value) when is_integer(value), do: value
+  def encode_title_padding(_), do: {:error, "Unexpected type when encoding VGAxisConfig.title_padding"}
+
+  def decode_title_x(value) when is_float(value), do: value
+  def decode_title_x(value) when is_integer(value), do: value
+  def decode_title_x(_), do: {:error, "Unexpected type when decoding VGAxisConfig.title_x"}
+
+  def encode_title_x(value) when is_float(value), do: value
+  def encode_title_x(value) when is_integer(value), do: value
+  def encode_title_x(_), do: {:error, "Unexpected type when encoding VGAxisConfig.title_x"}
+
+  def decode_title_y(value) when is_float(value), do: value
+  def decode_title_y(value) when is_integer(value), do: value
+  def decode_title_y(_), do: {:error, "Unexpected type when decoding VGAxisConfig.title_y"}
+
+  def encode_title_y(value) when is_float(value), do: value
+  def encode_title_y(value) when is_integer(value), do: value
+  def encode_title_y(_), do: {:error, "Unexpected type when encoding VGAxisConfig.title_y"}
+
   def from_map(m) do
     %VGAxisConfig{
-      band_position: m["bandPosition"],
+      band_position: m["bandPosition"] && decode_band_position(m["bandPosition"]),
       domain: m["domain"],
       domain_color: m["domainColor"] && decode_domain_color(m["domainColor"]),
-      domain_width: m["domainWidth"],
+      domain_width: m["domainWidth"] && decode_domain_width(m["domainWidth"]),
       grid: m["grid"],
       grid_color: m["gridColor"] && decode_grid_color(m["gridColor"]),
       grid_dash: m["gridDash"],
-      grid_opacity: m["gridOpacity"],
-      grid_width: m["gridWidth"],
-      label_angle: m["labelAngle"],
+      grid_opacity: m["gridOpacity"] && decode_grid_opacity(m["gridOpacity"]),
+      grid_width: m["gridWidth"] && decode_grid_width(m["gridWidth"]),
+      label_angle: m["labelAngle"] && decode_label_angle(m["labelAngle"]),
       label_bound: m["labelBound"],
       label_color: m["labelColor"] && decode_label_color(m["labelColor"]),
       label_flush: m["labelFlush"],
       label_font: m["labelFont"] && decode_label_font(m["labelFont"]),
-      label_font_size: m["labelFontSize"],
-      label_limit: m["labelLimit"],
+      label_font_size: m["labelFontSize"] && decode_label_font_size(m["labelFontSize"]),
+      label_limit: m["labelLimit"] && decode_label_limit(m["labelLimit"]),
       label_overlap: decode_label_overlap(m["labelOverlap"]),
-      label_padding: m["labelPadding"],
+      label_padding: m["labelPadding"] && decode_label_padding(m["labelPadding"]),
       labels: m["labels"],
-      max_extent: m["maxExtent"],
-      min_extent: m["minExtent"],
+      max_extent: m["maxExtent"] && decode_max_extent(m["maxExtent"]),
+      min_extent: m["minExtent"] && decode_min_extent(m["minExtent"]),
       tick_color: m["tickColor"] && decode_tick_color(m["tickColor"]),
       tick_round: m["tickRound"],
       ticks: m["ticks"],
-      tick_size: m["tickSize"],
-      tick_width: m["tickWidth"],
+      tick_size: m["tickSize"] && decode_tick_size(m["tickSize"]),
+      tick_width: m["tickWidth"] && decode_tick_width(m["tickWidth"]),
       title_align: m["titleAlign"] && decode_title_align(m["titleAlign"]),
-      title_angle: m["titleAngle"],
+      title_angle: m["titleAngle"] && decode_title_angle(m["titleAngle"]),
       title_baseline: m["titleBaseline"] && decode_title_baseline(m["titleBaseline"]),
       title_color: m["titleColor"] && decode_title_color(m["titleColor"]),
       title_font: m["titleFont"] && decode_title_font(m["titleFont"]),
-      title_font_size: m["titleFontSize"],
+      title_font_size: m["titleFontSize"] && decode_title_font_size(m["titleFontSize"]),
       title_font_weight: m["titleFontWeight"],
-      title_limit: m["titleLimit"],
-      title_max_length: m["titleMaxLength"],
-      title_padding: m["titlePadding"],
-      title_x: m["titleX"],
-      title_y: m["titleY"],
+      title_limit: m["titleLimit"] && decode_title_limit(m["titleLimit"]),
+      title_max_length: m["titleMaxLength"] && decode_title_max_length(m["titleMaxLength"]),
+      title_padding: m["titlePadding"] && decode_title_padding(m["titlePadding"]),
+      title_x: m["titleX"] && decode_title_x(m["titleX"]),
+      title_y: m["titleY"] && decode_title_y(m["titleY"]),
     }
   end
 
@@ -1436,27 +1852,91 @@ defmodule BarConfig do
           theta: float() | nil
         }
 
+  def decode_angle(value) when is_float(value) and value >= 0 and value <= 360, do: value
+  def decode_angle(value) when is_integer(value) and value >= 0 and value <= 360, do: value
+  def decode_angle(_), do: {:error, "Unexpected type when decoding BarConfig.angle"}
+
+  def encode_angle(value) when is_float(value), do: value
+  def encode_angle(value) when is_integer(value), do: value
+  def encode_angle(_), do: {:error, "Unexpected type when encoding BarConfig.angle"}
+
+  def decode_bin_spacing(value) when is_float(value) and value >= 0, do: value
+  def decode_bin_spacing(value) when is_integer(value) and value >= 0, do: value
+  def decode_bin_spacing(_), do: {:error, "Unexpected type when decoding BarConfig.bin_spacing"}
+
+  def encode_bin_spacing(value) when is_float(value), do: value
+  def encode_bin_spacing(value) when is_integer(value), do: value
+  def encode_bin_spacing(_), do: {:error, "Unexpected type when encoding BarConfig.bin_spacing"}
+
   def decode_color(value) when is_binary(value), do: value
   def decode_color(_), do: {:error, "Unexpected type when decoding BarConfig.color"}
 
   def encode_color(value) when is_binary(value), do: value
   def encode_color(_), do: {:error, "Unexpected type when encoding BarConfig.color"}
 
+  def decode_continuous_band_size(value) when is_float(value) and value >= 0, do: value
+  def decode_continuous_band_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_continuous_band_size(_), do: {:error, "Unexpected type when decoding BarConfig.continuous_band_size"}
+
+  def encode_continuous_band_size(value) when is_float(value), do: value
+  def encode_continuous_band_size(value) when is_integer(value), do: value
+  def encode_continuous_band_size(_), do: {:error, "Unexpected type when encoding BarConfig.continuous_band_size"}
+
+  def decode_discrete_band_size(value) when is_float(value) and value >= 0, do: value
+  def decode_discrete_band_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_discrete_band_size(_), do: {:error, "Unexpected type when decoding BarConfig.discrete_band_size"}
+
+  def encode_discrete_band_size(value) when is_float(value), do: value
+  def encode_discrete_band_size(value) when is_integer(value), do: value
+  def encode_discrete_band_size(_), do: {:error, "Unexpected type when encoding BarConfig.discrete_band_size"}
+
+  def decode_dx(value) when is_float(value), do: value
+  def decode_dx(value) when is_integer(value), do: value
+  def decode_dx(_), do: {:error, "Unexpected type when decoding BarConfig.dx"}
+
+  def encode_dx(value) when is_float(value), do: value
+  def encode_dx(value) when is_integer(value), do: value
+  def encode_dx(_), do: {:error, "Unexpected type when encoding BarConfig.dx"}
+
+  def decode_dy(value) when is_float(value), do: value
+  def decode_dy(value) when is_integer(value), do: value
+  def decode_dy(_), do: {:error, "Unexpected type when decoding BarConfig.dy"}
+
+  def encode_dy(value) when is_float(value), do: value
+  def encode_dy(value) when is_integer(value), do: value
+  def encode_dy(_), do: {:error, "Unexpected type when encoding BarConfig.dy"}
+
   def decode_fill(value) when is_binary(value), do: value
   def decode_fill(_), do: {:error, "Unexpected type when decoding BarConfig.fill"}
 
   def encode_fill(value) when is_binary(value), do: value
   def encode_fill(_), do: {:error, "Unexpected type when encoding BarConfig.fill"}
 
+  def decode_fill_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_fill_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_fill_opacity(_), do: {:error, "Unexpected type when decoding BarConfig.fill_opacity"}
+
+  def encode_fill_opacity(value) when is_float(value), do: value
+  def encode_fill_opacity(value) when is_integer(value), do: value
+  def encode_fill_opacity(_), do: {:error, "Unexpected type when encoding BarConfig.fill_opacity"}
+
   def decode_font(value) when is_binary(value), do: value
   def decode_font(_), do: {:error, "Unexpected type when decoding BarConfig.font"}
 
   def encode_font(value) when is_binary(value), do: value
   def encode_font(_), do: {:error, "Unexpected type when encoding BarConfig.font"}
 
+  def decode_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_font_size(_), do: {:error, "Unexpected type when decoding BarConfig.font_size"}
+
+  def encode_font_size(value) when is_float(value), do: value
+  def encode_font_size(value) when is_integer(value), do: value
+  def encode_font_size(_), do: {:error, "Unexpected type when encoding BarConfig.font_size"}
+
   def decode_font_weight(value) when is_binary(value), do: FontWeight.decode(value)
-  def decode_font_weight(value) when is_float(value), do: value
-  def decode_font_weight(value) when is_integer(value), do: value
+  def decode_font_weight(value) when is_float(value) and value >= 100 and value <= 900, do: value
+  def decode_font_weight(value) when is_integer(value) and value >= 100 and value <= 900, do: value
   def decode_font_weight(value) when is_nil(value), do: value
   def decode_font_weight(_), do: {:error, "Unexpected type when decoding BarConfig.font_weight"}
 
@@ -1472,59 +1952,131 @@ defmodule BarConfig do
   def encode_href(value) when is_binary(value), do: value
   def encode_href(_), do: {:error, "Unexpected type when encoding BarConfig.href"}
 
+  def decode_limit(value) when is_float(value), do: value
+  def decode_limit(value) when is_integer(value), do: value
+  def decode_limit(_), do: {:error, "Unexpected type when decoding BarConfig.limit"}
+
+  def encode_limit(value) when is_float(value), do: value
+  def encode_limit(value) when is_integer(value), do: value
+  def encode_limit(_), do: {:error, "Unexpected type when encoding BarConfig.limit"}
+
+  def decode_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_opacity(_), do: {:error, "Unexpected type when decoding BarConfig.opacity"}
+
+  def encode_opacity(value) when is_float(value), do: value
+  def encode_opacity(value) when is_integer(value), do: value
+  def encode_opacity(_), do: {:error, "Unexpected type when encoding BarConfig.opacity"}
+
+  def decode_radius(value) when is_float(value) and value >= 0, do: value
+  def decode_radius(value) when is_integer(value) and value >= 0, do: value
+  def decode_radius(_), do: {:error, "Unexpected type when decoding BarConfig.radius"}
+
+  def encode_radius(value) when is_float(value), do: value
+  def encode_radius(value) when is_integer(value), do: value
+  def encode_radius(_), do: {:error, "Unexpected type when encoding BarConfig.radius"}
+
   def decode_shape(value) when is_binary(value), do: value
   def decode_shape(_), do: {:error, "Unexpected type when decoding BarConfig.shape"}
 
   def encode_shape(value) when is_binary(value), do: value
   def encode_shape(_), do: {:error, "Unexpected type when encoding BarConfig.shape"}
 
+  def decode_size(value) when is_float(value) and value >= 0, do: value
+  def decode_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_size(_), do: {:error, "Unexpected type when decoding BarConfig.size"}
+
+  def encode_size(value) when is_float(value), do: value
+  def encode_size(value) when is_integer(value), do: value
+  def encode_size(_), do: {:error, "Unexpected type when encoding BarConfig.size"}
+
   def decode_stroke(value) when is_binary(value), do: value
   def decode_stroke(_), do: {:error, "Unexpected type when decoding BarConfig.stroke"}
 
   def encode_stroke(value) when is_binary(value), do: value
   def encode_stroke(_), do: {:error, "Unexpected type when encoding BarConfig.stroke"}
 
+  def decode_stroke_dash_offset(value) when is_float(value), do: value
+  def decode_stroke_dash_offset(value) when is_integer(value), do: value
+  def decode_stroke_dash_offset(_), do: {:error, "Unexpected type when decoding BarConfig.stroke_dash_offset"}
+
+  def encode_stroke_dash_offset(value) when is_float(value), do: value
+  def encode_stroke_dash_offset(value) when is_integer(value), do: value
+  def encode_stroke_dash_offset(_), do: {:error, "Unexpected type when encoding BarConfig.stroke_dash_offset"}
+
+  def decode_stroke_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_stroke_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_stroke_opacity(_), do: {:error, "Unexpected type when decoding BarConfig.stroke_opacity"}
+
+  def encode_stroke_opacity(value) when is_float(value), do: value
+  def encode_stroke_opacity(value) when is_integer(value), do: value
+  def encode_stroke_opacity(_), do: {:error, "Unexpected type when encoding BarConfig.stroke_opacity"}
+
+  def decode_stroke_width(value) when is_float(value) and value >= 0, do: value
+  def decode_stroke_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_stroke_width(_), do: {:error, "Unexpected type when decoding BarConfig.stroke_width"}
+
+  def encode_stroke_width(value) when is_float(value), do: value
+  def encode_stroke_width(value) when is_integer(value), do: value
+  def encode_stroke_width(_), do: {:error, "Unexpected type when encoding BarConfig.stroke_width"}
+
+  def decode_tension(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_tension(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_tension(_), do: {:error, "Unexpected type when decoding BarConfig.tension"}
+
+  def encode_tension(value) when is_float(value), do: value
+  def encode_tension(value) when is_integer(value), do: value
+  def encode_tension(_), do: {:error, "Unexpected type when encoding BarConfig.tension"}
+
   def decode_text(value) when is_binary(value), do: value
   def decode_text(_), do: {:error, "Unexpected type when decoding BarConfig.text"}
 
   def encode_text(value) when is_binary(value), do: value
   def encode_text(_), do: {:error, "Unexpected type when encoding BarConfig.text"}
 
+  def decode_theta(value) when is_float(value), do: value
+  def decode_theta(value) when is_integer(value), do: value
+  def decode_theta(_), do: {:error, "Unexpected type when decoding BarConfig.theta"}
+
+  def encode_theta(value) when is_float(value), do: value
+  def encode_theta(value) when is_integer(value), do: value
+  def encode_theta(_), do: {:error, "Unexpected type when encoding BarConfig.theta"}
+
   def from_map(m) do
     %BarConfig{
       align: m["align"] && HorizontalAlign.decode(m["align"]),
-      angle: m["angle"],
+      angle: m["angle"] && decode_angle(m["angle"]),
       baseline: m["baseline"] && VerticalAlign.decode(m["baseline"]),
-      bin_spacing: m["binSpacing"],
+      bin_spacing: m["binSpacing"] && decode_bin_spacing(m["binSpacing"]),
       color: m["color"] && decode_color(m["color"]),
-      continuous_band_size: m["continuousBandSize"],
+      continuous_band_size: m["continuousBandSize"] && decode_continuous_band_size(m["continuousBandSize"]),
       cursor: m["cursor"] && Cursor.decode(m["cursor"]),
-      discrete_band_size: m["discreteBandSize"],
-      dx: m["dx"],
-      dy: m["dy"],
+      discrete_band_size: m["discreteBandSize"] && decode_discrete_band_size(m["discreteBandSize"]),
+      dx: m["dx"] && decode_dx(m["dx"]),
+      dy: m["dy"] && decode_dy(m["dy"]),
       fill: m["fill"] && decode_fill(m["fill"]),
       filled: m["filled"],
-      fill_opacity: m["fillOpacity"],
+      fill_opacity: m["fillOpacity"] && decode_fill_opacity(m["fillOpacity"]),
       font: m["font"] && decode_font(m["font"]),
-      font_size: m["fontSize"],
+      font_size: m["fontSize"] && decode_font_size(m["fontSize"]),
       font_style: m["fontStyle"] && FontStyle.decode(m["fontStyle"]),
       font_weight: decode_font_weight(m["fontWeight"]),
       href: m["href"] && decode_href(m["href"]),
       interpolate: m["interpolate"] && Interpolate.decode(m["interpolate"]),
-      limit: m["limit"],
-      opacity: m["opacity"],
+      limit: m["limit"] && decode_limit(m["limit"]),
+      opacity: m["opacity"] && decode_opacity(m["opacity"]),
       orient: m["orient"] && Orient.decode(m["orient"]),
-      radius: m["radius"],
+      radius: m["radius"] && decode_radius(m["radius"]),
       shape: m["shape"] && decode_shape(m["shape"]),
-      size: m["size"],
+      size: m["size"] && decode_size(m["size"]),
       stroke: m["stroke"] && decode_stroke(m["stroke"]),
       stroke_dash: m["strokeDash"],
-      stroke_dash_offset: m["strokeDashOffset"],
-      stroke_opacity: m["strokeOpacity"],
-      stroke_width: m["strokeWidth"],
-      tension: m["tension"],
+      stroke_dash_offset: m["strokeDashOffset"] && decode_stroke_dash_offset(m["strokeDashOffset"]),
+      stroke_opacity: m["strokeOpacity"] && decode_stroke_opacity(m["strokeOpacity"]),
+      stroke_width: m["strokeWidth"] && decode_stroke_width(m["strokeWidth"]),
+      tension: m["tension"] && decode_tension(m["tension"]),
       text: m["text"] && decode_text(m["text"]),
-      theta: m["theta"],
+      theta: m["theta"] && decode_theta(m["theta"]),
     }
   end
 
@@ -1829,24 +2381,80 @@ defmodule LegendConfig do
           title_padding: float() | nil
         }
 
+  def decode_corner_radius(value) when is_float(value), do: value
+  def decode_corner_radius(value) when is_integer(value), do: value
+  def decode_corner_radius(_), do: {:error, "Unexpected type when decoding LegendConfig.corner_radius"}
+
+  def encode_corner_radius(value) when is_float(value), do: value
+  def encode_corner_radius(value) when is_integer(value), do: value
+  def encode_corner_radius(_), do: {:error, "Unexpected type when encoding LegendConfig.corner_radius"}
+
+  def decode_entry_padding(value) when is_float(value), do: value
+  def decode_entry_padding(value) when is_integer(value), do: value
+  def decode_entry_padding(_), do: {:error, "Unexpected type when decoding LegendConfig.entry_padding"}
+
+  def encode_entry_padding(value) when is_float(value), do: value
+  def encode_entry_padding(value) when is_integer(value), do: value
+  def encode_entry_padding(_), do: {:error, "Unexpected type when encoding LegendConfig.entry_padding"}
+
   def decode_fill_color(value) when is_binary(value), do: value
   def decode_fill_color(_), do: {:error, "Unexpected type when decoding LegendConfig.fill_color"}
 
   def encode_fill_color(value) when is_binary(value), do: value
   def encode_fill_color(_), do: {:error, "Unexpected type when encoding LegendConfig.fill_color"}
 
+  def decode_gradient_height(value) when is_float(value) and value >= 0, do: value
+  def decode_gradient_height(value) when is_integer(value) and value >= 0, do: value
+  def decode_gradient_height(_), do: {:error, "Unexpected type when decoding LegendConfig.gradient_height"}
+
+  def encode_gradient_height(value) when is_float(value), do: value
+  def encode_gradient_height(value) when is_integer(value), do: value
+  def encode_gradient_height(_), do: {:error, "Unexpected type when encoding LegendConfig.gradient_height"}
+
   def decode_gradient_label_baseline(value) when is_binary(value), do: value
   def decode_gradient_label_baseline(_), do: {:error, "Unexpected type when decoding LegendConfig.gradient_label_baseline"}
 
   def encode_gradient_label_baseline(value) when is_binary(value), do: value
   def encode_gradient_label_baseline(_), do: {:error, "Unexpected type when encoding LegendConfig.gradient_label_baseline"}
 
+  def decode_gradient_label_limit(value) when is_float(value), do: value
+  def decode_gradient_label_limit(value) when is_integer(value), do: value
+  def decode_gradient_label_limit(_), do: {:error, "Unexpected type when decoding LegendConfig.gradient_label_limit"}
+
+  def encode_gradient_label_limit(value) when is_float(value), do: value
+  def encode_gradient_label_limit(value) when is_integer(value), do: value
+  def encode_gradient_label_limit(_), do: {:error, "Unexpected type when encoding LegendConfig.gradient_label_limit"}
+
+  def decode_gradient_label_offset(value) when is_float(value), do: value
+  def decode_gradient_label_offset(value) when is_integer(value), do: value
+  def decode_gradient_label_offset(_), do: {:error, "Unexpected type when decoding LegendConfig.gradient_label_offset"}
+
+  def encode_gradient_label_offset(value) when is_float(value), do: value
+  def encode_gradient_label_offset(value) when is_integer(value), do: value
+  def encode_gradient_label_offset(_), do: {:error, "Unexpected type when encoding LegendConfig.gradient_label_offset"}
+
   def decode_gradient_stroke_color(value) when is_binary(value), do: value
   def decode_gradient_stroke_color(_), do: {:error, "Unexpected type when decoding LegendConfig.gradient_stroke_color"}
 
   def encode_gradient_stroke_color(value) when is_binary(value), do: value
   def encode_gradient_stroke_color(_), do: {:error, "Unexpected type when encoding LegendConfig.gradient_stroke_color"}
 
+  def decode_gradient_stroke_width(value) when is_float(value) and value >= 0, do: value
+  def decode_gradient_stroke_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_gradient_stroke_width(_), do: {:error, "Unexpected type when decoding LegendConfig.gradient_stroke_width"}
+
+  def encode_gradient_stroke_width(value) when is_float(value), do: value
+  def encode_gradient_stroke_width(value) when is_integer(value), do: value
+  def encode_gradient_stroke_width(_), do: {:error, "Unexpected type when encoding LegendConfig.gradient_stroke_width"}
+
+  def decode_gradient_width(value) when is_float(value) and value >= 0, do: value
+  def decode_gradient_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_gradient_width(_), do: {:error, "Unexpected type when decoding LegendConfig.gradient_width"}
+
+  def encode_gradient_width(value) when is_float(value), do: value
+  def encode_gradient_width(value) when is_integer(value), do: value
+  def encode_gradient_width(_), do: {:error, "Unexpected type when encoding LegendConfig.gradient_width"}
+
   def decode_label_align(value) when is_binary(value), do: value
   def decode_label_align(_), do: {:error, "Unexpected type when decoding LegendConfig.label_align"}
 
@@ -1871,18 +2479,82 @@ defmodule LegendConfig do
   def encode_label_font(value) when is_binary(value), do: value
   def encode_label_font(_), do: {:error, "Unexpected type when encoding LegendConfig.label_font"}
 
+  def decode_label_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_label_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_label_font_size(_), do: {:error, "Unexpected type when decoding LegendConfig.label_font_size"}
+
+  def encode_label_font_size(value) when is_float(value), do: value
+  def encode_label_font_size(value) when is_integer(value), do: value
+  def encode_label_font_size(_), do: {:error, "Unexpected type when encoding LegendConfig.label_font_size"}
+
+  def decode_label_limit(value) when is_float(value), do: value
+  def decode_label_limit(value) when is_integer(value), do: value
+  def decode_label_limit(_), do: {:error, "Unexpected type when decoding LegendConfig.label_limit"}
+
+  def encode_label_limit(value) when is_float(value), do: value
+  def encode_label_limit(value) when is_integer(value), do: value
+  def encode_label_limit(_), do: {:error, "Unexpected type when encoding LegendConfig.label_limit"}
+
+  def decode_label_offset(value) when is_float(value) and value >= 0, do: value
+  def decode_label_offset(value) when is_integer(value) and value >= 0, do: value
+  def decode_label_offset(_), do: {:error, "Unexpected type when decoding LegendConfig.label_offset"}
+
+  def encode_label_offset(value) when is_float(value), do: value
+  def encode_label_offset(value) when is_integer(value), do: value
+  def encode_label_offset(_), do: {:error, "Unexpected type when encoding LegendConfig.label_offset"}
+
+  def decode_offset(value) when is_float(value), do: value
+  def decode_offset(value) when is_integer(value), do: value
+  def decode_offset(_), do: {:error, "Unexpected type when decoding LegendConfig.offset"}
+
+  def encode_offset(value) when is_float(value), do: value
+  def encode_offset(value) when is_integer(value), do: value
+  def encode_offset(_), do: {:error, "Unexpected type when encoding LegendConfig.offset"}
+
+  def decode_padding(value) when is_float(value), do: value
+  def decode_padding(value) when is_integer(value), do: value
+  def decode_padding(_), do: {:error, "Unexpected type when decoding LegendConfig.padding"}
+
+  def encode_padding(value) when is_float(value), do: value
+  def encode_padding(value) when is_integer(value), do: value
+  def encode_padding(_), do: {:error, "Unexpected type when encoding LegendConfig.padding"}
+
   def decode_stroke_color(value) when is_binary(value), do: value
   def decode_stroke_color(_), do: {:error, "Unexpected type when decoding LegendConfig.stroke_color"}
 
   def encode_stroke_color(value) when is_binary(value), do: value
   def encode_stroke_color(_), do: {:error, "Unexpected type when encoding LegendConfig.stroke_color"}
 
+  def decode_stroke_width(value) when is_float(value), do: value
+  def decode_stroke_width(value) when is_integer(value), do: value
+  def decode_stroke_width(_), do: {:error, "Unexpected type when decoding LegendConfig.stroke_width"}
+
+  def encode_stroke_width(value) when is_float(value), do: value
+  def encode_stroke_width(value) when is_integer(value), do: value
+  def encode_stroke_width(_), do: {:error, "Unexpected type when encoding LegendConfig.stroke_width"}
+
   def decode_symbol_color(value) when is_binary(value), do: value
   def decode_symbol_color(_), do: {:error, "Unexpected type when decoding LegendConfig.symbol_color"}
 
   def encode_symbol_color(value) when is_binary(value), do: value
   def encode_symbol_color(_), do: {:error, "Unexpected type when encoding LegendConfig.symbol_color"}
 
+  def decode_symbol_size(value) when is_float(value) and value >= 0, do: value
+  def decode_symbol_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_symbol_size(_), do: {:error, "Unexpected type when decoding LegendConfig.symbol_size"}
+
+  def encode_symbol_size(value) when is_float(value), do: value
+  def encode_symbol_size(value) when is_integer(value), do: value
+  def encode_symbol_size(_), do: {:error, "Unexpected type when encoding LegendConfig.symbol_size"}
+
+  def decode_symbol_stroke_width(value) when is_float(value) and value >= 0, do: value
+  def decode_symbol_stroke_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_symbol_stroke_width(_), do: {:error, "Unexpected type when decoding LegendConfig.symbol_stroke_width"}
+
+  def encode_symbol_stroke_width(value) when is_float(value), do: value
+  def encode_symbol_stroke_width(value) when is_integer(value), do: value
+  def encode_symbol_stroke_width(_), do: {:error, "Unexpected type when encoding LegendConfig.symbol_stroke_width"}
+
   def decode_symbol_type(value) when is_binary(value), do: value
   def decode_symbol_type(_), do: {:error, "Unexpected type when decoding LegendConfig.symbol_type"}
 
@@ -1913,44 +2585,68 @@ defmodule LegendConfig do
   def encode_title_font(value) when is_binary(value), do: value
   def encode_title_font(_), do: {:error, "Unexpected type when encoding LegendConfig.title_font"}
 
+  def decode_title_font_size(value) when is_float(value), do: value
+  def decode_title_font_size(value) when is_integer(value), do: value
+  def decode_title_font_size(_), do: {:error, "Unexpected type when decoding LegendConfig.title_font_size"}
+
+  def encode_title_font_size(value) when is_float(value), do: value
+  def encode_title_font_size(value) when is_integer(value), do: value
+  def encode_title_font_size(_), do: {:error, "Unexpected type when encoding LegendConfig.title_font_size"}
+
+  def decode_title_limit(value) when is_float(value), do: value
+  def decode_title_limit(value) when is_integer(value), do: value
+  def decode_title_limit(_), do: {:error, "Unexpected type when decoding LegendConfig.title_limit"}
+
+  def encode_title_limit(value) when is_float(value), do: value
+  def encode_title_limit(value) when is_integer(value), do: value
+  def encode_title_limit(_), do: {:error, "Unexpected type when encoding LegendConfig.title_limit"}
+
+  def decode_title_padding(value) when is_float(value), do: value
+  def decode_title_padding(value) when is_integer(value), do: value
+  def decode_title_padding(_), do: {:error, "Unexpected type when decoding LegendConfig.title_padding"}
+
+  def encode_title_padding(value) when is_float(value), do: value
+  def encode_title_padding(value) when is_integer(value), do: value
+  def encode_title_padding(_), do: {:error, "Unexpected type when encoding LegendConfig.title_padding"}
+
   def from_map(m) do
     %LegendConfig{
-      corner_radius: m["cornerRadius"],
-      entry_padding: m["entryPadding"],
+      corner_radius: m["cornerRadius"] && decode_corner_radius(m["cornerRadius"]),
+      entry_padding: m["entryPadding"] && decode_entry_padding(m["entryPadding"]),
       fill_color: m["fillColor"] && decode_fill_color(m["fillColor"]),
-      gradient_height: m["gradientHeight"],
+      gradient_height: m["gradientHeight"] && decode_gradient_height(m["gradientHeight"]),
       gradient_label_baseline: m["gradientLabelBaseline"] && decode_gradient_label_baseline(m["gradientLabelBaseline"]),
-      gradient_label_limit: m["gradientLabelLimit"],
-      gradient_label_offset: m["gradientLabelOffset"],
+      gradient_label_limit: m["gradientLabelLimit"] && decode_gradient_label_limit(m["gradientLabelLimit"]),
+      gradient_label_offset: m["gradientLabelOffset"] && decode_gradient_label_offset(m["gradientLabelOffset"]),
       gradient_stroke_color: m["gradientStrokeColor"] && decode_gradient_stroke_color(m["gradientStrokeColor"]),
-      gradient_stroke_width: m["gradientStrokeWidth"],
-      gradient_width: m["gradientWidth"],
+      gradient_stroke_width: m["gradientStrokeWidth"] && decode_gradient_stroke_width(m["gradientStrokeWidth"]),
+      gradient_width: m["gradientWidth"] && decode_gradient_width(m["gradientWidth"]),
       label_align: m["labelAlign"] && decode_label_align(m["labelAlign"]),
       label_baseline: m["labelBaseline"] && decode_label_baseline(m["labelBaseline"]),
       label_color: m["labelColor"] && decode_label_color(m["labelColor"]),
       label_font: m["labelFont"] && decode_label_font(m["labelFont"]),
-      label_font_size: m["labelFontSize"],
-      label_limit: m["labelLimit"],
-      label_offset: m["labelOffset"],
-      offset: m["offset"],
+      label_font_size: m["labelFontSize"] && decode_label_font_size(m["labelFontSize"]),
+      label_limit: m["labelLimit"] && decode_label_limit(m["labelLimit"]),
+      label_offset: m["labelOffset"] && decode_label_offset(m["labelOffset"]),
+      offset: m["offset"] && decode_offset(m["offset"]),
       orient: m["orient"] && LegendOrient.decode(m["orient"]),
-      padding: m["padding"],
+      padding: m["padding"] && decode_padding(m["padding"]),
       short_time_labels: m["shortTimeLabels"],
       stroke_color: m["strokeColor"] && decode_stroke_color(m["strokeColor"]),
       stroke_dash: m["strokeDash"],
-      stroke_width: m["strokeWidth"],
+      stroke_width: m["strokeWidth"] && decode_stroke_width(m["strokeWidth"]),
       symbol_color: m["symbolColor"] && decode_symbol_color(m["symbolColor"]),
-      symbol_size: m["symbolSize"],
-      symbol_stroke_width: m["symbolStrokeWidth"],
+      symbol_size: m["symbolSize"] && decode_symbol_size(m["symbolSize"]),
+      symbol_stroke_width: m["symbolStrokeWidth"] && decode_symbol_stroke_width(m["symbolStrokeWidth"]),
       symbol_type: m["symbolType"] && decode_symbol_type(m["symbolType"]),
       title_align: m["titleAlign"] && decode_title_align(m["titleAlign"]),
       title_baseline: m["titleBaseline"] && decode_title_baseline(m["titleBaseline"]),
       title_color: m["titleColor"] && decode_title_color(m["titleColor"]),
       title_font: m["titleFont"] && decode_title_font(m["titleFont"]),
-      title_font_size: m["titleFontSize"],
+      title_font_size: m["titleFontSize"] && decode_title_font_size(m["titleFontSize"]),
       title_font_weight: m["titleFontWeight"],
-      title_limit: m["titleLimit"],
-      title_padding: m["titlePadding"],
+      title_limit: m["titleLimit"] && decode_title_limit(m["titleLimit"]),
+      title_padding: m["titlePadding"] && decode_title_padding(m["titlePadding"]),
     }
   end
 
@@ -2018,12 +2714,44 @@ defmodule PaddingClass do
           top: float() | nil
         }
 
+  def decode_bottom(value) when is_float(value), do: value
+  def decode_bottom(value) when is_integer(value), do: value
+  def decode_bottom(_), do: {:error, "Unexpected type when decoding PaddingClass.bottom"}
+
+  def encode_bottom(value) when is_float(value), do: value
+  def encode_bottom(value) when is_integer(value), do: value
+  def encode_bottom(_), do: {:error, "Unexpected type when encoding PaddingClass.bottom"}
+
+  def decode_left(value) when is_float(value), do: value
+  def decode_left(value) when is_integer(value), do: value
+  def decode_left(_), do: {:error, "Unexpected type when decoding PaddingClass.left"}
+
+  def encode_left(value) when is_float(value), do: value
+  def encode_left(value) when is_integer(value), do: value
+  def encode_left(_), do: {:error, "Unexpected type when encoding PaddingClass.left"}
+
+  def decode_right(value) when is_float(value), do: value
+  def decode_right(value) when is_integer(value), do: value
+  def decode_right(_), do: {:error, "Unexpected type when decoding PaddingClass.right"}
+
+  def encode_right(value) when is_float(value), do: value
+  def encode_right(value) when is_integer(value), do: value
+  def encode_right(_), do: {:error, "Unexpected type when encoding PaddingClass.right"}
+
+  def decode_top(value) when is_float(value), do: value
+  def decode_top(value) when is_integer(value), do: value
+  def decode_top(_), do: {:error, "Unexpected type when decoding PaddingClass.top"}
+
+  def encode_top(value) when is_float(value), do: value
+  def encode_top(value) when is_integer(value), do: value
+  def encode_top(_), do: {:error, "Unexpected type when encoding PaddingClass.top"}
+
   def from_map(m) do
     %PaddingClass{
-      bottom: m["bottom"],
-      left: m["left"],
-      right: m["right"],
-      top: m["top"],
+      bottom: m["bottom"] && decode_bottom(m["bottom"]),
+      left: m["left"] && decode_left(m["left"]),
+      right: m["right"] && decode_right(m["right"]),
+      top: m["top"] && decode_top(m["top"]),
     }
   end
 
@@ -2150,6 +2878,54 @@ defmodule ProjectionConfig do
           type: VGProjectionType.t() | nil
         }
 
+  def decode_clip_angle(value) when is_float(value), do: value
+  def decode_clip_angle(value) when is_integer(value), do: value
+  def decode_clip_angle(_), do: {:error, "Unexpected type when decoding ProjectionConfig.clip_angle"}
+
+  def encode_clip_angle(value) when is_float(value), do: value
+  def encode_clip_angle(value) when is_integer(value), do: value
+  def encode_clip_angle(_), do: {:error, "Unexpected type when encoding ProjectionConfig.clip_angle"}
+
+  def decode_coefficient(value) when is_float(value), do: value
+  def decode_coefficient(value) when is_integer(value), do: value
+  def decode_coefficient(_), do: {:error, "Unexpected type when decoding ProjectionConfig.coefficient"}
+
+  def encode_coefficient(value) when is_float(value), do: value
+  def encode_coefficient(value) when is_integer(value), do: value
+  def encode_coefficient(_), do: {:error, "Unexpected type when encoding ProjectionConfig.coefficient"}
+
+  def decode_distance(value) when is_float(value), do: value
+  def decode_distance(value) when is_integer(value), do: value
+  def decode_distance(_), do: {:error, "Unexpected type when decoding ProjectionConfig.distance"}
+
+  def encode_distance(value) when is_float(value), do: value
+  def encode_distance(value) when is_integer(value), do: value
+  def encode_distance(_), do: {:error, "Unexpected type when encoding ProjectionConfig.distance"}
+
+  def decode_fraction(value) when is_float(value), do: value
+  def decode_fraction(value) when is_integer(value), do: value
+  def decode_fraction(_), do: {:error, "Unexpected type when decoding ProjectionConfig.fraction"}
+
+  def encode_fraction(value) when is_float(value), do: value
+  def encode_fraction(value) when is_integer(value), do: value
+  def encode_fraction(_), do: {:error, "Unexpected type when encoding ProjectionConfig.fraction"}
+
+  def decode_lobes(value) when is_float(value), do: value
+  def decode_lobes(value) when is_integer(value), do: value
+  def decode_lobes(_), do: {:error, "Unexpected type when decoding ProjectionConfig.lobes"}
+
+  def encode_lobes(value) when is_float(value), do: value
+  def encode_lobes(value) when is_integer(value), do: value
+  def encode_lobes(_), do: {:error, "Unexpected type when encoding ProjectionConfig.lobes"}
+
+  def decode_parallel(value) when is_float(value), do: value
+  def decode_parallel(value) when is_integer(value), do: value
+  def decode_parallel(_), do: {:error, "Unexpected type when decoding ProjectionConfig.parallel"}
+
+  def encode_parallel(value) when is_float(value), do: value
+  def encode_parallel(value) when is_integer(value), do: value
+  def encode_parallel(_), do: {:error, "Unexpected type when encoding ProjectionConfig.parallel"}
+
   def decode_precision_value(value) when is_float(value), do: value
   def decode_precision_value(value) when is_integer(value), do: value
   def decode_precision_value(value) when is_binary(value), do: value
@@ -2160,23 +2936,55 @@ defmodule ProjectionConfig do
   def encode_precision_value(value) when is_binary(value), do: value
   def encode_precision_value(_), do: {:error, "Unexpected type when encoding ProjectionConfig.precision"}
 
+  def decode_radius(value) when is_float(value), do: value
+  def decode_radius(value) when is_integer(value), do: value
+  def decode_radius(_), do: {:error, "Unexpected type when decoding ProjectionConfig.radius"}
+
+  def encode_radius(value) when is_float(value), do: value
+  def encode_radius(value) when is_integer(value), do: value
+  def encode_radius(_), do: {:error, "Unexpected type when encoding ProjectionConfig.radius"}
+
+  def decode_ratio(value) when is_float(value), do: value
+  def decode_ratio(value) when is_integer(value), do: value
+  def decode_ratio(_), do: {:error, "Unexpected type when decoding ProjectionConfig.ratio"}
+
+  def encode_ratio(value) when is_float(value), do: value
+  def encode_ratio(value) when is_integer(value), do: value
+  def encode_ratio(_), do: {:error, "Unexpected type when encoding ProjectionConfig.ratio"}
+
+  def decode_spacing(value) when is_float(value), do: value
+  def decode_spacing(value) when is_integer(value), do: value
+  def decode_spacing(_), do: {:error, "Unexpected type when decoding ProjectionConfig.spacing"}
+
+  def encode_spacing(value) when is_float(value), do: value
+  def encode_spacing(value) when is_integer(value), do: value
+  def encode_spacing(_), do: {:error, "Unexpected type when encoding ProjectionConfig.spacing"}
+
+  def decode_tilt(value) when is_float(value), do: value
+  def decode_tilt(value) when is_integer(value), do: value
+  def decode_tilt(_), do: {:error, "Unexpected type when decoding ProjectionConfig.tilt"}
+
+  def encode_tilt(value) when is_float(value), do: value
+  def encode_tilt(value) when is_integer(value), do: value
+  def encode_tilt(_), do: {:error, "Unexpected type when encoding ProjectionConfig.tilt"}
+
   def from_map(m) do
     %ProjectionConfig{
       center: m["center"],
-      clip_angle: m["clipAngle"],
+      clip_angle: m["clipAngle"] && decode_clip_angle(m["clipAngle"]),
       clip_extent: m["clipExtent"],
-      coefficient: m["coefficient"],
-      distance: m["distance"],
-      fraction: m["fraction"],
-      lobes: m["lobes"],
-      parallel: m["parallel"],
+      coefficient: m["coefficient"] && decode_coefficient(m["coefficient"]),
+      distance: m["distance"] && decode_distance(m["distance"]),
+      fraction: m["fraction"] && decode_fraction(m["fraction"]),
+      lobes: m["lobes"] && decode_lobes(m["lobes"]),
+      parallel: m["parallel"] && decode_parallel(m["parallel"]),
       precision: m["precision"]
       |> Map.new(fn {key, value} -> {key, decode_precision_value(value)} end),
-      radius: m["radius"],
-      ratio: m["ratio"],
+      radius: m["radius"] && decode_radius(m["radius"]),
+      ratio: m["ratio"] && decode_ratio(m["ratio"]),
       rotate: m["rotate"],
-      spacing: m["spacing"],
-      tilt: m["tilt"],
+      spacing: m["spacing"] && decode_spacing(m["spacing"]),
+      tilt: m["tilt"] && decode_tilt(m["tilt"]),
       type: m["type"] && VGProjectionType.decode(m["type"]),
     }
   end
@@ -2225,18 +3033,34 @@ defmodule VGScheme do
           step: float() | nil
         }
 
+  def decode_count(value) when is_float(value), do: value
+  def decode_count(value) when is_integer(value), do: value
+  def decode_count(_), do: {:error, "Unexpected type when decoding VGScheme.count"}
+
+  def encode_count(value) when is_float(value), do: value
+  def encode_count(value) when is_integer(value), do: value
+  def encode_count(_), do: {:error, "Unexpected type when encoding VGScheme.count"}
+
   def decode_scheme(value) when is_binary(value), do: value
   def decode_scheme(_), do: {:error, "Unexpected type when decoding VGScheme.scheme"}
 
   def encode_scheme(value) when is_binary(value), do: value
   def encode_scheme(_), do: {:error, "Unexpected type when encoding VGScheme.scheme"}
 
+  def decode_step(value) when is_float(value), do: value
+  def decode_step(value) when is_integer(value), do: value
+  def decode_step(_), do: {:error, "Unexpected type when decoding VGScheme.step"}
+
+  def encode_step(value) when is_float(value), do: value
+  def encode_step(value) when is_integer(value), do: value
+  def encode_step(_), do: {:error, "Unexpected type when encoding VGScheme.step"}
+
   def from_map(m) do
     %VGScheme{
-      count: m["count"],
+      count: m["count"] && decode_count(m["count"]),
       extent: m["extent"],
       scheme: m["scheme"] && decode_scheme(m["scheme"]),
-      step: m["step"],
+      step: m["step"] && decode_step(m["step"]),
     }
   end
 
@@ -2312,26 +3136,146 @@ defmodule ScaleConfig do
           use_unaggregated_domain: boolean() | nil
         }
 
+  def decode_band_padding_inner(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_band_padding_inner(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_band_padding_inner(_), do: {:error, "Unexpected type when decoding ScaleConfig.band_padding_inner"}
+
+  def encode_band_padding_inner(value) when is_float(value), do: value
+  def encode_band_padding_inner(value) when is_integer(value), do: value
+  def encode_band_padding_inner(_), do: {:error, "Unexpected type when encoding ScaleConfig.band_padding_inner"}
+
+  def decode_band_padding_outer(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_band_padding_outer(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_band_padding_outer(_), do: {:error, "Unexpected type when decoding ScaleConfig.band_padding_outer"}
+
+  def encode_band_padding_outer(value) when is_float(value), do: value
+  def encode_band_padding_outer(value) when is_integer(value), do: value
+  def encode_band_padding_outer(_), do: {:error, "Unexpected type when encoding ScaleConfig.band_padding_outer"}
+
+  def decode_continuous_padding(value) when is_float(value) and value >= 0, do: value
+  def decode_continuous_padding(value) when is_integer(value) and value >= 0, do: value
+  def decode_continuous_padding(_), do: {:error, "Unexpected type when decoding ScaleConfig.continuous_padding"}
+
+  def encode_continuous_padding(value) when is_float(value), do: value
+  def encode_continuous_padding(value) when is_integer(value), do: value
+  def encode_continuous_padding(_), do: {:error, "Unexpected type when encoding ScaleConfig.continuous_padding"}
+
+  def decode_max_band_size(value) when is_float(value) and value >= 0, do: value
+  def decode_max_band_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_max_band_size(_), do: {:error, "Unexpected type when decoding ScaleConfig.max_band_size"}
+
+  def encode_max_band_size(value) when is_float(value), do: value
+  def encode_max_band_size(value) when is_integer(value), do: value
+  def encode_max_band_size(_), do: {:error, "Unexpected type when encoding ScaleConfig.max_band_size"}
+
+  def decode_max_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_max_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_max_font_size(_), do: {:error, "Unexpected type when decoding ScaleConfig.max_font_size"}
+
+  def encode_max_font_size(value) when is_float(value), do: value
+  def encode_max_font_size(value) when is_integer(value), do: value
+  def encode_max_font_size(_), do: {:error, "Unexpected type when encoding ScaleConfig.max_font_size"}
+
+  def decode_max_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_max_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_max_opacity(_), do: {:error, "Unexpected type when decoding ScaleConfig.max_opacity"}
+
+  def encode_max_opacity(value) when is_float(value), do: value
+  def encode_max_opacity(value) when is_integer(value), do: value
+  def encode_max_opacity(_), do: {:error, "Unexpected type when encoding ScaleConfig.max_opacity"}
+
+  def decode_max_size(value) when is_float(value) and value >= 0, do: value
+  def decode_max_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_max_size(_), do: {:error, "Unexpected type when decoding ScaleConfig.max_size"}
+
+  def encode_max_size(value) when is_float(value), do: value
+  def encode_max_size(value) when is_integer(value), do: value
+  def encode_max_size(_), do: {:error, "Unexpected type when encoding ScaleConfig.max_size"}
+
+  def decode_max_stroke_width(value) when is_float(value) and value >= 0, do: value
+  def decode_max_stroke_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_max_stroke_width(_), do: {:error, "Unexpected type when decoding ScaleConfig.max_stroke_width"}
+
+  def encode_max_stroke_width(value) when is_float(value), do: value
+  def encode_max_stroke_width(value) when is_integer(value), do: value
+  def encode_max_stroke_width(_), do: {:error, "Unexpected type when encoding ScaleConfig.max_stroke_width"}
+
+  def decode_min_band_size(value) when is_float(value) and value >= 0, do: value
+  def decode_min_band_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_min_band_size(_), do: {:error, "Unexpected type when decoding ScaleConfig.min_band_size"}
+
+  def encode_min_band_size(value) when is_float(value), do: value
+  def encode_min_band_size(value) when is_integer(value), do: value
+  def encode_min_band_size(_), do: {:error, "Unexpected type when encoding ScaleConfig.min_band_size"}
+
+  def decode_min_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_min_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_min_font_size(_), do: {:error, "Unexpected type when decoding ScaleConfig.min_font_size"}
+
+  def encode_min_font_size(value) when is_float(value), do: value
+  def encode_min_font_size(value) when is_integer(value), do: value
+  def encode_min_font_size(_), do: {:error, "Unexpected type when encoding ScaleConfig.min_font_size"}
+
+  def decode_min_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_min_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_min_opacity(_), do: {:error, "Unexpected type when decoding ScaleConfig.min_opacity"}
+
+  def encode_min_opacity(value) when is_float(value), do: value
+  def encode_min_opacity(value) when is_integer(value), do: value
+  def encode_min_opacity(_), do: {:error, "Unexpected type when encoding ScaleConfig.min_opacity"}
+
+  def decode_min_size(value) when is_float(value) and value >= 0, do: value
+  def decode_min_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_min_size(_), do: {:error, "Unexpected type when decoding ScaleConfig.min_size"}
+
+  def encode_min_size(value) when is_float(value), do: value
+  def encode_min_size(value) when is_integer(value), do: value
+  def encode_min_size(_), do: {:error, "Unexpected type when encoding ScaleConfig.min_size"}
+
+  def decode_min_stroke_width(value) when is_float(value) and value >= 0, do: value
+  def decode_min_stroke_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_min_stroke_width(_), do: {:error, "Unexpected type when decoding ScaleConfig.min_stroke_width"}
+
+  def encode_min_stroke_width(value) when is_float(value), do: value
+  def encode_min_stroke_width(value) when is_integer(value), do: value
+  def encode_min_stroke_width(_), do: {:error, "Unexpected type when encoding ScaleConfig.min_stroke_width"}
+
+  def decode_point_padding(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_point_padding(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_point_padding(_), do: {:error, "Unexpected type when decoding ScaleConfig.point_padding"}
+
+  def encode_point_padding(value) when is_float(value), do: value
+  def encode_point_padding(value) when is_integer(value), do: value
+  def encode_point_padding(_), do: {:error, "Unexpected type when encoding ScaleConfig.point_padding"}
+
+  def decode_text_x_range_step(value) when is_float(value) and value >= 0, do: value
+  def decode_text_x_range_step(value) when is_integer(value) and value >= 0, do: value
+  def decode_text_x_range_step(_), do: {:error, "Unexpected type when decoding ScaleConfig.text_x_range_step"}
+
+  def encode_text_x_range_step(value) when is_float(value), do: value
+  def encode_text_x_range_step(value) when is_integer(value), do: value
+  def encode_text_x_range_step(_), do: {:error, "Unexpected type when encoding ScaleConfig.text_x_range_step"}
+
   def from_map(m) do
     %ScaleConfig{
-      band_padding_inner: m["bandPaddingInner"],
-      band_padding_outer: m["bandPaddingOuter"],
+      band_padding_inner: m["bandPaddingInner"] && decode_band_padding_inner(m["bandPaddingInner"]),
+      band_padding_outer: m["bandPaddingOuter"] && decode_band_padding_outer(m["bandPaddingOuter"]),
       clamp: m["clamp"],
-      continuous_padding: m["continuousPadding"],
-      max_band_size: m["maxBandSize"],
-      max_font_size: m["maxFontSize"],
-      max_opacity: m["maxOpacity"],
-      max_size: m["maxSize"],
-      max_stroke_width: m["maxStrokeWidth"],
-      min_band_size: m["minBandSize"],
-      min_font_size: m["minFontSize"],
-      min_opacity: m["minOpacity"],
-      min_size: m["minSize"],
-      min_stroke_width: m["minStrokeWidth"],
-      point_padding: m["pointPadding"],
+      continuous_padding: m["continuousPadding"] && decode_continuous_padding(m["continuousPadding"]),
+      max_band_size: m["maxBandSize"] && decode_max_band_size(m["maxBandSize"]),
+      max_font_size: m["maxFontSize"] && decode_max_font_size(m["maxFontSize"]),
+      max_opacity: m["maxOpacity"] && decode_max_opacity(m["maxOpacity"]),
+      max_size: m["maxSize"] && decode_max_size(m["maxSize"]),
+      max_stroke_width: m["maxStrokeWidth"] && decode_max_stroke_width(m["maxStrokeWidth"]),
+      min_band_size: m["minBandSize"] && decode_min_band_size(m["minBandSize"]),
+      min_font_size: m["minFontSize"] && decode_min_font_size(m["minFontSize"]),
+      min_opacity: m["minOpacity"] && decode_min_opacity(m["minOpacity"]),
+      min_size: m["minSize"] && decode_min_size(m["minSize"]),
+      min_stroke_width: m["minStrokeWidth"] && decode_min_stroke_width(m["minStrokeWidth"]),
+      point_padding: m["pointPadding"] && decode_point_padding(m["pointPadding"]),
       range_step: m["rangeStep"],
       round: m["round"],
-      text_x_range_step: m["textXRangeStep"],
+      text_x_range_step: m["textXRangeStep"] && decode_text_x_range_step(m["textXRangeStep"]),
       use_unaggregated_domain: m["useUnaggregatedDomain"],
     }
   end
@@ -2562,21 +3506,53 @@ defmodule BrushConfig do
   def encode_fill(value) when is_binary(value), do: value
   def encode_fill(_), do: {:error, "Unexpected type when encoding BrushConfig.fill"}
 
+  def decode_fill_opacity(value) when is_float(value), do: value
+  def decode_fill_opacity(value) when is_integer(value), do: value
+  def decode_fill_opacity(_), do: {:error, "Unexpected type when decoding BrushConfig.fill_opacity"}
+
+  def encode_fill_opacity(value) when is_float(value), do: value
+  def encode_fill_opacity(value) when is_integer(value), do: value
+  def encode_fill_opacity(_), do: {:error, "Unexpected type when encoding BrushConfig.fill_opacity"}
+
   def decode_stroke(value) when is_binary(value), do: value
   def decode_stroke(_), do: {:error, "Unexpected type when decoding BrushConfig.stroke"}
 
   def encode_stroke(value) when is_binary(value), do: value
   def encode_stroke(_), do: {:error, "Unexpected type when encoding BrushConfig.stroke"}
 
+  def decode_stroke_dash_offset(value) when is_float(value), do: value
+  def decode_stroke_dash_offset(value) when is_integer(value), do: value
+  def decode_stroke_dash_offset(_), do: {:error, "Unexpected type when decoding BrushConfig.stroke_dash_offset"}
+
+  def encode_stroke_dash_offset(value) when is_float(value), do: value
+  def encode_stroke_dash_offset(value) when is_integer(value), do: value
+  def encode_stroke_dash_offset(_), do: {:error, "Unexpected type when encoding BrushConfig.stroke_dash_offset"}
+
+  def decode_stroke_opacity(value) when is_float(value), do: value
+  def decode_stroke_opacity(value) when is_integer(value), do: value
+  def decode_stroke_opacity(_), do: {:error, "Unexpected type when decoding BrushConfig.stroke_opacity"}
+
+  def encode_stroke_opacity(value) when is_float(value), do: value
+  def encode_stroke_opacity(value) when is_integer(value), do: value
+  def encode_stroke_opacity(_), do: {:error, "Unexpected type when encoding BrushConfig.stroke_opacity"}
+
+  def decode_stroke_width(value) when is_float(value), do: value
+  def decode_stroke_width(value) when is_integer(value), do: value
+  def decode_stroke_width(_), do: {:error, "Unexpected type when decoding BrushConfig.stroke_width"}
+
+  def encode_stroke_width(value) when is_float(value), do: value
+  def encode_stroke_width(value) when is_integer(value), do: value
+  def encode_stroke_width(_), do: {:error, "Unexpected type when encoding BrushConfig.stroke_width"}
+
   def from_map(m) do
     %BrushConfig{
       fill: m["fill"] && decode_fill(m["fill"]),
-      fill_opacity: m["fillOpacity"],
+      fill_opacity: m["fillOpacity"] && decode_fill_opacity(m["fillOpacity"]),
       stroke: m["stroke"] && decode_stroke(m["stroke"]),
       stroke_dash: m["strokeDash"],
-      stroke_dash_offset: m["strokeDashOffset"],
-      stroke_opacity: m["strokeOpacity"],
-      stroke_width: m["strokeWidth"],
+      stroke_dash_offset: m["strokeDashOffset"] && decode_stroke_dash_offset(m["strokeDashOffset"]),
+      stroke_opacity: m["strokeOpacity"] && decode_stroke_opacity(m["strokeOpacity"]),
+      stroke_width: m["strokeWidth"] && decode_stroke_width(m["strokeWidth"]),
     }
   end
 
@@ -2822,14 +3798,38 @@ defmodule VGBinding do
   def encode_input(value) when is_binary(value), do: value
   def encode_input(_), do: {:error, "Unexpected type when encoding VGBinding.input"}
 
+  def decode_max(value) when is_float(value), do: value
+  def decode_max(value) when is_integer(value), do: value
+  def decode_max(_), do: {:error, "Unexpected type when decoding VGBinding.max"}
+
+  def encode_max(value) when is_float(value), do: value
+  def encode_max(value) when is_integer(value), do: value
+  def encode_max(_), do: {:error, "Unexpected type when encoding VGBinding.max"}
+
+  def decode_min(value) when is_float(value), do: value
+  def decode_min(value) when is_integer(value), do: value
+  def decode_min(_), do: {:error, "Unexpected type when decoding VGBinding.min"}
+
+  def encode_min(value) when is_float(value), do: value
+  def encode_min(value) when is_integer(value), do: value
+  def encode_min(_), do: {:error, "Unexpected type when encoding VGBinding.min"}
+
+  def decode_step(value) when is_float(value), do: value
+  def decode_step(value) when is_integer(value), do: value
+  def decode_step(_), do: {:error, "Unexpected type when decoding VGBinding.step"}
+
+  def encode_step(value) when is_float(value), do: value
+  def encode_step(value) when is_integer(value), do: value
+  def encode_step(_), do: {:error, "Unexpected type when encoding VGBinding.step"}
+
   def from_map(m) do
     %VGBinding{
       element: m["element"] && decode_element(m["element"]),
       input: decode_input(m["input"]),
       options: m["options"],
-      max: m["max"],
-      min: m["min"],
-      step: m["step"],
+      max: m["max"] && decode_max(m["max"]),
+      min: m["min"] && decode_min(m["min"]),
+      step: m["step"] && decode_step(m["step"]),
     }
   end
 
@@ -3085,21 +4085,61 @@ defmodule VGMarkConfig do
           theta: float() | nil
         }
 
+  def decode_angle(value) when is_float(value) and value >= 0 and value <= 360, do: value
+  def decode_angle(value) when is_integer(value) and value >= 0 and value <= 360, do: value
+  def decode_angle(_), do: {:error, "Unexpected type when decoding VGMarkConfig.angle"}
+
+  def encode_angle(value) when is_float(value), do: value
+  def encode_angle(value) when is_integer(value), do: value
+  def encode_angle(_), do: {:error, "Unexpected type when encoding VGMarkConfig.angle"}
+
+  def decode_dx(value) when is_float(value), do: value
+  def decode_dx(value) when is_integer(value), do: value
+  def decode_dx(_), do: {:error, "Unexpected type when decoding VGMarkConfig.dx"}
+
+  def encode_dx(value) when is_float(value), do: value
+  def encode_dx(value) when is_integer(value), do: value
+  def encode_dx(_), do: {:error, "Unexpected type when encoding VGMarkConfig.dx"}
+
+  def decode_dy(value) when is_float(value), do: value
+  def decode_dy(value) when is_integer(value), do: value
+  def decode_dy(_), do: {:error, "Unexpected type when decoding VGMarkConfig.dy"}
+
+  def encode_dy(value) when is_float(value), do: value
+  def encode_dy(value) when is_integer(value), do: value
+  def encode_dy(_), do: {:error, "Unexpected type when encoding VGMarkConfig.dy"}
+
   def decode_fill(value) when is_binary(value), do: value
   def decode_fill(_), do: {:error, "Unexpected type when decoding VGMarkConfig.fill"}
 
   def encode_fill(value) when is_binary(value), do: value
   def encode_fill(_), do: {:error, "Unexpected type when encoding VGMarkConfig.fill"}
 
+  def decode_fill_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_fill_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_fill_opacity(_), do: {:error, "Unexpected type when decoding VGMarkConfig.fill_opacity"}
+
+  def encode_fill_opacity(value) when is_float(value), do: value
+  def encode_fill_opacity(value) when is_integer(value), do: value
+  def encode_fill_opacity(_), do: {:error, "Unexpected type when encoding VGMarkConfig.fill_opacity"}
+
   def decode_font(value) when is_binary(value), do: value
   def decode_font(_), do: {:error, "Unexpected type when decoding VGMarkConfig.font"}
 
   def encode_font(value) when is_binary(value), do: value
   def encode_font(_), do: {:error, "Unexpected type when encoding VGMarkConfig.font"}
 
+  def decode_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_font_size(_), do: {:error, "Unexpected type when decoding VGMarkConfig.font_size"}
+
+  def encode_font_size(value) when is_float(value), do: value
+  def encode_font_size(value) when is_integer(value), do: value
+  def encode_font_size(_), do: {:error, "Unexpected type when encoding VGMarkConfig.font_size"}
+
   def decode_font_weight(value) when is_binary(value), do: FontWeight.decode(value)
-  def decode_font_weight(value) when is_float(value), do: value
-  def decode_font_weight(value) when is_integer(value), do: value
+  def decode_font_weight(value) when is_float(value) and value >= 100 and value <= 900, do: value
+  def decode_font_weight(value) when is_integer(value) and value >= 100 and value <= 900, do: value
   def decode_font_weight(value) when is_nil(value), do: value
   def decode_font_weight(_), do: {:error, "Unexpected type when decoding VGMarkConfig.font_weight"}
 
@@ -3115,54 +4155,126 @@ defmodule VGMarkConfig do
   def encode_href(value) when is_binary(value), do: value
   def encode_href(_), do: {:error, "Unexpected type when encoding VGMarkConfig.href"}
 
+  def decode_limit(value) when is_float(value), do: value
+  def decode_limit(value) when is_integer(value), do: value
+  def decode_limit(_), do: {:error, "Unexpected type when decoding VGMarkConfig.limit"}
+
+  def encode_limit(value) when is_float(value), do: value
+  def encode_limit(value) when is_integer(value), do: value
+  def encode_limit(_), do: {:error, "Unexpected type when encoding VGMarkConfig.limit"}
+
+  def decode_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_opacity(_), do: {:error, "Unexpected type when decoding VGMarkConfig.opacity"}
+
+  def encode_opacity(value) when is_float(value), do: value
+  def encode_opacity(value) when is_integer(value), do: value
+  def encode_opacity(_), do: {:error, "Unexpected type when encoding VGMarkConfig.opacity"}
+
+  def decode_radius(value) when is_float(value) and value >= 0, do: value
+  def decode_radius(value) when is_integer(value) and value >= 0, do: value
+  def decode_radius(_), do: {:error, "Unexpected type when decoding VGMarkConfig.radius"}
+
+  def encode_radius(value) when is_float(value), do: value
+  def encode_radius(value) when is_integer(value), do: value
+  def encode_radius(_), do: {:error, "Unexpected type when encoding VGMarkConfig.radius"}
+
   def decode_shape(value) when is_binary(value), do: value
   def decode_shape(_), do: {:error, "Unexpected type when decoding VGMarkConfig.shape"}
 
   def encode_shape(value) when is_binary(value), do: value
   def encode_shape(_), do: {:error, "Unexpected type when encoding VGMarkConfig.shape"}
 
+  def decode_size(value) when is_float(value) and value >= 0, do: value
+  def decode_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_size(_), do: {:error, "Unexpected type when decoding VGMarkConfig.size"}
+
+  def encode_size(value) when is_float(value), do: value
+  def encode_size(value) when is_integer(value), do: value
+  def encode_size(_), do: {:error, "Unexpected type when encoding VGMarkConfig.size"}
+
   def decode_stroke(value) when is_binary(value), do: value
   def decode_stroke(_), do: {:error, "Unexpected type when decoding VGMarkConfig.stroke"}
 
   def encode_stroke(value) when is_binary(value), do: value
   def encode_stroke(_), do: {:error, "Unexpected type when encoding VGMarkConfig.stroke"}
 
+  def decode_stroke_dash_offset(value) when is_float(value), do: value
+  def decode_stroke_dash_offset(value) when is_integer(value), do: value
+  def decode_stroke_dash_offset(_), do: {:error, "Unexpected type when decoding VGMarkConfig.stroke_dash_offset"}
+
+  def encode_stroke_dash_offset(value) when is_float(value), do: value
+  def encode_stroke_dash_offset(value) when is_integer(value), do: value
+  def encode_stroke_dash_offset(_), do: {:error, "Unexpected type when encoding VGMarkConfig.stroke_dash_offset"}
+
+  def decode_stroke_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_stroke_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_stroke_opacity(_), do: {:error, "Unexpected type when decoding VGMarkConfig.stroke_opacity"}
+
+  def encode_stroke_opacity(value) when is_float(value), do: value
+  def encode_stroke_opacity(value) when is_integer(value), do: value
+  def encode_stroke_opacity(_), do: {:error, "Unexpected type when encoding VGMarkConfig.stroke_opacity"}
+
+  def decode_stroke_width(value) when is_float(value) and value >= 0, do: value
+  def decode_stroke_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_stroke_width(_), do: {:error, "Unexpected type when decoding VGMarkConfig.stroke_width"}
+
+  def encode_stroke_width(value) when is_float(value), do: value
+  def encode_stroke_width(value) when is_integer(value), do: value
+  def encode_stroke_width(_), do: {:error, "Unexpected type when encoding VGMarkConfig.stroke_width"}
+
+  def decode_tension(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_tension(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_tension(_), do: {:error, "Unexpected type when decoding VGMarkConfig.tension"}
+
+  def encode_tension(value) when is_float(value), do: value
+  def encode_tension(value) when is_integer(value), do: value
+  def encode_tension(_), do: {:error, "Unexpected type when encoding VGMarkConfig.tension"}
+
   def decode_text(value) when is_binary(value), do: value
   def decode_text(_), do: {:error, "Unexpected type when decoding VGMarkConfig.text"}
 
   def encode_text(value) when is_binary(value), do: value
   def encode_text(_), do: {:error, "Unexpected type when encoding VGMarkConfig.text"}
 
+  def decode_theta(value) when is_float(value), do: value
+  def decode_theta(value) when is_integer(value), do: value
+  def decode_theta(_), do: {:error, "Unexpected type when decoding VGMarkConfig.theta"}
+
+  def encode_theta(value) when is_float(value), do: value
+  def encode_theta(value) when is_integer(value), do: value
+  def encode_theta(_), do: {:error, "Unexpected type when encoding VGMarkConfig.theta"}
+
   def from_map(m) do
     %VGMarkConfig{
       align: m["align"] && HorizontalAlign.decode(m["align"]),
-      angle: m["angle"],
+      angle: m["angle"] && decode_angle(m["angle"]),
       baseline: m["baseline"] && VerticalAlign.decode(m["baseline"]),
       cursor: m["cursor"] && Cursor.decode(m["cursor"]),
-      dx: m["dx"],
-      dy: m["dy"],
+      dx: m["dx"] && decode_dx(m["dx"]),
+      dy: m["dy"] && decode_dy(m["dy"]),
       fill: m["fill"] && decode_fill(m["fill"]),
-      fill_opacity: m["fillOpacity"],
+      fill_opacity: m["fillOpacity"] && decode_fill_opacity(m["fillOpacity"]),
       font: m["font"] && decode_font(m["font"]),
-      font_size: m["fontSize"],
+      font_size: m["fontSize"] && decode_font_size(m["fontSize"]),
       font_style: m["fontStyle"] && FontStyle.decode(m["fontStyle"]),
       font_weight: decode_font_weight(m["fontWeight"]),
       href: m["href"] && decode_href(m["href"]),
       interpolate: m["interpolate"] && Interpolate.decode(m["interpolate"]),
-      limit: m["limit"],
-      opacity: m["opacity"],
+      limit: m["limit"] && decode_limit(m["limit"]),
+      opacity: m["opacity"] && decode_opacity(m["opacity"]),
       orient: m["orient"] && Orient.decode(m["orient"]),
-      radius: m["radius"],
+      radius: m["radius"] && decode_radius(m["radius"]),
       shape: m["shape"] && decode_shape(m["shape"]),
-      size: m["size"],
+      size: m["size"] && decode_size(m["size"]),
       stroke: m["stroke"] && decode_stroke(m["stroke"]),
       stroke_dash: m["strokeDash"],
-      stroke_dash_offset: m["strokeDashOffset"],
-      stroke_opacity: m["strokeOpacity"],
-      stroke_width: m["strokeWidth"],
-      tension: m["tension"],
+      stroke_dash_offset: m["strokeDashOffset"] && decode_stroke_dash_offset(m["strokeDashOffset"]),
+      stroke_opacity: m["strokeOpacity"] && decode_stroke_opacity(m["strokeOpacity"]),
+      stroke_width: m["strokeWidth"] && decode_stroke_width(m["strokeWidth"]),
+      tension: m["tension"] && decode_tension(m["tension"]),
       text: m["text"] && decode_text(m["text"]),
-      theta: m["theta"],
+      theta: m["theta"] && decode_theta(m["theta"]),
     }
   end
 
@@ -3284,27 +4396,67 @@ defmodule TextConfig do
           theta: float() | nil
         }
 
+  def decode_angle(value) when is_float(value) and value >= 0 and value <= 360, do: value
+  def decode_angle(value) when is_integer(value) and value >= 0 and value <= 360, do: value
+  def decode_angle(_), do: {:error, "Unexpected type when decoding TextConfig.angle"}
+
+  def encode_angle(value) when is_float(value), do: value
+  def encode_angle(value) when is_integer(value), do: value
+  def encode_angle(_), do: {:error, "Unexpected type when encoding TextConfig.angle"}
+
   def decode_color(value) when is_binary(value), do: value
   def decode_color(_), do: {:error, "Unexpected type when decoding TextConfig.color"}
 
   def encode_color(value) when is_binary(value), do: value
   def encode_color(_), do: {:error, "Unexpected type when encoding TextConfig.color"}
 
+  def decode_dx(value) when is_float(value), do: value
+  def decode_dx(value) when is_integer(value), do: value
+  def decode_dx(_), do: {:error, "Unexpected type when decoding TextConfig.dx"}
+
+  def encode_dx(value) when is_float(value), do: value
+  def encode_dx(value) when is_integer(value), do: value
+  def encode_dx(_), do: {:error, "Unexpected type when encoding TextConfig.dx"}
+
+  def decode_dy(value) when is_float(value), do: value
+  def decode_dy(value) when is_integer(value), do: value
+  def decode_dy(_), do: {:error, "Unexpected type when decoding TextConfig.dy"}
+
+  def encode_dy(value) when is_float(value), do: value
+  def encode_dy(value) when is_integer(value), do: value
+  def encode_dy(_), do: {:error, "Unexpected type when encoding TextConfig.dy"}
+
   def decode_fill(value) when is_binary(value), do: value
   def decode_fill(_), do: {:error, "Unexpected type when decoding TextConfig.fill"}
 
   def encode_fill(value) when is_binary(value), do: value
   def encode_fill(_), do: {:error, "Unexpected type when encoding TextConfig.fill"}
 
+  def decode_fill_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_fill_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_fill_opacity(_), do: {:error, "Unexpected type when decoding TextConfig.fill_opacity"}
+
+  def encode_fill_opacity(value) when is_float(value), do: value
+  def encode_fill_opacity(value) when is_integer(value), do: value
+  def encode_fill_opacity(_), do: {:error, "Unexpected type when encoding TextConfig.fill_opacity"}
+
   def decode_font(value) when is_binary(value), do: value
   def decode_font(_), do: {:error, "Unexpected type when decoding TextConfig.font"}
 
   def encode_font(value) when is_binary(value), do: value
   def encode_font(_), do: {:error, "Unexpected type when encoding TextConfig.font"}
 
+  def decode_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_font_size(_), do: {:error, "Unexpected type when decoding TextConfig.font_size"}
+
+  def encode_font_size(value) when is_float(value), do: value
+  def encode_font_size(value) when is_integer(value), do: value
+  def encode_font_size(_), do: {:error, "Unexpected type when encoding TextConfig.font_size"}
+
   def decode_font_weight(value) when is_binary(value), do: FontWeight.decode(value)
-  def decode_font_weight(value) when is_float(value), do: value
-  def decode_font_weight(value) when is_integer(value), do: value
+  def decode_font_weight(value) when is_float(value) and value >= 100 and value <= 900, do: value
+  def decode_font_weight(value) when is_integer(value) and value >= 100 and value <= 900, do: value
   def decode_font_weight(value) when is_nil(value), do: value
   def decode_font_weight(_), do: {:error, "Unexpected type when decoding TextConfig.font_weight"}
 
@@ -3320,57 +4472,129 @@ defmodule TextConfig do
   def encode_href(value) when is_binary(value), do: value
   def encode_href(_), do: {:error, "Unexpected type when encoding TextConfig.href"}
 
+  def decode_limit(value) when is_float(value), do: value
+  def decode_limit(value) when is_integer(value), do: value
+  def decode_limit(_), do: {:error, "Unexpected type when decoding TextConfig.limit"}
+
+  def encode_limit(value) when is_float(value), do: value
+  def encode_limit(value) when is_integer(value), do: value
+  def encode_limit(_), do: {:error, "Unexpected type when encoding TextConfig.limit"}
+
+  def decode_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_opacity(_), do: {:error, "Unexpected type when decoding TextConfig.opacity"}
+
+  def encode_opacity(value) when is_float(value), do: value
+  def encode_opacity(value) when is_integer(value), do: value
+  def encode_opacity(_), do: {:error, "Unexpected type when encoding TextConfig.opacity"}
+
+  def decode_radius(value) when is_float(value) and value >= 0, do: value
+  def decode_radius(value) when is_integer(value) and value >= 0, do: value
+  def decode_radius(_), do: {:error, "Unexpected type when decoding TextConfig.radius"}
+
+  def encode_radius(value) when is_float(value), do: value
+  def encode_radius(value) when is_integer(value), do: value
+  def encode_radius(_), do: {:error, "Unexpected type when encoding TextConfig.radius"}
+
   def decode_shape(value) when is_binary(value), do: value
   def decode_shape(_), do: {:error, "Unexpected type when decoding TextConfig.shape"}
 
   def encode_shape(value) when is_binary(value), do: value
   def encode_shape(_), do: {:error, "Unexpected type when encoding TextConfig.shape"}
 
+  def decode_size(value) when is_float(value) and value >= 0, do: value
+  def decode_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_size(_), do: {:error, "Unexpected type when decoding TextConfig.size"}
+
+  def encode_size(value) when is_float(value), do: value
+  def encode_size(value) when is_integer(value), do: value
+  def encode_size(_), do: {:error, "Unexpected type when encoding TextConfig.size"}
+
   def decode_stroke(value) when is_binary(value), do: value
   def decode_stroke(_), do: {:error, "Unexpected type when decoding TextConfig.stroke"}
 
   def encode_stroke(value) when is_binary(value), do: value
   def encode_stroke(_), do: {:error, "Unexpected type when encoding TextConfig.stroke"}
 
+  def decode_stroke_dash_offset(value) when is_float(value), do: value
+  def decode_stroke_dash_offset(value) when is_integer(value), do: value
+  def decode_stroke_dash_offset(_), do: {:error, "Unexpected type when decoding TextConfig.stroke_dash_offset"}
+
+  def encode_stroke_dash_offset(value) when is_float(value), do: value
+  def encode_stroke_dash_offset(value) when is_integer(value), do: value
+  def encode_stroke_dash_offset(_), do: {:error, "Unexpected type when encoding TextConfig.stroke_dash_offset"}
+
+  def decode_stroke_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_stroke_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_stroke_opacity(_), do: {:error, "Unexpected type when decoding TextConfig.stroke_opacity"}
+
+  def encode_stroke_opacity(value) when is_float(value), do: value
+  def encode_stroke_opacity(value) when is_integer(value), do: value
+  def encode_stroke_opacity(_), do: {:error, "Unexpected type when encoding TextConfig.stroke_opacity"}
+
+  def decode_stroke_width(value) when is_float(value) and value >= 0, do: value
+  def decode_stroke_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_stroke_width(_), do: {:error, "Unexpected type when decoding TextConfig.stroke_width"}
+
+  def encode_stroke_width(value) when is_float(value), do: value
+  def encode_stroke_width(value) when is_integer(value), do: value
+  def encode_stroke_width(_), do: {:error, "Unexpected type when encoding TextConfig.stroke_width"}
+
+  def decode_tension(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_tension(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_tension(_), do: {:error, "Unexpected type when decoding TextConfig.tension"}
+
+  def encode_tension(value) when is_float(value), do: value
+  def encode_tension(value) when is_integer(value), do: value
+  def encode_tension(_), do: {:error, "Unexpected type when encoding TextConfig.tension"}
+
   def decode_text(value) when is_binary(value), do: value
   def decode_text(_), do: {:error, "Unexpected type when decoding TextConfig.text"}
 
   def encode_text(value) when is_binary(value), do: value
   def encode_text(_), do: {:error, "Unexpected type when encoding TextConfig.text"}
 
+  def decode_theta(value) when is_float(value), do: value
+  def decode_theta(value) when is_integer(value), do: value
+  def decode_theta(_), do: {:error, "Unexpected type when decoding TextConfig.theta"}
+
+  def encode_theta(value) when is_float(value), do: value
+  def encode_theta(value) when is_integer(value), do: value
+  def encode_theta(_), do: {:error, "Unexpected type when encoding TextConfig.theta"}
+
   def from_map(m) do
     %TextConfig{
       align: m["align"] && HorizontalAlign.decode(m["align"]),
-      angle: m["angle"],
+      angle: m["angle"] && decode_angle(m["angle"]),
       baseline: m["baseline"] && VerticalAlign.decode(m["baseline"]),
       color: m["color"] && decode_color(m["color"]),
       cursor: m["cursor"] && Cursor.decode(m["cursor"]),
-      dx: m["dx"],
-      dy: m["dy"],
+      dx: m["dx"] && decode_dx(m["dx"]),
+      dy: m["dy"] && decode_dy(m["dy"]),
       fill: m["fill"] && decode_fill(m["fill"]),
       filled: m["filled"],
-      fill_opacity: m["fillOpacity"],
+      fill_opacity: m["fillOpacity"] && decode_fill_opacity(m["fillOpacity"]),
       font: m["font"] && decode_font(m["font"]),
-      font_size: m["fontSize"],
+      font_size: m["fontSize"] && decode_font_size(m["fontSize"]),
       font_style: m["fontStyle"] && FontStyle.decode(m["fontStyle"]),
       font_weight: decode_font_weight(m["fontWeight"]),
       href: m["href"] && decode_href(m["href"]),
       interpolate: m["interpolate"] && Interpolate.decode(m["interpolate"]),
-      limit: m["limit"],
-      opacity: m["opacity"],
+      limit: m["limit"] && decode_limit(m["limit"]),
+      opacity: m["opacity"] && decode_opacity(m["opacity"]),
       orient: m["orient"] && Orient.decode(m["orient"]),
-      radius: m["radius"],
+      radius: m["radius"] && decode_radius(m["radius"]),
       shape: m["shape"] && decode_shape(m["shape"]),
       short_time_labels: m["shortTimeLabels"],
-      size: m["size"],
+      size: m["size"] && decode_size(m["size"]),
       stroke: m["stroke"] && decode_stroke(m["stroke"]),
       stroke_dash: m["strokeDash"],
-      stroke_dash_offset: m["strokeDashOffset"],
-      stroke_opacity: m["strokeOpacity"],
-      stroke_width: m["strokeWidth"],
-      tension: m["tension"],
+      stroke_dash_offset: m["strokeDashOffset"] && decode_stroke_dash_offset(m["strokeDashOffset"]),
+      stroke_opacity: m["strokeOpacity"] && decode_stroke_opacity(m["strokeOpacity"]),
+      stroke_width: m["strokeWidth"] && decode_stroke_width(m["strokeWidth"]),
+      tension: m["tension"] && decode_tension(m["tension"]),
       text: m["text"] && decode_text(m["text"]),
-      theta: m["theta"],
+      theta: m["theta"] && decode_theta(m["theta"]),
     }
   end
 
@@ -3497,27 +4721,75 @@ defmodule TickConfig do
           thickness: float() | nil
         }
 
+  def decode_angle(value) when is_float(value) and value >= 0 and value <= 360, do: value
+  def decode_angle(value) when is_integer(value) and value >= 0 and value <= 360, do: value
+  def decode_angle(_), do: {:error, "Unexpected type when decoding TickConfig.angle"}
+
+  def encode_angle(value) when is_float(value), do: value
+  def encode_angle(value) when is_integer(value), do: value
+  def encode_angle(_), do: {:error, "Unexpected type when encoding TickConfig.angle"}
+
+  def decode_band_size(value) when is_float(value) and value >= 0, do: value
+  def decode_band_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_band_size(_), do: {:error, "Unexpected type when decoding TickConfig.band_size"}
+
+  def encode_band_size(value) when is_float(value), do: value
+  def encode_band_size(value) when is_integer(value), do: value
+  def encode_band_size(_), do: {:error, "Unexpected type when encoding TickConfig.band_size"}
+
   def decode_color(value) when is_binary(value), do: value
   def decode_color(_), do: {:error, "Unexpected type when decoding TickConfig.color"}
 
   def encode_color(value) when is_binary(value), do: value
   def encode_color(_), do: {:error, "Unexpected type when encoding TickConfig.color"}
 
+  def decode_dx(value) when is_float(value), do: value
+  def decode_dx(value) when is_integer(value), do: value
+  def decode_dx(_), do: {:error, "Unexpected type when decoding TickConfig.dx"}
+
+  def encode_dx(value) when is_float(value), do: value
+  def encode_dx(value) when is_integer(value), do: value
+  def encode_dx(_), do: {:error, "Unexpected type when encoding TickConfig.dx"}
+
+  def decode_dy(value) when is_float(value), do: value
+  def decode_dy(value) when is_integer(value), do: value
+  def decode_dy(_), do: {:error, "Unexpected type when decoding TickConfig.dy"}
+
+  def encode_dy(value) when is_float(value), do: value
+  def encode_dy(value) when is_integer(value), do: value
+  def encode_dy(_), do: {:error, "Unexpected type when encoding TickConfig.dy"}
+
   def decode_fill(value) when is_binary(value), do: value
   def decode_fill(_), do: {:error, "Unexpected type when decoding TickConfig.fill"}
 
   def encode_fill(value) when is_binary(value), do: value
   def encode_fill(_), do: {:error, "Unexpected type when encoding TickConfig.fill"}
 
+  def decode_fill_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_fill_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_fill_opacity(_), do: {:error, "Unexpected type when decoding TickConfig.fill_opacity"}
+
+  def encode_fill_opacity(value) when is_float(value), do: value
+  def encode_fill_opacity(value) when is_integer(value), do: value
+  def encode_fill_opacity(_), do: {:error, "Unexpected type when encoding TickConfig.fill_opacity"}
+
   def decode_font(value) when is_binary(value), do: value
   def decode_font(_), do: {:error, "Unexpected type when decoding TickConfig.font"}
 
   def encode_font(value) when is_binary(value), do: value
   def encode_font(_), do: {:error, "Unexpected type when encoding TickConfig.font"}
 
+  def decode_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_font_size(_), do: {:error, "Unexpected type when decoding TickConfig.font_size"}
+
+  def encode_font_size(value) when is_float(value), do: value
+  def encode_font_size(value) when is_integer(value), do: value
+  def encode_font_size(_), do: {:error, "Unexpected type when encoding TickConfig.font_size"}
+
   def decode_font_weight(value) when is_binary(value), do: FontWeight.decode(value)
-  def decode_font_weight(value) when is_float(value), do: value
-  def decode_font_weight(value) when is_integer(value), do: value
+  def decode_font_weight(value) when is_float(value) and value >= 100 and value <= 900, do: value
+  def decode_font_weight(value) when is_integer(value) and value >= 100 and value <= 900, do: value
   def decode_font_weight(value) when is_nil(value), do: value
   def decode_font_weight(_), do: {:error, "Unexpected type when decoding TickConfig.font_weight"}
 
@@ -3533,58 +4805,138 @@ defmodule TickConfig do
   def encode_href(value) when is_binary(value), do: value
   def encode_href(_), do: {:error, "Unexpected type when encoding TickConfig.href"}
 
+  def decode_limit(value) when is_float(value), do: value
+  def decode_limit(value) when is_integer(value), do: value
+  def decode_limit(_), do: {:error, "Unexpected type when decoding TickConfig.limit"}
+
+  def encode_limit(value) when is_float(value), do: value
+  def encode_limit(value) when is_integer(value), do: value
+  def encode_limit(_), do: {:error, "Unexpected type when encoding TickConfig.limit"}
+
+  def decode_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_opacity(_), do: {:error, "Unexpected type when decoding TickConfig.opacity"}
+
+  def encode_opacity(value) when is_float(value), do: value
+  def encode_opacity(value) when is_integer(value), do: value
+  def encode_opacity(_), do: {:error, "Unexpected type when encoding TickConfig.opacity"}
+
+  def decode_radius(value) when is_float(value) and value >= 0, do: value
+  def decode_radius(value) when is_integer(value) and value >= 0, do: value
+  def decode_radius(_), do: {:error, "Unexpected type when decoding TickConfig.radius"}
+
+  def encode_radius(value) when is_float(value), do: value
+  def encode_radius(value) when is_integer(value), do: value
+  def encode_radius(_), do: {:error, "Unexpected type when encoding TickConfig.radius"}
+
   def decode_shape(value) when is_binary(value), do: value
   def decode_shape(_), do: {:error, "Unexpected type when decoding TickConfig.shape"}
 
   def encode_shape(value) when is_binary(value), do: value
   def encode_shape(_), do: {:error, "Unexpected type when encoding TickConfig.shape"}
 
+  def decode_size(value) when is_float(value) and value >= 0, do: value
+  def decode_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_size(_), do: {:error, "Unexpected type when decoding TickConfig.size"}
+
+  def encode_size(value) when is_float(value), do: value
+  def encode_size(value) when is_integer(value), do: value
+  def encode_size(_), do: {:error, "Unexpected type when encoding TickConfig.size"}
+
   def decode_stroke(value) when is_binary(value), do: value
   def decode_stroke(_), do: {:error, "Unexpected type when decoding TickConfig.stroke"}
 
   def encode_stroke(value) when is_binary(value), do: value
   def encode_stroke(_), do: {:error, "Unexpected type when encoding TickConfig.stroke"}
 
+  def decode_stroke_dash_offset(value) when is_float(value), do: value
+  def decode_stroke_dash_offset(value) when is_integer(value), do: value
+  def decode_stroke_dash_offset(_), do: {:error, "Unexpected type when decoding TickConfig.stroke_dash_offset"}
+
+  def encode_stroke_dash_offset(value) when is_float(value), do: value
+  def encode_stroke_dash_offset(value) when is_integer(value), do: value
+  def encode_stroke_dash_offset(_), do: {:error, "Unexpected type when encoding TickConfig.stroke_dash_offset"}
+
+  def decode_stroke_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_stroke_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_stroke_opacity(_), do: {:error, "Unexpected type when decoding TickConfig.stroke_opacity"}
+
+  def encode_stroke_opacity(value) when is_float(value), do: value
+  def encode_stroke_opacity(value) when is_integer(value), do: value
+  def encode_stroke_opacity(_), do: {:error, "Unexpected type when encoding TickConfig.stroke_opacity"}
+
+  def decode_stroke_width(value) when is_float(value) and value >= 0, do: value
+  def decode_stroke_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_stroke_width(_), do: {:error, "Unexpected type when decoding TickConfig.stroke_width"}
+
+  def encode_stroke_width(value) when is_float(value), do: value
+  def encode_stroke_width(value) when is_integer(value), do: value
+  def encode_stroke_width(_), do: {:error, "Unexpected type when encoding TickConfig.stroke_width"}
+
+  def decode_tension(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_tension(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_tension(_), do: {:error, "Unexpected type when decoding TickConfig.tension"}
+
+  def encode_tension(value) when is_float(value), do: value
+  def encode_tension(value) when is_integer(value), do: value
+  def encode_tension(_), do: {:error, "Unexpected type when encoding TickConfig.tension"}
+
   def decode_text(value) when is_binary(value), do: value
   def decode_text(_), do: {:error, "Unexpected type when decoding TickConfig.text"}
 
   def encode_text(value) when is_binary(value), do: value
   def encode_text(_), do: {:error, "Unexpected type when encoding TickConfig.text"}
 
+  def decode_theta(value) when is_float(value), do: value
+  def decode_theta(value) when is_integer(value), do: value
+  def decode_theta(_), do: {:error, "Unexpected type when decoding TickConfig.theta"}
+
+  def encode_theta(value) when is_float(value), do: value
+  def encode_theta(value) when is_integer(value), do: value
+  def encode_theta(_), do: {:error, "Unexpected type when encoding TickConfig.theta"}
+
+  def decode_thickness(value) when is_float(value) and value >= 0, do: value
+  def decode_thickness(value) when is_integer(value) and value >= 0, do: value
+  def decode_thickness(_), do: {:error, "Unexpected type when decoding TickConfig.thickness"}
+
+  def encode_thickness(value) when is_float(value), do: value
+  def encode_thickness(value) when is_integer(value), do: value
+  def encode_thickness(_), do: {:error, "Unexpected type when encoding TickConfig.thickness"}
+
   def from_map(m) do
     %TickConfig{
       align: m["align"] && HorizontalAlign.decode(m["align"]),
-      angle: m["angle"],
-      band_size: m["bandSize"],
+      angle: m["angle"] && decode_angle(m["angle"]),
+      band_size: m["bandSize"] && decode_band_size(m["bandSize"]),
       baseline: m["baseline"] && VerticalAlign.decode(m["baseline"]),
       color: m["color"] && decode_color(m["color"]),
       cursor: m["cursor"] && Cursor.decode(m["cursor"]),
-      dx: m["dx"],
-      dy: m["dy"],
+      dx: m["dx"] && decode_dx(m["dx"]),
+      dy: m["dy"] && decode_dy(m["dy"]),
       fill: m["fill"] && decode_fill(m["fill"]),
       filled: m["filled"],
-      fill_opacity: m["fillOpacity"],
+      fill_opacity: m["fillOpacity"] && decode_fill_opacity(m["fillOpacity"]),
       font: m["font"] && decode_font(m["font"]),
-      font_size: m["fontSize"],
+      font_size: m["fontSize"] && decode_font_size(m["fontSize"]),
       font_style: m["fontStyle"] && FontStyle.decode(m["fontStyle"]),
       font_weight: decode_font_weight(m["fontWeight"]),
       href: m["href"] && decode_href(m["href"]),
       interpolate: m["interpolate"] && Interpolate.decode(m["interpolate"]),
-      limit: m["limit"],
-      opacity: m["opacity"],
+      limit: m["limit"] && decode_limit(m["limit"]),
+      opacity: m["opacity"] && decode_opacity(m["opacity"]),
       orient: m["orient"] && Orient.decode(m["orient"]),
-      radius: m["radius"],
+      radius: m["radius"] && decode_radius(m["radius"]),
       shape: m["shape"] && decode_shape(m["shape"]),
-      size: m["size"],
+      size: m["size"] && decode_size(m["size"]),
       stroke: m["stroke"] && decode_stroke(m["stroke"]),
       stroke_dash: m["strokeDash"],
-      stroke_dash_offset: m["strokeDashOffset"],
-      stroke_opacity: m["strokeOpacity"],
-      stroke_width: m["strokeWidth"],
-      tension: m["tension"],
+      stroke_dash_offset: m["strokeDashOffset"] && decode_stroke_dash_offset(m["strokeDashOffset"]),
+      stroke_opacity: m["strokeOpacity"] && decode_stroke_opacity(m["strokeOpacity"]),
+      stroke_width: m["strokeWidth"] && decode_stroke_width(m["strokeWidth"]),
+      tension: m["tension"] && decode_tension(m["tension"]),
       text: m["text"] && decode_text(m["text"]),
-      theta: m["theta"],
-      thickness: m["thickness"],
+      theta: m["theta"] && decode_theta(m["theta"]),
+      thickness: m["thickness"] && decode_thickness(m["thickness"]),
     }
   end
 
@@ -3789,6 +5141,14 @@ defmodule VGTitleConfig do
           orient: TitleOrient.t() | nil
         }
 
+  def decode_angle(value) when is_float(value), do: value
+  def decode_angle(value) when is_integer(value), do: value
+  def decode_angle(_), do: {:error, "Unexpected type when decoding VGTitleConfig.angle"}
+
+  def encode_angle(value) when is_float(value), do: value
+  def encode_angle(value) when is_integer(value), do: value
+  def encode_angle(_), do: {:error, "Unexpected type when encoding VGTitleConfig.angle"}
+
   def decode_color(value) when is_binary(value), do: value
   def decode_color(_), do: {:error, "Unexpected type when decoding VGTitleConfig.color"}
 
@@ -3801,9 +5161,17 @@ defmodule VGTitleConfig do
   def encode_font(value) when is_binary(value), do: value
   def encode_font(_), do: {:error, "Unexpected type when encoding VGTitleConfig.font"}
 
+  def decode_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_font_size(_), do: {:error, "Unexpected type when decoding VGTitleConfig.font_size"}
+
+  def encode_font_size(value) when is_float(value), do: value
+  def encode_font_size(value) when is_integer(value), do: value
+  def encode_font_size(_), do: {:error, "Unexpected type when encoding VGTitleConfig.font_size"}
+
   def decode_font_weight(value) when is_binary(value), do: FontWeight.decode(value)
-  def decode_font_weight(value) when is_float(value), do: value
-  def decode_font_weight(value) when is_integer(value), do: value
+  def decode_font_weight(value) when is_float(value) and value >= 100 and value <= 900, do: value
+  def decode_font_weight(value) when is_integer(value) and value >= 100 and value <= 900, do: value
   def decode_font_weight(value) when is_nil(value), do: value
   def decode_font_weight(_), do: {:error, "Unexpected type when decoding VGTitleConfig.font_weight"}
 
@@ -3813,17 +5181,33 @@ defmodule VGTitleConfig do
   def encode_font_weight(value) when is_nil(value), do: value
   def encode_font_weight(_), do: {:error, "Unexpected type when encoding VGTitleConfig.font_weight"}
 
+  def decode_limit(value) when is_float(value) and value >= 0, do: value
+  def decode_limit(value) when is_integer(value) and value >= 0, do: value
+  def decode_limit(_), do: {:error, "Unexpected type when decoding VGTitleConfig.limit"}
+
+  def encode_limit(value) when is_float(value), do: value
+  def encode_limit(value) when is_integer(value), do: value
+  def encode_limit(_), do: {:error, "Unexpected type when encoding VGTitleConfig.limit"}
+
+  def decode_offset(value) when is_float(value), do: value
+  def decode_offset(value) when is_integer(value), do: value
+  def decode_offset(_), do: {:error, "Unexpected type when decoding VGTitleConfig.offset"}
+
+  def encode_offset(value) when is_float(value), do: value
+  def encode_offset(value) when is_integer(value), do: value
+  def encode_offset(_), do: {:error, "Unexpected type when encoding VGTitleConfig.offset"}
+
   def from_map(m) do
     %VGTitleConfig{
       anchor: m["anchor"] && Anchor.decode(m["anchor"]),
-      angle: m["angle"],
+      angle: m["angle"] && decode_angle(m["angle"]),
       baseline: m["baseline"] && VerticalAlign.decode(m["baseline"]),
       color: m["color"] && decode_color(m["color"]),
       font: m["font"] && decode_font(m["font"]),
-      font_size: m["fontSize"],
+      font_size: m["fontSize"] && decode_font_size(m["fontSize"]),
       font_weight: decode_font_weight(m["fontWeight"]),
-      limit: m["limit"],
-      offset: m["offset"],
+      limit: m["limit"] && decode_limit(m["limit"]),
+      offset: m["offset"] && decode_offset(m["offset"]),
       orient: m["orient"] && TitleOrient.decode(m["orient"]),
     }
   end
@@ -3892,24 +5276,72 @@ defmodule ViewConfig do
   def encode_fill(value) when is_binary(value), do: value
   def encode_fill(_), do: {:error, "Unexpected type when encoding ViewConfig.fill"}
 
+  def decode_fill_opacity(value) when is_float(value), do: value
+  def decode_fill_opacity(value) when is_integer(value), do: value
+  def decode_fill_opacity(_), do: {:error, "Unexpected type when decoding ViewConfig.fill_opacity"}
+
+  def encode_fill_opacity(value) when is_float(value), do: value
+  def encode_fill_opacity(value) when is_integer(value), do: value
+  def encode_fill_opacity(_), do: {:error, "Unexpected type when encoding ViewConfig.fill_opacity"}
+
+  def decode_height(value) when is_float(value), do: value
+  def decode_height(value) when is_integer(value), do: value
+  def decode_height(_), do: {:error, "Unexpected type when decoding ViewConfig.height"}
+
+  def encode_height(value) when is_float(value), do: value
+  def encode_height(value) when is_integer(value), do: value
+  def encode_height(_), do: {:error, "Unexpected type when encoding ViewConfig.height"}
+
   def decode_stroke(value) when is_binary(value), do: value
   def decode_stroke(_), do: {:error, "Unexpected type when decoding ViewConfig.stroke"}
 
   def encode_stroke(value) when is_binary(value), do: value
   def encode_stroke(_), do: {:error, "Unexpected type when encoding ViewConfig.stroke"}
 
+  def decode_stroke_dash_offset(value) when is_float(value), do: value
+  def decode_stroke_dash_offset(value) when is_integer(value), do: value
+  def decode_stroke_dash_offset(_), do: {:error, "Unexpected type when decoding ViewConfig.stroke_dash_offset"}
+
+  def encode_stroke_dash_offset(value) when is_float(value), do: value
+  def encode_stroke_dash_offset(value) when is_integer(value), do: value
+  def encode_stroke_dash_offset(_), do: {:error, "Unexpected type when encoding ViewConfig.stroke_dash_offset"}
+
+  def decode_stroke_opacity(value) when is_float(value), do: value
+  def decode_stroke_opacity(value) when is_integer(value), do: value
+  def decode_stroke_opacity(_), do: {:error, "Unexpected type when decoding ViewConfig.stroke_opacity"}
+
+  def encode_stroke_opacity(value) when is_float(value), do: value
+  def encode_stroke_opacity(value) when is_integer(value), do: value
+  def encode_stroke_opacity(_), do: {:error, "Unexpected type when encoding ViewConfig.stroke_opacity"}
+
+  def decode_stroke_width(value) when is_float(value), do: value
+  def decode_stroke_width(value) when is_integer(value), do: value
+  def decode_stroke_width(_), do: {:error, "Unexpected type when decoding ViewConfig.stroke_width"}
+
+  def encode_stroke_width(value) when is_float(value), do: value
+  def encode_stroke_width(value) when is_integer(value), do: value
+  def encode_stroke_width(_), do: {:error, "Unexpected type when encoding ViewConfig.stroke_width"}
+
+  def decode_width(value) when is_float(value), do: value
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding ViewConfig.width"}
+
+  def encode_width(value) when is_float(value), do: value
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding ViewConfig.width"}
+
   def from_map(m) do
     %ViewConfig{
       clip: m["clip"],
       fill: m["fill"] && decode_fill(m["fill"]),
-      fill_opacity: m["fillOpacity"],
-      height: m["height"],
+      fill_opacity: m["fillOpacity"] && decode_fill_opacity(m["fillOpacity"]),
+      height: m["height"] && decode_height(m["height"]),
       stroke: m["stroke"] && decode_stroke(m["stroke"]),
       stroke_dash: m["strokeDash"],
-      stroke_dash_offset: m["strokeDashOffset"],
-      stroke_opacity: m["strokeOpacity"],
-      stroke_width: m["strokeWidth"],
-      width: m["width"],
+      stroke_dash_offset: m["strokeDashOffset"] && decode_stroke_dash_offset(m["strokeDashOffset"]),
+      stroke_opacity: m["strokeOpacity"] && decode_stroke_opacity(m["strokeOpacity"]),
+      stroke_width: m["strokeWidth"] && decode_stroke_width(m["strokeWidth"]),
+      width: m["width"] && decode_width(m["width"]),
     }
   end
 
@@ -4550,15 +5982,47 @@ defmodule BinParams do
           steps: [float()] | nil
         }
 
+  def decode_base(value) when is_float(value), do: value
+  def decode_base(value) when is_integer(value), do: value
+  def decode_base(_), do: {:error, "Unexpected type when decoding BinParams.base"}
+
+  def encode_base(value) when is_float(value), do: value
+  def encode_base(value) when is_integer(value), do: value
+  def encode_base(_), do: {:error, "Unexpected type when encoding BinParams.base"}
+
+  def decode_maxbins(value) when is_float(value) and value >= 2, do: value
+  def decode_maxbins(value) when is_integer(value) and value >= 2, do: value
+  def decode_maxbins(_), do: {:error, "Unexpected type when decoding BinParams.maxbins"}
+
+  def encode_maxbins(value) when is_float(value), do: value
+  def encode_maxbins(value) when is_integer(value), do: value
+  def encode_maxbins(_), do: {:error, "Unexpected type when encoding BinParams.maxbins"}
+
+  def decode_minstep(value) when is_float(value), do: value
+  def decode_minstep(value) when is_integer(value), do: value
+  def decode_minstep(_), do: {:error, "Unexpected type when decoding BinParams.minstep"}
+
+  def encode_minstep(value) when is_float(value), do: value
+  def encode_minstep(value) when is_integer(value), do: value
+  def encode_minstep(_), do: {:error, "Unexpected type when encoding BinParams.minstep"}
+
+  def decode_step(value) when is_float(value), do: value
+  def decode_step(value) when is_integer(value), do: value
+  def decode_step(_), do: {:error, "Unexpected type when decoding BinParams.step"}
+
+  def encode_step(value) when is_float(value), do: value
+  def encode_step(value) when is_integer(value), do: value
+  def encode_step(_), do: {:error, "Unexpected type when encoding BinParams.step"}
+
   def from_map(m) do
     %BinParams{
-      base: m["base"],
+      base: m["base"] && decode_base(m["base"]),
       divide: m["divide"],
       extent: m["extent"],
-      maxbins: m["maxbins"],
-      minstep: m["minstep"],
+      maxbins: m["maxbins"] && decode_maxbins(m["maxbins"]),
+      minstep: m["minstep"] && decode_minstep(m["minstep"]),
       nice: m["nice"],
-      step: m["step"],
+      step: m["step"] && decode_step(m["step"]),
       steps: m["steps"],
     }
   end
@@ -4686,18 +6150,74 @@ defmodule DateTimeClass do
           year: float() | nil
         }
 
+  def decode_date(value) when is_float(value) and value >= 1 and value <= 31, do: value
+  def decode_date(value) when is_integer(value) and value >= 1 and value <= 31, do: value
+  def decode_date(_), do: {:error, "Unexpected type when decoding DateTimeClass.date"}
+
+  def encode_date(value) when is_float(value), do: value
+  def encode_date(value) when is_integer(value), do: value
+  def encode_date(_), do: {:error, "Unexpected type when encoding DateTimeClass.date"}
+
+  def decode_hours(value) when is_float(value) and value >= 0 and value <= 23, do: value
+  def decode_hours(value) when is_integer(value) and value >= 0 and value <= 23, do: value
+  def decode_hours(_), do: {:error, "Unexpected type when decoding DateTimeClass.hours"}
+
+  def encode_hours(value) when is_float(value), do: value
+  def encode_hours(value) when is_integer(value), do: value
+  def encode_hours(_), do: {:error, "Unexpected type when encoding DateTimeClass.hours"}
+
+  def decode_milliseconds(value) when is_float(value) and value >= 0 and value <= 999, do: value
+  def decode_milliseconds(value) when is_integer(value) and value >= 0 and value <= 999, do: value
+  def decode_milliseconds(_), do: {:error, "Unexpected type when decoding DateTimeClass.milliseconds"}
+
+  def encode_milliseconds(value) when is_float(value), do: value
+  def encode_milliseconds(value) when is_integer(value), do: value
+  def encode_milliseconds(_), do: {:error, "Unexpected type when encoding DateTimeClass.milliseconds"}
+
+  def decode_minutes(value) when is_float(value) and value >= 0 and value <= 59, do: value
+  def decode_minutes(value) when is_integer(value) and value >= 0 and value <= 59, do: value
+  def decode_minutes(_), do: {:error, "Unexpected type when decoding DateTimeClass.minutes"}
+
+  def encode_minutes(value) when is_float(value), do: value
+  def encode_minutes(value) when is_integer(value), do: value
+  def encode_minutes(_), do: {:error, "Unexpected type when encoding DateTimeClass.minutes"}
+
+  def decode_quarter(value) when is_float(value) and value >= 1 and value <= 4, do: value
+  def decode_quarter(value) when is_integer(value) and value >= 1 and value <= 4, do: value
+  def decode_quarter(_), do: {:error, "Unexpected type when decoding DateTimeClass.quarter"}
+
+  def encode_quarter(value) when is_float(value), do: value
+  def encode_quarter(value) when is_integer(value), do: value
+  def encode_quarter(_), do: {:error, "Unexpected type when encoding DateTimeClass.quarter"}
+
+  def decode_seconds(value) when is_float(value) and value >= 0 and value <= 59, do: value
+  def decode_seconds(value) when is_integer(value) and value >= 0 and value <= 59, do: value
+  def decode_seconds(_), do: {:error, "Unexpected type when decoding DateTimeClass.seconds"}
+
+  def encode_seconds(value) when is_float(value), do: value
+  def encode_seconds(value) when is_integer(value), do: value
+  def encode_seconds(_), do: {:error, "Unexpected type when encoding DateTimeClass.seconds"}
+
+  def decode_year(value) when is_float(value), do: value
+  def decode_year(value) when is_integer(value), do: value
+  def decode_year(_), do: {:error, "Unexpected type when decoding DateTimeClass.year"}
+
+  def encode_year(value) when is_float(value), do: value
+  def encode_year(value) when is_integer(value), do: value
+  def encode_year(_), do: {:error, "Unexpected type when encoding DateTimeClass.year"}
+
   def from_map(m) do
     %DateTimeClass{
-      date: m["date"],
+      date: m["date"] && decode_date(m["date"]),
       day: m["day"],
-      hours: m["hours"],
-      milliseconds: m["milliseconds"],
-      minutes: m["minutes"],
+      hours: m["hours"] && decode_hours(m["hours"]),
+      milliseconds: m["milliseconds"] && decode_milliseconds(m["milliseconds"]),
+      minutes: m["minutes"] && decode_minutes(m["minutes"]),
       month: m["month"],
-      quarter: m["quarter"],
-      seconds: m["seconds"],
+      quarter: m["quarter"] && decode_quarter(m["quarter"]),
+      seconds: m["seconds"] && decode_seconds(m["seconds"]),
       utc: m["utc"],
-      year: m["year"],
+      year: m["year"] && decode_year(m["year"]),
     }
   end
 
@@ -5208,12 +6728,44 @@ defmodule Legend do
           zindex: float() | nil
         }
 
+  def decode_entry_padding(value) when is_float(value), do: value
+  def decode_entry_padding(value) when is_integer(value), do: value
+  def decode_entry_padding(_), do: {:error, "Unexpected type when decoding Legend.entry_padding"}
+
+  def encode_entry_padding(value) when is_float(value), do: value
+  def encode_entry_padding(value) when is_integer(value), do: value
+  def encode_entry_padding(_), do: {:error, "Unexpected type when encoding Legend.entry_padding"}
+
   def decode_format(value) when is_binary(value), do: value
   def decode_format(_), do: {:error, "Unexpected type when decoding Legend.format"}
 
   def encode_format(value) when is_binary(value), do: value
   def encode_format(_), do: {:error, "Unexpected type when encoding Legend.format"}
 
+  def decode_offset(value) when is_float(value), do: value
+  def decode_offset(value) when is_integer(value), do: value
+  def decode_offset(_), do: {:error, "Unexpected type when decoding Legend.offset"}
+
+  def encode_offset(value) when is_float(value), do: value
+  def encode_offset(value) when is_integer(value), do: value
+  def encode_offset(_), do: {:error, "Unexpected type when encoding Legend.offset"}
+
+  def decode_padding(value) when is_float(value), do: value
+  def decode_padding(value) when is_integer(value), do: value
+  def decode_padding(_), do: {:error, "Unexpected type when decoding Legend.padding"}
+
+  def encode_padding(value) when is_float(value), do: value
+  def encode_padding(value) when is_integer(value), do: value
+  def encode_padding(_), do: {:error, "Unexpected type when encoding Legend.padding"}
+
+  def decode_tick_count(value) when is_float(value), do: value
+  def decode_tick_count(value) when is_integer(value), do: value
+  def decode_tick_count(_), do: {:error, "Unexpected type when decoding Legend.tick_count"}
+
+  def encode_tick_count(value) when is_float(value), do: value
+  def encode_tick_count(value) when is_integer(value), do: value
+  def encode_tick_count(_), do: {:error, "Unexpected type when encoding Legend.tick_count"}
+
   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
@@ -5226,18 +6778,26 @@ defmodule Legend do
   def encode_values_element(value) when is_binary(value), do: value
   def encode_values_element(_), do: {:error, "Unexpected type when encoding Legend.values"}
 
+  def decode_zindex(value) when is_float(value) and value >= 0, do: value
+  def decode_zindex(value) when is_integer(value) and value >= 0, do: value
+  def decode_zindex(_), do: {:error, "Unexpected type when decoding Legend.zindex"}
+
+  def encode_zindex(value) when is_float(value), do: value
+  def encode_zindex(value) when is_integer(value), do: value
+  def encode_zindex(_), do: {:error, "Unexpected type when encoding Legend.zindex"}
+
   def from_map(m) do
     %Legend{
-      entry_padding: m["entryPadding"],
+      entry_padding: m["entryPadding"] && decode_entry_padding(m["entryPadding"]),
       format: m["format"] && decode_format(m["format"]),
-      offset: m["offset"],
+      offset: m["offset"] && decode_offset(m["offset"]),
       orient: m["orient"] && LegendOrient.decode(m["orient"]),
-      padding: m["padding"],
-      tick_count: m["tickCount"],
+      padding: m["padding"] && decode_padding(m["padding"]),
+      tick_count: m["tickCount"] && decode_tick_count(m["tickCount"]),
       title: m["title"],
       type: m["type"] && LegendType.decode(m["type"]),
       values: m["values"] && Enum.map(m["values"], &decode_values_element/1),
-      zindex: m["zindex"],
+      zindex: m["zindex"] && decode_zindex(m["zindex"]),
     }
   end
 
@@ -5433,9 +6993,17 @@ defmodule InterpolateParams do
           type: InterpolateParamsType.t()
         }
 
+  def decode_gamma(value) when is_float(value), do: value
+  def decode_gamma(value) when is_integer(value), do: value
+  def decode_gamma(_), do: {:error, "Unexpected type when decoding InterpolateParams.gamma"}
+
+  def encode_gamma(value) when is_float(value), do: value
+  def encode_gamma(value) when is_integer(value), do: value
+  def encode_gamma(_), do: {:error, "Unexpected type when encoding InterpolateParams.gamma"}
+
   def from_map(m) do
     %InterpolateParams{
-      gamma: m["gamma"],
+      gamma: m["gamma"] && decode_gamma(m["gamma"]),
       type: InterpolateParamsType.decode(m["type"]),
     }
   end
@@ -5726,6 +7294,14 @@ defmodule Scale do
           zero: boolean() | nil
         }
 
+  def decode_base(value) when is_float(value), do: value
+  def decode_base(value) when is_integer(value), do: value
+  def decode_base(_), do: {:error, "Unexpected type when decoding Scale.base"}
+
+  def encode_base(value) when is_float(value), do: value
+  def encode_base(value) when is_integer(value), do: value
+  def encode_base(_), do: {:error, "Unexpected type when encoding Scale.base"}
+
   def decode_domain(%{"selection" => _,} = value), do: DomainClass.from_map(value)
   def decode_domain(value) when is_binary(value), do: Domain.decode(value)
   def decode_domain(value) when is_list(value), do: value
@@ -5738,6 +7314,14 @@ defmodule Scale do
   def encode_domain(value) when is_nil(value), do: value
   def encode_domain(_), do: {:error, "Unexpected type when encoding Scale.domain"}
 
+  def decode_exponent(value) when is_float(value), do: value
+  def decode_exponent(value) when is_integer(value), do: value
+  def decode_exponent(_), do: {:error, "Unexpected type when decoding Scale.exponent"}
+
+  def encode_exponent(value) when is_float(value), do: value
+  def encode_exponent(value) when is_integer(value), do: value
+  def encode_exponent(_), do: {:error, "Unexpected type when encoding Scale.exponent"}
+
   def decode_interpolate(%{"type" => _,} = value), do: InterpolateParams.from_map(value)
   def decode_interpolate(value) when is_binary(value), do: Interpolate.decode(value)
   def decode_interpolate(value) when is_nil(value), do: value
@@ -5764,6 +7348,30 @@ defmodule Scale do
   def encode_nice(value) when is_nil(value), do: value
   def encode_nice(_), do: {:error, "Unexpected type when encoding Scale.nice"}
 
+  def decode_padding(value) when is_float(value) and value >= 0, do: value
+  def decode_padding(value) when is_integer(value) and value >= 0, do: value
+  def decode_padding(_), do: {:error, "Unexpected type when decoding Scale.padding"}
+
+  def encode_padding(value) when is_float(value), do: value
+  def encode_padding(value) when is_integer(value), do: value
+  def encode_padding(_), do: {:error, "Unexpected type when encoding Scale.padding"}
+
+  def decode_padding_inner(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_padding_inner(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_padding_inner(_), do: {:error, "Unexpected type when decoding Scale.padding_inner"}
+
+  def encode_padding_inner(value) when is_float(value), do: value
+  def encode_padding_inner(value) when is_integer(value), do: value
+  def encode_padding_inner(_), do: {:error, "Unexpected type when encoding Scale.padding_inner"}
+
+  def decode_padding_outer(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_padding_outer(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_padding_outer(_), do: {:error, "Unexpected type when decoding Scale.padding_outer"}
+
+  def encode_padding_outer(value) when is_float(value), do: value
+  def encode_padding_outer(value) when is_integer(value), do: value
+  def encode_padding_outer(_), do: {:error, "Unexpected type when encoding Scale.padding_outer"}
+
   def decode_range(value) when is_binary(value), do: value
   def decode_range(value) when is_list(value), do: value
   def decode_range(value) when is_nil(value), do: value
@@ -5786,15 +7394,15 @@ defmodule Scale do
 
   def from_map(m) do
     %Scale{
-      base: m["base"],
+      base: m["base"] && decode_base(m["base"]),
       clamp: m["clamp"],
       domain: decode_domain(m["domain"]),
-      exponent: m["exponent"],
+      exponent: m["exponent"] && decode_exponent(m["exponent"]),
       interpolate: decode_interpolate(m["interpolate"]),
       nice: decode_nice(m["nice"]),
-      padding: m["padding"],
-      padding_inner: m["paddingInner"],
-      padding_outer: m["paddingOuter"],
+      padding: m["padding"] && decode_padding(m["padding"]),
+      padding_inner: m["paddingInner"] && decode_padding_inner(m["paddingInner"]),
+      padding_outer: m["paddingOuter"] && decode_padding_outer(m["paddingOuter"]),
       range: decode_range(m["range"]),
       range_step: m["rangeStep"],
       round: m["round"],
@@ -6300,10 +7908,18 @@ defmodule Header do
   def encode_format(value) when is_binary(value), do: value
   def encode_format(_), do: {:error, "Unexpected type when encoding Header.format"}
 
+  def decode_label_angle(value) when is_float(value) and value >= -360 and value <= 360, do: value
+  def decode_label_angle(value) when is_integer(value) and value >= -360 and value <= 360, do: value
+  def decode_label_angle(_), do: {:error, "Unexpected type when decoding Header.label_angle"}
+
+  def encode_label_angle(value) when is_float(value), do: value
+  def encode_label_angle(value) when is_integer(value), do: value
+  def encode_label_angle(_), do: {:error, "Unexpected type when encoding Header.label_angle"}
+
   def from_map(m) do
     %Header{
       format: m["format"] && decode_format(m["format"]),
-      label_angle: m["labelAngle"],
+      label_angle: m["labelAngle"] && decode_label_angle(m["labelAngle"]),
       title: m["title"],
     }
   end
@@ -7059,6 +8675,14 @@ defmodule Axis do
   def encode_format(value) when is_binary(value), do: value
   def encode_format(_), do: {:error, "Unexpected type when encoding Axis.format"}
 
+  def decode_label_angle(value) when is_float(value) and value >= -360 and value <= 360, do: value
+  def decode_label_angle(value) when is_integer(value) and value >= -360 and value <= 360, do: value
+  def decode_label_angle(_), do: {:error, "Unexpected type when decoding Axis.label_angle"}
+
+  def encode_label_angle(value) when is_float(value), do: value
+  def encode_label_angle(value) when is_integer(value), do: value
+  def encode_label_angle(_), do: {:error, "Unexpected type when encoding Axis.label_angle"}
+
   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
@@ -7069,6 +8693,78 @@ 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_label_padding(value) when is_float(value), do: value
+  def decode_label_padding(value) when is_integer(value), do: value
+  def decode_label_padding(_), do: {:error, "Unexpected type when decoding Axis.label_padding"}
+
+  def encode_label_padding(value) when is_float(value), do: value
+  def encode_label_padding(value) when is_integer(value), do: value
+  def encode_label_padding(_), do: {:error, "Unexpected type when encoding Axis.label_padding"}
+
+  def decode_max_extent(value) when is_float(value), do: value
+  def decode_max_extent(value) when is_integer(value), do: value
+  def decode_max_extent(_), do: {:error, "Unexpected type when decoding Axis.max_extent"}
+
+  def encode_max_extent(value) when is_float(value), do: value
+  def encode_max_extent(value) when is_integer(value), do: value
+  def encode_max_extent(_), do: {:error, "Unexpected type when encoding Axis.max_extent"}
+
+  def decode_min_extent(value) when is_float(value), do: value
+  def decode_min_extent(value) when is_integer(value), do: value
+  def decode_min_extent(_), do: {:error, "Unexpected type when decoding Axis.min_extent"}
+
+  def encode_min_extent(value) when is_float(value), do: value
+  def encode_min_extent(value) when is_integer(value), do: value
+  def encode_min_extent(_), do: {:error, "Unexpected type when encoding Axis.min_extent"}
+
+  def decode_offset(value) when is_float(value), do: value
+  def decode_offset(value) when is_integer(value), do: value
+  def decode_offset(_), do: {:error, "Unexpected type when decoding Axis.offset"}
+
+  def encode_offset(value) when is_float(value), do: value
+  def encode_offset(value) when is_integer(value), do: value
+  def encode_offset(_), do: {:error, "Unexpected type when encoding Axis.offset"}
+
+  def decode_position(value) when is_float(value), do: value
+  def decode_position(value) when is_integer(value), do: value
+  def decode_position(_), do: {:error, "Unexpected type when decoding Axis.position"}
+
+  def encode_position(value) when is_float(value), do: value
+  def encode_position(value) when is_integer(value), do: value
+  def encode_position(_), do: {:error, "Unexpected type when encoding Axis.position"}
+
+  def decode_tick_count(value) when is_float(value), do: value
+  def decode_tick_count(value) when is_integer(value), do: value
+  def decode_tick_count(_), do: {:error, "Unexpected type when decoding Axis.tick_count"}
+
+  def encode_tick_count(value) when is_float(value), do: value
+  def encode_tick_count(value) when is_integer(value), do: value
+  def encode_tick_count(_), do: {:error, "Unexpected type when encoding Axis.tick_count"}
+
+  def decode_tick_size(value) when is_float(value) and value >= 0, do: value
+  def decode_tick_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_tick_size(_), do: {:error, "Unexpected type when decoding Axis.tick_size"}
+
+  def encode_tick_size(value) when is_float(value), do: value
+  def encode_tick_size(value) when is_integer(value), do: value
+  def encode_tick_size(_), do: {:error, "Unexpected type when encoding Axis.tick_size"}
+
+  def decode_title_max_length(value) when is_float(value), do: value
+  def decode_title_max_length(value) when is_integer(value), do: value
+  def decode_title_max_length(_), do: {:error, "Unexpected type when decoding Axis.title_max_length"}
+
+  def encode_title_max_length(value) when is_float(value), do: value
+  def encode_title_max_length(value) when is_integer(value), do: value
+  def encode_title_max_length(_), do: {:error, "Unexpected type when encoding Axis.title_max_length"}
+
+  def decode_title_padding(value) when is_float(value), do: value
+  def decode_title_padding(value) when is_integer(value), do: value
+  def decode_title_padding(_), do: {:error, "Unexpected type when decoding Axis.title_padding"}
+
+  def encode_title_padding(value) when is_float(value), do: value
+  def encode_title_padding(value) when is_integer(value), do: value
+  def encode_title_padding(_), do: {:error, "Unexpected type when encoding Axis.title_padding"}
+
   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
@@ -7079,30 +8775,38 @@ defmodule Axis do
   def encode_values_element(value) when is_integer(value), do: value
   def encode_values_element(_), do: {:error, "Unexpected type when encoding Axis.values"}
 
+  def decode_zindex(value) when is_float(value) and value >= 0, do: value
+  def decode_zindex(value) when is_integer(value) and value >= 0, do: value
+  def decode_zindex(_), do: {:error, "Unexpected type when decoding Axis.zindex"}
+
+  def encode_zindex(value) when is_float(value), do: value
+  def encode_zindex(value) when is_integer(value), do: value
+  def encode_zindex(_), do: {:error, "Unexpected type when encoding Axis.zindex"}
+
   def from_map(m) do
     %Axis{
       domain: m["domain"],
       format: m["format"] && decode_format(m["format"]),
       grid: m["grid"],
-      label_angle: m["labelAngle"],
+      label_angle: m["labelAngle"] && decode_label_angle(m["labelAngle"]),
       label_bound: m["labelBound"],
       label_flush: m["labelFlush"],
       label_overlap: decode_label_overlap(m["labelOverlap"]),
-      label_padding: m["labelPadding"],
+      label_padding: m["labelPadding"] && decode_label_padding(m["labelPadding"]),
       labels: m["labels"],
-      max_extent: m["maxExtent"],
-      min_extent: m["minExtent"],
-      offset: m["offset"],
+      max_extent: m["maxExtent"] && decode_max_extent(m["maxExtent"]),
+      min_extent: m["minExtent"] && decode_min_extent(m["minExtent"]),
+      offset: m["offset"] && decode_offset(m["offset"]),
       orient: m["orient"] && TitleOrient.decode(m["orient"]),
-      position: m["position"],
-      tick_count: m["tickCount"],
+      position: m["position"] && decode_position(m["position"]),
+      tick_count: m["tickCount"] && decode_tick_count(m["tickCount"]),
       ticks: m["ticks"],
-      tick_size: m["tickSize"],
+      tick_size: m["tickSize"] && decode_tick_size(m["tickSize"]),
       title: m["title"],
-      title_max_length: m["titleMaxLength"],
-      title_padding: m["titlePadding"],
+      title_max_length: m["titleMaxLength"] && decode_title_max_length(m["titleMaxLength"]),
+      title_padding: m["titlePadding"] && decode_title_padding(m["titlePadding"]),
       values: m["values"] && Enum.map(m["values"], &decode_values_element/1),
-      zindex: m["zindex"],
+      zindex: m["zindex"] && decode_zindex(m["zindex"]),
     }
   end
 
@@ -7734,27 +9438,67 @@ defmodule MarkDef do
           type: Mark.t()
         }
 
+  def decode_angle(value) when is_float(value) and value >= 0 and value <= 360, do: value
+  def decode_angle(value) when is_integer(value) and value >= 0 and value <= 360, do: value
+  def decode_angle(_), do: {:error, "Unexpected type when decoding MarkDef.angle"}
+
+  def encode_angle(value) when is_float(value), do: value
+  def encode_angle(value) when is_integer(value), do: value
+  def encode_angle(_), do: {:error, "Unexpected type when encoding MarkDef.angle"}
+
   def decode_color(value) when is_binary(value), do: value
   def decode_color(_), do: {:error, "Unexpected type when decoding MarkDef.color"}
 
   def encode_color(value) when is_binary(value), do: value
   def encode_color(_), do: {:error, "Unexpected type when encoding MarkDef.color"}
 
+  def decode_dx(value) when is_float(value), do: value
+  def decode_dx(value) when is_integer(value), do: value
+  def decode_dx(_), do: {:error, "Unexpected type when decoding MarkDef.dx"}
+
+  def encode_dx(value) when is_float(value), do: value
+  def encode_dx(value) when is_integer(value), do: value
+  def encode_dx(_), do: {:error, "Unexpected type when encoding MarkDef.dx"}
+
+  def decode_dy(value) when is_float(value), do: value
+  def decode_dy(value) when is_integer(value), do: value
+  def decode_dy(_), do: {:error, "Unexpected type when decoding MarkDef.dy"}
+
+  def encode_dy(value) when is_float(value), do: value
+  def encode_dy(value) when is_integer(value), do: value
+  def encode_dy(_), do: {:error, "Unexpected type when encoding MarkDef.dy"}
+
   def decode_fill(value) when is_binary(value), do: value
   def decode_fill(_), do: {:error, "Unexpected type when decoding MarkDef.fill"}
 
   def encode_fill(value) when is_binary(value), do: value
   def encode_fill(_), do: {:error, "Unexpected type when encoding MarkDef.fill"}
 
+  def decode_fill_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_fill_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_fill_opacity(_), do: {:error, "Unexpected type when decoding MarkDef.fill_opacity"}
+
+  def encode_fill_opacity(value) when is_float(value), do: value
+  def encode_fill_opacity(value) when is_integer(value), do: value
+  def encode_fill_opacity(_), do: {:error, "Unexpected type when encoding MarkDef.fill_opacity"}
+
   def decode_font(value) when is_binary(value), do: value
   def decode_font(_), do: {:error, "Unexpected type when decoding MarkDef.font"}
 
   def encode_font(value) when is_binary(value), do: value
   def encode_font(_), do: {:error, "Unexpected type when encoding MarkDef.font"}
 
+  def decode_font_size(value) when is_float(value) and value >= 0, do: value
+  def decode_font_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_font_size(_), do: {:error, "Unexpected type when decoding MarkDef.font_size"}
+
+  def encode_font_size(value) when is_float(value), do: value
+  def encode_font_size(value) when is_integer(value), do: value
+  def encode_font_size(_), do: {:error, "Unexpected type when encoding MarkDef.font_size"}
+
   def decode_font_weight(value) when is_binary(value), do: FontWeight.decode(value)
-  def decode_font_weight(value) when is_float(value), do: value
-  def decode_font_weight(value) when is_integer(value), do: value
+  def decode_font_weight(value) when is_float(value) and value >= 100 and value <= 900, do: value
+  def decode_font_weight(value) when is_integer(value) and value >= 100 and value <= 900, do: value
   def decode_font_weight(value) when is_nil(value), do: value
   def decode_font_weight(_), do: {:error, "Unexpected type when decoding MarkDef.font_weight"}
 
@@ -7770,18 +9514,74 @@ defmodule MarkDef do
   def encode_href(value) when is_binary(value), do: value
   def encode_href(_), do: {:error, "Unexpected type when encoding MarkDef.href"}
 
+  def decode_limit(value) when is_float(value), do: value
+  def decode_limit(value) when is_integer(value), do: value
+  def decode_limit(_), do: {:error, "Unexpected type when decoding MarkDef.limit"}
+
+  def encode_limit(value) when is_float(value), do: value
+  def encode_limit(value) when is_integer(value), do: value
+  def encode_limit(_), do: {:error, "Unexpected type when encoding MarkDef.limit"}
+
+  def decode_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_opacity(_), do: {:error, "Unexpected type when decoding MarkDef.opacity"}
+
+  def encode_opacity(value) when is_float(value), do: value
+  def encode_opacity(value) when is_integer(value), do: value
+  def encode_opacity(_), do: {:error, "Unexpected type when encoding MarkDef.opacity"}
+
+  def decode_radius(value) when is_float(value) and value >= 0, do: value
+  def decode_radius(value) when is_integer(value) and value >= 0, do: value
+  def decode_radius(_), do: {:error, "Unexpected type when decoding MarkDef.radius"}
+
+  def encode_radius(value) when is_float(value), do: value
+  def encode_radius(value) when is_integer(value), do: value
+  def encode_radius(_), do: {:error, "Unexpected type when encoding MarkDef.radius"}
+
   def decode_shape(value) when is_binary(value), do: value
   def decode_shape(_), do: {:error, "Unexpected type when decoding MarkDef.shape"}
 
   def encode_shape(value) when is_binary(value), do: value
   def encode_shape(_), do: {:error, "Unexpected type when encoding MarkDef.shape"}
 
+  def decode_size(value) when is_float(value) and value >= 0, do: value
+  def decode_size(value) when is_integer(value) and value >= 0, do: value
+  def decode_size(_), do: {:error, "Unexpected type when decoding MarkDef.size"}
+
+  def encode_size(value) when is_float(value), do: value
+  def encode_size(value) when is_integer(value), do: value
+  def encode_size(_), do: {:error, "Unexpected type when encoding MarkDef.size"}
+
   def decode_stroke(value) when is_binary(value), do: value
   def decode_stroke(_), do: {:error, "Unexpected type when decoding MarkDef.stroke"}
 
   def encode_stroke(value) when is_binary(value), do: value
   def encode_stroke(_), do: {:error, "Unexpected type when encoding MarkDef.stroke"}
 
+  def decode_stroke_dash_offset(value) when is_float(value), do: value
+  def decode_stroke_dash_offset(value) when is_integer(value), do: value
+  def decode_stroke_dash_offset(_), do: {:error, "Unexpected type when decoding MarkDef.stroke_dash_offset"}
+
+  def encode_stroke_dash_offset(value) when is_float(value), do: value
+  def encode_stroke_dash_offset(value) when is_integer(value), do: value
+  def encode_stroke_dash_offset(_), do: {:error, "Unexpected type when encoding MarkDef.stroke_dash_offset"}
+
+  def decode_stroke_opacity(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_stroke_opacity(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_stroke_opacity(_), do: {:error, "Unexpected type when decoding MarkDef.stroke_opacity"}
+
+  def encode_stroke_opacity(value) when is_float(value), do: value
+  def encode_stroke_opacity(value) when is_integer(value), do: value
+  def encode_stroke_opacity(_), do: {:error, "Unexpected type when encoding MarkDef.stroke_opacity"}
+
+  def decode_stroke_width(value) when is_float(value) and value >= 0, do: value
+  def decode_stroke_width(value) when is_integer(value) and value >= 0, do: value
+  def decode_stroke_width(_), do: {:error, "Unexpected type when decoding MarkDef.stroke_width"}
+
+  def encode_stroke_width(value) when is_float(value), do: value
+  def encode_stroke_width(value) when is_integer(value), do: value
+  def encode_stroke_width(_), do: {:error, "Unexpected type when encoding MarkDef.stroke_width"}
+
   def decode_style(value) when is_binary(value), do: value
   def decode_style(value) when is_list(value), do: value
   def decode_style(value) when is_nil(value), do: value
@@ -7792,46 +9592,62 @@ defmodule MarkDef do
   def encode_style(value) when is_nil(value), do: value
   def encode_style(_), do: {:error, "Unexpected type when encoding MarkDef.style"}
 
+  def decode_tension(value) when is_float(value) and value >= 0 and value <= 1, do: value
+  def decode_tension(value) when is_integer(value) and value >= 0 and value <= 1, do: value
+  def decode_tension(_), do: {:error, "Unexpected type when decoding MarkDef.tension"}
+
+  def encode_tension(value) when is_float(value), do: value
+  def encode_tension(value) when is_integer(value), do: value
+  def encode_tension(_), do: {:error, "Unexpected type when encoding MarkDef.tension"}
+
   def decode_text(value) when is_binary(value), do: value
   def decode_text(_), do: {:error, "Unexpected type when decoding MarkDef.text"}
 
   def encode_text(value) when is_binary(value), do: value
   def encode_text(_), do: {:error, "Unexpected type when encoding MarkDef.text"}
 
+  def decode_theta(value) when is_float(value), do: value
+  def decode_theta(value) when is_integer(value), do: value
+  def decode_theta(_), do: {:error, "Unexpected type when decoding MarkDef.theta"}
+
+  def encode_theta(value) when is_float(value), do: value
+  def encode_theta(value) when is_integer(value), do: value
+  def encode_theta(_), do: {:error, "Unexpected type when encoding MarkDef.theta"}
+
   def from_map(m) do
     %MarkDef{
       align: m["align"] && HorizontalAlign.decode(m["align"]),
-      angle: m["angle"],
+      angle: m["angle"] && decode_angle(m["angle"]),
       baseline: m["baseline"] && VerticalAlign.decode(m["baseline"]),
       clip: m["clip"],
       color: m["color"] && decode_color(m["color"]),
       cursor: m["cursor"] && Cursor.decode(m["cursor"]),
-      dx: m["dx"],
-      dy: m["dy"],
+      dx: m["dx"] && decode_dx(m["dx"]),
+      dy: m["dy"] && decode_dy(m["dy"]),
       fill: m["fill"] && decode_fill(m["fill"]),
       filled: m["filled"],
-      fill_opacity: m["fillOpacity"],
+      fill_opacity: m["fillOpacity"] && decode_fill_opacity(m["fillOpacity"]),
       font: m["font"] && decode_font(m["font"]),
-      font_size: m["fontSize"],
+      font_size: m["fontSize"] && decode_font_size(m["fontSize"]),
       font_style: m["fontStyle"] && FontStyle.decode(m["fontStyle"]),
       font_weight: decode_font_weight(m["fontWeight"]),
       href: m["href"] && decode_href(m["href"]),
       interpolate: m["interpolate"] && Interpolate.decode(m["interpolate"]),
-      limit: m["limit"],
-      opacity: m["opacity"],
+      limit: m["limit"] && decode_limit(m["limit"]),
+      opacity: m["opacity"] && decode_opacity(m["opacity"]),
       orient: m["orient"] && Orient.decode(m["orient"]),
-      radius: m["radius"],
+      radius: m["radius"] && decode_radius(m["radius"]),
       shape: m["shape"] && decode_shape(m["shape"]),
-      size: m["size"],
+      size: m["size"] && decode_size(m["size"]),
       stroke: m["stroke"] && decode_stroke(m["stroke"]),
       stroke_dash: m["strokeDash"],
-      stroke_dash_offset: m["strokeDashOffset"],
-      stroke_opacity: m["strokeOpacity"],
-      stroke_width: m["strokeWidth"],
+      stroke_dash_offset: m["strokeDashOffset"] && decode_stroke_dash_offset(m["strokeDashOffset"]),
+      stroke_opacity: m["strokeOpacity"] && decode_stroke_opacity(m["strokeOpacity"]),
+      stroke_width: m["strokeWidth"] && decode_stroke_width(m["strokeWidth"]),
       style: decode_style(m["style"]),
-      tension: m["tension"],
+      tension: m["tension"] && decode_tension(m["tension"]),
       text: m["text"] && decode_text(m["text"]),
-      theta: m["theta"],
+      theta: m["theta"] && decode_theta(m["theta"]),
       type: Mark.decode(m["type"]),
     }
   end
@@ -7921,6 +9737,54 @@ defmodule Projection do
           type: VGProjectionType.t() | nil
         }
 
+  def decode_clip_angle(value) when is_float(value), do: value
+  def decode_clip_angle(value) when is_integer(value), do: value
+  def decode_clip_angle(_), do: {:error, "Unexpected type when decoding Projection.clip_angle"}
+
+  def encode_clip_angle(value) when is_float(value), do: value
+  def encode_clip_angle(value) when is_integer(value), do: value
+  def encode_clip_angle(_), do: {:error, "Unexpected type when encoding Projection.clip_angle"}
+
+  def decode_coefficient(value) when is_float(value), do: value
+  def decode_coefficient(value) when is_integer(value), do: value
+  def decode_coefficient(_), do: {:error, "Unexpected type when decoding Projection.coefficient"}
+
+  def encode_coefficient(value) when is_float(value), do: value
+  def encode_coefficient(value) when is_integer(value), do: value
+  def encode_coefficient(_), do: {:error, "Unexpected type when encoding Projection.coefficient"}
+
+  def decode_distance(value) when is_float(value), do: value
+  def decode_distance(value) when is_integer(value), do: value
+  def decode_distance(_), do: {:error, "Unexpected type when decoding Projection.distance"}
+
+  def encode_distance(value) when is_float(value), do: value
+  def encode_distance(value) when is_integer(value), do: value
+  def encode_distance(_), do: {:error, "Unexpected type when encoding Projection.distance"}
+
+  def decode_fraction(value) when is_float(value), do: value
+  def decode_fraction(value) when is_integer(value), do: value
+  def decode_fraction(_), do: {:error, "Unexpected type when decoding Projection.fraction"}
+
+  def encode_fraction(value) when is_float(value), do: value
+  def encode_fraction(value) when is_integer(value), do: value
+  def encode_fraction(_), do: {:error, "Unexpected type when encoding Projection.fraction"}
+
+  def decode_lobes(value) when is_float(value), do: value
+  def decode_lobes(value) when is_integer(value), do: value
+  def decode_lobes(_), do: {:error, "Unexpected type when decoding Projection.lobes"}
+
+  def encode_lobes(value) when is_float(value), do: value
+  def encode_lobes(value) when is_integer(value), do: value
+  def encode_lobes(_), do: {:error, "Unexpected type when encoding Projection.lobes"}
+
+  def decode_parallel(value) when is_float(value), do: value
+  def decode_parallel(value) when is_integer(value), do: value
+  def decode_parallel(_), do: {:error, "Unexpected type when decoding Projection.parallel"}
+
+  def encode_parallel(value) when is_float(value), do: value
+  def encode_parallel(value) when is_integer(value), do: value
+  def encode_parallel(_), do: {:error, "Unexpected type when encoding Projection.parallel"}
+
   def decode_precision_value(value) when is_float(value), do: value
   def decode_precision_value(value) when is_integer(value), do: value
   def decode_precision_value(value) when is_binary(value), do: value
@@ -7931,23 +9795,55 @@ defmodule Projection do
   def encode_precision_value(value) when is_binary(value), do: value
   def encode_precision_value(_), do: {:error, "Unexpected type when encoding Projection.precision"}
 
+  def decode_radius(value) when is_float(value), do: value
+  def decode_radius(value) when is_integer(value), do: value
+  def decode_radius(_), do: {:error, "Unexpected type when decoding Projection.radius"}
+
+  def encode_radius(value) when is_float(value), do: value
+  def encode_radius(value) when is_integer(value), do: value
+  def encode_radius(_), do: {:error, "Unexpected type when encoding Projection.radius"}
+
+  def decode_ratio(value) when is_float(value), do: value
+  def decode_ratio(value) when is_integer(value), do: value
+  def decode_ratio(_), do: {:error, "Unexpected type when decoding Projection.ratio"}
+
+  def encode_ratio(value) when is_float(value), do: value
+  def encode_ratio(value) when is_integer(value), do: value
+  def encode_ratio(_), do: {:error, "Unexpected type when encoding Projection.ratio"}
+
+  def decode_spacing(value) when is_float(value), do: value
+  def decode_spacing(value) when is_integer(value), do: value
+  def decode_spacing(_), do: {:error, "Unexpected type when decoding Projection.spacing"}
+
+  def encode_spacing(value) when is_float(value), do: value
+  def encode_spacing(value) when is_integer(value), do: value
+  def encode_spacing(_), do: {:error, "Unexpected type when encoding Projection.spacing"}
+
+  def decode_tilt(value) when is_float(value), do: value
+  def decode_tilt(value) when is_integer(value), do: value
+  def decode_tilt(_), do: {:error, "Unexpected type when decoding Projection.tilt"}
+
+  def encode_tilt(value) when is_float(value), do: value
+  def encode_tilt(value) when is_integer(value), do: value
+  def encode_tilt(_), do: {:error, "Unexpected type when encoding Projection.tilt"}
+
   def from_map(m) do
     %Projection{
       center: m["center"],
-      clip_angle: m["clipAngle"],
+      clip_angle: m["clipAngle"] && decode_clip_angle(m["clipAngle"]),
       clip_extent: m["clipExtent"],
-      coefficient: m["coefficient"],
-      distance: m["distance"],
-      fraction: m["fraction"],
-      lobes: m["lobes"],
-      parallel: m["parallel"],
+      coefficient: m["coefficient"] && decode_coefficient(m["coefficient"]),
+      distance: m["distance"] && decode_distance(m["distance"]),
+      fraction: m["fraction"] && decode_fraction(m["fraction"]),
+      lobes: m["lobes"] && decode_lobes(m["lobes"]),
+      parallel: m["parallel"] && decode_parallel(m["parallel"]),
       precision: m["precision"]
       |> Map.new(fn {key, value} -> {key, decode_precision_value(value)} end),
-      radius: m["radius"],
-      ratio: m["ratio"],
+      radius: m["radius"] && decode_radius(m["radius"]),
+      ratio: m["ratio"] && decode_ratio(m["ratio"]),
       rotate: m["rotate"],
-      spacing: m["spacing"],
-      tilt: m["tilt"],
+      spacing: m["spacing"] && decode_spacing(m["spacing"]),
+      tilt: m["tilt"] && decode_tilt(m["tilt"]),
       type: m["type"] && VGProjectionType.decode(m["type"]),
     }
   end
@@ -8365,6 +10261,14 @@ defmodule TitleParams do
           text: String.t()
         }
 
+  def decode_offset(value) when is_float(value), do: value
+  def decode_offset(value) when is_integer(value), do: value
+  def decode_offset(_), do: {:error, "Unexpected type when decoding TitleParams.offset"}
+
+  def encode_offset(value) when is_float(value), do: value
+  def encode_offset(value) when is_integer(value), do: value
+  def encode_offset(_), do: {:error, "Unexpected type when encoding TitleParams.offset"}
+
   def decode_style(value) when is_binary(value), do: value
   def decode_style(value) when is_list(value), do: value
   def decode_style(value) when is_nil(value), do: value
@@ -8384,7 +10288,7 @@ defmodule TitleParams do
   def from_map(m) do
     %TitleParams{
       anchor: m["anchor"] && Anchor.decode(m["anchor"]),
-      offset: m["offset"],
+      offset: m["offset"] && decode_offset(m["offset"]),
       orient: m["orient"] && TitleOrient.decode(m["orient"]),
       style: decode_style(m["style"]),
       text: decode_text(m["text"]),
@@ -8695,6 +10599,14 @@ defmodule LayerSpec do
   def encode_description(value) when is_binary(value), do: value
   def encode_description(_), do: {:error, "Unexpected type when encoding LayerSpec.description"}
 
+  def decode_height(value) when is_float(value), do: value
+  def decode_height(value) when is_integer(value), do: value
+  def decode_height(_), do: {:error, "Unexpected type when decoding LayerSpec.height"}
+
+  def encode_height(value) when is_float(value), do: value
+  def encode_height(value) when is_integer(value), do: value
+  def encode_height(_), do: {:error, "Unexpected type when encoding LayerSpec.height"}
+
   def decode_name(value) when is_binary(value), do: value
   def decode_name(_), do: {:error, "Unexpected type when decoding LayerSpec.name"}
 
@@ -8711,6 +10623,14 @@ defmodule LayerSpec do
   def encode_title(value) when is_nil(value), do: value
   def encode_title(_), do: {:error, "Unexpected type when encoding LayerSpec.title"}
 
+  def decode_width(value) when is_float(value), do: value
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding LayerSpec.width"}
+
+  def encode_width(value) when is_float(value), do: value
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding LayerSpec.width"}
+
   def decode_mark(%{"type" => _,} = value), do: MarkDef.from_map(value)
   def decode_mark(value) when is_binary(value), do: Mark.decode(value)
   def decode_mark(value) when is_nil(value), do: value
@@ -8725,13 +10645,13 @@ defmodule LayerSpec do
     %LayerSpec{
       data: m["data"] && Data.from_map(m["data"]),
       description: m["description"] && decode_description(m["description"]),
-      height: m["height"],
+      height: m["height"] && decode_height(m["height"]),
       layer: m["layer"] && Enum.map(m["layer"], &LayerSpec.from_map/1),
       name: m["name"] && decode_name(m["name"]),
       resolve: m["resolve"] && Resolve.from_map(m["resolve"]),
       title: decode_title(m["title"]),
       transform: m["transform"] && Enum.map(m["transform"], &Transform.from_map/1),
-      width: m["width"],
+      width: m["width"] && decode_width(m["width"]),
       encoding: m["encoding"] && Encoding.from_map(m["encoding"]),
       mark: decode_mark(m["mark"]),
       projection: m["projection"] && Projection.from_map(m["projection"]),
@@ -8866,6 +10786,14 @@ defmodule Spec do
   def encode_description(value) when is_binary(value), do: value
   def encode_description(_), do: {:error, "Unexpected type when encoding Spec.description"}
 
+  def decode_height(value) when is_float(value), do: value
+  def decode_height(value) when is_integer(value), do: value
+  def decode_height(_), do: {:error, "Unexpected type when decoding Spec.height"}
+
+  def encode_height(value) when is_float(value), do: value
+  def encode_height(value) when is_integer(value), do: value
+  def encode_height(_), do: {:error, "Unexpected type when encoding Spec.height"}
+
   def decode_name(value) when is_binary(value), do: value
   def decode_name(_), do: {:error, "Unexpected type when decoding Spec.name"}
 
@@ -8882,6 +10810,14 @@ defmodule Spec do
   def encode_title(value) when is_nil(value), do: value
   def encode_title(_), do: {:error, "Unexpected type when encoding Spec.title"}
 
+  def decode_width(value) when is_float(value), do: value
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding Spec.width"}
+
+  def encode_width(value) when is_float(value), do: value
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding Spec.width"}
+
   def decode_mark(%{"type" => _,} = value), do: MarkDef.from_map(value)
   def decode_mark(value) when is_binary(value), do: Mark.decode(value)
   def decode_mark(value) when is_nil(value), do: value
@@ -8896,13 +10832,13 @@ defmodule Spec do
     %Spec{
       data: m["data"] && Data.from_map(m["data"]),
       description: m["description"] && decode_description(m["description"]),
-      height: m["height"],
+      height: m["height"] && decode_height(m["height"]),
       layer: m["layer"] && Enum.map(m["layer"], &LayerSpec.from_map/1),
       name: m["name"] && decode_name(m["name"]),
       resolve: m["resolve"] && Resolve.from_map(m["resolve"]),
       title: decode_title(m["title"]),
       transform: m["transform"] && Enum.map(m["transform"], &Transform.from_map/1),
-      width: m["width"],
+      width: m["width"] && decode_width(m["width"]),
       encoding: m["encoding"] && Encoding.from_map(m["encoding"]),
       mark: decode_mark(m["mark"]),
       projection: m["projection"] && Projection.from_map(m["projection"]),
@@ -9036,6 +10972,14 @@ defmodule TopLevel do
   def encode_description(value) when is_binary(value), do: value
   def encode_description(_), do: {:error, "Unexpected type when encoding TopLevel.description"}
 
+  def decode_height(value) when is_float(value), do: value
+  def decode_height(value) when is_integer(value), do: value
+  def decode_height(_), do: {:error, "Unexpected type when decoding TopLevel.height"}
+
+  def encode_height(value) when is_float(value), do: value
+  def encode_height(value) when is_integer(value), do: value
+  def encode_height(_), do: {:error, "Unexpected type when encoding TopLevel.height"}
+
   def decode_mark(%{"type" => _,} = value), do: MarkDef.from_map(value)
   def decode_mark(value) when is_binary(value), do: Mark.decode(value)
   def decode_mark(value) when is_nil(value), do: value
@@ -9074,6 +11018,14 @@ defmodule TopLevel do
   def encode_title(value) when is_nil(value), do: value
   def encode_title(_), do: {:error, "Unexpected type when encoding TopLevel.title"}
 
+  def decode_width(value) when is_float(value), do: value
+  def decode_width(value) when is_integer(value), do: value
+  def decode_width(_), do: {:error, "Unexpected type when decoding TopLevel.width"}
+
+  def encode_width(value) when is_float(value), do: value
+  def encode_width(value) when is_integer(value), do: value
+  def encode_width(_), do: {:error, "Unexpected type when encoding TopLevel.width"}
+
   def from_map(m) do
     %TopLevel{
       schema: m["$schema"] && decode_schema(m["$schema"]),
@@ -9083,7 +11035,7 @@ defmodule TopLevel do
       data: m["data"] && Data.from_map(m["data"]),
       description: m["description"] && decode_description(m["description"]),
       encoding: m["encoding"] && EncodingWithFacet.from_map(m["encoding"]),
-      height: m["height"],
+      height: m["height"] && decode_height(m["height"]),
       mark: decode_mark(m["mark"]),
       name: m["name"] && decode_name(m["name"]),
       padding: decode_padding(m["padding"]),
@@ -9092,7 +11044,7 @@ defmodule TopLevel do
       |> Map.new(fn {key, value} -> {key, SelectionDef.from_map(value)} end),
       title: decode_title(m["title"]),
       transform: m["transform"] && Enum.map(m["transform"], &Transform.from_map/1),
-      width: m["width"],
+      width: m["width"] && decode_width(m["width"]),
       layer: m["layer"] && Enum.map(m["layer"], &LayerSpec.from_map/1),
       resolve: m["resolve"] && Resolve.from_map(m["resolve"]),
       facet: m["facet"] && FacetMapping.from_map(m["facet"]),