From d1c9cbdf9dafd68d97f635cfa0d231ee493ae9a4 Mon Sep 17 00:00:00 2001
From: Matt Muller <53055821+mullermp@users.noreply.github.com>
Date: Thu, 18 Jul 2024 18:16:45 -0400
Subject: [PATCH] Remove Struct from Types (#209)

---
 .github/workflows/downstream_ci.yml           |    6 +-
 .../rails_json/lib/rails_json/builders.rb     |  554 ++---
 .../rails_json/lib/rails_json/client.rb       |    4 +-
 .../rails_json/lib/rails_json/stubs.rb        |  388 +--
 .../rails_json/lib/rails_json/types.rb        | 2117 ++++++++++-------
 .../rails_json/lib/rails_json/validators.rb   |  916 ++++---
 .../rails_json/sig/rails_json/client.rbs      |    6 +-
 .../rails_json/sig/rails_json/types.rbs       | 1012 ++++----
 .../rails_json/spec/protocol_spec.rb          |   22 +-
 .../rpcv2_cbor/lib/rpcv2_cbor/builders.rb     |  138 +-
 .../rpcv2_cbor/lib/rpcv2_cbor/stubs.rb        |  172 +-
 .../rpcv2_cbor/lib/rpcv2_cbor/types.rb        |  607 +++--
 .../rpcv2_cbor/lib/rpcv2_cbor/validators.rb   |  324 +--
 .../rpcv2_cbor/sig/rpcv2_cbor/types.rbs       |  342 +--
 .../white_label/lib/white_label/builders.rb   |    8 +-
 .../white_label/lib/white_label/client.rb     |    2 +-
 .../white_label/lib/white_label/stubs.rb      |    6 +-
 .../white_label/lib/white_label/types.rb      |  676 +++---
 .../white_label/lib/white_label/validators.rb |  270 ++-
 .../white_label/sig/white_label/client.rbs    |    6 +-
 .../white_label/sig/white_label/types.rbs     |  208 +-
 .../white_label/spec/endpoints_spec.rb        |    2 +-
 .../white_label/spec/params_spec.rb           |   45 +-
 .../white_label/spec/streaming_spec.rb        |    8 +-
 .../white_label/spec/types_spec.rb            |   23 +-
 .../white_label/spec/validators_spec.rb       |   76 +-
 .../protocol/generators/BuilderGenerator.java |    5 +-
 .../integration-specs/endpoints_spec.rb       |    2 +-
 .../integration-specs/params_spec.rb          |   45 +-
 .../integration-specs/streaming_spec.rb       |    8 +-
 .../integration-specs/types_spec.rb           |   23 +-
 .../integration-specs/validators_spec.rb      |   76 +-
 .../endpoints-string-array.smithy             |    5 +
 codegen/smithy-ruby-codegen/CHANGELOG.md      |    1 +
 .../ruby/codegen/RubySymbolProvider.java      |   61 +-
 .../generators/BuilderGeneratorBase.java      |    6 +-
 .../generators/HttpProtocolTestGenerator.java |   60 +-
 .../codegen/generators/ParamsGenerator.java   |    3 +-
 .../generators/RestBuilderGeneratorBase.java  |   27 +-
 .../generators/RestStubsGeneratorBase.java    |   15 +-
 .../generators/StubsGeneratorBase.java        |   13 +-
 .../generators/ValidatorsGenerator.java       |   18 +-
 .../generators/types/StructureGenerator.java  |   48 +-
 .../generators/BuilderGenerator.java          |    5 +-
 .../rpcv2cbor/generators/StubsGenerator.java  |    4 +-
 .../codegen/util/DefaultValueRetriever.java   |    7 +-
 .../generators/BuilderGenerator.java          |    7 +-
 .../railsjson/generators/StubsGenerator.java  |   10 +-
 hearth/CHANGELOG.md                           |    1 +
 hearth/lib/hearth/middleware/host_prefix.rb   |    4 +-
 hearth/lib/hearth/structure.rb                |   33 +-
 hearth/lib/hearth/union.rb                    |    2 +-
 hearth/lib/hearth/validator.rb                |    8 +-
 hearth/sig/lib/hearth/aliases.rbs             |    2 +-
 hearth/sig/lib/hearth/interfaces.rbs          |    5 +
 hearth/sig/lib/hearth/request.rbs             |    2 +-
 hearth/spec/hearth/structure_spec.rb          |   57 +-
 hearth/spec/hearth/union_spec.rb              |   14 +
 hearth/spec/hearth/validator_spec.rb          |   56 +-
 59 files changed, 4554 insertions(+), 4017 deletions(-)

diff --git a/.github/workflows/downstream_ci.yml b/.github/workflows/downstream_ci.yml
index 90fc45913..6ef395428 100644
--- a/.github/workflows/downstream_ci.yml
+++ b/.github/workflows/downstream_ci.yml
@@ -41,13 +41,13 @@ jobs:
           cd aws-sdk-ruby-v4
           bundle config local.Hearth ../
           bundle config disable_local_branch_check true
-          bundle install
+          bundle install 
           bundle exec rake codegen:build
 
       - name: v4 core gem tests
         working-directory: aws-sdk-ruby-v4
-        run: bundle exec rake test:core
+        run: bundle exec rake test:all
 
       - name: v4 protocol tests
         working-directory: aws-sdk-ruby-v4
-        run: bundle exec rake test:protocol-tests
+        run: bundle exec rake protocol-test:all
diff --git a/codegen/projections/rails_json/lib/rails_json/builders.rb b/codegen/projections/rails_json/lib/rails_json/builders.rb
index 3ce6a8c22..4458f4c3d 100644
--- a/codegen/projections/rails_json/lib/rails_json/builders.rb
+++ b/codegen/projections/rails_json/lib/rails_json/builders.rb
@@ -18,8 +18,8 @@ def self.build(http_req, input:)
         http_req.http_method = 'GET'
         http_req.append_path('/AllQueryStringTypesInput')
         params = Hearth::Query::ParamList.new
-        unless input[:query_params_map_of_string_list].nil? || input[:query_params_map_of_string_list].empty?
-          input[:query_params_map_of_string_list].each do |k, v|
+        unless input.query_params_map_of_string_list.nil? || input.query_params_map_of_string_list.empty?
+          input.query_params_map_of_string_list.each do |k, v|
             unless v.nil? || v.empty?
               params[k] = v.map do |value|
                 value.to_s unless value.nil?
@@ -27,59 +27,59 @@ def self.build(http_req, input:)
             end
           end
         end
-        params['String'] = input[:query_string].to_s unless input[:query_string].nil?
-        unless input[:query_string_list].nil? || input[:query_string_list].empty?
-          params['StringList'] = input[:query_string_list].map do |value|
+        params['String'] = input.query_string.to_s unless input.query_string.nil?
+        unless input.query_string_list.nil? || input.query_string_list.empty?
+          params['StringList'] = input.query_string_list.map do |value|
             value.to_s unless value.nil?
           end
         end
-        unless input[:query_string_set].nil? || input[:query_string_set].empty?
-          params['StringSet'] = input[:query_string_set].map do |value|
+        unless input.query_string_set.nil? || input.query_string_set.empty?
+          params['StringSet'] = input.query_string_set.map do |value|
             value.to_s unless value.nil?
           end
         end
-        params['Byte'] = input[:query_byte].to_s unless input[:query_byte].nil?
-        params['Short'] = input[:query_short].to_s unless input[:query_short].nil?
-        params['Integer'] = input[:query_integer].to_s unless input[:query_integer].nil?
-        unless input[:query_integer_list].nil? || input[:query_integer_list].empty?
-          params['IntegerList'] = input[:query_integer_list].map do |value|
+        params['Byte'] = input.query_byte.to_s unless input.query_byte.nil?
+        params['Short'] = input.query_short.to_s unless input.query_short.nil?
+        params['Integer'] = input.query_integer.to_s unless input.query_integer.nil?
+        unless input.query_integer_list.nil? || input.query_integer_list.empty?
+          params['IntegerList'] = input.query_integer_list.map do |value|
             value.to_s unless value.nil?
           end
         end
-        unless input[:query_integer_set].nil? || input[:query_integer_set].empty?
-          params['IntegerSet'] = input[:query_integer_set].map do |value|
+        unless input.query_integer_set.nil? || input.query_integer_set.empty?
+          params['IntegerSet'] = input.query_integer_set.map do |value|
             value.to_s unless value.nil?
           end
         end
-        params['Long'] = input[:query_long].to_s unless input[:query_long].nil?
-        params['Float'] = input[:query_float].to_s unless input[:query_float].nil?
-        params['Double'] = input[:query_double].to_s unless input[:query_double].nil?
-        unless input[:query_double_list].nil? || input[:query_double_list].empty?
-          params['DoubleList'] = input[:query_double_list].map do |value|
+        params['Long'] = input.query_long.to_s unless input.query_long.nil?
+        params['Float'] = input.query_float.to_s unless input.query_float.nil?
+        params['Double'] = input.query_double.to_s unless input.query_double.nil?
+        unless input.query_double_list.nil? || input.query_double_list.empty?
+          params['DoubleList'] = input.query_double_list.map do |value|
             value.to_s unless value.nil?
           end
         end
-        params['Boolean'] = input[:query_boolean].to_s unless input[:query_boolean].nil?
-        unless input[:query_boolean_list].nil? || input[:query_boolean_list].empty?
-          params['BooleanList'] = input[:query_boolean_list].map do |value|
+        params['Boolean'] = input.query_boolean.to_s unless input.query_boolean.nil?
+        unless input.query_boolean_list.nil? || input.query_boolean_list.empty?
+          params['BooleanList'] = input.query_boolean_list.map do |value|
             value.to_s unless value.nil?
           end
         end
-        params['Timestamp'] = Hearth::TimeHelper.to_date_time(input[:query_timestamp]) unless input[:query_timestamp].nil?
-        unless input[:query_timestamp_list].nil? || input[:query_timestamp_list].empty?
-          params['TimestampList'] = input[:query_timestamp_list].map do |value|
+        params['Timestamp'] = Hearth::TimeHelper.to_date_time(input.query_timestamp) unless input.query_timestamp.nil?
+        unless input.query_timestamp_list.nil? || input.query_timestamp_list.empty?
+          params['TimestampList'] = input.query_timestamp_list.map do |value|
             Hearth::TimeHelper.to_date_time(value) unless value.nil?
           end
         end
-        params['Enum'] = input[:query_enum].to_s unless input[:query_enum].nil?
-        unless input[:query_enum_list].nil? || input[:query_enum_list].empty?
-          params['EnumList'] = input[:query_enum_list].map do |value|
+        params['Enum'] = input.query_enum.to_s unless input.query_enum.nil?
+        unless input.query_enum_list.nil? || input.query_enum_list.empty?
+          params['EnumList'] = input.query_enum_list.map do |value|
             value.to_s unless value.nil?
           end
         end
-        params['IntegerEnum'] = input[:query_integer_enum].to_s unless input[:query_integer_enum].nil?
-        unless input[:query_integer_enum_list].nil? || input[:query_integer_enum_list].empty?
-          params['IntegerEnumList'] = input[:query_integer_enum_list].map do |value|
+        params['IntegerEnum'] = input.query_integer_enum.to_s unless input.query_integer_enum.nil?
+        unless input.query_integer_enum_list.nil? || input.query_integer_enum_list.empty?
+          params['IntegerEnumList'] = input.query_integer_enum_list.map do |value|
             value.to_s unless value.nil?
           end
         end
@@ -100,7 +100,7 @@ def self.build(input)
     class ClientOptionalDefaults
       def self.build(input)
         data = {}
-        data[:member] = input[:member] unless input[:member].nil?
+        data[:member] = input.member unless input.member.nil?
         data
       end
     end
@@ -113,8 +113,8 @@ def self.build(http_req, input:)
         end
         http_req.append_path('/ConstantAndVariableQueryString')
         params = Hearth::Query::ParamList.new
-        params['baz'] = input[:baz].to_s unless input[:baz].nil?
-        params['maybeSet'] = input[:maybe_set].to_s unless input[:maybe_set].nil?
+        params['baz'] = input.baz.to_s unless input.baz.nil?
+        params['maybeSet'] = input.maybe_set.to_s unless input.maybe_set.nil?
         http_req.append_query_param_list(params)
       end
     end
@@ -125,12 +125,12 @@ def self.build(http_req, input:)
         CGI.parse('foo=bar&hello').each do |k,v|
           http_req.append_query_param(k, v)
         end
-        if input[:hello].to_s.empty?
+        if input.hello.to_s.empty?
           raise ArgumentError, "HTTP label :hello cannot be empty."
         end
         http_req.append_path(format(
             '/ConstantQueryString/%<hello>s',
-            hello: Hearth::HTTP.uri_escape(input[:hello].to_s)
+            hello: Hearth::HTTP.uri_escape(input.hello.to_s)
           )
         )
       end
@@ -146,34 +146,34 @@ def self.build(http_req, input:)
     class Defaults
       def self.build(input)
         data = {}
-        data[:default_string] = input[:default_string] unless input[:default_string].nil?
-        data[:default_boolean] = input[:default_boolean] unless input[:default_boolean].nil?
-        data[:default_list] = Builders::TestStringList.build(input[:default_list]) unless input[:default_list].nil?
-        data[:default_document_map] = input[:default_document_map] unless input[:default_document_map].nil?
-        data[:default_document_string] = input[:default_document_string] unless input[:default_document_string].nil?
-        data[:default_document_boolean] = input[:default_document_boolean] unless input[:default_document_boolean].nil?
-        data[:default_document_list] = input[:default_document_list] unless input[:default_document_list].nil?
-        data[:default_null_document] = input[:default_null_document] unless input[:default_null_document].nil?
-        data[:default_timestamp] = Hearth::TimeHelper.to_date_time(input[:default_timestamp]) unless input[:default_timestamp].nil?
-        data[:default_blob] = ::Base64::strict_encode64(input[:default_blob]).strip unless input[:default_blob].nil?
-        data[:default_byte] = input[:default_byte] unless input[:default_byte].nil?
-        data[:default_short] = input[:default_short] unless input[:default_short].nil?
-        data[:default_integer] = input[:default_integer] unless input[:default_integer].nil?
-        data[:default_long] = input[:default_long] unless input[:default_long].nil?
-        data[:default_float] = Hearth::NumberHelper.serialize(input[:default_float]) unless input[:default_float].nil?
-        data[:default_double] = Hearth::NumberHelper.serialize(input[:default_double]) unless input[:default_double].nil?
-        data[:default_map] = Builders::TestStringMap.build(input[:default_map]) unless input[:default_map].nil?
-        data[:default_enum] = input[:default_enum] unless input[:default_enum].nil?
-        data[:default_int_enum] = input[:default_int_enum] unless input[:default_int_enum].nil?
-        data[:empty_string] = input[:empty_string] unless input[:empty_string].nil?
-        data[:false_boolean] = input[:false_boolean] unless input[:false_boolean].nil?
-        data[:empty_blob] = ::Base64::strict_encode64(input[:empty_blob]).strip unless input[:empty_blob].nil?
-        data[:zero_byte] = input[:zero_byte] unless input[:zero_byte].nil?
-        data[:zero_short] = input[:zero_short] unless input[:zero_short].nil?
-        data[:zero_integer] = input[:zero_integer] unless input[:zero_integer].nil?
-        data[:zero_long] = input[:zero_long] unless input[:zero_long].nil?
-        data[:zero_float] = Hearth::NumberHelper.serialize(input[:zero_float]) unless input[:zero_float].nil?
-        data[:zero_double] = Hearth::NumberHelper.serialize(input[:zero_double]) unless input[:zero_double].nil?
+        data[:default_string] = input.default_string unless input.default_string.nil?
+        data[:default_boolean] = input.default_boolean unless input.default_boolean.nil?
+        data[:default_list] = Builders::TestStringList.build(input.default_list) unless input.default_list.nil?
+        data[:default_document_map] = input.default_document_map unless input.default_document_map.nil?
+        data[:default_document_string] = input.default_document_string unless input.default_document_string.nil?
+        data[:default_document_boolean] = input.default_document_boolean unless input.default_document_boolean.nil?
+        data[:default_document_list] = input.default_document_list unless input.default_document_list.nil?
+        data[:default_null_document] = input.default_null_document unless input.default_null_document.nil?
+        data[:default_timestamp] = Hearth::TimeHelper.to_date_time(input.default_timestamp) unless input.default_timestamp.nil?
+        data[:default_blob] = ::Base64::strict_encode64(input.default_blob).strip unless input.default_blob.nil?
+        data[:default_byte] = input.default_byte unless input.default_byte.nil?
+        data[:default_short] = input.default_short unless input.default_short.nil?
+        data[:default_integer] = input.default_integer unless input.default_integer.nil?
+        data[:default_long] = input.default_long unless input.default_long.nil?
+        data[:default_float] = Hearth::NumberHelper.serialize(input.default_float) unless input.default_float.nil?
+        data[:default_double] = Hearth::NumberHelper.serialize(input.default_double) unless input.default_double.nil?
+        data[:default_map] = Builders::TestStringMap.build(input.default_map) unless input.default_map.nil?
+        data[:default_enum] = input.default_enum unless input.default_enum.nil?
+        data[:default_int_enum] = input.default_int_enum unless input.default_int_enum.nil?
+        data[:empty_string] = input.empty_string unless input.empty_string.nil?
+        data[:false_boolean] = input.false_boolean unless input.false_boolean.nil?
+        data[:empty_blob] = ::Base64::strict_encode64(input.empty_blob).strip unless input.empty_blob.nil?
+        data[:zero_byte] = input.zero_byte unless input.zero_byte.nil?
+        data[:zero_short] = input.zero_short unless input.zero_short.nil?
+        data[:zero_integer] = input.zero_integer unless input.zero_integer.nil?
+        data[:zero_long] = input.zero_long unless input.zero_long.nil?
+        data[:zero_float] = Hearth::NumberHelper.serialize(input.zero_float) unless input.zero_float.nil?
+        data[:zero_double] = Hearth::NumberHelper.serialize(input.zero_double) unless input.zero_double.nil?
         data
       end
     end
@@ -231,9 +231,9 @@ def self.build(input)
     class Dialog
       def self.build(input)
         data = {}
-        data[:language] = input[:language] unless input[:language].nil?
-        data[:greeting] = input[:greeting] unless input[:greeting].nil?
-        data[:farewell] = Builders::Farewell.build(input[:farewell]) unless input[:farewell].nil?
+        data[:language] = input.language unless input.language.nil?
+        data[:greeting] = input.greeting unless input.greeting.nil?
+        data[:farewell] = Builders::Farewell.build(input.farewell) unless input.farewell.nil?
         data
       end
     end
@@ -264,8 +264,8 @@ def self.build(http_req, input:)
         http_req.append_path('/DocumentType')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:string_value] = input[:string_value] unless input[:string_value].nil?
-        data[:document_value] = input[:document_value] unless input[:document_value].nil?
+        data[:string_value] = input.string_value unless input.string_value.nil?
+        data[:document_value] = input.document_value unless input.document_value.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -276,7 +276,7 @@ def self.build(http_req, input:)
         http_req.append_path('/DocumentTypeAsMapValue')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:doc_valued_map] = Builders::DocumentValuedMap.build(input[:doc_valued_map]) unless input[:doc_valued_map].nil?
+        data[:doc_valued_map] = Builders::DocumentValuedMap.build(input.doc_valued_map) unless input.doc_valued_map.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -286,7 +286,7 @@ def self.build(http_req, input:)
         http_req.http_method = 'PUT'
         http_req.append_path('/DocumentTypeAsPayload')
         http_req.headers['Content-Type'] = 'application/json'
-        http_req.body = StringIO.new(Hearth::JSON.dump(input[:document_value]))
+        http_req.body = StringIO.new(Hearth::JSON.dump(input.document_value))
       end
     end
 
@@ -330,7 +330,7 @@ def self.build(http_req, input:)
         http_req.append_path('/EndpointWithHostLabelOperation')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:label] = input[:label] unless input[:label].nil?
+        data[:label] = input.label unless input.label.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -338,7 +338,7 @@ def self.build(http_req, input:)
     class Farewell
       def self.build(input)
         data = {}
-        data[:phrase] = input[:phrase] unless input[:phrase].nil?
+        data[:phrase] = input.phrase unless input.phrase.nil?
         data
       end
     end
@@ -383,7 +383,7 @@ def self.build(http_req, input:)
     class GreetingStruct
       def self.build(input)
         data = {}
-        data[:hi] = input[:hi] unless input[:hi].nil?
+        data[:hi] = input.hi unless input.hi.nil?
         data
       end
     end
@@ -391,7 +391,7 @@ def self.build(input)
     class RenamedGreeting
       def self.build(input)
         data = {}
-        data[:salutation] = input[:salutation] unless input[:salutation].nil?
+        data[:salutation] = input.salutation unless input.salutation.nil?
         data
       end
     end
@@ -416,7 +416,7 @@ def self.build(http_req, input:)
         http_req.append_path('/HttpChecksumRequired')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:foo] = input[:foo] unless input[:foo].nil?
+        data[:foo] = input.foo unless input.foo.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -426,7 +426,7 @@ def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/EnumPayload')
         http_req.headers['Content-Type'] = 'text/plain'
-        http_req.body = StringIO.new(input[:payload] || '')
+        http_req.body = StringIO.new(input.payload || '')
       end
     end
 
@@ -435,8 +435,8 @@ def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/HttpPayloadTraits')
         http_req.headers['Content-Type'] = 'application/octet-stream'
-        http_req.body = StringIO.new(input[:blob] || '')
-        http_req.headers['X-Foo'] = input[:foo] unless input[:foo].nil? || input[:foo].empty?
+        http_req.body = StringIO.new(input.blob || '')
+        http_req.headers['X-Foo'] = input.foo unless input.foo.nil? || input.foo.empty?
       end
     end
 
@@ -445,8 +445,8 @@ def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/HttpPayloadTraitsWithMediaType')
         http_req.headers['Content-Type'] = 'text/plain'
-        http_req.body = StringIO.new(input[:blob] || '')
-        http_req.headers['X-Foo'] = input[:foo] unless input[:foo].nil? || input[:foo].empty?
+        http_req.body = StringIO.new(input.blob || '')
+        http_req.headers['X-Foo'] = input.foo unless input.foo.nil? || input.foo.empty?
       end
     end
 
@@ -455,7 +455,7 @@ def self.build(http_req, input:)
         http_req.http_method = 'PUT'
         http_req.append_path('/HttpPayloadWithStructure')
         http_req.headers['Content-Type'] = 'application/json'
-        data = Builders::NestedPayload.build(input[:nested]) unless input[:nested].nil?
+        data = Builders::NestedPayload.build(input.nested) unless input.nested.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data || {}))
       end
     end
@@ -465,7 +465,7 @@ def self.build(http_req, input:)
         http_req.http_method = 'PUT'
         http_req.append_path('/HttpPayloadWithUnion')
         http_req.headers['Content-Type'] = 'application/json'
-        data = Builders::UnionPayload.build(input[:nested]) unless input[:nested].nil?
+        data = Builders::UnionPayload.build(input.nested) unless input.nested.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data || {}))
       end
     end
@@ -474,8 +474,8 @@ class HttpPrefixHeaders
       def self.build(http_req, input:)
         http_req.http_method = 'GET'
         http_req.append_path('/HttpPrefixHeaders')
-        http_req.headers['X-Foo'] = input[:foo] unless input[:foo].nil? || input[:foo].empty?
-        input[:foo_map]&.each do |key, value|
+        http_req.headers['X-Foo'] = input.foo unless input.foo.nil? || input.foo.empty?
+        input.foo_map.each do |key, value|
           http_req.headers["X-Foo-#{key}"] = value unless value.nil? || value.empty?
         end
       end
@@ -491,16 +491,16 @@ def self.build(http_req, input:)
     class HttpRequestWithFloatLabels
       def self.build(http_req, input:)
         http_req.http_method = 'GET'
-        if input[:float].to_s.empty?
+        if input.float.to_s.empty?
           raise ArgumentError, "HTTP label :float cannot be empty."
         end
-        if input[:double].to_s.empty?
+        if input.double.to_s.empty?
           raise ArgumentError, "HTTP label :double cannot be empty."
         end
         http_req.append_path(format(
             '/FloatHttpLabels/%<float>s/%<double>s',
-            float: Hearth::HTTP.uri_escape(input[:float].to_s),
-            double: Hearth::HTTP.uri_escape(input[:double].to_s)
+            float: Hearth::HTTP.uri_escape(input.float.to_s),
+            double: Hearth::HTTP.uri_escape(input.double.to_s)
           )
         )
       end
@@ -509,16 +509,16 @@ def self.build(http_req, input:)
     class HttpRequestWithGreedyLabelInPath
       def self.build(http_req, input:)
         http_req.http_method = 'GET'
-        if input[:foo].to_s.empty?
+        if input.foo.to_s.empty?
           raise ArgumentError, "HTTP label :foo cannot be empty."
         end
-        if input[:baz].to_s.empty?
+        if input.baz.to_s.empty?
           raise ArgumentError, "HTTP label :baz cannot be empty."
         end
         http_req.append_path(format(
             '/HttpRequestWithGreedyLabelInPath/foo/%<foo>s/baz/%<baz>s',
-            foo: Hearth::HTTP.uri_escape(input[:foo].to_s),
-            baz: (input[:baz].to_s).split('/').map { |s| Hearth::HTTP.uri_escape(s) }.join('/')
+            foo: Hearth::HTTP.uri_escape(input.foo.to_s),
+            baz: (input.baz.to_s).split('/').map { |s| Hearth::HTTP.uri_escape(s) }.join('/')
           )
         )
       end
@@ -527,40 +527,40 @@ def self.build(http_req, input:)
     class HttpRequestWithLabels
       def self.build(http_req, input:)
         http_req.http_method = 'GET'
-        if input[:string].to_s.empty?
+        if input.string.to_s.empty?
           raise ArgumentError, "HTTP label :string cannot be empty."
         end
-        if input[:short].to_s.empty?
+        if input.short.to_s.empty?
           raise ArgumentError, "HTTP label :short cannot be empty."
         end
-        if input[:integer].to_s.empty?
+        if input.integer.to_s.empty?
           raise ArgumentError, "HTTP label :integer cannot be empty."
         end
-        if input[:long].to_s.empty?
+        if input.long.to_s.empty?
           raise ArgumentError, "HTTP label :long cannot be empty."
         end
-        if input[:float].to_s.empty?
+        if input.float.to_s.empty?
           raise ArgumentError, "HTTP label :float cannot be empty."
         end
-        if input[:double].to_s.empty?
+        if input.double.to_s.empty?
           raise ArgumentError, "HTTP label :double cannot be empty."
         end
-        if input[:boolean].to_s.empty?
+        if input.boolean.to_s.empty?
           raise ArgumentError, "HTTP label :boolean cannot be empty."
         end
-        if Hearth::TimeHelper.to_date_time(input[:timestamp]).empty?
+        if Hearth::TimeHelper.to_date_time(input.timestamp).empty?
           raise ArgumentError, "HTTP label :timestamp cannot be empty."
         end
         http_req.append_path(format(
             '/HttpRequestWithLabels/%<string>s/%<short>s/%<integer>s/%<long>s/%<float>s/%<double>s/%<boolean>s/%<timestamp>s',
-            string: Hearth::HTTP.uri_escape(input[:string].to_s),
-            short: Hearth::HTTP.uri_escape(input[:short].to_s),
-            integer: Hearth::HTTP.uri_escape(input[:integer].to_s),
-            long: Hearth::HTTP.uri_escape(input[:long].to_s),
-            float: Hearth::HTTP.uri_escape(input[:float].to_s),
-            double: Hearth::HTTP.uri_escape(input[:double].to_s),
-            boolean: Hearth::HTTP.uri_escape(input[:boolean].to_s),
-            timestamp: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_date_time(input[:timestamp]))
+            string: Hearth::HTTP.uri_escape(input.string.to_s),
+            short: Hearth::HTTP.uri_escape(input.short.to_s),
+            integer: Hearth::HTTP.uri_escape(input.integer.to_s),
+            long: Hearth::HTTP.uri_escape(input.long.to_s),
+            float: Hearth::HTTP.uri_escape(input.float.to_s),
+            double: Hearth::HTTP.uri_escape(input.double.to_s),
+            boolean: Hearth::HTTP.uri_escape(input.boolean.to_s),
+            timestamp: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_date_time(input.timestamp))
           )
         )
       end
@@ -569,36 +569,36 @@ def self.build(http_req, input:)
     class HttpRequestWithLabelsAndTimestampFormat
       def self.build(http_req, input:)
         http_req.http_method = 'GET'
-        if Hearth::TimeHelper.to_epoch_seconds(input[:member_epoch_seconds]).to_i.to_s.empty?
+        if Hearth::TimeHelper.to_epoch_seconds(input.member_epoch_seconds).to_i.to_s.empty?
           raise ArgumentError, "HTTP label :member_epoch_seconds cannot be empty."
         end
-        if Hearth::TimeHelper.to_http_date(input[:member_http_date]).empty?
+        if Hearth::TimeHelper.to_http_date(input.member_http_date).empty?
           raise ArgumentError, "HTTP label :member_http_date cannot be empty."
         end
-        if Hearth::TimeHelper.to_date_time(input[:member_date_time]).empty?
+        if Hearth::TimeHelper.to_date_time(input.member_date_time).empty?
           raise ArgumentError, "HTTP label :member_date_time cannot be empty."
         end
-        if Hearth::TimeHelper.to_date_time(input[:default_format]).empty?
+        if Hearth::TimeHelper.to_date_time(input.default_format).empty?
           raise ArgumentError, "HTTP label :default_format cannot be empty."
         end
-        if Hearth::TimeHelper.to_epoch_seconds(input[:target_epoch_seconds]).to_i.to_s.empty?
+        if Hearth::TimeHelper.to_epoch_seconds(input.target_epoch_seconds).to_i.to_s.empty?
           raise ArgumentError, "HTTP label :target_epoch_seconds cannot be empty."
         end
-        if Hearth::TimeHelper.to_http_date(input[:target_http_date]).empty?
+        if Hearth::TimeHelper.to_http_date(input.target_http_date).empty?
           raise ArgumentError, "HTTP label :target_http_date cannot be empty."
         end
-        if Hearth::TimeHelper.to_date_time(input[:target_date_time]).empty?
+        if Hearth::TimeHelper.to_date_time(input.target_date_time).empty?
           raise ArgumentError, "HTTP label :target_date_time cannot be empty."
         end
         http_req.append_path(format(
             '/HttpRequestWithLabelsAndTimestampFormat/%<memberEpochSeconds>s/%<memberHttpDate>s/%<memberDateTime>s/%<defaultFormat>s/%<targetEpochSeconds>s/%<targetHttpDate>s/%<targetDateTime>s',
-            memberEpochSeconds: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_epoch_seconds(input[:member_epoch_seconds]).to_i.to_s),
-            memberHttpDate: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_http_date(input[:member_http_date])),
-            memberDateTime: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_date_time(input[:member_date_time])),
-            defaultFormat: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_date_time(input[:default_format])),
-            targetEpochSeconds: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_epoch_seconds(input[:target_epoch_seconds]).to_i.to_s),
-            targetHttpDate: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_http_date(input[:target_http_date])),
-            targetDateTime: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_date_time(input[:target_date_time]))
+            memberEpochSeconds: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_epoch_seconds(input.member_epoch_seconds).to_i.to_s),
+            memberHttpDate: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_http_date(input.member_http_date)),
+            memberDateTime: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_date_time(input.member_date_time)),
+            defaultFormat: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_date_time(input.default_format)),
+            targetEpochSeconds: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_epoch_seconds(input.target_epoch_seconds).to_i.to_s),
+            targetHttpDate: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_http_date(input.target_http_date)),
+            targetDateTime: Hearth::HTTP.uri_escape(Hearth::TimeHelper.to_date_time(input.target_date_time))
           )
         )
       end
@@ -607,12 +607,12 @@ def self.build(http_req, input:)
     class HttpRequestWithRegexLiteral
       def self.build(http_req, input:)
         http_req.http_method = 'GET'
-        if input[:str].to_s.empty?
+        if input.str.to_s.empty?
           raise ArgumentError, "HTTP label :str cannot be empty."
         end
         http_req.append_path(format(
             '/ReDosLiteral/%<str>s/(a+)+',
-            str: Hearth::HTTP.uri_escape(input[:str].to_s)
+            str: Hearth::HTTP.uri_escape(input.str.to_s)
           )
         )
       end
@@ -630,7 +630,7 @@ def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/StringPayload')
         http_req.headers['Content-Type'] = 'text/plain'
-        http_req.body = StringIO.new(input[:payload] || '')
+        http_req.body = StringIO.new(input.payload || '')
       end
     end
 
@@ -645,37 +645,37 @@ class InputAndOutputWithHeaders
       def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/InputAndOutputWithHeaders')
-        http_req.headers['X-String'] = input[:header_string] unless input[:header_string].nil? || input[:header_string].empty?
-        http_req.headers['X-Byte'] = input[:header_byte].to_s unless input[:header_byte].nil?
-        http_req.headers['X-Short'] = input[:header_short].to_s unless input[:header_short].nil?
-        http_req.headers['X-Integer'] = input[:header_integer].to_s unless input[:header_integer].nil?
-        http_req.headers['X-Long'] = input[:header_long].to_s unless input[:header_long].nil?
-        http_req.headers['X-Float'] = Hearth::NumberHelper.serialize(input[:header_float]) unless input[:header_float].nil?
-        http_req.headers['X-Double'] = Hearth::NumberHelper.serialize(input[:header_double]) unless input[:header_double].nil?
-        http_req.headers['X-Boolean1'] = input[:header_true_bool].to_s unless input[:header_true_bool].nil?
-        http_req.headers['X-Boolean2'] = input[:header_false_bool].to_s unless input[:header_false_bool].nil?
-        unless input[:header_string_list].nil? || input[:header_string_list].empty?
-          http_req.headers['X-StringList'] = Hearth::HTTP::HeaderListBuilder.build_string_list(input[:header_string_list])
+        http_req.headers['X-String'] = input.header_string unless input.header_string.nil? || input.header_string.empty?
+        http_req.headers['X-Byte'] = input.header_byte.to_s unless input.header_byte.nil?
+        http_req.headers['X-Short'] = input.header_short.to_s unless input.header_short.nil?
+        http_req.headers['X-Integer'] = input.header_integer.to_s unless input.header_integer.nil?
+        http_req.headers['X-Long'] = input.header_long.to_s unless input.header_long.nil?
+        http_req.headers['X-Float'] = Hearth::NumberHelper.serialize(input.header_float) unless input.header_float.nil?
+        http_req.headers['X-Double'] = Hearth::NumberHelper.serialize(input.header_double) unless input.header_double.nil?
+        http_req.headers['X-Boolean1'] = input.header_true_bool.to_s unless input.header_true_bool.nil?
+        http_req.headers['X-Boolean2'] = input.header_false_bool.to_s unless input.header_false_bool.nil?
+        unless input.header_string_list.nil? || input.header_string_list.empty?
+          http_req.headers['X-StringList'] = Hearth::HTTP::HeaderListBuilder.build_string_list(input.header_string_list)
         end
-        unless input[:header_string_set].nil? || input[:header_string_set].empty?
-          http_req.headers['X-StringSet'] = Hearth::HTTP::HeaderListBuilder.build_string_list(input[:header_string_set])
+        unless input.header_string_set.nil? || input.header_string_set.empty?
+          http_req.headers['X-StringSet'] = Hearth::HTTP::HeaderListBuilder.build_string_list(input.header_string_set)
         end
-        unless input[:header_integer_list].nil? || input[:header_integer_list].empty?
-          http_req.headers['X-IntegerList'] = Hearth::HTTP::HeaderListBuilder.build_list(input[:header_integer_list])
+        unless input.header_integer_list.nil? || input.header_integer_list.empty?
+          http_req.headers['X-IntegerList'] = Hearth::HTTP::HeaderListBuilder.build_list(input.header_integer_list)
         end
-        unless input[:header_boolean_list].nil? || input[:header_boolean_list].empty?
-          http_req.headers['X-BooleanList'] = Hearth::HTTP::HeaderListBuilder.build_list(input[:header_boolean_list])
+        unless input.header_boolean_list.nil? || input.header_boolean_list.empty?
+          http_req.headers['X-BooleanList'] = Hearth::HTTP::HeaderListBuilder.build_list(input.header_boolean_list)
         end
-        unless input[:header_timestamp_list].nil? || input[:header_timestamp_list].empty?
-          http_req.headers['X-TimestampList'] = Hearth::HTTP::HeaderListBuilder.build_http_date_list(input[:header_timestamp_list])
+        unless input.header_timestamp_list.nil? || input.header_timestamp_list.empty?
+          http_req.headers['X-TimestampList'] = Hearth::HTTP::HeaderListBuilder.build_http_date_list(input.header_timestamp_list)
         end
-        http_req.headers['X-Enum'] = input[:header_enum] unless input[:header_enum].nil? || input[:header_enum].empty?
-        unless input[:header_enum_list].nil? || input[:header_enum_list].empty?
-          http_req.headers['X-EnumList'] = Hearth::HTTP::HeaderListBuilder.build_string_list(input[:header_enum_list])
+        http_req.headers['X-Enum'] = input.header_enum unless input.header_enum.nil? || input.header_enum.empty?
+        unless input.header_enum_list.nil? || input.header_enum_list.empty?
+          http_req.headers['X-EnumList'] = Hearth::HTTP::HeaderListBuilder.build_string_list(input.header_enum_list)
         end
-        http_req.headers['X-IntegerEnum'] = input[:header_integer_enum].to_s unless input[:header_integer_enum].nil?
-        unless input[:header_integer_enum_list].nil? || input[:header_integer_enum_list].empty?
-          http_req.headers['X-IntegerEnumList'] = Hearth::HTTP::HeaderListBuilder.build_list(input[:header_integer_enum_list])
+        http_req.headers['X-IntegerEnum'] = input.header_integer_enum.to_s unless input.header_integer_enum.nil?
+        unless input.header_integer_enum_list.nil? || input.header_integer_enum_list.empty?
+          http_req.headers['X-IntegerEnumList'] = Hearth::HTTP::HeaderListBuilder.build_list(input.header_integer_enum_list)
         end
       end
     end
@@ -736,7 +736,7 @@ def self.build(http_req, input:)
         http_req.append_path('/JsonBlobs')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:data] = ::Base64::strict_encode64(input[:data]).strip unless input[:data].nil?
+        data[:data] = ::Base64::strict_encode64(input.data).strip unless input.data.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -747,12 +747,12 @@ def self.build(http_req, input:)
         http_req.append_path('/JsonEnums')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:foo_enum1] = input[:foo_enum1] unless input[:foo_enum1].nil?
-        data[:foo_enum2] = input[:foo_enum2] unless input[:foo_enum2].nil?
-        data[:foo_enum3] = input[:foo_enum3] unless input[:foo_enum3].nil?
-        data[:foo_enum_list] = Builders::FooEnumList.build(input[:foo_enum_list]) unless input[:foo_enum_list].nil?
-        data[:foo_enum_set] = Builders::FooEnumSet.build(input[:foo_enum_set]) unless input[:foo_enum_set].nil?
-        data[:foo_enum_map] = Builders::FooEnumMap.build(input[:foo_enum_map]) unless input[:foo_enum_map].nil?
+        data[:foo_enum1] = input.foo_enum1 unless input.foo_enum1.nil?
+        data[:foo_enum2] = input.foo_enum2 unless input.foo_enum2.nil?
+        data[:foo_enum3] = input.foo_enum3 unless input.foo_enum3.nil?
+        data[:foo_enum_list] = Builders::FooEnumList.build(input.foo_enum_list) unless input.foo_enum_list.nil?
+        data[:foo_enum_set] = Builders::FooEnumSet.build(input.foo_enum_set) unless input.foo_enum_set.nil?
+        data[:foo_enum_map] = Builders::FooEnumMap.build(input.foo_enum_map) unless input.foo_enum_map.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -763,12 +763,12 @@ def self.build(http_req, input:)
         http_req.append_path('/JsonIntEnums')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:integer_enum1] = input[:integer_enum1] unless input[:integer_enum1].nil?
-        data[:integer_enum2] = input[:integer_enum2] unless input[:integer_enum2].nil?
-        data[:integer_enum3] = input[:integer_enum3] unless input[:integer_enum3].nil?
-        data[:integer_enum_list] = Builders::IntegerEnumList.build(input[:integer_enum_list]) unless input[:integer_enum_list].nil?
-        data[:integer_enum_set] = Builders::IntegerEnumSet.build(input[:integer_enum_set]) unless input[:integer_enum_set].nil?
-        data[:integer_enum_map] = Builders::IntegerEnumMap.build(input[:integer_enum_map]) unless input[:integer_enum_map].nil?
+        data[:integer_enum1] = input.integer_enum1 unless input.integer_enum1.nil?
+        data[:integer_enum2] = input.integer_enum2 unless input.integer_enum2.nil?
+        data[:integer_enum3] = input.integer_enum3 unless input.integer_enum3.nil?
+        data[:integer_enum_list] = Builders::IntegerEnumList.build(input.integer_enum_list) unless input.integer_enum_list.nil?
+        data[:integer_enum_set] = Builders::IntegerEnumSet.build(input.integer_enum_set) unless input.integer_enum_set.nil?
+        data[:integer_enum_map] = Builders::IntegerEnumMap.build(input.integer_enum_map) unless input.integer_enum_map.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -779,15 +779,15 @@ def self.build(http_req, input:)
         http_req.append_path('/JsonLists')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:string_list] = Builders::StringList.build(input[:string_list]) unless input[:string_list].nil?
-        data[:string_set] = Builders::StringSet.build(input[:string_set]) unless input[:string_set].nil?
-        data[:integer_list] = Builders::IntegerList.build(input[:integer_list]) unless input[:integer_list].nil?
-        data[:boolean_list] = Builders::BooleanList.build(input[:boolean_list]) unless input[:boolean_list].nil?
-        data[:timestamp_list] = Builders::TimestampList.build(input[:timestamp_list]) unless input[:timestamp_list].nil?
-        data[:enum_list] = Builders::FooEnumList.build(input[:enum_list]) unless input[:enum_list].nil?
-        data[:int_enum_list] = Builders::IntegerEnumList.build(input[:int_enum_list]) unless input[:int_enum_list].nil?
-        data[:nested_string_list] = Builders::NestedStringList.build(input[:nested_string_list]) unless input[:nested_string_list].nil?
-        data['myStructureList'] = Builders::StructureList.build(input[:structure_list]) unless input[:structure_list].nil?
+        data[:string_list] = Builders::StringList.build(input.string_list) unless input.string_list.nil?
+        data[:string_set] = Builders::StringSet.build(input.string_set) unless input.string_set.nil?
+        data[:integer_list] = Builders::IntegerList.build(input.integer_list) unless input.integer_list.nil?
+        data[:boolean_list] = Builders::BooleanList.build(input.boolean_list) unless input.boolean_list.nil?
+        data[:timestamp_list] = Builders::TimestampList.build(input.timestamp_list) unless input.timestamp_list.nil?
+        data[:enum_list] = Builders::FooEnumList.build(input.enum_list) unless input.enum_list.nil?
+        data[:int_enum_list] = Builders::IntegerEnumList.build(input.int_enum_list) unless input.int_enum_list.nil?
+        data[:nested_string_list] = Builders::NestedStringList.build(input.nested_string_list) unless input.nested_string_list.nil?
+        data['myStructureList'] = Builders::StructureList.build(input.structure_list) unless input.structure_list.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -798,11 +798,11 @@ def self.build(http_req, input:)
         http_req.append_path('/JsonMaps')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:dense_struct_map] = Builders::DenseStructMap.build(input[:dense_struct_map]) unless input[:dense_struct_map].nil?
-        data[:dense_number_map] = Builders::DenseNumberMap.build(input[:dense_number_map]) unless input[:dense_number_map].nil?
-        data[:dense_boolean_map] = Builders::DenseBooleanMap.build(input[:dense_boolean_map]) unless input[:dense_boolean_map].nil?
-        data[:dense_string_map] = Builders::DenseStringMap.build(input[:dense_string_map]) unless input[:dense_string_map].nil?
-        data[:dense_set_map] = Builders::DenseSetMap.build(input[:dense_set_map]) unless input[:dense_set_map].nil?
+        data[:dense_struct_map] = Builders::DenseStructMap.build(input.dense_struct_map) unless input.dense_struct_map.nil?
+        data[:dense_number_map] = Builders::DenseNumberMap.build(input.dense_number_map) unless input.dense_number_map.nil?
+        data[:dense_boolean_map] = Builders::DenseBooleanMap.build(input.dense_boolean_map) unless input.dense_boolean_map.nil?
+        data[:dense_string_map] = Builders::DenseStringMap.build(input.dense_string_map) unless input.dense_string_map.nil?
+        data[:dense_set_map] = Builders::DenseSetMap.build(input.dense_set_map) unless input.dense_set_map.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -813,13 +813,13 @@ def self.build(http_req, input:)
         http_req.append_path('/JsonTimestamps')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:normal] = Hearth::TimeHelper.to_epoch_seconds(input[:normal]).to_i unless input[:normal].nil?
-        data[:date_time] = Hearth::TimeHelper.to_date_time(input[:date_time]) unless input[:date_time].nil?
-        data[:date_time_on_target] = Hearth::TimeHelper.to_date_time(input[:date_time_on_target]) unless input[:date_time_on_target].nil?
-        data[:epoch_seconds] = Hearth::TimeHelper.to_epoch_seconds(input[:epoch_seconds]).to_i unless input[:epoch_seconds].nil?
-        data[:epoch_seconds_on_target] = Hearth::TimeHelper.to_epoch_seconds(input[:epoch_seconds_on_target]).to_i unless input[:epoch_seconds_on_target].nil?
-        data[:http_date] = Hearth::TimeHelper.to_http_date(input[:http_date]) unless input[:http_date].nil?
-        data[:http_date_on_target] = Hearth::TimeHelper.to_http_date(input[:http_date_on_target]) unless input[:http_date_on_target].nil?
+        data[:normal] = Hearth::TimeHelper.to_epoch_seconds(input.normal).to_i unless input.normal.nil?
+        data[:date_time] = Hearth::TimeHelper.to_date_time(input.date_time) unless input.date_time.nil?
+        data[:date_time_on_target] = Hearth::TimeHelper.to_date_time(input.date_time_on_target) unless input.date_time_on_target.nil?
+        data[:epoch_seconds] = Hearth::TimeHelper.to_epoch_seconds(input.epoch_seconds).to_i unless input.epoch_seconds.nil?
+        data[:epoch_seconds_on_target] = Hearth::TimeHelper.to_epoch_seconds(input.epoch_seconds_on_target).to_i unless input.epoch_seconds_on_target.nil?
+        data[:http_date] = Hearth::TimeHelper.to_http_date(input.http_date) unless input.http_date.nil?
+        data[:http_date_on_target] = Hearth::TimeHelper.to_http_date(input.http_date_on_target) unless input.http_date_on_target.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -830,7 +830,7 @@ def self.build(http_req, input:)
         http_req.append_path('/JsonUnions')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:contents] = Builders::MyUnion.build(input[:contents]) unless input[:contents].nil?
+        data[:contents] = Builders::MyUnion.build(input.contents) unless input.contents.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -839,7 +839,7 @@ class MediaTypeHeader
       def self.build(http_req, input:)
         http_req.http_method = 'GET'
         http_req.append_path('/MediaTypeHeader')
-        http_req.headers['X-Json'] = ::Base64::strict_encode64(input[:json]).strip unless input[:json].nil? || input[:json].empty?
+        http_req.headers['X-Json'] = ::Base64::strict_encode64(input.json).strip unless input.json.nil? || input.json.empty?
       end
     end
 
@@ -879,8 +879,8 @@ def self.build(input)
     class NestedPayload
       def self.build(input)
         data = {}
-        data[:greeting] = input[:greeting] unless input[:greeting].nil?
-        data[:name] = input[:name] unless input[:name].nil?
+        data[:greeting] = input.greeting unless input.greeting.nil?
+        data[:name] = input.name unless input.name.nil?
         data
       end
     end
@@ -913,10 +913,10 @@ class NullAndEmptyHeadersClient
       def self.build(http_req, input:)
         http_req.http_method = 'GET'
         http_req.append_path('/NullAndEmptyHeadersClient')
-        http_req.headers['X-A'] = input[:a] unless input[:a].nil? || input[:a].empty?
-        http_req.headers['X-B'] = input[:b] unless input[:b].nil? || input[:b].empty?
-        unless input[:c].nil? || input[:c].empty?
-          http_req.headers['X-C'] = Hearth::HTTP::HeaderListBuilder.build_string_list(input[:c])
+        http_req.headers['X-A'] = input.a unless input.a.nil? || input.a.empty?
+        http_req.headers['X-B'] = input.b unless input.b.nil? || input.b.empty?
+        unless input.c.nil? || input.c.empty?
+          http_req.headers['X-C'] = Hearth::HTTP::HeaderListBuilder.build_string_list(input.c)
         end
       end
     end
@@ -925,10 +925,10 @@ class NullAndEmptyHeadersServer
       def self.build(http_req, input:)
         http_req.http_method = 'GET'
         http_req.append_path('/NullAndEmptyHeadersServer')
-        http_req.headers['X-A'] = input[:a] unless input[:a].nil? || input[:a].empty?
-        http_req.headers['X-B'] = input[:b] unless input[:b].nil? || input[:b].empty?
-        unless input[:c].nil? || input[:c].empty?
-          http_req.headers['X-C'] = Hearth::HTTP::HeaderListBuilder.build_string_list(input[:c])
+        http_req.headers['X-A'] = input.a unless input.a.nil? || input.a.empty?
+        http_req.headers['X-B'] = input.b unless input.b.nil? || input.b.empty?
+        unless input.c.nil? || input.c.empty?
+          http_req.headers['X-C'] = Hearth::HTTP::HeaderListBuilder.build_string_list(input.c)
         end
       end
     end
@@ -938,8 +938,8 @@ def self.build(http_req, input:)
         http_req.http_method = 'GET'
         http_req.append_path('/OmitsNullSerializesEmptyString')
         params = Hearth::Query::ParamList.new
-        params['Null'] = input[:null_value].to_s unless input[:null_value].nil?
-        params['Empty'] = input[:empty_string].to_s unless input[:empty_string].nil?
+        params['Null'] = input.null_value.to_s unless input.null_value.nil?
+        params['Empty'] = input.empty_string.to_s unless input.empty_string.nil?
         http_req.append_query_param_list(params)
       end
     end
@@ -949,38 +949,38 @@ def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/OmitsSerializingEmptyLists')
         params = Hearth::Query::ParamList.new
-        unless input[:query_string_list].nil? || input[:query_string_list].empty?
-          params['StringList'] = input[:query_string_list].map do |value|
+        unless input.query_string_list.nil? || input.query_string_list.empty?
+          params['StringList'] = input.query_string_list.map do |value|
             value.to_s unless value.nil?
           end
         end
-        unless input[:query_integer_list].nil? || input[:query_integer_list].empty?
-          params['IntegerList'] = input[:query_integer_list].map do |value|
+        unless input.query_integer_list.nil? || input.query_integer_list.empty?
+          params['IntegerList'] = input.query_integer_list.map do |value|
             value.to_s unless value.nil?
           end
         end
-        unless input[:query_double_list].nil? || input[:query_double_list].empty?
-          params['DoubleList'] = input[:query_double_list].map do |value|
+        unless input.query_double_list.nil? || input.query_double_list.empty?
+          params['DoubleList'] = input.query_double_list.map do |value|
             value.to_s unless value.nil?
           end
         end
-        unless input[:query_boolean_list].nil? || input[:query_boolean_list].empty?
-          params['BooleanList'] = input[:query_boolean_list].map do |value|
+        unless input.query_boolean_list.nil? || input.query_boolean_list.empty?
+          params['BooleanList'] = input.query_boolean_list.map do |value|
             value.to_s unless value.nil?
           end
         end
-        unless input[:query_timestamp_list].nil? || input[:query_timestamp_list].empty?
-          params['TimestampList'] = input[:query_timestamp_list].map do |value|
+        unless input.query_timestamp_list.nil? || input.query_timestamp_list.empty?
+          params['TimestampList'] = input.query_timestamp_list.map do |value|
             Hearth::TimeHelper.to_date_time(value) unless value.nil?
           end
         end
-        unless input[:query_enum_list].nil? || input[:query_enum_list].empty?
-          params['EnumList'] = input[:query_enum_list].map do |value|
+        unless input.query_enum_list.nil? || input.query_enum_list.empty?
+          params['EnumList'] = input.query_enum_list.map do |value|
             value.to_s unless value.nil?
           end
         end
-        unless input[:query_integer_enum_list].nil? || input[:query_integer_enum_list].empty?
-          params['IntegerEnumList'] = input[:query_integer_enum_list].map do |value|
+        unless input.query_integer_enum_list.nil? || input.query_integer_enum_list.empty?
+          params['IntegerEnumList'] = input.query_integer_enum_list.map do |value|
             value.to_s unless value.nil?
           end
         end
@@ -994,10 +994,10 @@ def self.build(http_req, input:)
         http_req.append_path('/OperationWithDefaults')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:defaults] = Builders::Defaults.build(input[:defaults]) unless input[:defaults].nil?
-        data[:client_optional_defaults] = Builders::ClientOptionalDefaults.build(input[:client_optional_defaults]) unless input[:client_optional_defaults].nil?
-        data[:top_level_default] = input[:top_level_default] unless input[:top_level_default].nil?
-        data[:other_top_level_default] = input[:other_top_level_default] unless input[:other_top_level_default].nil?
+        data[:defaults] = Builders::Defaults.build(input.defaults) unless input.defaults.nil?
+        data[:client_optional_defaults] = Builders::ClientOptionalDefaults.build(input.client_optional_defaults) unless input.client_optional_defaults.nil?
+        data[:top_level_default] = input.top_level_default unless input.top_level_default.nil?
+        data[:other_top_level_default] = input.other_top_level_default unless input.other_top_level_default.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -1008,7 +1008,7 @@ def self.build(http_req, input:)
         http_req.append_path('/OperationWithNestedStructure')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:top_level] = Builders::TopLevel.build(input[:top_level]) unless input[:top_level].nil?
+        data[:top_level] = Builders::TopLevel.build(input.top_level) unless input.top_level.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -1016,7 +1016,7 @@ def self.build(http_req, input:)
     class PayloadConfig
       def self.build(input)
         data = {}
-        data[:data] = input[:data] unless input[:data].nil?
+        data[:data] = input.data unless input.data.nil?
         data
       end
     end
@@ -1042,7 +1042,7 @@ def self.build(http_req, input:)
         http_req.append_path('/PostPlayerAction')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:action] = Builders::PlayerAction.build(input[:action]) unless input[:action].nil?
+        data[:action] = Builders::PlayerAction.build(input.action) unless input.action.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -1053,7 +1053,7 @@ def self.build(http_req, input:)
         http_req.append_path('/PostUnionWithJsonName')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:value] = Builders::UnionWithJsonName.build(input[:value]) unless input[:value].nil?
+        data[:value] = Builders::UnionWithJsonName.build(input.value) unless input.value.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -1064,9 +1064,9 @@ def self.build(http_req, input:)
         http_req.append_path('/requestcompression/putcontentwithencoding')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:data] = input[:data] unless input[:data].nil?
+        data[:data] = input.data unless input.data.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
-        http_req.headers['Content-Encoding'] = input[:encoding] unless input[:encoding].nil? || input[:encoding].empty?
+        http_req.headers['Content-Encoding'] = input.encoding unless input.encoding.nil? || input.encoding.empty?
       end
     end
 
@@ -1075,7 +1075,7 @@ def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/QueryIdempotencyTokenAutoFill')
         params = Hearth::Query::ParamList.new
-        params['token'] = input[:token].to_s unless input[:token].nil?
+        params['token'] = input.token.to_s unless input.token.nil?
         http_req.append_query_param_list(params)
       end
     end
@@ -1085,8 +1085,8 @@ def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/StringListMap')
         params = Hearth::Query::ParamList.new
-        unless input[:foo].nil? || input[:foo].empty?
-          input[:foo].each do |k, v|
+        unless input.foo.nil? || input.foo.empty?
+          input.foo.each do |k, v|
             unless v.nil? || v.empty?
               params[k] = v.map do |value|
                 value.to_s unless value.nil?
@@ -1094,7 +1094,7 @@ def self.build(http_req, input:)
             end
           end
         end
-        params['corge'] = input[:qux].to_s unless input[:qux].nil?
+        params['corge'] = input.qux.to_s unless input.qux.nil?
         http_req.append_query_param_list(params)
       end
     end
@@ -1104,12 +1104,12 @@ def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/Precedence')
         params = Hearth::Query::ParamList.new
-        unless input[:baz].nil? || input[:baz].empty?
-          input[:baz].each do |k, v|
+        unless input.baz.nil? || input.baz.empty?
+          input.baz.each do |k, v|
             params[k] = v.to_s unless v.nil?
           end
         end
-        params['bar'] = input[:foo].to_s unless input[:foo].nil?
+        params['bar'] = input.foo.to_s unless input.foo.nil?
         http_req.append_query_param_list(params)
       end
     end
@@ -1120,7 +1120,7 @@ def self.build(http_req, input:)
         http_req.append_path('/RecursiveShapes')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:nested] = Builders::RecursiveShapesInputOutputNested1.build(input[:nested]) unless input[:nested].nil?
+        data[:nested] = Builders::RecursiveShapesInputOutputNested1.build(input.nested) unless input.nested.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -1128,8 +1128,8 @@ def self.build(http_req, input:)
     class RecursiveShapesInputOutputNested1
       def self.build(input)
         data = {}
-        data[:foo] = input[:foo] unless input[:foo].nil?
-        data[:nested] = Builders::RecursiveShapesInputOutputNested2.build(input[:nested]) unless input[:nested].nil?
+        data[:foo] = input.foo unless input.foo.nil?
+        data[:nested] = Builders::RecursiveShapesInputOutputNested2.build(input.nested) unless input.nested.nil?
         data
       end
     end
@@ -1137,8 +1137,8 @@ def self.build(input)
     class RecursiveShapesInputOutputNested2
       def self.build(input)
         data = {}
-        data[:bar] = input[:bar] unless input[:bar].nil?
-        data[:recursive_member] = Builders::RecursiveShapesInputOutputNested1.build(input[:recursive_member]) unless input[:recursive_member].nil?
+        data[:bar] = input.bar unless input.bar.nil?
+        data[:recursive_member] = Builders::RecursiveShapesInputOutputNested1.build(input.recursive_member) unless input.recursive_member.nil?
         data
       end
     end
@@ -1149,17 +1149,17 @@ def self.build(http_req, input:)
         http_req.append_path('/SimpleScalarProperties')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:string_value] = input[:string_value] unless input[:string_value].nil?
-        data[:true_boolean_value] = input[:true_boolean_value] unless input[:true_boolean_value].nil?
-        data[:false_boolean_value] = input[:false_boolean_value] unless input[:false_boolean_value].nil?
-        data[:byte_value] = input[:byte_value] unless input[:byte_value].nil?
-        data[:short_value] = input[:short_value] unless input[:short_value].nil?
-        data[:integer_value] = input[:integer_value] unless input[:integer_value].nil?
-        data[:long_value] = input[:long_value] unless input[:long_value].nil?
-        data[:float_value] = Hearth::NumberHelper.serialize(input[:float_value]) unless input[:float_value].nil?
-        data['DoubleDribble'] = Hearth::NumberHelper.serialize(input[:double_value]) unless input[:double_value].nil?
+        data[:string_value] = input.string_value unless input.string_value.nil?
+        data[:true_boolean_value] = input.true_boolean_value unless input.true_boolean_value.nil?
+        data[:false_boolean_value] = input.false_boolean_value unless input.false_boolean_value.nil?
+        data[:byte_value] = input.byte_value unless input.byte_value.nil?
+        data[:short_value] = input.short_value unless input.short_value.nil?
+        data[:integer_value] = input.integer_value unless input.integer_value.nil?
+        data[:long_value] = input.long_value unless input.long_value.nil?
+        data[:float_value] = Hearth::NumberHelper.serialize(input.float_value) unless input.float_value.nil?
+        data['DoubleDribble'] = Hearth::NumberHelper.serialize(input.double_value) unless input.double_value.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
-        http_req.headers['X-Foo'] = input[:foo] unless input[:foo].nil? || input[:foo].empty?
+        http_req.headers['X-Foo'] = input.foo unless input.foo.nil? || input.foo.empty?
       end
     end
 
@@ -1179,7 +1179,7 @@ def self.build(http_req, input:)
         http_req.append_path('/SparseJsonLists')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:sparse_string_list] = Builders::SparseStringList.build(input[:sparse_string_list]) unless input[:sparse_string_list].nil?
+        data[:sparse_string_list] = Builders::SparseStringList.build(input.sparse_string_list) unless input.sparse_string_list.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -1190,11 +1190,11 @@ def self.build(http_req, input:)
         http_req.append_path('/SparseJsonMaps')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:sparse_struct_map] = Builders::SparseStructMap.build(input[:sparse_struct_map]) unless input[:sparse_struct_map].nil?
-        data[:sparse_number_map] = Builders::SparseNumberMap.build(input[:sparse_number_map]) unless input[:sparse_number_map].nil?
-        data[:sparse_boolean_map] = Builders::SparseBooleanMap.build(input[:sparse_boolean_map]) unless input[:sparse_boolean_map].nil?
-        data[:sparse_string_map] = Builders::SparseStringMap.build(input[:sparse_string_map]) unless input[:sparse_string_map].nil?
-        data[:sparse_set_map] = Builders::SparseSetMap.build(input[:sparse_set_map]) unless input[:sparse_set_map].nil?
+        data[:sparse_struct_map] = Builders::SparseStructMap.build(input.sparse_struct_map) unless input.sparse_struct_map.nil?
+        data[:sparse_number_map] = Builders::SparseNumberMap.build(input.sparse_number_map) unless input.sparse_number_map.nil?
+        data[:sparse_boolean_map] = Builders::SparseBooleanMap.build(input.sparse_boolean_map) unless input.sparse_boolean_map.nil?
+        data[:sparse_string_map] = Builders::SparseStringMap.build(input.sparse_string_map) unless input.sparse_string_map.nil?
+        data[:sparse_set_map] = Builders::SparseSetMap.build(input.sparse_set_map) unless input.sparse_set_map.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
       end
     end
@@ -1253,10 +1253,10 @@ class StreamingTraits
       def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/StreamingTraits')
-        http_req.body = input[:blob]
+        http_req.body = input.blob
         http_req.headers['Transfer-Encoding'] = 'chunked'
         http_req.headers['Content-Type'] = 'application/octet-stream'
-        http_req.headers['X-Foo'] = input[:foo] unless input[:foo].nil? || input[:foo].empty?
+        http_req.headers['X-Foo'] = input.foo unless input.foo.nil? || input.foo.empty?
       end
     end
 
@@ -1264,9 +1264,9 @@ class StreamingTraitsRequireLength
       def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/StreamingTraitsRequireLength')
-        http_req.body = input[:blob]
+        http_req.body = input.blob
         http_req.headers['Content-Type'] = 'application/octet-stream'
-        http_req.headers['X-Foo'] = input[:foo] unless input[:foo].nil? || input[:foo].empty?
+        http_req.headers['X-Foo'] = input.foo unless input.foo.nil? || input.foo.empty?
       end
     end
 
@@ -1274,10 +1274,10 @@ class StreamingTraitsWithMediaType
       def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/StreamingTraitsWithMediaType')
-        http_req.body = input[:blob]
+        http_req.body = input.blob
         http_req.headers['Transfer-Encoding'] = 'chunked'
         http_req.headers['Content-Type'] = 'text/plain'
-        http_req.headers['X-Foo'] = input[:foo] unless input[:foo].nil? || input[:foo].empty?
+        http_req.headers['X-Foo'] = input.foo unless input.foo.nil? || input.foo.empty?
       end
     end
 
@@ -1334,8 +1334,8 @@ def self.build(input)
     class StructureListMember
       def self.build(input)
         data = {}
-        data['value'] = input[:a] unless input[:a].nil?
-        data['other'] = input[:b] unless input[:b].nil?
+        data['value'] = input.a unless input.a.nil?
+        data['other'] = input.b unless input.b.nil?
         data
       end
     end
@@ -1346,16 +1346,16 @@ def self.build(http_req, input:)
         http_req.append_path('/body')
         http_req.headers['Content-Type'] = 'application/json'
         data = {}
-        data[:test_config] = Builders::TestConfig.build(input[:test_config]) unless input[:test_config].nil?
+        data[:test_config] = Builders::TestConfig.build(input.test_config) unless input.test_config.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data))
-        http_req.headers['x-amz-test-id'] = input[:test_id] unless input[:test_id].nil? || input[:test_id].empty?
+        http_req.headers['x-amz-test-id'] = input.test_id unless input.test_id.nil? || input.test_id.empty?
       end
     end
 
     class TestConfig
       def self.build(input)
         data = {}
-        data[:timeout] = input[:timeout] unless input[:timeout].nil?
+        data[:timeout] = input.timeout unless input.timeout.nil?
         data
       end
     end
@@ -1364,7 +1364,7 @@ class TestNoPayload
       def self.build(http_req, input:)
         http_req.http_method = 'GET'
         http_req.append_path('/no_payload')
-        http_req.headers['X-Amz-Test-Id'] = input[:test_id] unless input[:test_id].nil? || input[:test_id].empty?
+        http_req.headers['X-Amz-Test-Id'] = input.test_id unless input.test_id.nil? || input.test_id.empty?
       end
     end
 
@@ -1373,8 +1373,8 @@ def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/blob_payload')
         http_req.headers['Content-Type'] = 'application/octet-stream'
-        http_req.body = StringIO.new(input[:data] || '')
-        http_req.headers['Content-Type'] = input[:content_type] unless input[:content_type].nil? || input[:content_type].empty?
+        http_req.body = StringIO.new(input.data || '')
+        http_req.headers['Content-Type'] = input.content_type unless input.content_type.nil? || input.content_type.empty?
       end
     end
 
@@ -1383,9 +1383,9 @@ def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/payload')
         http_req.headers['Content-Type'] = 'application/json'
-        data = Builders::PayloadConfig.build(input[:payload_config]) unless input[:payload_config].nil?
+        data = Builders::PayloadConfig.build(input.payload_config) unless input.payload_config.nil?
         http_req.body = StringIO.new(Hearth::JSON.dump(data || {}))
-        http_req.headers['x-amz-test-id'] = input[:test_id] unless input[:test_id].nil? || input[:test_id].empty?
+        http_req.headers['x-amz-test-id'] = input.test_id unless input.test_id.nil? || input.test_id.empty?
       end
     end
 
@@ -1413,13 +1413,13 @@ class TimestampFormatHeaders
       def self.build(http_req, input:)
         http_req.http_method = 'POST'
         http_req.append_path('/TimestampFormatHeaders')
-        http_req.headers['X-memberEpochSeconds'] = Hearth::TimeHelper.to_epoch_seconds(input[:member_epoch_seconds]).to_i unless input[:member_epoch_seconds].nil?
-        http_req.headers['X-memberHttpDate'] = Hearth::TimeHelper.to_http_date(input[:member_http_date]) unless input[:member_http_date].nil?
-        http_req.headers['X-memberDateTime'] = Hearth::TimeHelper.to_date_time(input[:member_date_time]) unless input[:member_date_time].nil?
-        http_req.headers['X-defaultFormat'] = Hearth::TimeHelper.to_http_date(input[:default_format]) unless input[:default_format].nil?
-        http_req.headers['X-targetEpochSeconds'] = Hearth::TimeHelper.to_epoch_seconds(input[:target_epoch_seconds]).to_i unless input[:target_epoch_seconds].nil?
-        http_req.headers['X-targetHttpDate'] = Hearth::TimeHelper.to_http_date(input[:target_http_date]) unless input[:target_http_date].nil?
-        http_req.headers['X-targetDateTime'] = Hearth::TimeHelper.to_date_time(input[:target_date_time]) unless input[:target_date_time].nil?
+        http_req.headers['X-memberEpochSeconds'] = Hearth::TimeHelper.to_epoch_seconds(input.member_epoch_seconds).to_i unless input.member_epoch_seconds.nil?
+        http_req.headers['X-memberHttpDate'] = Hearth::TimeHelper.to_http_date(input.member_http_date) unless input.member_http_date.nil?
+        http_req.headers['X-memberDateTime'] = Hearth::TimeHelper.to_date_time(input.member_date_time) unless input.member_date_time.nil?
+        http_req.headers['X-defaultFormat'] = Hearth::TimeHelper.to_http_date(input.default_format) unless input.default_format.nil?
+        http_req.headers['X-targetEpochSeconds'] = Hearth::TimeHelper.to_epoch_seconds(input.target_epoch_seconds).to_i unless input.target_epoch_seconds.nil?
+        http_req.headers['X-targetHttpDate'] = Hearth::TimeHelper.to_http_date(input.target_http_date) unless input.target_http_date.nil?
+        http_req.headers['X-targetDateTime'] = Hearth::TimeHelper.to_date_time(input.target_date_time) unless input.target_date_time.nil?
       end
     end
 
@@ -1436,9 +1436,9 @@ def self.build(input)
     class TopLevel
       def self.build(input)
         data = {}
-        data[:dialog] = Builders::Dialog.build(input[:dialog]) unless input[:dialog].nil?
-        data[:dialog_list] = Builders::DialogList.build(input[:dialog_list]) unless input[:dialog_list].nil?
-        data[:dialog_map] = Builders::DialogMap.build(input[:dialog_map]) unless input[:dialog_map].nil?
+        data[:dialog] = Builders::Dialog.build(input.dialog) unless input.dialog.nil?
+        data[:dialog_list] = Builders::DialogList.build(input.dialog_list) unless input.dialog_list.nil?
+        data[:dialog_map] = Builders::DialogMap.build(input.dialog_map) unless input.dialog_map.nil?
         data
       end
     end
diff --git a/codegen/projections/rails_json/lib/rails_json/client.rb b/codegen/projections/rails_json/lib/rails_json/client.rb
index fc9e58c83..df4510e7f 100644
--- a/codegen/projections/rails_json/lib/rails_json/client.rb
+++ b/codegen/projections/rails_json/lib/rails_json/client.rb
@@ -2563,7 +2563,7 @@ def sparse_json_maps(params = {}, options = {})
     # @example Response structure
     #   resp.data #=> Types::StreamingTraitsOutput
     #   resp.data.foo #=> String
-    #   resp.data.blob #=> String
+    #   resp.data.blob #=> IO
     def streaming_traits(params = {}, options = {}, &block)
       response_body = output_stream(options, &block)
       config = operation_config(options)
@@ -2644,7 +2644,7 @@ def streaming_traits_require_length(params = {}, options = {})
     # @example Response structure
     #   resp.data #=> Types::StreamingTraitsWithMediaTypeOutput
     #   resp.data.foo #=> String
-    #   resp.data.blob #=> String
+    #   resp.data.blob #=> IO
     def streaming_traits_with_media_type(params = {}, options = {}, &block)
       response_body = output_stream(options, &block)
       config = operation_config(options)
diff --git a/codegen/projections/rails_json/lib/rails_json/stubs.rb b/codegen/projections/rails_json/lib/rails_json/stubs.rb
index 983ca13d3..dbdddb32a 100644
--- a/codegen/projections/rails_json/lib/rails_json/stubs.rb
+++ b/codegen/projections/rails_json/lib/rails_json/stubs.rb
@@ -73,10 +73,10 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 403
         http_resp.headers['X-Amzn-Errortype'] = 'ComplexError'
-        http_resp.headers['X-Header'] = stub[:header] unless stub[:header].nil? || stub[:header].empty?
+        http_resp.headers['X-Header'] = stub.header unless stub.header.nil? || stub.header.empty?
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:top_level] = stub[:top_level] unless stub[:top_level].nil?
-        data[:nested] = Stubs::ComplexNestedErrorData.stub(stub[:nested]) unless stub[:nested].nil?
+        data[:top_level] = stub.top_level unless stub.top_level.nil?
+        data[:nested] = Stubs::ComplexNestedErrorData.stub(stub.nested) unless stub.nested.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -93,7 +93,7 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::ComplexNestedErrorData.new
         data = {}
-        data['Fooooo'] = stub[:foo] unless stub[:foo].nil?
+        data['Fooooo'] = stub.foo unless stub.foo.nil?
         data
       end
     end
@@ -157,7 +157,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:datetime] = Hearth::TimeHelper.to_date_time(stub[:datetime]) unless stub[:datetime].nil?
+        data[:datetime] = Hearth::TimeHelper.to_date_time(stub.datetime) unless stub.datetime.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -167,7 +167,7 @@ def self.default(visited = [])
         return nil if visited.include?('DenseBooleanMap')
         visited = visited + ['DenseBooleanMap']
         {
-          key: false
+          'key' => false
         }
       end
 
@@ -186,7 +186,7 @@ def self.default(visited = [])
         return nil if visited.include?('DenseNumberMap')
         visited = visited + ['DenseNumberMap']
         {
-          key: 1
+          'key' => 1
         }
       end
 
@@ -205,7 +205,7 @@ def self.default(visited = [])
         return nil if visited.include?('DenseSetMap')
         visited = visited + ['DenseSetMap']
         {
-          key: StringSet.default(visited)
+          'key' => StringSet.default(visited)
         }
       end
 
@@ -224,7 +224,7 @@ def self.default(visited = [])
         return nil if visited.include?('DenseStringMap')
         visited = visited + ['DenseStringMap']
         {
-          key: 'value'
+          'key' => 'value'
         }
       end
 
@@ -243,7 +243,7 @@ def self.default(visited = [])
         return nil if visited.include?('DenseStructMap')
         visited = visited + ['DenseStructMap']
         {
-          key: GreetingStruct.default(visited)
+          'key' => GreetingStruct.default(visited)
         }
       end
 
@@ -271,9 +271,9 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::Dialog.new
         data = {}
-        data[:language] = stub[:language] unless stub[:language].nil?
-        data[:greeting] = stub[:greeting] unless stub[:greeting].nil?
-        data[:farewell] = Stubs::Farewell.stub(stub[:farewell]) unless stub[:farewell].nil?
+        data[:language] = stub.language unless stub.language.nil?
+        data[:greeting] = stub.greeting unless stub.greeting.nil?
+        data[:farewell] = Stubs::Farewell.stub(stub.farewell) unless stub.farewell.nil?
         data
       end
     end
@@ -302,7 +302,7 @@ def self.default(visited = [])
         return nil if visited.include?('DialogMap')
         visited = visited + ['DialogMap']
         {
-          key: Dialog.default(visited)
+          'key' => Dialog.default(visited)
         }
       end
 
@@ -348,8 +348,8 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:string_value] = stub[:string_value] unless stub[:string_value].nil?
-        data[:document_value] = stub[:document_value] unless stub[:document_value].nil?
+        data[:string_value] = stub.string_value unless stub.string_value.nil?
+        data[:document_value] = stub.document_value unless stub.document_value.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -373,7 +373,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:doc_valued_map] = Stubs::DocumentValuedMap.stub(stub[:doc_valued_map]) unless stub[:doc_valued_map].nil?
+        data[:doc_valued_map] = Stubs::DocumentValuedMap.stub(stub.doc_valued_map) unless stub.doc_valued_map.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -397,7 +397,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        http_resp.body.write(Hearth::JSON.dump(stub[:document_value]))
+        http_resp.body.write(Hearth::JSON.dump(stub.document_value))
       end
     end
 
@@ -406,7 +406,7 @@ def self.default(visited = [])
         return nil if visited.include?('DocumentValuedMap')
         visited = visited + ['DocumentValuedMap']
         {
-          key: nil
+          'key' => nil
         }
       end
 
@@ -492,7 +492,7 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::Farewell.new
         data = {}
-        data[:phrase] = stub[:phrase] unless stub[:phrase].nil?
+        data[:phrase] = stub.phrase unless stub.phrase.nil?
         data
       end
     end
@@ -521,7 +521,7 @@ def self.default(visited = [])
         return nil if visited.include?('FooEnumMap')
         visited = visited + ['FooEnumMap']
         {
-          key: 'value'
+          'key' => 'value'
         }
       end
 
@@ -573,7 +573,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:datetime] = Hearth::TimeHelper.to_date_time(stub[:datetime]) unless stub[:datetime].nil?
+        data[:datetime] = Hearth::TimeHelper.to_date_time(stub.datetime) unless stub.datetime.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -590,7 +590,7 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::GreetingStruct.new
         data = {}
-        data[:hi] = stub[:hi] unless stub[:hi].nil?
+        data[:hi] = stub.hi unless stub.hi.nil?
         data
       end
     end
@@ -607,7 +607,7 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::RenamedGreeting.new
         data = {}
-        data[:salutation] = stub[:salutation] unless stub[:salutation].nil?
+        data[:salutation] = stub.salutation unless stub.salutation.nil?
         data
       end
     end
@@ -630,7 +630,7 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['X-Greeting'] = stub[:greeting] unless stub[:greeting].nil? || stub[:greeting].empty?
+        http_resp.headers['X-Greeting'] = stub.greeting unless stub.greeting.nil? || stub.greeting.empty?
       end
     end
 
@@ -673,7 +673,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:foo] = stub[:foo] unless stub[:foo].nil?
+        data[:foo] = stub.foo unless stub.foo.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -697,7 +697,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'text/plain'
-        http_resp.body.write(stub[:payload] || '')
+        http_resp.body.write(stub.payload || '')
       end
     end
 
@@ -720,9 +720,9 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['X-Foo'] = stub[:foo] unless stub[:foo].nil? || stub[:foo].empty?
+        http_resp.headers['X-Foo'] = stub.foo unless stub.foo.nil? || stub.foo.empty?
         http_resp.headers['Content-Type'] = 'application/octet-stream'
-        http_resp.body.write(stub[:blob] || '')
+        http_resp.body.write(stub.blob || '')
       end
     end
 
@@ -745,9 +745,9 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['X-Foo'] = stub[:foo] unless stub[:foo].nil? || stub[:foo].empty?
+        http_resp.headers['X-Foo'] = stub.foo unless stub.foo.nil? || stub.foo.empty?
         http_resp.headers['Content-Type'] = 'text/plain'
-        http_resp.body.write(stub[:blob] || '')
+        http_resp.body.write(stub.blob || '')
       end
     end
 
@@ -770,7 +770,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data = Stubs::NestedPayload.stub(stub[:nested]) unless stub[:nested].nil?
+        data = Stubs::NestedPayload.stub(stub.nested) unless stub.nested.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -794,7 +794,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data = Stubs::UnionPayload.stub(stub[:nested]) unless stub[:nested].nil?
+        data = Stubs::UnionPayload.stub(stub.nested) unless stub.nested.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -818,8 +818,8 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['X-Foo'] = stub[:foo] unless stub[:foo].nil? || stub[:foo].empty?
-        stub[:foo_map]&.each do |key, value|
+        http_resp.headers['X-Foo'] = stub.foo unless stub.foo.nil? || stub.foo.empty?
+        stub.foo_map.each do |key, value|
           http_resp.headers["X-Foo-#{key}"] = value unless value.nil? || value.empty?
         end
       end
@@ -843,7 +843,7 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        stub[:prefix_headers]&.each do |key, value|
+        stub.prefix_headers.each do |key, value|
           http_resp.headers["#{key}"] = value unless value.nil? || value.empty?
         end
       end
@@ -967,7 +967,7 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.status = stub[:status]
+        http_resp.status = stub.status
       end
     end
 
@@ -990,7 +990,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'text/plain'
-        http_resp.body.write(stub[:payload] || '')
+        http_resp.body.write(stub.payload || '')
       end
     end
 
@@ -1050,55 +1050,55 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['X-String'] = stub[:header_string] unless stub[:header_string].nil? || stub[:header_string].empty?
-        http_resp.headers['X-Byte'] = stub[:header_byte].to_s unless stub[:header_byte].nil?
-        http_resp.headers['X-Short'] = stub[:header_short].to_s unless stub[:header_short].nil?
-        http_resp.headers['X-Integer'] = stub[:header_integer].to_s unless stub[:header_integer].nil?
-        http_resp.headers['X-Long'] = stub[:header_long].to_s unless stub[:header_long].nil?
-        http_resp.headers['X-Float'] = Hearth::NumberHelper.serialize(stub[:header_float]) unless stub[:header_float].nil?
-        http_resp.headers['X-Double'] = Hearth::NumberHelper.serialize(stub[:header_double]) unless stub[:header_double].nil?
-        http_resp.headers['X-Boolean1'] = stub[:header_true_bool].to_s unless stub[:header_true_bool].nil?
-        http_resp.headers['X-Boolean2'] = stub[:header_false_bool].to_s unless stub[:header_false_bool].nil?
-        unless stub[:header_string_list].nil? || stub[:header_string_list].empty?
-          http_resp.headers['X-StringList'] = stub[:header_string_list]
+        http_resp.headers['X-String'] = stub.header_string unless stub.header_string.nil? || stub.header_string.empty?
+        http_resp.headers['X-Byte'] = stub.header_byte.to_s unless stub.header_byte.nil?
+        http_resp.headers['X-Short'] = stub.header_short.to_s unless stub.header_short.nil?
+        http_resp.headers['X-Integer'] = stub.header_integer.to_s unless stub.header_integer.nil?
+        http_resp.headers['X-Long'] = stub.header_long.to_s unless stub.header_long.nil?
+        http_resp.headers['X-Float'] = Hearth::NumberHelper.serialize(stub.header_float) unless stub.header_float.nil?
+        http_resp.headers['X-Double'] = Hearth::NumberHelper.serialize(stub.header_double) unless stub.header_double.nil?
+        http_resp.headers['X-Boolean1'] = stub.header_true_bool.to_s unless stub.header_true_bool.nil?
+        http_resp.headers['X-Boolean2'] = stub.header_false_bool.to_s unless stub.header_false_bool.nil?
+        unless stub.header_string_list.nil? || stub.header_string_list.empty?
+          http_resp.headers['X-StringList'] = stub.header_string_list
             .compact
             .map { |s| (s.include?('"') || s.include?(",")) ? "\"#{s.gsub('"', '\"')}\"" : s }
             .join(', ')
         end
-        unless stub[:header_string_set].nil? || stub[:header_string_set].empty?
-          http_resp.headers['X-StringSet'] = stub[:header_string_set]
+        unless stub.header_string_set.nil? || stub.header_string_set.empty?
+          http_resp.headers['X-StringSet'] = stub.header_string_set
             .compact
             .map { |s| (s.include?('"') || s.include?(",")) ? "\"#{s.gsub('"', '\"')}\"" : s }
             .join(', ')
         end
-        unless stub[:header_integer_list].nil? || stub[:header_integer_list].empty?
-          http_resp.headers['X-IntegerList'] = stub[:header_integer_list]
+        unless stub.header_integer_list.nil? || stub.header_integer_list.empty?
+          http_resp.headers['X-IntegerList'] = stub.header_integer_list
             .compact
             .map { |s| s.to_s }
             .join(', ')
         end
-        unless stub[:header_boolean_list].nil? || stub[:header_boolean_list].empty?
-          http_resp.headers['X-BooleanList'] = stub[:header_boolean_list]
+        unless stub.header_boolean_list.nil? || stub.header_boolean_list.empty?
+          http_resp.headers['X-BooleanList'] = stub.header_boolean_list
             .compact
             .map { |s| s.to_s }
             .join(', ')
         end
-        unless stub[:header_timestamp_list].nil? || stub[:header_timestamp_list].empty?
-          http_resp.headers['X-TimestampList'] = stub[:header_timestamp_list]
+        unless stub.header_timestamp_list.nil? || stub.header_timestamp_list.empty?
+          http_resp.headers['X-TimestampList'] = stub.header_timestamp_list
             .compact
             .map { |s| Hearth::TimeHelper.to_http_date(s) }
             .join(', ')
         end
-        http_resp.headers['X-Enum'] = stub[:header_enum] unless stub[:header_enum].nil? || stub[:header_enum].empty?
-        unless stub[:header_enum_list].nil? || stub[:header_enum_list].empty?
-          http_resp.headers['X-EnumList'] = stub[:header_enum_list]
+        http_resp.headers['X-Enum'] = stub.header_enum unless stub.header_enum.nil? || stub.header_enum.empty?
+        unless stub.header_enum_list.nil? || stub.header_enum_list.empty?
+          http_resp.headers['X-EnumList'] = stub.header_enum_list
             .compact
             .map { |s| (s.include?('"') || s.include?(",")) ? "\"#{s.gsub('"', '\"')}\"" : s }
             .join(', ')
         end
-        http_resp.headers['X-IntegerEnum'] = stub[:header_integer_enum].to_s unless stub[:header_integer_enum].nil?
-        unless stub[:header_integer_enum_list].nil? || stub[:header_integer_enum_list].empty?
-          http_resp.headers['X-IntegerEnumList'] = stub[:header_integer_enum_list]
+        http_resp.headers['X-IntegerEnum'] = stub.header_integer_enum.to_s unless stub.header_integer_enum.nil?
+        unless stub.header_integer_enum_list.nil? || stub.header_integer_enum_list.empty?
+          http_resp.headers['X-IntegerEnumList'] = stub.header_integer_enum_list
             .compact
             .map { |s| s.to_s }
             .join(', ')
@@ -1130,7 +1130,7 @@ def self.default(visited = [])
         return nil if visited.include?('IntegerEnumMap')
         visited = visited + ['IntegerEnumMap']
         {
-          key: 1
+          'key' => 1
         }
       end
 
@@ -1202,7 +1202,7 @@ def self.stub(http_resp, stub:)
         http_resp.status = 400
         http_resp.headers['X-Amzn-Errortype'] = 'InvalidGreeting'
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:message] = stub[:message] unless stub[:message].nil?
+        data[:message] = stub.message unless stub.message.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -1226,7 +1226,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:data] = ::Base64::strict_encode64(stub[:data]) unless stub[:data].nil?
+        data[:data] = ::Base64::strict_encode64(stub.data) unless stub.data.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -1255,12 +1255,12 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:foo_enum1] = stub[:foo_enum1] unless stub[:foo_enum1].nil?
-        data[:foo_enum2] = stub[:foo_enum2] unless stub[:foo_enum2].nil?
-        data[:foo_enum3] = stub[:foo_enum3] unless stub[:foo_enum3].nil?
-        data[:foo_enum_list] = Stubs::FooEnumList.stub(stub[:foo_enum_list]) unless stub[:foo_enum_list].nil?
-        data[:foo_enum_set] = Stubs::FooEnumSet.stub(stub[:foo_enum_set]) unless stub[:foo_enum_set].nil?
-        data[:foo_enum_map] = Stubs::FooEnumMap.stub(stub[:foo_enum_map]) unless stub[:foo_enum_map].nil?
+        data[:foo_enum1] = stub.foo_enum1 unless stub.foo_enum1.nil?
+        data[:foo_enum2] = stub.foo_enum2 unless stub.foo_enum2.nil?
+        data[:foo_enum3] = stub.foo_enum3 unless stub.foo_enum3.nil?
+        data[:foo_enum_list] = Stubs::FooEnumList.stub(stub.foo_enum_list) unless stub.foo_enum_list.nil?
+        data[:foo_enum_set] = Stubs::FooEnumSet.stub(stub.foo_enum_set) unless stub.foo_enum_set.nil?
+        data[:foo_enum_map] = Stubs::FooEnumMap.stub(stub.foo_enum_map) unless stub.foo_enum_map.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -1289,12 +1289,12 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:integer_enum1] = stub[:integer_enum1] unless stub[:integer_enum1].nil?
-        data[:integer_enum2] = stub[:integer_enum2] unless stub[:integer_enum2].nil?
-        data[:integer_enum3] = stub[:integer_enum3] unless stub[:integer_enum3].nil?
-        data[:integer_enum_list] = Stubs::IntegerEnumList.stub(stub[:integer_enum_list]) unless stub[:integer_enum_list].nil?
-        data[:integer_enum_set] = Stubs::IntegerEnumSet.stub(stub[:integer_enum_set]) unless stub[:integer_enum_set].nil?
-        data[:integer_enum_map] = Stubs::IntegerEnumMap.stub(stub[:integer_enum_map]) unless stub[:integer_enum_map].nil?
+        data[:integer_enum1] = stub.integer_enum1 unless stub.integer_enum1.nil?
+        data[:integer_enum2] = stub.integer_enum2 unless stub.integer_enum2.nil?
+        data[:integer_enum3] = stub.integer_enum3 unless stub.integer_enum3.nil?
+        data[:integer_enum_list] = Stubs::IntegerEnumList.stub(stub.integer_enum_list) unless stub.integer_enum_list.nil?
+        data[:integer_enum_set] = Stubs::IntegerEnumSet.stub(stub.integer_enum_set) unless stub.integer_enum_set.nil?
+        data[:integer_enum_map] = Stubs::IntegerEnumMap.stub(stub.integer_enum_map) unless stub.integer_enum_map.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -1326,15 +1326,15 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:string_list] = Stubs::StringList.stub(stub[:string_list]) unless stub[:string_list].nil?
-        data[:string_set] = Stubs::StringSet.stub(stub[:string_set]) unless stub[:string_set].nil?
-        data[:integer_list] = Stubs::IntegerList.stub(stub[:integer_list]) unless stub[:integer_list].nil?
-        data[:boolean_list] = Stubs::BooleanList.stub(stub[:boolean_list]) unless stub[:boolean_list].nil?
-        data[:timestamp_list] = Stubs::TimestampList.stub(stub[:timestamp_list]) unless stub[:timestamp_list].nil?
-        data[:enum_list] = Stubs::FooEnumList.stub(stub[:enum_list]) unless stub[:enum_list].nil?
-        data[:int_enum_list] = Stubs::IntegerEnumList.stub(stub[:int_enum_list]) unless stub[:int_enum_list].nil?
-        data[:nested_string_list] = Stubs::NestedStringList.stub(stub[:nested_string_list]) unless stub[:nested_string_list].nil?
-        data['myStructureList'] = Stubs::StructureList.stub(stub[:structure_list]) unless stub[:structure_list].nil?
+        data[:string_list] = Stubs::StringList.stub(stub.string_list) unless stub.string_list.nil?
+        data[:string_set] = Stubs::StringSet.stub(stub.string_set) unless stub.string_set.nil?
+        data[:integer_list] = Stubs::IntegerList.stub(stub.integer_list) unless stub.integer_list.nil?
+        data[:boolean_list] = Stubs::BooleanList.stub(stub.boolean_list) unless stub.boolean_list.nil?
+        data[:timestamp_list] = Stubs::TimestampList.stub(stub.timestamp_list) unless stub.timestamp_list.nil?
+        data[:enum_list] = Stubs::FooEnumList.stub(stub.enum_list) unless stub.enum_list.nil?
+        data[:int_enum_list] = Stubs::IntegerEnumList.stub(stub.int_enum_list) unless stub.int_enum_list.nil?
+        data[:nested_string_list] = Stubs::NestedStringList.stub(stub.nested_string_list) unless stub.nested_string_list.nil?
+        data['myStructureList'] = Stubs::StructureList.stub(stub.structure_list) unless stub.structure_list.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -1362,11 +1362,11 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:dense_struct_map] = Stubs::DenseStructMap.stub(stub[:dense_struct_map]) unless stub[:dense_struct_map].nil?
-        data[:dense_number_map] = Stubs::DenseNumberMap.stub(stub[:dense_number_map]) unless stub[:dense_number_map].nil?
-        data[:dense_boolean_map] = Stubs::DenseBooleanMap.stub(stub[:dense_boolean_map]) unless stub[:dense_boolean_map].nil?
-        data[:dense_string_map] = Stubs::DenseStringMap.stub(stub[:dense_string_map]) unless stub[:dense_string_map].nil?
-        data[:dense_set_map] = Stubs::DenseSetMap.stub(stub[:dense_set_map]) unless stub[:dense_set_map].nil?
+        data[:dense_struct_map] = Stubs::DenseStructMap.stub(stub.dense_struct_map) unless stub.dense_struct_map.nil?
+        data[:dense_number_map] = Stubs::DenseNumberMap.stub(stub.dense_number_map) unless stub.dense_number_map.nil?
+        data[:dense_boolean_map] = Stubs::DenseBooleanMap.stub(stub.dense_boolean_map) unless stub.dense_boolean_map.nil?
+        data[:dense_string_map] = Stubs::DenseStringMap.stub(stub.dense_string_map) unless stub.dense_string_map.nil?
+        data[:dense_set_map] = Stubs::DenseSetMap.stub(stub.dense_set_map) unless stub.dense_set_map.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -1396,13 +1396,13 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:normal] = Hearth::TimeHelper.to_epoch_seconds(stub[:normal]).to_i unless stub[:normal].nil?
-        data[:date_time] = Hearth::TimeHelper.to_date_time(stub[:date_time]) unless stub[:date_time].nil?
-        data[:date_time_on_target] = Hearth::TimeHelper.to_date_time(stub[:date_time_on_target]) unless stub[:date_time_on_target].nil?
-        data[:epoch_seconds] = Hearth::TimeHelper.to_epoch_seconds(stub[:epoch_seconds]).to_i unless stub[:epoch_seconds].nil?
-        data[:epoch_seconds_on_target] = Hearth::TimeHelper.to_epoch_seconds(stub[:epoch_seconds_on_target]).to_i unless stub[:epoch_seconds_on_target].nil?
-        data[:http_date] = Hearth::TimeHelper.to_http_date(stub[:http_date]) unless stub[:http_date].nil?
-        data[:http_date_on_target] = Hearth::TimeHelper.to_http_date(stub[:http_date_on_target]) unless stub[:http_date_on_target].nil?
+        data[:normal] = Hearth::TimeHelper.to_epoch_seconds(stub.normal).to_i unless stub.normal.nil?
+        data[:date_time] = Hearth::TimeHelper.to_date_time(stub.date_time) unless stub.date_time.nil?
+        data[:date_time_on_target] = Hearth::TimeHelper.to_date_time(stub.date_time_on_target) unless stub.date_time_on_target.nil?
+        data[:epoch_seconds] = Hearth::TimeHelper.to_epoch_seconds(stub.epoch_seconds).to_i unless stub.epoch_seconds.nil?
+        data[:epoch_seconds_on_target] = Hearth::TimeHelper.to_epoch_seconds(stub.epoch_seconds_on_target).to_i unless stub.epoch_seconds_on_target.nil?
+        data[:http_date] = Hearth::TimeHelper.to_http_date(stub.http_date) unless stub.http_date.nil?
+        data[:http_date_on_target] = Hearth::TimeHelper.to_http_date(stub.http_date_on_target) unless stub.http_date_on_target.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -1426,7 +1426,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:contents] = Stubs::MyUnion.stub(stub[:contents]) unless stub[:contents].nil?
+        data[:contents] = Stubs::MyUnion.stub(stub.contents) unless stub.contents.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -1449,7 +1449,7 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['X-Json'] = ::Base64::strict_encode64(stub[:json]).strip unless stub[:json].nil? || stub[:json].empty?
+        http_resp.headers['X-Json'] = ::Base64::strict_encode64(stub.json).strip unless stub.json.nil? || stub.json.empty?
       end
     end
 
@@ -1507,8 +1507,8 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::NestedPayload.new
         data = {}
-        data[:greeting] = stub[:greeting] unless stub[:greeting].nil?
-        data[:name] = stub[:name] unless stub[:name].nil?
+        data[:greeting] = stub.greeting unless stub.greeting.nil?
+        data[:name] = stub.name unless stub.name.nil?
         data
       end
     end
@@ -1592,10 +1592,10 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['X-A'] = stub[:a] unless stub[:a].nil? || stub[:a].empty?
-        http_resp.headers['X-B'] = stub[:b] unless stub[:b].nil? || stub[:b].empty?
-        unless stub[:c].nil? || stub[:c].empty?
-          http_resp.headers['X-C'] = stub[:c]
+        http_resp.headers['X-A'] = stub.a unless stub.a.nil? || stub.a.empty?
+        http_resp.headers['X-B'] = stub.b unless stub.b.nil? || stub.b.empty?
+        unless stub.c.nil? || stub.c.empty?
+          http_resp.headers['X-C'] = stub.c
             .compact
             .map { |s| (s.include?('"') || s.include?(",")) ? "\"#{s.gsub('"', '\"')}\"" : s }
             .join(', ')
@@ -1623,10 +1623,10 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['X-A'] = stub[:a] unless stub[:a].nil? || stub[:a].empty?
-        http_resp.headers['X-B'] = stub[:b] unless stub[:b].nil? || stub[:b].empty?
-        unless stub[:c].nil? || stub[:c].empty?
-          http_resp.headers['X-C'] = stub[:c]
+        http_resp.headers['X-A'] = stub.a unless stub.a.nil? || stub.a.empty?
+        http_resp.headers['X-B'] = stub.b unless stub.b.nil? || stub.b.empty?
+        unless stub.c.nil? || stub.c.empty?
+          http_resp.headers['X-C'] = stub.c
             .compact
             .map { |s| (s.include?('"') || s.include?(",")) ? "\"#{s.gsub('"', '\"')}\"" : s }
             .join(', ')
@@ -1720,34 +1720,34 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:default_string] = stub[:default_string] unless stub[:default_string].nil?
-        data[:default_boolean] = stub[:default_boolean] unless stub[:default_boolean].nil?
-        data[:default_list] = Stubs::TestStringList.stub(stub[:default_list]) unless stub[:default_list].nil?
-        data[:default_document_map] = stub[:default_document_map] unless stub[:default_document_map].nil?
-        data[:default_document_string] = stub[:default_document_string] unless stub[:default_document_string].nil?
-        data[:default_document_boolean] = stub[:default_document_boolean] unless stub[:default_document_boolean].nil?
-        data[:default_document_list] = stub[:default_document_list] unless stub[:default_document_list].nil?
-        data[:default_null_document] = stub[:default_null_document] unless stub[:default_null_document].nil?
-        data[:default_timestamp] = Hearth::TimeHelper.to_date_time(stub[:default_timestamp]) unless stub[:default_timestamp].nil?
-        data[:default_blob] = ::Base64::strict_encode64(stub[:default_blob]) unless stub[:default_blob].nil?
-        data[:default_byte] = stub[:default_byte] unless stub[:default_byte].nil?
-        data[:default_short] = stub[:default_short] unless stub[:default_short].nil?
-        data[:default_integer] = stub[:default_integer] unless stub[:default_integer].nil?
-        data[:default_long] = stub[:default_long] unless stub[:default_long].nil?
-        data[:default_float] = Hearth::NumberHelper.serialize(stub[:default_float])
-        data[:default_double] = Hearth::NumberHelper.serialize(stub[:default_double])
-        data[:default_map] = Stubs::TestStringMap.stub(stub[:default_map]) unless stub[:default_map].nil?
-        data[:default_enum] = stub[:default_enum] unless stub[:default_enum].nil?
-        data[:default_int_enum] = stub[:default_int_enum] unless stub[:default_int_enum].nil?
-        data[:empty_string] = stub[:empty_string] unless stub[:empty_string].nil?
-        data[:false_boolean] = stub[:false_boolean] unless stub[:false_boolean].nil?
-        data[:empty_blob] = ::Base64::strict_encode64(stub[:empty_blob]) unless stub[:empty_blob].nil?
-        data[:zero_byte] = stub[:zero_byte] unless stub[:zero_byte].nil?
-        data[:zero_short] = stub[:zero_short] unless stub[:zero_short].nil?
-        data[:zero_integer] = stub[:zero_integer] unless stub[:zero_integer].nil?
-        data[:zero_long] = stub[:zero_long] unless stub[:zero_long].nil?
-        data[:zero_float] = Hearth::NumberHelper.serialize(stub[:zero_float])
-        data[:zero_double] = Hearth::NumberHelper.serialize(stub[:zero_double])
+        data[:default_string] = stub.default_string unless stub.default_string.nil?
+        data[:default_boolean] = stub.default_boolean unless stub.default_boolean.nil?
+        data[:default_list] = Stubs::TestStringList.stub(stub.default_list) unless stub.default_list.nil?
+        data[:default_document_map] = stub.default_document_map unless stub.default_document_map.nil?
+        data[:default_document_string] = stub.default_document_string unless stub.default_document_string.nil?
+        data[:default_document_boolean] = stub.default_document_boolean unless stub.default_document_boolean.nil?
+        data[:default_document_list] = stub.default_document_list unless stub.default_document_list.nil?
+        data[:default_null_document] = stub.default_null_document unless stub.default_null_document.nil?
+        data[:default_timestamp] = Hearth::TimeHelper.to_date_time(stub.default_timestamp) unless stub.default_timestamp.nil?
+        data[:default_blob] = ::Base64::strict_encode64(stub.default_blob) unless stub.default_blob.nil?
+        data[:default_byte] = stub.default_byte unless stub.default_byte.nil?
+        data[:default_short] = stub.default_short unless stub.default_short.nil?
+        data[:default_integer] = stub.default_integer unless stub.default_integer.nil?
+        data[:default_long] = stub.default_long unless stub.default_long.nil?
+        data[:default_float] = Hearth::NumberHelper.serialize(stub.default_float)
+        data[:default_double] = Hearth::NumberHelper.serialize(stub.default_double)
+        data[:default_map] = Stubs::TestStringMap.stub(stub.default_map) unless stub.default_map.nil?
+        data[:default_enum] = stub.default_enum unless stub.default_enum.nil?
+        data[:default_int_enum] = stub.default_int_enum unless stub.default_int_enum.nil?
+        data[:empty_string] = stub.empty_string unless stub.empty_string.nil?
+        data[:false_boolean] = stub.false_boolean unless stub.false_boolean.nil?
+        data[:empty_blob] = ::Base64::strict_encode64(stub.empty_blob) unless stub.empty_blob.nil?
+        data[:zero_byte] = stub.zero_byte unless stub.zero_byte.nil?
+        data[:zero_short] = stub.zero_short unless stub.zero_short.nil?
+        data[:zero_integer] = stub.zero_integer unless stub.zero_integer.nil?
+        data[:zero_long] = stub.zero_long unless stub.zero_long.nil?
+        data[:zero_float] = Hearth::NumberHelper.serialize(stub.zero_float)
+        data[:zero_double] = Hearth::NumberHelper.serialize(stub.zero_double)
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -1773,9 +1773,9 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:dialog] = Stubs::Dialog.stub(stub[:dialog]) unless stub[:dialog].nil?
-        data[:dialog_list] = Stubs::DialogList.stub(stub[:dialog_list]) unless stub[:dialog_list].nil?
-        data[:dialog_map] = Stubs::DialogMap.stub(stub[:dialog_map]) unless stub[:dialog_map].nil?
+        data[:dialog] = Stubs::Dialog.stub(stub.dialog) unless stub.dialog.nil?
+        data[:dialog_list] = Stubs::DialogList.stub(stub.dialog_list) unless stub.dialog_list.nil?
+        data[:dialog_map] = Stubs::DialogMap.stub(stub.dialog_map) unless stub.dialog_map.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -1792,7 +1792,7 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::PayloadConfig.new
         data = {}
-        data[:data] = stub[:data] unless stub[:data].nil?
+        data[:data] = stub.data unless stub.data.nil?
         data
       end
     end
@@ -1839,7 +1839,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:action] = Stubs::PlayerAction.stub(stub[:action]) unless stub[:action].nil?
+        data[:action] = Stubs::PlayerAction.stub(stub.action) unless stub.action.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -1863,7 +1863,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:value] = Stubs::UnionWithJsonName.stub(stub[:value]) unless stub[:value].nil?
+        data[:value] = Stubs::UnionWithJsonName.stub(stub.value) unless stub.value.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -1967,7 +1967,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:nested] = Stubs::RecursiveShapesInputOutputNested1.stub(stub[:nested]) unless stub[:nested].nil?
+        data[:nested] = Stubs::RecursiveShapesInputOutputNested1.stub(stub.nested) unless stub.nested.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -1985,8 +1985,8 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::RecursiveShapesInputOutputNested1.new
         data = {}
-        data[:foo] = stub[:foo] unless stub[:foo].nil?
-        data[:nested] = Stubs::RecursiveShapesInputOutputNested2.stub(stub[:nested]) unless stub[:nested].nil?
+        data[:foo] = stub.foo unless stub.foo.nil?
+        data[:nested] = Stubs::RecursiveShapesInputOutputNested2.stub(stub.nested) unless stub.nested.nil?
         data
       end
     end
@@ -2004,8 +2004,8 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::RecursiveShapesInputOutputNested2.new
         data = {}
-        data[:bar] = stub[:bar] unless stub[:bar].nil?
-        data[:recursive_member] = Stubs::RecursiveShapesInputOutputNested1.stub(stub[:recursive_member]) unless stub[:recursive_member].nil?
+        data[:bar] = stub.bar unless stub.bar.nil?
+        data[:recursive_member] = Stubs::RecursiveShapesInputOutputNested1.stub(stub.recursive_member) unless stub.recursive_member.nil?
         data
       end
     end
@@ -2037,17 +2037,17 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['X-Foo'] = stub[:foo] unless stub[:foo].nil? || stub[:foo].empty?
+        http_resp.headers['X-Foo'] = stub.foo unless stub.foo.nil? || stub.foo.empty?
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:string_value] = stub[:string_value] unless stub[:string_value].nil?
-        data[:true_boolean_value] = stub[:true_boolean_value] unless stub[:true_boolean_value].nil?
-        data[:false_boolean_value] = stub[:false_boolean_value] unless stub[:false_boolean_value].nil?
-        data[:byte_value] = stub[:byte_value] unless stub[:byte_value].nil?
-        data[:short_value] = stub[:short_value] unless stub[:short_value].nil?
-        data[:integer_value] = stub[:integer_value] unless stub[:integer_value].nil?
-        data[:long_value] = stub[:long_value] unless stub[:long_value].nil?
-        data[:float_value] = Hearth::NumberHelper.serialize(stub[:float_value])
-        data['DoubleDribble'] = Hearth::NumberHelper.serialize(stub[:double_value])
+        data[:string_value] = stub.string_value unless stub.string_value.nil?
+        data[:true_boolean_value] = stub.true_boolean_value unless stub.true_boolean_value.nil?
+        data[:false_boolean_value] = stub.false_boolean_value unless stub.false_boolean_value.nil?
+        data[:byte_value] = stub.byte_value unless stub.byte_value.nil?
+        data[:short_value] = stub.short_value unless stub.short_value.nil?
+        data[:integer_value] = stub.integer_value unless stub.integer_value.nil?
+        data[:long_value] = stub.long_value unless stub.long_value.nil?
+        data[:float_value] = Hearth::NumberHelper.serialize(stub.float_value)
+        data['DoubleDribble'] = Hearth::NumberHelper.serialize(stub.double_value)
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -2057,7 +2057,7 @@ def self.default(visited = [])
         return nil if visited.include?('SparseBooleanMap')
         visited = visited + ['SparseBooleanMap']
         {
-          key: false
+          'key' => false
         }
       end
 
@@ -2090,7 +2090,7 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:sparse_string_list] = Stubs::SparseStringList.stub(stub[:sparse_string_list]) unless stub[:sparse_string_list].nil?
+        data[:sparse_string_list] = Stubs::SparseStringList.stub(stub.sparse_string_list) unless stub.sparse_string_list.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -2118,11 +2118,11 @@ def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:sparse_struct_map] = Stubs::SparseStructMap.stub(stub[:sparse_struct_map]) unless stub[:sparse_struct_map].nil?
-        data[:sparse_number_map] = Stubs::SparseNumberMap.stub(stub[:sparse_number_map]) unless stub[:sparse_number_map].nil?
-        data[:sparse_boolean_map] = Stubs::SparseBooleanMap.stub(stub[:sparse_boolean_map]) unless stub[:sparse_boolean_map].nil?
-        data[:sparse_string_map] = Stubs::SparseStringMap.stub(stub[:sparse_string_map]) unless stub[:sparse_string_map].nil?
-        data[:sparse_set_map] = Stubs::SparseSetMap.stub(stub[:sparse_set_map]) unless stub[:sparse_set_map].nil?
+        data[:sparse_struct_map] = Stubs::SparseStructMap.stub(stub.sparse_struct_map) unless stub.sparse_struct_map.nil?
+        data[:sparse_number_map] = Stubs::SparseNumberMap.stub(stub.sparse_number_map) unless stub.sparse_number_map.nil?
+        data[:sparse_boolean_map] = Stubs::SparseBooleanMap.stub(stub.sparse_boolean_map) unless stub.sparse_boolean_map.nil?
+        data[:sparse_string_map] = Stubs::SparseStringMap.stub(stub.sparse_string_map) unless stub.sparse_string_map.nil?
+        data[:sparse_set_map] = Stubs::SparseSetMap.stub(stub.sparse_set_map) unless stub.sparse_set_map.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -2132,7 +2132,7 @@ def self.default(visited = [])
         return nil if visited.include?('SparseNumberMap')
         visited = visited + ['SparseNumberMap']
         {
-          key: 1
+          'key' => 1
         }
       end
 
@@ -2151,7 +2151,7 @@ def self.default(visited = [])
         return nil if visited.include?('SparseSetMap')
         visited = visited + ['SparseSetMap']
         {
-          key: StringSet.default(visited)
+          'key' => StringSet.default(visited)
         }
       end
 
@@ -2189,7 +2189,7 @@ def self.default(visited = [])
         return nil if visited.include?('SparseStringMap')
         visited = visited + ['SparseStringMap']
         {
-          key: 'value'
+          'key' => 'value'
         }
       end
 
@@ -2208,7 +2208,7 @@ def self.default(visited = [])
         return nil if visited.include?('SparseStructMap')
         visited = visited + ['SparseStructMap']
         {
-          key: GreetingStruct.default(visited)
+          'key' => GreetingStruct.default(visited)
         }
       end
 
@@ -2241,8 +2241,8 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['X-Foo'] = stub[:foo] unless stub[:foo].nil? || stub[:foo].empty?
-        IO.copy_stream(stub[:blob], http_resp.body)
+        http_resp.headers['X-Foo'] = stub.foo unless stub.foo.nil? || stub.foo.empty?
+        IO.copy_stream(stub.blob, http_resp.body)
       end
     end
 
@@ -2285,8 +2285,8 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['X-Foo'] = stub[:foo] unless stub[:foo].nil? || stub[:foo].empty?
-        IO.copy_stream(stub[:blob], http_resp.body)
+        http_resp.headers['X-Foo'] = stub.foo unless stub.foo.nil? || stub.foo.empty?
+        IO.copy_stream(stub.blob, http_resp.body)
       end
     end
 
@@ -2314,7 +2314,7 @@ def self.default(visited = [])
         return nil if visited.include?('StringMap')
         visited = visited + ['StringMap']
         {
-          key: 'value'
+          'key' => 'value'
         }
       end
 
@@ -2379,8 +2379,8 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::StructureListMember.new
         data = {}
-        data['value'] = stub[:a] unless stub[:a].nil?
-        data['other'] = stub[:b] unless stub[:b].nil?
+        data['value'] = stub.a unless stub.a.nil?
+        data['other'] = stub.b unless stub.b.nil?
         data
       end
     end
@@ -2404,9 +2404,9 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['x-amz-test-id'] = stub[:test_id] unless stub[:test_id].nil? || stub[:test_id].empty?
+        http_resp.headers['x-amz-test-id'] = stub.test_id unless stub.test_id.nil? || stub.test_id.empty?
         http_resp.headers['Content-Type'] = 'application/json'
-        data[:test_config] = Stubs::TestConfig.stub(stub[:test_config]) unless stub[:test_config].nil?
+        data[:test_config] = Stubs::TestConfig.stub(stub.test_config) unless stub.test_config.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -2423,7 +2423,7 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::TestConfig.new
         data = {}
-        data[:timeout] = stub[:timeout] unless stub[:timeout].nil?
+        data[:timeout] = stub.timeout unless stub.timeout.nil?
         data
       end
     end
@@ -2446,7 +2446,7 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['X-Amz-Test-Id'] = stub[:test_id] unless stub[:test_id].nil? || stub[:test_id].empty?
+        http_resp.headers['X-Amz-Test-Id'] = stub.test_id unless stub.test_id.nil? || stub.test_id.empty?
       end
     end
 
@@ -2469,9 +2469,9 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['Content-Type'] = stub[:content_type] unless stub[:content_type].nil? || stub[:content_type].empty?
+        http_resp.headers['Content-Type'] = stub.content_type unless stub.content_type.nil? || stub.content_type.empty?
         http_resp.headers['Content-Type'] = 'application/octet-stream'
-        http_resp.body.write(stub[:data] || '')
+        http_resp.body.write(stub.data || '')
       end
     end
 
@@ -2494,9 +2494,9 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['x-amz-test-id'] = stub[:test_id] unless stub[:test_id].nil? || stub[:test_id].empty?
+        http_resp.headers['x-amz-test-id'] = stub.test_id unless stub.test_id.nil? || stub.test_id.empty?
         http_resp.headers['Content-Type'] = 'application/json'
-        data = Stubs::PayloadConfig.stub(stub[:payload_config]) unless stub[:payload_config].nil?
+        data = Stubs::PayloadConfig.stub(stub.payload_config) unless stub.payload_config.nil?
         http_resp.body.write(Hearth::JSON.dump(data))
       end
     end
@@ -2525,7 +2525,7 @@ def self.default(visited = [])
         return nil if visited.include?('TestStringMap')
         visited = visited + ['TestStringMap']
         {
-          key: 'value'
+          'key' => 'value'
         }
       end
 
@@ -2563,13 +2563,13 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        http_resp.headers['X-memberEpochSeconds'] = Hearth::TimeHelper.to_epoch_seconds(stub[:member_epoch_seconds]).to_i unless stub[:member_epoch_seconds].nil?
-        http_resp.headers['X-memberHttpDate'] = Hearth::TimeHelper.to_http_date(stub[:member_http_date]) unless stub[:member_http_date].nil?
-        http_resp.headers['X-memberDateTime'] = Hearth::TimeHelper.to_date_time(stub[:member_date_time]) unless stub[:member_date_time].nil?
-        http_resp.headers['X-defaultFormat'] = Hearth::TimeHelper.to_http_date(stub[:default_format]) unless stub[:default_format].nil?
-        http_resp.headers['X-targetEpochSeconds'] = Hearth::TimeHelper.to_epoch_seconds(stub[:target_epoch_seconds]).to_i unless stub[:target_epoch_seconds].nil?
-        http_resp.headers['X-targetHttpDate'] = Hearth::TimeHelper.to_http_date(stub[:target_http_date]) unless stub[:target_http_date].nil?
-        http_resp.headers['X-targetDateTime'] = Hearth::TimeHelper.to_date_time(stub[:target_date_time]) unless stub[:target_date_time].nil?
+        http_resp.headers['X-memberEpochSeconds'] = Hearth::TimeHelper.to_epoch_seconds(stub.member_epoch_seconds).to_i unless stub.member_epoch_seconds.nil?
+        http_resp.headers['X-memberHttpDate'] = Hearth::TimeHelper.to_http_date(stub.member_http_date) unless stub.member_http_date.nil?
+        http_resp.headers['X-memberDateTime'] = Hearth::TimeHelper.to_date_time(stub.member_date_time) unless stub.member_date_time.nil?
+        http_resp.headers['X-defaultFormat'] = Hearth::TimeHelper.to_http_date(stub.default_format) unless stub.default_format.nil?
+        http_resp.headers['X-targetEpochSeconds'] = Hearth::TimeHelper.to_epoch_seconds(stub.target_epoch_seconds).to_i unless stub.target_epoch_seconds.nil?
+        http_resp.headers['X-targetHttpDate'] = Hearth::TimeHelper.to_http_date(stub.target_http_date) unless stub.target_http_date.nil?
+        http_resp.headers['X-targetDateTime'] = Hearth::TimeHelper.to_date_time(stub.target_date_time) unless stub.target_date_time.nil?
       end
     end
 
diff --git a/codegen/projections/rails_json/lib/rails_json/types.rb b/codegen/projections/rails_json/lib/rails_json/types.rb
index e4820040b..e2e0f443e 100644
--- a/codegen/projections/rails_json/lib/rails_json/types.rb
+++ b/codegen/projections/rails_json/lib/rails_json/types.rb
@@ -76,40 +76,44 @@ module Types
     #   @return [Array<Integer>]
     # @!attribute query_params_map_of_string_list
     #   @return [Hash<String, Array<String>>]
-    AllQueryStringTypesInput = ::Struct.new(
-      :query_string,
-      :query_string_list,
-      :query_string_set,
-      :query_byte,
-      :query_short,
-      :query_integer,
-      :query_integer_list,
-      :query_integer_set,
-      :query_long,
-      :query_float,
-      :query_double,
-      :query_double_list,
-      :query_boolean,
-      :query_boolean_list,
-      :query_timestamp,
-      :query_timestamp_list,
-      :query_enum,
-      :query_enum_list,
-      :query_integer_enum,
-      :query_integer_enum_list,
-      :query_params_map_of_string_list,
-      keyword_init: true
-    ) do
+    class AllQueryStringTypesInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        query_string
+        query_string_list
+        query_string_set
+        query_byte
+        query_short
+        query_integer
+        query_integer_list
+        query_integer_set
+        query_long
+        query_float
+        query_double
+        query_double_list
+        query_boolean
+        query_boolean_list
+        query_timestamp
+        query_timestamp_list
+        query_enum
+        query_enum_list
+        query_integer_enum
+        query_integer_enum_list
+        query_params_map_of_string_list
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    AllQueryStringTypesOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class AllQueryStringTypesOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -117,11 +121,14 @@ module Types
     #   @option params [Integer] :member
     # @!attribute member
     #   @return [Integer]
-    ClientOptionalDefaults = ::Struct.new(
-      :member,
-      keyword_init: true
-    ) do
+    class ClientOptionalDefaults
       include Hearth::Structure
+
+      MEMBERS = %i[
+        member
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # This error is thrown when a request is invalid.
@@ -136,13 +143,16 @@ module Types
     #   @return [String]
     # @!attribute nested
     #   @return [ComplexNestedErrorData]
-    ComplexError = ::Struct.new(
-      :header,
-      :top_level,
-      :nested,
-      keyword_init: true
-    ) do
+    class ComplexError
       include Hearth::Structure
+
+      MEMBERS = %i[
+        header
+        top_level
+        nested
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -150,11 +160,14 @@ module Types
     #   @option params [String] :foo
     # @!attribute foo
     #   @return [String]
-    ComplexNestedErrorData = ::Struct.new(
-      :foo,
-      keyword_init: true
-    ) do
+    class ComplexNestedErrorData
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -165,21 +178,25 @@ module Types
     #   @return [String]
     # @!attribute maybe_set
     #   @return [String]
-    ConstantAndVariableQueryStringInput = ::Struct.new(
-      :baz,
-      :maybe_set,
-      keyword_init: true
-    ) do
+    class ConstantAndVariableQueryStringInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        baz
+        maybe_set
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    ConstantAndVariableQueryStringOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class ConstantAndVariableQueryStringOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -187,29 +204,34 @@ module Types
     #   @option params [String] :hello
     # @!attribute hello
     #   @return [String]
-    ConstantQueryStringInput = ::Struct.new(
-      :hello,
-      keyword_init: true
-    ) do
+    class ConstantQueryStringInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        hello
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    ConstantQueryStringOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class ConstantQueryStringOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    DatetimeOffsetsInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class DatetimeOffsetsInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -217,11 +239,14 @@ module Types
     #   @option params [Time] :datetime
     # @!attribute datetime
     #   @return [Time]
-    DatetimeOffsetsOutput = ::Struct.new(
-      :datetime,
-      keyword_init: true
-    ) do
+    class DatetimeOffsetsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        datetime
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -311,38 +336,41 @@ module Types
     #   @return [Float]
     # @!attribute zero_double
     #   @return [Float]
-    Defaults = ::Struct.new(
-      :default_string,
-      :default_boolean,
-      :default_list,
-      :default_document_map,
-      :default_document_string,
-      :default_document_boolean,
-      :default_document_list,
-      :default_null_document,
-      :default_timestamp,
-      :default_blob,
-      :default_byte,
-      :default_short,
-      :default_integer,
-      :default_long,
-      :default_float,
-      :default_double,
-      :default_map,
-      :default_enum,
-      :default_int_enum,
-      :empty_string,
-      :false_boolean,
-      :empty_blob,
-      :zero_byte,
-      :zero_short,
-      :zero_integer,
-      :zero_long,
-      :zero_float,
-      :zero_double,
-      keyword_init: true
-    ) do
-      include Hearth::Structure
+    class Defaults
+      include Hearth::Structure
+
+      MEMBERS = %i[
+        default_string
+        default_boolean
+        default_list
+        default_document_map
+        default_document_string
+        default_document_boolean
+        default_document_list
+        default_null_document
+        default_timestamp
+        default_blob
+        default_byte
+        default_short
+        default_integer
+        default_long
+        default_float
+        default_double
+        default_map
+        default_enum
+        default_int_enum
+        empty_string
+        false_boolean
+        empty_blob
+        zero_byte
+        zero_short
+        zero_integer
+        zero_long
+        zero_float
+        zero_double
+      ].freeze
+
+      attr_accessor(*MEMBERS)
 
       private
 
@@ -390,14 +418,17 @@ def _defaults
     #   @return [String]
     # @!attribute farewell
     #   @return [Farewell]
-    Dialog = ::Struct.new(
-      :language,
-      :greeting,
-      :farewell,
-      keyword_init: true
-    ) do
+    class Dialog
       include Hearth::Structure
 
+      MEMBERS = %i[
+        language
+        greeting
+        farewell
+      ].freeze
+
+      attr_accessor(*MEMBERS)
+
       private
 
       def _defaults
@@ -412,11 +443,14 @@ def _defaults
     #   @option params [Hash<String, Hash, Array, String, Boolean, Numeric>] :doc_valued_map
     # @!attribute doc_valued_map
     #   @return [Hash<String, Hash, Array, String, Boolean, Numeric>]
-    DocumentTypeAsMapValueInput = ::Struct.new(
-      :doc_valued_map,
-      keyword_init: true
-    ) do
+    class DocumentTypeAsMapValueInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        doc_valued_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -424,11 +458,14 @@ def _defaults
     #   @option params [Hash<String, Hash, Array, String, Boolean, Numeric>] :doc_valued_map
     # @!attribute doc_valued_map
     #   @return [Hash<String, Hash, Array, String, Boolean, Numeric>]
-    DocumentTypeAsMapValueOutput = ::Struct.new(
-      :doc_valued_map,
-      keyword_init: true
-    ) do
+    class DocumentTypeAsMapValueOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        doc_valued_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -436,11 +473,14 @@ def _defaults
     #   @option params [Hash, Array, String, Boolean, Numeric] :document_value
     # @!attribute document_value
     #   @return [Hash, Array, String, Boolean, Numeric]
-    DocumentTypeAsPayloadInput = ::Struct.new(
-      :document_value,
-      keyword_init: true
-    ) do
+    class DocumentTypeAsPayloadInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        document_value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -448,11 +488,14 @@ def _defaults
     #   @option params [Hash, Array, String, Boolean, Numeric] :document_value
     # @!attribute document_value
     #   @return [Hash, Array, String, Boolean, Numeric]
-    DocumentTypeAsPayloadOutput = ::Struct.new(
-      :document_value,
-      keyword_init: true
-    ) do
+    class DocumentTypeAsPayloadOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        document_value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -463,12 +506,15 @@ def _defaults
     #   @return [String]
     # @!attribute document_value
     #   @return [Hash, Array, String, Boolean, Numeric]
-    DocumentTypeInput = ::Struct.new(
-      :string_value,
-      :document_value,
-      keyword_init: true
-    ) do
+    class DocumentTypeInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        string_value
+        document_value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -479,48 +525,55 @@ def _defaults
     #   @return [String]
     # @!attribute document_value
     #   @return [Hash, Array, String, Boolean, Numeric]
-    DocumentTypeOutput = ::Struct.new(
-      :string_value,
-      :document_value,
-      keyword_init: true
-    ) do
+    class DocumentTypeOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        string_value
+        document_value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    EmptyInputAndEmptyOutputInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class EmptyInputAndEmptyOutputInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    EmptyInputAndEmptyOutputOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class EmptyInputAndEmptyOutputOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    EndpointOperationInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class EndpointOperationInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    EndpointOperationOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class EndpointOperationOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -528,20 +581,24 @@ def _defaults
     #   @option params [String] :label
     # @!attribute label
     #   @return [String]
-    EndpointWithHostLabelOperationInput = ::Struct.new(
-      :label,
-      keyword_init: true
-    ) do
+    class EndpointWithHostLabelOperationInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        label
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    EndpointWithHostLabelOperationOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class EndpointWithHostLabelOperationOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -549,12 +606,15 @@ def _defaults
     #   @option params [String] :phrase
     # @!attribute phrase
     #   @return [String]
-    Farewell = ::Struct.new(
-      :phrase,
-      keyword_init: true
-    ) do
+    class Farewell
       include Hearth::Structure
 
+      MEMBERS = %i[
+        phrase
+      ].freeze
+
+      attr_accessor(*MEMBERS)
+
       private
 
       def _defaults
@@ -579,11 +639,12 @@ module FooEnum
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    FractionalSecondsInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class FractionalSecondsInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -591,11 +652,14 @@ module FooEnum
     #   @option params [Time] :datetime
     # @!attribute datetime
     #   @return [Time]
-    FractionalSecondsOutput = ::Struct.new(
-      :datetime,
-      keyword_init: true
-    ) do
+    class FractionalSecondsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        datetime
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -603,20 +667,24 @@ module FooEnum
     #   @option params [String] :hi
     # @!attribute hi
     #   @return [String]
-    GreetingStruct = ::Struct.new(
-      :hi,
-      keyword_init: true
-    ) do
+    class GreetingStruct
       include Hearth::Structure
+
+      MEMBERS = %i[
+        hi
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    GreetingWithErrorsInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class GreetingWithErrorsInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -624,29 +692,34 @@ module FooEnum
     #   @option params [String] :greeting
     # @!attribute greeting
     #   @return [String]
-    GreetingWithErrorsOutput = ::Struct.new(
-      :greeting,
-      keyword_init: true
-    ) do
+    class GreetingWithErrorsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        greeting
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HostWithPathOperationInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HostWithPathOperationInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HostWithPathOperationOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HostWithPathOperationOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -654,11 +727,14 @@ module FooEnum
     #   @option params [String] :foo
     # @!attribute foo
     #   @return [String]
-    HttpChecksumRequiredInput = ::Struct.new(
-      :foo,
-      keyword_init: true
-    ) do
+    class HttpChecksumRequiredInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -666,11 +742,14 @@ module FooEnum
     #   @option params [String] :foo
     # @!attribute foo
     #   @return [String]
-    HttpChecksumRequiredOutput = ::Struct.new(
-      :foo,
-      keyword_init: true
-    ) do
+    class HttpChecksumRequiredOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -679,11 +758,14 @@ module FooEnum
     # @!attribute payload
     #   Enum, one of: ["enumvalue"]
     #   @return [String]
-    HttpEnumPayloadInput = ::Struct.new(
-      :payload,
-      keyword_init: true
-    ) do
+    class HttpEnumPayloadInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        payload
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -692,11 +774,14 @@ module FooEnum
     # @!attribute payload
     #   Enum, one of: ["enumvalue"]
     #   @return [String]
-    HttpEnumPayloadOutput = ::Struct.new(
-      :payload,
-      keyword_init: true
-    ) do
+    class HttpEnumPayloadOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        payload
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -707,12 +792,15 @@ module FooEnum
     #   @return [String]
     # @!attribute blob
     #   @return [String]
-    HttpPayloadTraitsInput = ::Struct.new(
-      :foo,
-      :blob,
-      keyword_init: true
-    ) do
+    class HttpPayloadTraitsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        blob
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -723,12 +811,15 @@ module FooEnum
     #   @return [String]
     # @!attribute blob
     #   @return [String]
-    HttpPayloadTraitsOutput = ::Struct.new(
-      :foo,
-      :blob,
-      keyword_init: true
-    ) do
+    class HttpPayloadTraitsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        blob
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -739,12 +830,15 @@ module FooEnum
     #   @return [String]
     # @!attribute blob
     #   @return [String]
-    HttpPayloadTraitsWithMediaTypeInput = ::Struct.new(
-      :foo,
-      :blob,
-      keyword_init: true
-    ) do
+    class HttpPayloadTraitsWithMediaTypeInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        blob
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -755,12 +849,15 @@ module FooEnum
     #   @return [String]
     # @!attribute blob
     #   @return [String]
-    HttpPayloadTraitsWithMediaTypeOutput = ::Struct.new(
-      :foo,
-      :blob,
-      keyword_init: true
-    ) do
+    class HttpPayloadTraitsWithMediaTypeOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        blob
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -768,11 +865,14 @@ module FooEnum
     #   @option params [NestedPayload] :nested
     # @!attribute nested
     #   @return [NestedPayload]
-    HttpPayloadWithStructureInput = ::Struct.new(
-      :nested,
-      keyword_init: true
-    ) do
+    class HttpPayloadWithStructureInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        nested
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -780,11 +880,14 @@ module FooEnum
     #   @option params [NestedPayload] :nested
     # @!attribute nested
     #   @return [NestedPayload]
-    HttpPayloadWithStructureOutput = ::Struct.new(
-      :nested,
-      keyword_init: true
-    ) do
+    class HttpPayloadWithStructureOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        nested
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -792,11 +895,14 @@ module FooEnum
     #   @option params [UnionPayload] :nested
     # @!attribute nested
     #   @return [UnionPayload]
-    HttpPayloadWithUnionInput = ::Struct.new(
-      :nested,
-      keyword_init: true
-    ) do
+    class HttpPayloadWithUnionInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        nested
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -804,20 +910,24 @@ module FooEnum
     #   @option params [UnionPayload] :nested
     # @!attribute nested
     #   @return [UnionPayload]
-    HttpPayloadWithUnionOutput = ::Struct.new(
-      :nested,
-      keyword_init: true
-    ) do
+    class HttpPayloadWithUnionOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        nested
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpPrefixHeadersInResponseInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpPrefixHeadersInResponseInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -825,11 +935,14 @@ module FooEnum
     #   @option params [Hash<String, String>] :prefix_headers
     # @!attribute prefix_headers
     #   @return [Hash<String, String>]
-    HttpPrefixHeadersInResponseOutput = ::Struct.new(
-      :prefix_headers,
-      keyword_init: true
-    ) do
+    class HttpPrefixHeadersInResponseOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        prefix_headers
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -840,12 +953,15 @@ module FooEnum
     #   @return [String]
     # @!attribute foo_map
     #   @return [Hash<String, String>]
-    HttpPrefixHeadersInput = ::Struct.new(
-      :foo,
-      :foo_map,
-      keyword_init: true
-    ) do
+    class HttpPrefixHeadersInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        foo_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -856,12 +972,15 @@ module FooEnum
     #   @return [String]
     # @!attribute foo_map
     #   @return [Hash<String, String>]
-    HttpPrefixHeadersOutput = ::Struct.new(
-      :foo,
-      :foo_map,
-      keyword_init: true
-    ) do
+    class HttpPrefixHeadersOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        foo_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -872,21 +991,25 @@ module FooEnum
     #   @return [Float]
     # @!attribute double
     #   @return [Float]
-    HttpRequestWithFloatLabelsInput = ::Struct.new(
-      :float,
-      :double,
-      keyword_init: true
-    ) do
+    class HttpRequestWithFloatLabelsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        float
+        double
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpRequestWithFloatLabelsOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpRequestWithFloatLabelsOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -897,21 +1020,25 @@ module FooEnum
     #   @return [String]
     # @!attribute baz
     #   @return [String]
-    HttpRequestWithGreedyLabelInPathInput = ::Struct.new(
-      :foo,
-      :baz,
-      keyword_init: true
-    ) do
+    class HttpRequestWithGreedyLabelInPathInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        baz
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpRequestWithGreedyLabelInPathOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpRequestWithGreedyLabelInPathOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -937,26 +1064,30 @@ module FooEnum
     #   @return [Time]
     # @!attribute target_date_time
     #   @return [Time]
-    HttpRequestWithLabelsAndTimestampFormatInput = ::Struct.new(
-      :member_epoch_seconds,
-      :member_http_date,
-      :member_date_time,
-      :default_format,
-      :target_epoch_seconds,
-      :target_http_date,
-      :target_date_time,
-      keyword_init: true
-    ) do
+    class HttpRequestWithLabelsAndTimestampFormatInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        member_epoch_seconds
+        member_http_date
+        member_date_time
+        default_format
+        target_epoch_seconds
+        target_http_date
+        target_date_time
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpRequestWithLabelsAndTimestampFormatOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpRequestWithLabelsAndTimestampFormatOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -987,27 +1118,31 @@ module FooEnum
     # @!attribute timestamp
     #   Note that this member has no format, so it's serialized as an RFC 3399 date-time.
     #   @return [Time]
-    HttpRequestWithLabelsInput = ::Struct.new(
-      :string,
-      :short,
-      :integer,
-      :long,
-      :float,
-      :double,
-      :boolean,
-      :timestamp,
-      keyword_init: true
-    ) do
+    class HttpRequestWithLabelsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        string
+        short
+        integer
+        long
+        float
+        double
+        boolean
+        timestamp
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpRequestWithLabelsOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpRequestWithLabelsOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1015,29 +1150,34 @@ module FooEnum
     #   @option params [String] :str
     # @!attribute str
     #   @return [String]
-    HttpRequestWithRegexLiteralInput = ::Struct.new(
-      :str,
-      keyword_init: true
-    ) do
+    class HttpRequestWithRegexLiteralInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        str
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpRequestWithRegexLiteralOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpRequestWithRegexLiteralOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpResponseCodeInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpResponseCodeInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1045,11 +1185,14 @@ module FooEnum
     #   @option params [Integer] :status
     # @!attribute status
     #   @return [Integer]
-    HttpResponseCodeOutput = ::Struct.new(
-      :status,
-      keyword_init: true
-    ) do
+    class HttpResponseCodeOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        status
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1057,11 +1200,14 @@ module FooEnum
     #   @option params [String] :payload
     # @!attribute payload
     #   @return [String]
-    HttpStringPayloadInput = ::Struct.new(
-      :payload,
-      keyword_init: true
-    ) do
+    class HttpStringPayloadInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        payload
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1069,20 +1215,24 @@ module FooEnum
     #   @option params [String] :payload
     # @!attribute payload
     #   @return [String]
-    HttpStringPayloadOutput = ::Struct.new(
-      :payload,
-      keyword_init: true
-    ) do
+    class HttpStringPayloadOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        payload
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    IgnoreQueryParamsInResponseInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class IgnoreQueryParamsInResponseInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1090,11 +1240,14 @@ module FooEnum
     #   @option params [String] :baz
     # @!attribute baz
     #   @return [String]
-    IgnoreQueryParamsInResponseOutput = ::Struct.new(
-      :baz,
-      keyword_init: true
-    ) do
+    class IgnoreQueryParamsInResponseOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        baz
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1154,28 +1307,31 @@ module FooEnum
     #   @return [Integer]
     # @!attribute header_integer_enum_list
     #   @return [Array<Integer>]
-    InputAndOutputWithHeadersInput = ::Struct.new(
-      :header_string,
-      :header_byte,
-      :header_short,
-      :header_integer,
-      :header_long,
-      :header_float,
-      :header_double,
-      :header_true_bool,
-      :header_false_bool,
-      :header_string_list,
-      :header_string_set,
-      :header_integer_list,
-      :header_boolean_list,
-      :header_timestamp_list,
-      :header_enum,
-      :header_enum_list,
-      :header_integer_enum,
-      :header_integer_enum_list,
-      keyword_init: true
-    ) do
+    class InputAndOutputWithHeadersInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        header_string
+        header_byte
+        header_short
+        header_integer
+        header_long
+        header_float
+        header_double
+        header_true_bool
+        header_false_bool
+        header_string_list
+        header_string_set
+        header_integer_list
+        header_boolean_list
+        header_timestamp_list
+        header_enum
+        header_enum_list
+        header_integer_enum
+        header_integer_enum_list
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1235,28 +1391,31 @@ module FooEnum
     #   @return [Integer]
     # @!attribute header_integer_enum_list
     #   @return [Array<Integer>]
-    InputAndOutputWithHeadersOutput = ::Struct.new(
-      :header_string,
-      :header_byte,
-      :header_short,
-      :header_integer,
-      :header_long,
-      :header_float,
-      :header_double,
-      :header_true_bool,
-      :header_false_bool,
-      :header_string_list,
-      :header_string_set,
-      :header_integer_list,
-      :header_boolean_list,
-      :header_timestamp_list,
-      :header_enum,
-      :header_enum_list,
-      :header_integer_enum,
-      :header_integer_enum_list,
-      keyword_init: true
-    ) do
-      include Hearth::Structure
+    class InputAndOutputWithHeadersOutput
+      include Hearth::Structure
+
+      MEMBERS = %i[
+        header_string
+        header_byte
+        header_short
+        header_integer
+        header_long
+        header_float
+        header_double
+        header_true_bool
+        header_false_bool
+        header_string_list
+        header_string_set
+        header_integer_list
+        header_boolean_list
+        header_timestamp_list
+        header_enum
+        header_enum_list
+        header_integer_enum
+        header_integer_enum_list
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # Enum constants for IntegerEnum
@@ -1274,11 +1433,14 @@ module IntegerEnum
     #   @option params [String] :message
     # @!attribute message
     #   @return [String]
-    InvalidGreeting = ::Struct.new(
-      :message,
-      keyword_init: true
-    ) do
+    class InvalidGreeting
       include Hearth::Structure
+
+      MEMBERS = %i[
+        message
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1286,11 +1448,14 @@ module IntegerEnum
     #   @option params [String] :data
     # @!attribute data
     #   @return [String]
-    JsonBlobsInput = ::Struct.new(
-      :data,
-      keyword_init: true
-    ) do
+    class JsonBlobsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        data
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1298,11 +1463,14 @@ module IntegerEnum
     #   @option params [String] :data
     # @!attribute data
     #   @return [String]
-    JsonBlobsOutput = ::Struct.new(
-      :data,
-      keyword_init: true
-    ) do
+    class JsonBlobsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        data
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1328,16 +1496,19 @@ module IntegerEnum
     #   @return [Array<String>]
     # @!attribute foo_enum_map
     #   @return [Hash<String, String>]
-    JsonEnumsInput = ::Struct.new(
-      :foo_enum1,
-      :foo_enum2,
-      :foo_enum3,
-      :foo_enum_list,
-      :foo_enum_set,
-      :foo_enum_map,
-      keyword_init: true
-    ) do
+    class JsonEnumsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo_enum1
+        foo_enum2
+        foo_enum3
+        foo_enum_list
+        foo_enum_set
+        foo_enum_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1363,16 +1534,19 @@ module IntegerEnum
     #   @return [Array<String>]
     # @!attribute foo_enum_map
     #   @return [Hash<String, String>]
-    JsonEnumsOutput = ::Struct.new(
-      :foo_enum1,
-      :foo_enum2,
-      :foo_enum3,
-      :foo_enum_list,
-      :foo_enum_set,
-      :foo_enum_map,
-      keyword_init: true
-    ) do
+    class JsonEnumsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo_enum1
+        foo_enum2
+        foo_enum3
+        foo_enum_list
+        foo_enum_set
+        foo_enum_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1395,16 +1569,19 @@ module IntegerEnum
     #   @return [Array<Integer>]
     # @!attribute integer_enum_map
     #   @return [Hash<String, Integer>]
-    JsonIntEnumsInput = ::Struct.new(
-      :integer_enum1,
-      :integer_enum2,
-      :integer_enum3,
-      :integer_enum_list,
-      :integer_enum_set,
-      :integer_enum_map,
-      keyword_init: true
-    ) do
+    class JsonIntEnumsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        integer_enum1
+        integer_enum2
+        integer_enum3
+        integer_enum_list
+        integer_enum_set
+        integer_enum_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1427,16 +1604,19 @@ module IntegerEnum
     #   @return [Array<Integer>]
     # @!attribute integer_enum_map
     #   @return [Hash<String, Integer>]
-    JsonIntEnumsOutput = ::Struct.new(
-      :integer_enum1,
-      :integer_enum2,
-      :integer_enum3,
-      :integer_enum_list,
-      :integer_enum_set,
-      :integer_enum_map,
-      keyword_init: true
-    ) do
+    class JsonIntEnumsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        integer_enum1
+        integer_enum2
+        integer_enum3
+        integer_enum_list
+        integer_enum_set
+        integer_enum_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1469,19 +1649,22 @@ module IntegerEnum
     #   @return [Array<Array<String>>]
     # @!attribute structure_list
     #   @return [Array<StructureListMember>]
-    JsonListsInput = ::Struct.new(
-      :string_list,
-      :string_set,
-      :integer_list,
-      :boolean_list,
-      :timestamp_list,
-      :enum_list,
-      :int_enum_list,
-      :nested_string_list,
-      :structure_list,
-      keyword_init: true
-    ) do
+    class JsonListsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        string_list
+        string_set
+        integer_list
+        boolean_list
+        timestamp_list
+        enum_list
+        int_enum_list
+        nested_string_list
+        structure_list
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1514,19 +1697,22 @@ module IntegerEnum
     #   @return [Array<Array<String>>]
     # @!attribute structure_list
     #   @return [Array<StructureListMember>]
-    JsonListsOutput = ::Struct.new(
-      :string_list,
-      :string_set,
-      :integer_list,
-      :boolean_list,
-      :timestamp_list,
-      :enum_list,
-      :int_enum_list,
-      :nested_string_list,
-      :structure_list,
-      keyword_init: true
-    ) do
+    class JsonListsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        string_list
+        string_set
+        integer_list
+        boolean_list
+        timestamp_list
+        enum_list
+        int_enum_list
+        nested_string_list
+        structure_list
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1546,15 +1732,18 @@ module IntegerEnum
     #   @return [Hash<String, String>]
     # @!attribute dense_set_map
     #   @return [Hash<String, Array<String>>]
-    JsonMapsInput = ::Struct.new(
-      :dense_struct_map,
-      :dense_number_map,
-      :dense_boolean_map,
-      :dense_string_map,
-      :dense_set_map,
-      keyword_init: true
-    ) do
+    class JsonMapsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        dense_struct_map
+        dense_number_map
+        dense_boolean_map
+        dense_string_map
+        dense_set_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1574,15 +1763,18 @@ module IntegerEnum
     #   @return [Hash<String, String>]
     # @!attribute dense_set_map
     #   @return [Hash<String, Array<String>>]
-    JsonMapsOutput = ::Struct.new(
-      :dense_struct_map,
-      :dense_number_map,
-      :dense_boolean_map,
-      :dense_string_map,
-      :dense_set_map,
-      keyword_init: true
-    ) do
+    class JsonMapsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        dense_struct_map
+        dense_number_map
+        dense_boolean_map
+        dense_string_map
+        dense_set_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1608,17 +1800,20 @@ module IntegerEnum
     #   @return [Time]
     # @!attribute http_date_on_target
     #   @return [Time]
-    JsonTimestampsInput = ::Struct.new(
-      :normal,
-      :date_time,
-      :date_time_on_target,
-      :epoch_seconds,
-      :epoch_seconds_on_target,
-      :http_date,
-      :http_date_on_target,
-      keyword_init: true
-    ) do
+    class JsonTimestampsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        normal
+        date_time
+        date_time_on_target
+        epoch_seconds
+        epoch_seconds_on_target
+        http_date
+        http_date_on_target
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1644,17 +1839,20 @@ module IntegerEnum
     #   @return [Time]
     # @!attribute http_date_on_target
     #   @return [Time]
-    JsonTimestampsOutput = ::Struct.new(
-      :normal,
-      :date_time,
-      :date_time_on_target,
-      :epoch_seconds,
-      :epoch_seconds_on_target,
-      :http_date,
-      :http_date_on_target,
-      keyword_init: true
-    ) do
+    class JsonTimestampsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        normal
+        date_time
+        date_time_on_target
+        epoch_seconds
+        epoch_seconds_on_target
+        http_date
+        http_date_on_target
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # A shared structure that contains a single union member.
@@ -1664,11 +1862,14 @@ module IntegerEnum
     # @!attribute contents
     #   A union with a representative set of types for members.
     #   @return [MyUnion]
-    JsonUnionsInput = ::Struct.new(
-      :contents,
-      keyword_init: true
-    ) do
+    class JsonUnionsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        contents
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # A shared structure that contains a single union member.
@@ -1678,11 +1879,14 @@ module IntegerEnum
     # @!attribute contents
     #   A union with a representative set of types for members.
     #   @return [MyUnion]
-    JsonUnionsOutput = ::Struct.new(
-      :contents,
-      keyword_init: true
-    ) do
+    class JsonUnionsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        contents
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1690,11 +1894,14 @@ module IntegerEnum
     #   @option params [String] :json
     # @!attribute json
     #   @return [String]
-    MediaTypeHeaderInput = ::Struct.new(
-      :json,
-      keyword_init: true
-    ) do
+    class MediaTypeHeaderInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        json
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1702,11 +1909,14 @@ module IntegerEnum
     #   @option params [String] :json
     # @!attribute json
     #   @return [String]
-    MediaTypeHeaderOutput = ::Struct.new(
-      :json,
-      keyword_init: true
-    ) do
+    class MediaTypeHeaderOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        json
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # A union with a representative set of types for members.
@@ -1835,48 +2045,55 @@ def to_s
     #   @return [String]
     # @!attribute name
     #   @return [String]
-    NestedPayload = ::Struct.new(
-      :greeting,
-      :name,
-      keyword_init: true
-    ) do
+    class NestedPayload
       include Hearth::Structure
+
+      MEMBERS = %i[
+        greeting
+        name
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    NoInputAndNoOutputInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class NoInputAndNoOutputInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    NoInputAndNoOutputOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class NoInputAndNoOutputOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    NoInputAndOutputInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class NoInputAndOutputInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    NoInputAndOutputOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class NoInputAndOutputOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1890,13 +2107,16 @@ def to_s
     #   @return [String]
     # @!attribute c
     #   @return [Array<String>]
-    NullAndEmptyHeadersClientInput = ::Struct.new(
-      :a,
-      :b,
-      :c,
-      keyword_init: true
-    ) do
+    class NullAndEmptyHeadersClientInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        a
+        b
+        c
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1910,13 +2130,16 @@ def to_s
     #   @return [String]
     # @!attribute c
     #   @return [Array<String>]
-    NullAndEmptyHeadersClientOutput = ::Struct.new(
-      :a,
-      :b,
-      :c,
-      keyword_init: true
-    ) do
+    class NullAndEmptyHeadersClientOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        a
+        b
+        c
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1930,13 +2153,16 @@ def to_s
     #   @return [String]
     # @!attribute c
     #   @return [Array<String>]
-    NullAndEmptyHeadersServerInput = ::Struct.new(
-      :a,
-      :b,
-      :c,
-      keyword_init: true
-    ) do
+    class NullAndEmptyHeadersServerInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        a
+        b
+        c
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1950,13 +2176,16 @@ def to_s
     #   @return [String]
     # @!attribute c
     #   @return [Array<String>]
-    NullAndEmptyHeadersServerOutput = ::Struct.new(
-      :a,
-      :b,
-      :c,
-      keyword_init: true
-    ) do
+    class NullAndEmptyHeadersServerOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        a
+        b
+        c
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1967,21 +2196,25 @@ def to_s
     #   @return [String]
     # @!attribute empty_string
     #   @return [String]
-    OmitsNullSerializesEmptyStringInput = ::Struct.new(
-      :null_value,
-      :empty_string,
-      keyword_init: true
-    ) do
+    class OmitsNullSerializesEmptyStringInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        null_value
+        empty_string
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    OmitsNullSerializesEmptyStringOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class OmitsNullSerializesEmptyStringOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2007,26 +2240,30 @@ def to_s
     #   @return [Array<String>]
     # @!attribute query_integer_enum_list
     #   @return [Array<Integer>]
-    OmitsSerializingEmptyListsInput = ::Struct.new(
-      :query_string_list,
-      :query_integer_list,
-      :query_double_list,
-      :query_boolean_list,
-      :query_timestamp_list,
-      :query_enum_list,
-      :query_integer_enum_list,
-      keyword_init: true
-    ) do
+    class OmitsSerializingEmptyListsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        query_string_list
+        query_integer_list
+        query_double_list
+        query_boolean_list
+        query_timestamp_list
+        query_enum_list
+        query_integer_enum_list
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    OmitsSerializingEmptyListsOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class OmitsSerializingEmptyListsOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2043,14 +2280,17 @@ def to_s
     #   @return [String]
     # @!attribute other_top_level_default
     #   @return [Integer]
-    OperationWithDefaultsInput = ::Struct.new(
-      :defaults,
-      :client_optional_defaults,
-      :top_level_default,
-      :other_top_level_default,
-      keyword_init: true
-    ) do
+    class OperationWithDefaultsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        defaults
+        client_optional_defaults
+        top_level_default
+        other_top_level_default
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2140,38 +2380,41 @@ def to_s
     #   @return [Float]
     # @!attribute zero_double
     #   @return [Float]
-    OperationWithDefaultsOutput = ::Struct.new(
-      :default_string,
-      :default_boolean,
-      :default_list,
-      :default_document_map,
-      :default_document_string,
-      :default_document_boolean,
-      :default_document_list,
-      :default_null_document,
-      :default_timestamp,
-      :default_blob,
-      :default_byte,
-      :default_short,
-      :default_integer,
-      :default_long,
-      :default_float,
-      :default_double,
-      :default_map,
-      :default_enum,
-      :default_int_enum,
-      :empty_string,
-      :false_boolean,
-      :empty_blob,
-      :zero_byte,
-      :zero_short,
-      :zero_integer,
-      :zero_long,
-      :zero_float,
-      :zero_double,
-      keyword_init: true
-    ) do
-      include Hearth::Structure
+    class OperationWithDefaultsOutput
+      include Hearth::Structure
+
+      MEMBERS = %i[
+        default_string
+        default_boolean
+        default_list
+        default_document_map
+        default_document_string
+        default_document_boolean
+        default_document_list
+        default_null_document
+        default_timestamp
+        default_blob
+        default_byte
+        default_short
+        default_integer
+        default_long
+        default_float
+        default_double
+        default_map
+        default_enum
+        default_int_enum
+        empty_string
+        false_boolean
+        empty_blob
+        zero_byte
+        zero_short
+        zero_integer
+        zero_long
+        zero_float
+        zero_double
+      ].freeze
+
+      attr_accessor(*MEMBERS)
 
       private
 
@@ -2213,11 +2456,14 @@ def _defaults
     #   @option params [TopLevel] :top_level
     # @!attribute top_level
     #   @return [TopLevel]
-    OperationWithNestedStructureInput = ::Struct.new(
-      :top_level,
-      keyword_init: true
-    ) do
+    class OperationWithNestedStructureInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        top_level
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2231,14 +2477,17 @@ def _defaults
     #   @return [Array<Dialog>]
     # @!attribute dialog_map
     #   @return [Hash<String, Dialog>]
-    OperationWithNestedStructureOutput = ::Struct.new(
-      :dialog,
-      :dialog_list,
-      :dialog_map,
-      keyword_init: true
-    ) do
+    class OperationWithNestedStructureOutput
       include Hearth::Structure
 
+      MEMBERS = %i[
+        dialog
+        dialog_list
+        dialog_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
+
       private
 
       def _defaults
@@ -2254,11 +2503,14 @@ def _defaults
     #   @option params [Integer] :data
     # @!attribute data
     #   @return [Integer]
-    PayloadConfig = ::Struct.new(
-      :data,
-      keyword_init: true
-    ) do
+    class PayloadConfig
       include Hearth::Structure
+
+      MEMBERS = %i[
+        data
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     class PlayerAction < Hearth::Union
@@ -2293,11 +2545,14 @@ def to_s
     #   @option params [PlayerAction] :action
     # @!attribute action
     #   @return [PlayerAction]
-    PostPlayerActionInput = ::Struct.new(
-      :action,
-      keyword_init: true
-    ) do
+    class PostPlayerActionInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        action
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2305,11 +2560,14 @@ def to_s
     #   @option params [PlayerAction] :action
     # @!attribute action
     #   @return [PlayerAction]
-    PostPlayerActionOutput = ::Struct.new(
-      :action,
-      keyword_init: true
-    ) do
+    class PostPlayerActionOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        action
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2317,11 +2575,14 @@ def to_s
     #   @option params [UnionWithJsonName] :value
     # @!attribute value
     #   @return [UnionWithJsonName]
-    PostUnionWithJsonNameInput = ::Struct.new(
-      :value,
-      keyword_init: true
-    ) do
+    class PostUnionWithJsonNameInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2329,11 +2590,14 @@ def to_s
     #   @option params [UnionWithJsonName] :value
     # @!attribute value
     #   @return [UnionWithJsonName]
-    PostUnionWithJsonNameOutput = ::Struct.new(
-      :value,
-      keyword_init: true
-    ) do
+    class PostUnionWithJsonNameOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2344,21 +2608,25 @@ def to_s
     #   @return [String]
     # @!attribute data
     #   @return [String]
-    PutWithContentEncodingInput = ::Struct.new(
-      :encoding,
-      :data,
-      keyword_init: true
-    ) do
+    class PutWithContentEncodingInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        encoding
+        data
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    PutWithContentEncodingOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class PutWithContentEncodingOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2366,20 +2634,24 @@ def to_s
     #   @option params [String] :token
     # @!attribute token
     #   @return [String]
-    QueryIdempotencyTokenAutoFillInput = ::Struct.new(
-      :token,
-      keyword_init: true
-    ) do
+    class QueryIdempotencyTokenAutoFillInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        token
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    QueryIdempotencyTokenAutoFillOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class QueryIdempotencyTokenAutoFillOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2390,21 +2662,25 @@ def to_s
     #   @return [String]
     # @!attribute foo
     #   @return [Hash<String, Array<String>>]
-    QueryParamsAsStringListMapInput = ::Struct.new(
-      :qux,
-      :foo,
-      keyword_init: true
-    ) do
+    class QueryParamsAsStringListMapInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        qux
+        foo
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    QueryParamsAsStringListMapOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class QueryParamsAsStringListMapOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2415,21 +2691,25 @@ def to_s
     #   @return [String]
     # @!attribute baz
     #   @return [Hash<String, String>]
-    QueryPrecedenceInput = ::Struct.new(
-      :foo,
-      :baz,
-      keyword_init: true
-    ) do
+    class QueryPrecedenceInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        baz
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    QueryPrecedenceOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class QueryPrecedenceOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2437,11 +2717,14 @@ def to_s
     #   @option params [RecursiveShapesInputOutputNested1] :nested
     # @!attribute nested
     #   @return [RecursiveShapesInputOutputNested1]
-    RecursiveShapesInput = ::Struct.new(
-      :nested,
-      keyword_init: true
-    ) do
+    class RecursiveShapesInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        nested
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2452,12 +2735,15 @@ def to_s
     #   @return [String]
     # @!attribute nested
     #   @return [RecursiveShapesInputOutputNested2]
-    RecursiveShapesInputOutputNested1 = ::Struct.new(
-      :foo,
-      :nested,
-      keyword_init: true
-    ) do
+    class RecursiveShapesInputOutputNested1
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        nested
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2468,12 +2754,15 @@ def to_s
     #   @return [String]
     # @!attribute recursive_member
     #   @return [RecursiveShapesInputOutputNested1]
-    RecursiveShapesInputOutputNested2 = ::Struct.new(
-      :bar,
-      :recursive_member,
-      keyword_init: true
-    ) do
+    class RecursiveShapesInputOutputNested2
       include Hearth::Structure
+
+      MEMBERS = %i[
+        bar
+        recursive_member
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2481,11 +2770,14 @@ def to_s
     #   @option params [RecursiveShapesInputOutputNested1] :nested
     # @!attribute nested
     #   @return [RecursiveShapesInputOutputNested1]
-    RecursiveShapesOutput = ::Struct.new(
-      :nested,
-      keyword_init: true
-    ) do
+    class RecursiveShapesOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        nested
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2493,11 +2785,14 @@ def to_s
     #   @option params [String] :salutation
     # @!attribute salutation
     #   @return [String]
-    RenamedGreeting = ::Struct.new(
-      :salutation,
-      keyword_init: true
-    ) do
+    class RenamedGreeting
       include Hearth::Structure
+
+      MEMBERS = %i[
+        salutation
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2532,20 +2827,23 @@ def to_s
     #   @return [Float]
     # @!attribute double_value
     #   @return [Float]
-    SimpleScalarPropertiesInput = ::Struct.new(
-      :foo,
-      :string_value,
-      :true_boolean_value,
-      :false_boolean_value,
-      :byte_value,
-      :short_value,
-      :integer_value,
-      :long_value,
-      :float_value,
-      :double_value,
-      keyword_init: true
-    ) do
+    class SimpleScalarPropertiesInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        string_value
+        true_boolean_value
+        false_boolean_value
+        byte_value
+        short_value
+        integer_value
+        long_value
+        float_value
+        double_value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2580,20 +2878,23 @@ def to_s
     #   @return [Float]
     # @!attribute double_value
     #   @return [Float]
-    SimpleScalarPropertiesOutput = ::Struct.new(
-      :foo,
-      :string_value,
-      :true_boolean_value,
-      :false_boolean_value,
-      :byte_value,
-      :short_value,
-      :integer_value,
-      :long_value,
-      :float_value,
-      :double_value,
-      keyword_init: true
-    ) do
+    class SimpleScalarPropertiesOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        string_value
+        true_boolean_value
+        false_boolean_value
+        byte_value
+        short_value
+        integer_value
+        long_value
+        float_value
+        double_value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2601,11 +2902,14 @@ def to_s
     #   @option params [Array<String>] :sparse_string_list
     # @!attribute sparse_string_list
     #   @return [Array<String>]
-    SparseJsonListsInput = ::Struct.new(
-      :sparse_string_list,
-      keyword_init: true
-    ) do
+    class SparseJsonListsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        sparse_string_list
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2613,11 +2917,14 @@ def to_s
     #   @option params [Array<String>] :sparse_string_list
     # @!attribute sparse_string_list
     #   @return [Array<String>]
-    SparseJsonListsOutput = ::Struct.new(
-      :sparse_string_list,
-      keyword_init: true
-    ) do
+    class SparseJsonListsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        sparse_string_list
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2637,15 +2944,18 @@ def to_s
     #   @return [Hash<String, String>]
     # @!attribute sparse_set_map
     #   @return [Hash<String, Array<String>>]
-    SparseJsonMapsInput = ::Struct.new(
-      :sparse_struct_map,
-      :sparse_number_map,
-      :sparse_boolean_map,
-      :sparse_string_map,
-      :sparse_set_map,
-      keyword_init: true
-    ) do
+    class SparseJsonMapsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        sparse_struct_map
+        sparse_number_map
+        sparse_boolean_map
+        sparse_string_map
+        sparse_set_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2665,53 +2975,62 @@ def to_s
     #   @return [Hash<String, String>]
     # @!attribute sparse_set_map
     #   @return [Hash<String, Array<String>>]
-    SparseJsonMapsOutput = ::Struct.new(
-      :sparse_struct_map,
-      :sparse_number_map,
-      :sparse_boolean_map,
-      :sparse_string_map,
-      :sparse_set_map,
-      keyword_init: true
-    ) do
+    class SparseJsonMapsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        sparse_struct_map
+        sparse_number_map
+        sparse_boolean_map
+        sparse_string_map
+        sparse_set_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
     #   @option params [String] :foo
-    #   @option params [String] :blob
+    #   @option params [IO] :blob
     # @!attribute foo
     #   @return [String]
     # @!attribute blob
-    #   @return [String]
-    StreamingTraitsInput = ::Struct.new(
-      :foo,
-      :blob,
-      keyword_init: true
-    ) do
+    #   @return [IO]
+    class StreamingTraitsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        blob
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
     #   @option params [String] :foo
-    #   @option params [String] :blob
+    #   @option params [IO] :blob
     # @!attribute foo
     #   @return [String]
     # @!attribute blob
-    #   @return [String]
-    StreamingTraitsOutput = ::Struct.new(
-      :foo,
-      :blob,
-      keyword_init: true
-    ) do
+    #   @return [IO]
+    class StreamingTraitsOutput
       include Hearth::Structure
 
+      MEMBERS = %i[
+        foo
+        blob
+      ].freeze
+
+      attr_accessor(*MEMBERS)
+
       private
 
       def _defaults
         {
-          blob: ""
+          blob: StringIO.new("")
         }
       end
     end
@@ -2719,64 +3038,74 @@ def _defaults
     # @!method initialize(params = {})
     #   @param [Hash] params
     #   @option params [String] :foo
-    #   @option params [String] :blob
+    #   @option params [IO] :blob
     # @!attribute foo
     #   @return [String]
     # @!attribute blob
-    #   @return [String]
-    StreamingTraitsRequireLengthInput = ::Struct.new(
-      :foo,
-      :blob,
-      keyword_init: true
-    ) do
+    #   @return [IO]
+    class StreamingTraitsRequireLengthInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        blob
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    StreamingTraitsRequireLengthOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class StreamingTraitsRequireLengthOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
     #   @option params [String] :foo
-    #   @option params [String] :blob
+    #   @option params [IO] :blob
     # @!attribute foo
     #   @return [String]
     # @!attribute blob
-    #   @return [String]
-    StreamingTraitsWithMediaTypeInput = ::Struct.new(
-      :foo,
-      :blob,
-      keyword_init: true
-    ) do
+    #   @return [IO]
+    class StreamingTraitsWithMediaTypeInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        blob
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
     #   @option params [String] :foo
-    #   @option params [String] :blob
+    #   @option params [IO] :blob
     # @!attribute foo
     #   @return [String]
     # @!attribute blob
-    #   @return [String]
-    StreamingTraitsWithMediaTypeOutput = ::Struct.new(
-      :foo,
-      :blob,
-      keyword_init: true
-    ) do
+    #   @return [IO]
+    class StreamingTraitsWithMediaTypeOutput
       include Hearth::Structure
 
+      MEMBERS = %i[
+        foo
+        blob
+      ].freeze
+
+      attr_accessor(*MEMBERS)
+
       private
 
       def _defaults
         {
-          blob: ""
+          blob: StringIO.new("")
         }
       end
     end
@@ -2794,12 +3123,15 @@ module StringEnum
     #   @return [String]
     # @!attribute b
     #   @return [String]
-    StructureListMember = ::Struct.new(
-      :a,
-      :b,
-      keyword_init: true
-    ) do
+    class StructureListMember
       include Hearth::Structure
+
+      MEMBERS = %i[
+        a
+        b
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2810,12 +3142,15 @@ module StringEnum
     #   @return [String]
     # @!attribute test_config
     #   @return [TestConfig]
-    TestBodyStructureInput = ::Struct.new(
-      :test_id,
-      :test_config,
-      keyword_init: true
-    ) do
+    class TestBodyStructureInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        test_id
+        test_config
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2826,12 +3161,15 @@ module StringEnum
     #   @return [String]
     # @!attribute test_config
     #   @return [TestConfig]
-    TestBodyStructureOutput = ::Struct.new(
-      :test_id,
-      :test_config,
-      keyword_init: true
-    ) do
+    class TestBodyStructureOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        test_id
+        test_config
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2839,11 +3177,14 @@ module StringEnum
     #   @option params [Integer] :timeout
     # @!attribute timeout
     #   @return [Integer]
-    TestConfig = ::Struct.new(
-      :timeout,
-      keyword_init: true
-    ) do
+    class TestConfig
       include Hearth::Structure
+
+      MEMBERS = %i[
+        timeout
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # Enum constants for TestEnum
@@ -2867,11 +3208,14 @@ module TestIntEnum
     #   @option params [String] :test_id
     # @!attribute test_id
     #   @return [String]
-    TestNoPayloadInput = ::Struct.new(
-      :test_id,
-      keyword_init: true
-    ) do
+    class TestNoPayloadInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        test_id
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2879,11 +3223,14 @@ module TestIntEnum
     #   @option params [String] :test_id
     # @!attribute test_id
     #   @return [String]
-    TestNoPayloadOutput = ::Struct.new(
-      :test_id,
-      keyword_init: true
-    ) do
+    class TestNoPayloadOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        test_id
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2894,12 +3241,15 @@ module TestIntEnum
     #   @return [String]
     # @!attribute data
     #   @return [String]
-    TestPayloadBlobInput = ::Struct.new(
-      :content_type,
-      :data,
-      keyword_init: true
-    ) do
+    class TestPayloadBlobInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        content_type
+        data
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2910,12 +3260,15 @@ module TestIntEnum
     #   @return [String]
     # @!attribute data
     #   @return [String]
-    TestPayloadBlobOutput = ::Struct.new(
-      :content_type,
-      :data,
-      keyword_init: true
-    ) do
+    class TestPayloadBlobOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        content_type
+        data
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2926,12 +3279,15 @@ module TestIntEnum
     #   @return [String]
     # @!attribute payload_config
     #   @return [PayloadConfig]
-    TestPayloadStructureInput = ::Struct.new(
-      :test_id,
-      :payload_config,
-      keyword_init: true
-    ) do
+    class TestPayloadStructureInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        test_id
+        payload_config
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2942,12 +3298,15 @@ module TestIntEnum
     #   @return [String]
     # @!attribute payload_config
     #   @return [PayloadConfig]
-    TestPayloadStructureOutput = ::Struct.new(
-      :test_id,
-      :payload_config,
-      keyword_init: true
-    ) do
+    class TestPayloadStructureOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        test_id
+        payload_config
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -2973,17 +3332,20 @@ module TestIntEnum
     #   @return [Time]
     # @!attribute target_date_time
     #   @return [Time]
-    TimestampFormatHeadersInput = ::Struct.new(
-      :member_epoch_seconds,
-      :member_http_date,
-      :member_date_time,
-      :default_format,
-      :target_epoch_seconds,
-      :target_http_date,
-      :target_date_time,
-      keyword_init: true
-    ) do
+    class TimestampFormatHeadersInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        member_epoch_seconds
+        member_http_date
+        member_date_time
+        default_format
+        target_epoch_seconds
+        target_http_date
+        target_date_time
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -3009,17 +3371,20 @@ module TestIntEnum
     #   @return [Time]
     # @!attribute target_date_time
     #   @return [Time]
-    TimestampFormatHeadersOutput = ::Struct.new(
-      :member_epoch_seconds,
-      :member_http_date,
-      :member_date_time,
-      :default_format,
-      :target_epoch_seconds,
-      :target_http_date,
-      :target_date_time,
-      keyword_init: true
-    ) do
+    class TimestampFormatHeadersOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        member_epoch_seconds
+        member_http_date
+        member_date_time
+        default_format
+        target_epoch_seconds
+        target_http_date
+        target_date_time
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -3033,14 +3398,17 @@ module TestIntEnum
     #   @return [Array<Dialog>]
     # @!attribute dialog_map
     #   @return [Hash<String, Dialog>]
-    TopLevel = ::Struct.new(
-      :dialog,
-      :dialog_list,
-      :dialog_map,
-      keyword_init: true
-    ) do
+    class TopLevel
       include Hearth::Structure
 
+      MEMBERS = %i[
+        dialog
+        dialog_list
+        dialog_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
+
       private
 
       def _defaults
@@ -3125,29 +3493,32 @@ def to_s
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    Unit = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class Unit
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    UnitInputAndOutputInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class UnitInputAndOutputInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    UnitInputAndOutputOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class UnitInputAndOutputOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
   end
diff --git a/codegen/projections/rails_json/lib/rails_json/validators.rb b/codegen/projections/rails_json/lib/rails_json/validators.rb
index e1b2184c7..80c6b0d50 100644
--- a/codegen/projections/rails_json/lib/rails_json/validators.rb
+++ b/codegen/projections/rails_json/lib/rails_json/validators.rb
@@ -16,27 +16,27 @@ module Validators
     class AllQueryStringTypesInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::AllQueryStringTypesInput, context: context)
-        Hearth::Validator.validate_types!(input[:query_string], ::String, context: "#{context}[:query_string]")
-        StringList.validate!(input[:query_string_list], context: "#{context}[:query_string_list]") unless input[:query_string_list].nil?
-        StringSet.validate!(input[:query_string_set], context: "#{context}[:query_string_set]") unless input[:query_string_set].nil?
-        Hearth::Validator.validate_types!(input[:query_byte], ::Integer, context: "#{context}[:query_byte]")
-        Hearth::Validator.validate_types!(input[:query_short], ::Integer, context: "#{context}[:query_short]")
-        Hearth::Validator.validate_types!(input[:query_integer], ::Integer, context: "#{context}[:query_integer]")
-        IntegerList.validate!(input[:query_integer_list], context: "#{context}[:query_integer_list]") unless input[:query_integer_list].nil?
-        IntegerSet.validate!(input[:query_integer_set], context: "#{context}[:query_integer_set]") unless input[:query_integer_set].nil?
-        Hearth::Validator.validate_types!(input[:query_long], ::Integer, context: "#{context}[:query_long]")
-        Hearth::Validator.validate_types!(input[:query_float], ::Float, context: "#{context}[:query_float]")
-        Hearth::Validator.validate_types!(input[:query_double], ::Float, context: "#{context}[:query_double]")
-        DoubleList.validate!(input[:query_double_list], context: "#{context}[:query_double_list]") unless input[:query_double_list].nil?
-        Hearth::Validator.validate_types!(input[:query_boolean], ::TrueClass, ::FalseClass, context: "#{context}[:query_boolean]")
-        BooleanList.validate!(input[:query_boolean_list], context: "#{context}[:query_boolean_list]") unless input[:query_boolean_list].nil?
-        Hearth::Validator.validate_types!(input[:query_timestamp], ::Time, context: "#{context}[:query_timestamp]")
-        TimestampList.validate!(input[:query_timestamp_list], context: "#{context}[:query_timestamp_list]") unless input[:query_timestamp_list].nil?
-        Hearth::Validator.validate_types!(input[:query_enum], ::String, context: "#{context}[:query_enum]")
-        FooEnumList.validate!(input[:query_enum_list], context: "#{context}[:query_enum_list]") unless input[:query_enum_list].nil?
-        Hearth::Validator.validate_types!(input[:query_integer_enum], ::Integer, context: "#{context}[:query_integer_enum]")
-        IntegerEnumList.validate!(input[:query_integer_enum_list], context: "#{context}[:query_integer_enum_list]") unless input[:query_integer_enum_list].nil?
-        StringListMap.validate!(input[:query_params_map_of_string_list], context: "#{context}[:query_params_map_of_string_list]") unless input[:query_params_map_of_string_list].nil?
+        Hearth::Validator.validate_types!(input.query_string, ::String, context: "#{context}[:query_string]")
+        StringList.validate!(input.query_string_list, context: "#{context}[:query_string_list]") unless input.query_string_list.nil?
+        StringSet.validate!(input.query_string_set, context: "#{context}[:query_string_set]") unless input.query_string_set.nil?
+        Hearth::Validator.validate_types!(input.query_byte, ::Integer, context: "#{context}[:query_byte]")
+        Hearth::Validator.validate_types!(input.query_short, ::Integer, context: "#{context}[:query_short]")
+        Hearth::Validator.validate_types!(input.query_integer, ::Integer, context: "#{context}[:query_integer]")
+        IntegerList.validate!(input.query_integer_list, context: "#{context}[:query_integer_list]") unless input.query_integer_list.nil?
+        IntegerSet.validate!(input.query_integer_set, context: "#{context}[:query_integer_set]") unless input.query_integer_set.nil?
+        Hearth::Validator.validate_types!(input.query_long, ::Integer, context: "#{context}[:query_long]")
+        Hearth::Validator.validate_types!(input.query_float, ::Float, context: "#{context}[:query_float]")
+        Hearth::Validator.validate_types!(input.query_double, ::Float, context: "#{context}[:query_double]")
+        DoubleList.validate!(input.query_double_list, context: "#{context}[:query_double_list]") unless input.query_double_list.nil?
+        Hearth::Validator.validate_types!(input.query_boolean, ::TrueClass, ::FalseClass, context: "#{context}[:query_boolean]")
+        BooleanList.validate!(input.query_boolean_list, context: "#{context}[:query_boolean_list]") unless input.query_boolean_list.nil?
+        Hearth::Validator.validate_types!(input.query_timestamp, ::Time, context: "#{context}[:query_timestamp]")
+        TimestampList.validate!(input.query_timestamp_list, context: "#{context}[:query_timestamp_list]") unless input.query_timestamp_list.nil?
+        Hearth::Validator.validate_types!(input.query_enum, ::String, context: "#{context}[:query_enum]")
+        FooEnumList.validate!(input.query_enum_list, context: "#{context}[:query_enum_list]") unless input.query_enum_list.nil?
+        Hearth::Validator.validate_types!(input.query_integer_enum, ::Integer, context: "#{context}[:query_integer_enum]")
+        IntegerEnumList.validate!(input.query_integer_enum_list, context: "#{context}[:query_integer_enum_list]") unless input.query_integer_enum_list.nil?
+        StringListMap.validate!(input.query_params_map_of_string_list, context: "#{context}[:query_params_map_of_string_list]") unless input.query_params_map_of_string_list.nil?
       end
     end
 
@@ -58,31 +58,31 @@ def self.validate!(input, context:)
     class ClientOptionalDefaults
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::ClientOptionalDefaults, context: context)
-        Hearth::Validator.validate_types!(input[:member], ::Integer, context: "#{context}[:member]")
+        Hearth::Validator.validate_types!(input.member, ::Integer, context: "#{context}[:member]")
       end
     end
 
     class ComplexError
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::ComplexError, context: context)
-        Hearth::Validator.validate_types!(input[:header], ::String, context: "#{context}[:header]")
-        Hearth::Validator.validate_types!(input[:top_level], ::String, context: "#{context}[:top_level]")
-        ComplexNestedErrorData.validate!(input[:nested], context: "#{context}[:nested]") unless input[:nested].nil?
+        Hearth::Validator.validate_types!(input.header, ::String, context: "#{context}[:header]")
+        Hearth::Validator.validate_types!(input.top_level, ::String, context: "#{context}[:top_level]")
+        ComplexNestedErrorData.validate!(input.nested, context: "#{context}[:nested]") unless input.nested.nil?
       end
     end
 
     class ComplexNestedErrorData
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::ComplexNestedErrorData, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
       end
     end
 
     class ConstantAndVariableQueryStringInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::ConstantAndVariableQueryStringInput, context: context)
-        Hearth::Validator.validate_types!(input[:baz], ::String, context: "#{context}[:baz]")
-        Hearth::Validator.validate_types!(input[:maybe_set], ::String, context: "#{context}[:maybe_set]")
+        Hearth::Validator.validate_types!(input.baz, ::String, context: "#{context}[:baz]")
+        Hearth::Validator.validate_types!(input.maybe_set, ::String, context: "#{context}[:maybe_set]")
       end
     end
 
@@ -95,8 +95,8 @@ def self.validate!(input, context:)
     class ConstantQueryStringInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::ConstantQueryStringInput, context: context)
-        Hearth::Validator.validate_required!(input[:hello], context: "#{context}[:hello]")
-        Hearth::Validator.validate_types!(input[:hello], ::String, context: "#{context}[:hello]")
+        Hearth::Validator.validate_required!(input.hello, context: "#{context}[:hello]")
+        Hearth::Validator.validate_types!(input.hello, ::String, context: "#{context}[:hello]")
       end
     end
 
@@ -115,41 +115,41 @@ def self.validate!(input, context:)
     class DatetimeOffsetsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::DatetimeOffsetsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:datetime], ::Time, context: "#{context}[:datetime]")
+        Hearth::Validator.validate_types!(input.datetime, ::Time, context: "#{context}[:datetime]")
       end
     end
 
     class Defaults
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::Defaults, context: context)
-        Hearth::Validator.validate_types!(input[:default_string], ::String, context: "#{context}[:default_string]")
-        Hearth::Validator.validate_types!(input[:default_boolean], ::TrueClass, ::FalseClass, context: "#{context}[:default_boolean]")
-        TestStringList.validate!(input[:default_list], context: "#{context}[:default_list]") unless input[:default_list].nil?
-        Document.validate!(input[:default_document_map], context: "#{context}[:default_document_map]") unless input[:default_document_map].nil?
-        Document.validate!(input[:default_document_string], context: "#{context}[:default_document_string]") unless input[:default_document_string].nil?
-        Document.validate!(input[:default_document_boolean], context: "#{context}[:default_document_boolean]") unless input[:default_document_boolean].nil?
-        Document.validate!(input[:default_document_list], context: "#{context}[:default_document_list]") unless input[:default_document_list].nil?
-        Document.validate!(input[:default_null_document], context: "#{context}[:default_null_document]") unless input[:default_null_document].nil?
-        Hearth::Validator.validate_types!(input[:default_timestamp], ::Time, context: "#{context}[:default_timestamp]")
-        Hearth::Validator.validate_types!(input[:default_blob], ::String, context: "#{context}[:default_blob]")
-        Hearth::Validator.validate_types!(input[:default_byte], ::Integer, context: "#{context}[:default_byte]")
-        Hearth::Validator.validate_types!(input[:default_short], ::Integer, context: "#{context}[:default_short]")
-        Hearth::Validator.validate_types!(input[:default_integer], ::Integer, context: "#{context}[:default_integer]")
-        Hearth::Validator.validate_types!(input[:default_long], ::Integer, context: "#{context}[:default_long]")
-        Hearth::Validator.validate_types!(input[:default_float], ::Float, context: "#{context}[:default_float]")
-        Hearth::Validator.validate_types!(input[:default_double], ::Float, context: "#{context}[:default_double]")
-        TestStringMap.validate!(input[:default_map], context: "#{context}[:default_map]") unless input[:default_map].nil?
-        Hearth::Validator.validate_types!(input[:default_enum], ::String, context: "#{context}[:default_enum]")
-        Hearth::Validator.validate_types!(input[:default_int_enum], ::Integer, context: "#{context}[:default_int_enum]")
-        Hearth::Validator.validate_types!(input[:empty_string], ::String, context: "#{context}[:empty_string]")
-        Hearth::Validator.validate_types!(input[:false_boolean], ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean]")
-        Hearth::Validator.validate_types!(input[:empty_blob], ::String, context: "#{context}[:empty_blob]")
-        Hearth::Validator.validate_types!(input[:zero_byte], ::Integer, context: "#{context}[:zero_byte]")
-        Hearth::Validator.validate_types!(input[:zero_short], ::Integer, context: "#{context}[:zero_short]")
-        Hearth::Validator.validate_types!(input[:zero_integer], ::Integer, context: "#{context}[:zero_integer]")
-        Hearth::Validator.validate_types!(input[:zero_long], ::Integer, context: "#{context}[:zero_long]")
-        Hearth::Validator.validate_types!(input[:zero_float], ::Float, context: "#{context}[:zero_float]")
-        Hearth::Validator.validate_types!(input[:zero_double], ::Float, context: "#{context}[:zero_double]")
+        Hearth::Validator.validate_types!(input.default_string, ::String, context: "#{context}[:default_string]")
+        Hearth::Validator.validate_types!(input.default_boolean, ::TrueClass, ::FalseClass, context: "#{context}[:default_boolean]")
+        TestStringList.validate!(input.default_list, context: "#{context}[:default_list]") unless input.default_list.nil?
+        Document.validate!(input.default_document_map, context: "#{context}[:default_document_map]") unless input.default_document_map.nil?
+        Document.validate!(input.default_document_string, context: "#{context}[:default_document_string]") unless input.default_document_string.nil?
+        Document.validate!(input.default_document_boolean, context: "#{context}[:default_document_boolean]") unless input.default_document_boolean.nil?
+        Document.validate!(input.default_document_list, context: "#{context}[:default_document_list]") unless input.default_document_list.nil?
+        Document.validate!(input.default_null_document, context: "#{context}[:default_null_document]") unless input.default_null_document.nil?
+        Hearth::Validator.validate_types!(input.default_timestamp, ::Time, context: "#{context}[:default_timestamp]")
+        Hearth::Validator.validate_types!(input.default_blob, ::String, context: "#{context}[:default_blob]")
+        Hearth::Validator.validate_types!(input.default_byte, ::Integer, context: "#{context}[:default_byte]")
+        Hearth::Validator.validate_types!(input.default_short, ::Integer, context: "#{context}[:default_short]")
+        Hearth::Validator.validate_types!(input.default_integer, ::Integer, context: "#{context}[:default_integer]")
+        Hearth::Validator.validate_types!(input.default_long, ::Integer, context: "#{context}[:default_long]")
+        Hearth::Validator.validate_types!(input.default_float, ::Float, context: "#{context}[:default_float]")
+        Hearth::Validator.validate_types!(input.default_double, ::Float, context: "#{context}[:default_double]")
+        TestStringMap.validate!(input.default_map, context: "#{context}[:default_map]") unless input.default_map.nil?
+        Hearth::Validator.validate_types!(input.default_enum, ::String, context: "#{context}[:default_enum]")
+        Hearth::Validator.validate_types!(input.default_int_enum, ::Integer, context: "#{context}[:default_int_enum]")
+        Hearth::Validator.validate_types!(input.empty_string, ::String, context: "#{context}[:empty_string]")
+        Hearth::Validator.validate_types!(input.false_boolean, ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean]")
+        Hearth::Validator.validate_types!(input.empty_blob, ::String, context: "#{context}[:empty_blob]")
+        Hearth::Validator.validate_types!(input.zero_byte, ::Integer, context: "#{context}[:zero_byte]")
+        Hearth::Validator.validate_types!(input.zero_short, ::Integer, context: "#{context}[:zero_short]")
+        Hearth::Validator.validate_types!(input.zero_integer, ::Integer, context: "#{context}[:zero_integer]")
+        Hearth::Validator.validate_types!(input.zero_long, ::Integer, context: "#{context}[:zero_long]")
+        Hearth::Validator.validate_types!(input.zero_float, ::Float, context: "#{context}[:zero_float]")
+        Hearth::Validator.validate_types!(input.zero_double, ::Float, context: "#{context}[:zero_double]")
       end
     end
 
@@ -157,8 +157,8 @@ class DenseBooleanMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::TrueClass, ::FalseClass, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::TrueClass, ::FalseClass, context: "#{context}['#{key}']")
         end
       end
     end
@@ -167,8 +167,8 @@ class DenseNumberMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::Integer, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::Integer, context: "#{context}['#{key}']")
         end
       end
     end
@@ -177,8 +177,8 @@ class DenseSetMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          StringSet.validate!(value, context: "#{context}[:#{key}]") unless value.nil?
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          StringSet.validate!(value, context: "#{context}['#{key}']") unless value.nil?
         end
       end
     end
@@ -187,8 +187,8 @@ class DenseStringMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::String, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::String, context: "#{context}['#{key}']")
         end
       end
     end
@@ -197,8 +197,8 @@ class DenseStructMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          GreetingStruct.validate!(value, context: "#{context}[:#{key}]") unless value.nil?
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          GreetingStruct.validate!(value, context: "#{context}['#{key}']") unless value.nil?
         end
       end
     end
@@ -206,9 +206,9 @@ def self.validate!(input, context:)
     class Dialog
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::Dialog, context: context)
-        Hearth::Validator.validate_types!(input[:language], ::String, context: "#{context}[:language]")
-        Hearth::Validator.validate_types!(input[:greeting], ::String, context: "#{context}[:greeting]")
-        Farewell.validate!(input[:farewell], context: "#{context}[:farewell]") unless input[:farewell].nil?
+        Hearth::Validator.validate_types!(input.language, ::String, context: "#{context}[:language]")
+        Hearth::Validator.validate_types!(input.greeting, ::String, context: "#{context}[:greeting]")
+        Farewell.validate!(input.farewell, context: "#{context}[:farewell]") unless input.farewell.nil?
       end
     end
 
@@ -225,8 +225,8 @@ class DialogMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Dialog.validate!(value, context: "#{context}[:#{key}]") unless value.nil?
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Dialog.validate!(value, context: "#{context}['#{key}']") unless value.nil?
         end
       end
     end
@@ -237,7 +237,7 @@ def self.validate!(input, context:)
         case input
         when ::Hash
           input.each do |k,v|
-            validate!(v, context: "#{context}[:#{k}]")
+            validate!(v, context: "#{context}['#{k}']")
           end
         when ::Array
           input.each_with_index do |v, i|
@@ -250,44 +250,44 @@ def self.validate!(input, context:)
     class DocumentTypeAsMapValueInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::DocumentTypeAsMapValueInput, context: context)
-        DocumentValuedMap.validate!(input[:doc_valued_map], context: "#{context}[:doc_valued_map]") unless input[:doc_valued_map].nil?
+        DocumentValuedMap.validate!(input.doc_valued_map, context: "#{context}[:doc_valued_map]") unless input.doc_valued_map.nil?
       end
     end
 
     class DocumentTypeAsMapValueOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::DocumentTypeAsMapValueOutput, context: context)
-        DocumentValuedMap.validate!(input[:doc_valued_map], context: "#{context}[:doc_valued_map]") unless input[:doc_valued_map].nil?
+        DocumentValuedMap.validate!(input.doc_valued_map, context: "#{context}[:doc_valued_map]") unless input.doc_valued_map.nil?
       end
     end
 
     class DocumentTypeAsPayloadInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::DocumentTypeAsPayloadInput, context: context)
-        Document.validate!(input[:document_value], context: "#{context}[:document_value]") unless input[:document_value].nil?
+        Document.validate!(input.document_value, context: "#{context}[:document_value]") unless input.document_value.nil?
       end
     end
 
     class DocumentTypeAsPayloadOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::DocumentTypeAsPayloadOutput, context: context)
-        Document.validate!(input[:document_value], context: "#{context}[:document_value]") unless input[:document_value].nil?
+        Document.validate!(input.document_value, context: "#{context}[:document_value]") unless input.document_value.nil?
       end
     end
 
     class DocumentTypeInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::DocumentTypeInput, context: context)
-        Hearth::Validator.validate_types!(input[:string_value], ::String, context: "#{context}[:string_value]")
-        Document.validate!(input[:document_value], context: "#{context}[:document_value]") unless input[:document_value].nil?
+        Hearth::Validator.validate_types!(input.string_value, ::String, context: "#{context}[:string_value]")
+        Document.validate!(input.document_value, context: "#{context}[:document_value]") unless input.document_value.nil?
       end
     end
 
     class DocumentTypeOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::DocumentTypeOutput, context: context)
-        Hearth::Validator.validate_types!(input[:string_value], ::String, context: "#{context}[:string_value]")
-        Document.validate!(input[:document_value], context: "#{context}[:document_value]") unless input[:document_value].nil?
+        Hearth::Validator.validate_types!(input.string_value, ::String, context: "#{context}[:string_value]")
+        Document.validate!(input.document_value, context: "#{context}[:document_value]") unless input.document_value.nil?
       end
     end
 
@@ -295,8 +295,8 @@ class DocumentValuedMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Document.validate!(value, context: "#{context}[:#{key}]") unless value.nil?
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Document.validate!(value, context: "#{context}['#{key}']") unless value.nil?
         end
       end
     end
@@ -337,8 +337,8 @@ def self.validate!(input, context:)
     class EndpointWithHostLabelOperationInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::EndpointWithHostLabelOperationInput, context: context)
-        Hearth::Validator.validate_required!(input[:label], context: "#{context}[:label]")
-        Hearth::Validator.validate_types!(input[:label], ::String, context: "#{context}[:label]")
+        Hearth::Validator.validate_required!(input.label, context: "#{context}[:label]")
+        Hearth::Validator.validate_types!(input.label, ::String, context: "#{context}[:label]")
       end
     end
 
@@ -351,7 +351,7 @@ def self.validate!(input, context:)
     class Farewell
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::Farewell, context: context)
-        Hearth::Validator.validate_types!(input[:phrase], ::String, context: "#{context}[:phrase]")
+        Hearth::Validator.validate_types!(input.phrase, ::String, context: "#{context}[:phrase]")
       end
     end
 
@@ -368,8 +368,8 @@ class FooEnumMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::String, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::String, context: "#{context}['#{key}']")
         end
       end
     end
@@ -392,21 +392,21 @@ def self.validate!(input, context:)
     class FractionalSecondsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::FractionalSecondsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:datetime], ::Time, context: "#{context}[:datetime]")
+        Hearth::Validator.validate_types!(input.datetime, ::Time, context: "#{context}[:datetime]")
       end
     end
 
     class RenamedGreeting
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RenamedGreeting, context: context)
-        Hearth::Validator.validate_types!(input[:salutation], ::String, context: "#{context}[:salutation]")
+        Hearth::Validator.validate_types!(input.salutation, ::String, context: "#{context}[:salutation]")
       end
     end
 
     class GreetingStruct
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::GreetingStruct, context: context)
-        Hearth::Validator.validate_types!(input[:hi], ::String, context: "#{context}[:hi]")
+        Hearth::Validator.validate_types!(input.hi, ::String, context: "#{context}[:hi]")
       end
     end
 
@@ -419,7 +419,7 @@ def self.validate!(input, context:)
     class GreetingWithErrorsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::GreetingWithErrorsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:greeting], ::String, context: "#{context}[:greeting]")
+        Hearth::Validator.validate_types!(input.greeting, ::String, context: "#{context}[:greeting]")
       end
     end
 
@@ -438,88 +438,88 @@ def self.validate!(input, context:)
     class HttpChecksumRequiredInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpChecksumRequiredInput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
       end
     end
 
     class HttpChecksumRequiredOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpChecksumRequiredOutput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
       end
     end
 
     class HttpEnumPayloadInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpEnumPayloadInput, context: context)
-        Hearth::Validator.validate_types!(input[:payload], ::String, context: "#{context}[:payload]")
+        Hearth::Validator.validate_types!(input.payload, ::String, context: "#{context}[:payload]")
       end
     end
 
     class HttpEnumPayloadOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpEnumPayloadOutput, context: context)
-        Hearth::Validator.validate_types!(input[:payload], ::String, context: "#{context}[:payload]")
+        Hearth::Validator.validate_types!(input.payload, ::String, context: "#{context}[:payload]")
       end
     end
 
     class HttpPayloadTraitsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpPayloadTraitsInput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        Hearth::Validator.validate_types!(input[:blob], ::String, context: "#{context}[:blob]")
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        Hearth::Validator.validate_types!(input.blob, ::String, context: "#{context}[:blob]")
       end
     end
 
     class HttpPayloadTraitsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpPayloadTraitsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        Hearth::Validator.validate_types!(input[:blob], ::String, context: "#{context}[:blob]")
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        Hearth::Validator.validate_types!(input.blob, ::String, context: "#{context}[:blob]")
       end
     end
 
     class HttpPayloadTraitsWithMediaTypeInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpPayloadTraitsWithMediaTypeInput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        Hearth::Validator.validate_types!(input[:blob], ::String, context: "#{context}[:blob]")
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        Hearth::Validator.validate_types!(input.blob, ::String, context: "#{context}[:blob]")
       end
     end
 
     class HttpPayloadTraitsWithMediaTypeOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpPayloadTraitsWithMediaTypeOutput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        Hearth::Validator.validate_types!(input[:blob], ::String, context: "#{context}[:blob]")
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        Hearth::Validator.validate_types!(input.blob, ::String, context: "#{context}[:blob]")
       end
     end
 
     class HttpPayloadWithStructureInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpPayloadWithStructureInput, context: context)
-        NestedPayload.validate!(input[:nested], context: "#{context}[:nested]") unless input[:nested].nil?
+        NestedPayload.validate!(input.nested, context: "#{context}[:nested]") unless input.nested.nil?
       end
     end
 
     class HttpPayloadWithStructureOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpPayloadWithStructureOutput, context: context)
-        NestedPayload.validate!(input[:nested], context: "#{context}[:nested]") unless input[:nested].nil?
+        NestedPayload.validate!(input.nested, context: "#{context}[:nested]") unless input.nested.nil?
       end
     end
 
     class HttpPayloadWithUnionInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpPayloadWithUnionInput, context: context)
-        UnionPayload.validate!(input[:nested], context: "#{context}[:nested]") unless input[:nested].nil?
+        UnionPayload.validate!(input.nested, context: "#{context}[:nested]") unless input.nested.nil?
       end
     end
 
     class HttpPayloadWithUnionOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpPayloadWithUnionOutput, context: context)
-        UnionPayload.validate!(input[:nested], context: "#{context}[:nested]") unless input[:nested].nil?
+        UnionPayload.validate!(input.nested, context: "#{context}[:nested]") unless input.nested.nil?
       end
     end
 
@@ -532,33 +532,33 @@ def self.validate!(input, context:)
     class HttpPrefixHeadersInResponseOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpPrefixHeadersInResponseOutput, context: context)
-        StringMap.validate!(input[:prefix_headers], context: "#{context}[:prefix_headers]") unless input[:prefix_headers].nil?
+        StringMap.validate!(input.prefix_headers, context: "#{context}[:prefix_headers]") unless input.prefix_headers.nil?
       end
     end
 
     class HttpPrefixHeadersInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpPrefixHeadersInput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        StringMap.validate!(input[:foo_map], context: "#{context}[:foo_map]") unless input[:foo_map].nil?
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        StringMap.validate!(input.foo_map, context: "#{context}[:foo_map]") unless input.foo_map.nil?
       end
     end
 
     class HttpPrefixHeadersOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpPrefixHeadersOutput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        StringMap.validate!(input[:foo_map], context: "#{context}[:foo_map]") unless input[:foo_map].nil?
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        StringMap.validate!(input.foo_map, context: "#{context}[:foo_map]") unless input.foo_map.nil?
       end
     end
 
     class HttpRequestWithFloatLabelsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpRequestWithFloatLabelsInput, context: context)
-        Hearth::Validator.validate_required!(input[:float], context: "#{context}[:float]")
-        Hearth::Validator.validate_types!(input[:float], ::Float, context: "#{context}[:float]")
-        Hearth::Validator.validate_required!(input[:double], context: "#{context}[:double]")
-        Hearth::Validator.validate_types!(input[:double], ::Float, context: "#{context}[:double]")
+        Hearth::Validator.validate_required!(input.float, context: "#{context}[:float]")
+        Hearth::Validator.validate_types!(input.float, ::Float, context: "#{context}[:float]")
+        Hearth::Validator.validate_required!(input.double, context: "#{context}[:double]")
+        Hearth::Validator.validate_types!(input.double, ::Float, context: "#{context}[:double]")
       end
     end
 
@@ -571,10 +571,10 @@ def self.validate!(input, context:)
     class HttpRequestWithGreedyLabelInPathInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpRequestWithGreedyLabelInPathInput, context: context)
-        Hearth::Validator.validate_required!(input[:foo], context: "#{context}[:foo]")
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        Hearth::Validator.validate_required!(input[:baz], context: "#{context}[:baz]")
-        Hearth::Validator.validate_types!(input[:baz], ::String, context: "#{context}[:baz]")
+        Hearth::Validator.validate_required!(input.foo, context: "#{context}[:foo]")
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        Hearth::Validator.validate_required!(input.baz, context: "#{context}[:baz]")
+        Hearth::Validator.validate_types!(input.baz, ::String, context: "#{context}[:baz]")
       end
     end
 
@@ -587,20 +587,20 @@ def self.validate!(input, context:)
     class HttpRequestWithLabelsAndTimestampFormatInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpRequestWithLabelsAndTimestampFormatInput, context: context)
-        Hearth::Validator.validate_required!(input[:member_epoch_seconds], context: "#{context}[:member_epoch_seconds]")
-        Hearth::Validator.validate_types!(input[:member_epoch_seconds], ::Time, context: "#{context}[:member_epoch_seconds]")
-        Hearth::Validator.validate_required!(input[:member_http_date], context: "#{context}[:member_http_date]")
-        Hearth::Validator.validate_types!(input[:member_http_date], ::Time, context: "#{context}[:member_http_date]")
-        Hearth::Validator.validate_required!(input[:member_date_time], context: "#{context}[:member_date_time]")
-        Hearth::Validator.validate_types!(input[:member_date_time], ::Time, context: "#{context}[:member_date_time]")
-        Hearth::Validator.validate_required!(input[:default_format], context: "#{context}[:default_format]")
-        Hearth::Validator.validate_types!(input[:default_format], ::Time, context: "#{context}[:default_format]")
-        Hearth::Validator.validate_required!(input[:target_epoch_seconds], context: "#{context}[:target_epoch_seconds]")
-        Hearth::Validator.validate_types!(input[:target_epoch_seconds], ::Time, context: "#{context}[:target_epoch_seconds]")
-        Hearth::Validator.validate_required!(input[:target_http_date], context: "#{context}[:target_http_date]")
-        Hearth::Validator.validate_types!(input[:target_http_date], ::Time, context: "#{context}[:target_http_date]")
-        Hearth::Validator.validate_required!(input[:target_date_time], context: "#{context}[:target_date_time]")
-        Hearth::Validator.validate_types!(input[:target_date_time], ::Time, context: "#{context}[:target_date_time]")
+        Hearth::Validator.validate_required!(input.member_epoch_seconds, context: "#{context}[:member_epoch_seconds]")
+        Hearth::Validator.validate_types!(input.member_epoch_seconds, ::Time, context: "#{context}[:member_epoch_seconds]")
+        Hearth::Validator.validate_required!(input.member_http_date, context: "#{context}[:member_http_date]")
+        Hearth::Validator.validate_types!(input.member_http_date, ::Time, context: "#{context}[:member_http_date]")
+        Hearth::Validator.validate_required!(input.member_date_time, context: "#{context}[:member_date_time]")
+        Hearth::Validator.validate_types!(input.member_date_time, ::Time, context: "#{context}[:member_date_time]")
+        Hearth::Validator.validate_required!(input.default_format, context: "#{context}[:default_format]")
+        Hearth::Validator.validate_types!(input.default_format, ::Time, context: "#{context}[:default_format]")
+        Hearth::Validator.validate_required!(input.target_epoch_seconds, context: "#{context}[:target_epoch_seconds]")
+        Hearth::Validator.validate_types!(input.target_epoch_seconds, ::Time, context: "#{context}[:target_epoch_seconds]")
+        Hearth::Validator.validate_required!(input.target_http_date, context: "#{context}[:target_http_date]")
+        Hearth::Validator.validate_types!(input.target_http_date, ::Time, context: "#{context}[:target_http_date]")
+        Hearth::Validator.validate_required!(input.target_date_time, context: "#{context}[:target_date_time]")
+        Hearth::Validator.validate_types!(input.target_date_time, ::Time, context: "#{context}[:target_date_time]")
       end
     end
 
@@ -613,22 +613,22 @@ def self.validate!(input, context:)
     class HttpRequestWithLabelsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpRequestWithLabelsInput, context: context)
-        Hearth::Validator.validate_required!(input[:string], context: "#{context}[:string]")
-        Hearth::Validator.validate_types!(input[:string], ::String, context: "#{context}[:string]")
-        Hearth::Validator.validate_required!(input[:short], context: "#{context}[:short]")
-        Hearth::Validator.validate_types!(input[:short], ::Integer, context: "#{context}[:short]")
-        Hearth::Validator.validate_required!(input[:integer], context: "#{context}[:integer]")
-        Hearth::Validator.validate_types!(input[:integer], ::Integer, context: "#{context}[:integer]")
-        Hearth::Validator.validate_required!(input[:long], context: "#{context}[:long]")
-        Hearth::Validator.validate_types!(input[:long], ::Integer, context: "#{context}[:long]")
-        Hearth::Validator.validate_required!(input[:float], context: "#{context}[:float]")
-        Hearth::Validator.validate_types!(input[:float], ::Float, context: "#{context}[:float]")
-        Hearth::Validator.validate_required!(input[:double], context: "#{context}[:double]")
-        Hearth::Validator.validate_types!(input[:double], ::Float, context: "#{context}[:double]")
-        Hearth::Validator.validate_required!(input[:boolean], context: "#{context}[:boolean]")
-        Hearth::Validator.validate_types!(input[:boolean], ::TrueClass, ::FalseClass, context: "#{context}[:boolean]")
-        Hearth::Validator.validate_required!(input[:timestamp], context: "#{context}[:timestamp]")
-        Hearth::Validator.validate_types!(input[:timestamp], ::Time, context: "#{context}[:timestamp]")
+        Hearth::Validator.validate_required!(input.string, context: "#{context}[:string]")
+        Hearth::Validator.validate_types!(input.string, ::String, context: "#{context}[:string]")
+        Hearth::Validator.validate_required!(input.short, context: "#{context}[:short]")
+        Hearth::Validator.validate_types!(input.short, ::Integer, context: "#{context}[:short]")
+        Hearth::Validator.validate_required!(input.integer, context: "#{context}[:integer]")
+        Hearth::Validator.validate_types!(input.integer, ::Integer, context: "#{context}[:integer]")
+        Hearth::Validator.validate_required!(input.long, context: "#{context}[:long]")
+        Hearth::Validator.validate_types!(input.long, ::Integer, context: "#{context}[:long]")
+        Hearth::Validator.validate_required!(input.float, context: "#{context}[:float]")
+        Hearth::Validator.validate_types!(input.float, ::Float, context: "#{context}[:float]")
+        Hearth::Validator.validate_required!(input.double, context: "#{context}[:double]")
+        Hearth::Validator.validate_types!(input.double, ::Float, context: "#{context}[:double]")
+        Hearth::Validator.validate_required!(input.boolean, context: "#{context}[:boolean]")
+        Hearth::Validator.validate_types!(input.boolean, ::TrueClass, ::FalseClass, context: "#{context}[:boolean]")
+        Hearth::Validator.validate_required!(input.timestamp, context: "#{context}[:timestamp]")
+        Hearth::Validator.validate_types!(input.timestamp, ::Time, context: "#{context}[:timestamp]")
       end
     end
 
@@ -641,8 +641,8 @@ def self.validate!(input, context:)
     class HttpRequestWithRegexLiteralInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpRequestWithRegexLiteralInput, context: context)
-        Hearth::Validator.validate_required!(input[:str], context: "#{context}[:str]")
-        Hearth::Validator.validate_types!(input[:str], ::String, context: "#{context}[:str]")
+        Hearth::Validator.validate_required!(input.str, context: "#{context}[:str]")
+        Hearth::Validator.validate_types!(input.str, ::String, context: "#{context}[:str]")
       end
     end
 
@@ -661,21 +661,21 @@ def self.validate!(input, context:)
     class HttpResponseCodeOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpResponseCodeOutput, context: context)
-        Hearth::Validator.validate_types!(input[:status], ::Integer, context: "#{context}[:status]")
+        Hearth::Validator.validate_types!(input.status, ::Integer, context: "#{context}[:status]")
       end
     end
 
     class HttpStringPayloadInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpStringPayloadInput, context: context)
-        Hearth::Validator.validate_types!(input[:payload], ::String, context: "#{context}[:payload]")
+        Hearth::Validator.validate_types!(input.payload, ::String, context: "#{context}[:payload]")
       end
     end
 
     class HttpStringPayloadOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::HttpStringPayloadOutput, context: context)
-        Hearth::Validator.validate_types!(input[:payload], ::String, context: "#{context}[:payload]")
+        Hearth::Validator.validate_types!(input.payload, ::String, context: "#{context}[:payload]")
       end
     end
 
@@ -688,55 +688,55 @@ def self.validate!(input, context:)
     class IgnoreQueryParamsInResponseOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::IgnoreQueryParamsInResponseOutput, context: context)
-        Hearth::Validator.validate_types!(input[:baz], ::String, context: "#{context}[:baz]")
+        Hearth::Validator.validate_types!(input.baz, ::String, context: "#{context}[:baz]")
       end
     end
 
     class InputAndOutputWithHeadersInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::InputAndOutputWithHeadersInput, context: context)
-        Hearth::Validator.validate_types!(input[:header_string], ::String, context: "#{context}[:header_string]")
-        Hearth::Validator.validate_types!(input[:header_byte], ::Integer, context: "#{context}[:header_byte]")
-        Hearth::Validator.validate_types!(input[:header_short], ::Integer, context: "#{context}[:header_short]")
-        Hearth::Validator.validate_types!(input[:header_integer], ::Integer, context: "#{context}[:header_integer]")
-        Hearth::Validator.validate_types!(input[:header_long], ::Integer, context: "#{context}[:header_long]")
-        Hearth::Validator.validate_types!(input[:header_float], ::Float, context: "#{context}[:header_float]")
-        Hearth::Validator.validate_types!(input[:header_double], ::Float, context: "#{context}[:header_double]")
-        Hearth::Validator.validate_types!(input[:header_true_bool], ::TrueClass, ::FalseClass, context: "#{context}[:header_true_bool]")
-        Hearth::Validator.validate_types!(input[:header_false_bool], ::TrueClass, ::FalseClass, context: "#{context}[:header_false_bool]")
-        StringList.validate!(input[:header_string_list], context: "#{context}[:header_string_list]") unless input[:header_string_list].nil?
-        StringSet.validate!(input[:header_string_set], context: "#{context}[:header_string_set]") unless input[:header_string_set].nil?
-        IntegerList.validate!(input[:header_integer_list], context: "#{context}[:header_integer_list]") unless input[:header_integer_list].nil?
-        BooleanList.validate!(input[:header_boolean_list], context: "#{context}[:header_boolean_list]") unless input[:header_boolean_list].nil?
-        TimestampList.validate!(input[:header_timestamp_list], context: "#{context}[:header_timestamp_list]") unless input[:header_timestamp_list].nil?
-        Hearth::Validator.validate_types!(input[:header_enum], ::String, context: "#{context}[:header_enum]")
-        FooEnumList.validate!(input[:header_enum_list], context: "#{context}[:header_enum_list]") unless input[:header_enum_list].nil?
-        Hearth::Validator.validate_types!(input[:header_integer_enum], ::Integer, context: "#{context}[:header_integer_enum]")
-        IntegerEnumList.validate!(input[:header_integer_enum_list], context: "#{context}[:header_integer_enum_list]") unless input[:header_integer_enum_list].nil?
+        Hearth::Validator.validate_types!(input.header_string, ::String, context: "#{context}[:header_string]")
+        Hearth::Validator.validate_types!(input.header_byte, ::Integer, context: "#{context}[:header_byte]")
+        Hearth::Validator.validate_types!(input.header_short, ::Integer, context: "#{context}[:header_short]")
+        Hearth::Validator.validate_types!(input.header_integer, ::Integer, context: "#{context}[:header_integer]")
+        Hearth::Validator.validate_types!(input.header_long, ::Integer, context: "#{context}[:header_long]")
+        Hearth::Validator.validate_types!(input.header_float, ::Float, context: "#{context}[:header_float]")
+        Hearth::Validator.validate_types!(input.header_double, ::Float, context: "#{context}[:header_double]")
+        Hearth::Validator.validate_types!(input.header_true_bool, ::TrueClass, ::FalseClass, context: "#{context}[:header_true_bool]")
+        Hearth::Validator.validate_types!(input.header_false_bool, ::TrueClass, ::FalseClass, context: "#{context}[:header_false_bool]")
+        StringList.validate!(input.header_string_list, context: "#{context}[:header_string_list]") unless input.header_string_list.nil?
+        StringSet.validate!(input.header_string_set, context: "#{context}[:header_string_set]") unless input.header_string_set.nil?
+        IntegerList.validate!(input.header_integer_list, context: "#{context}[:header_integer_list]") unless input.header_integer_list.nil?
+        BooleanList.validate!(input.header_boolean_list, context: "#{context}[:header_boolean_list]") unless input.header_boolean_list.nil?
+        TimestampList.validate!(input.header_timestamp_list, context: "#{context}[:header_timestamp_list]") unless input.header_timestamp_list.nil?
+        Hearth::Validator.validate_types!(input.header_enum, ::String, context: "#{context}[:header_enum]")
+        FooEnumList.validate!(input.header_enum_list, context: "#{context}[:header_enum_list]") unless input.header_enum_list.nil?
+        Hearth::Validator.validate_types!(input.header_integer_enum, ::Integer, context: "#{context}[:header_integer_enum]")
+        IntegerEnumList.validate!(input.header_integer_enum_list, context: "#{context}[:header_integer_enum_list]") unless input.header_integer_enum_list.nil?
       end
     end
 
     class InputAndOutputWithHeadersOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::InputAndOutputWithHeadersOutput, context: context)
-        Hearth::Validator.validate_types!(input[:header_string], ::String, context: "#{context}[:header_string]")
-        Hearth::Validator.validate_types!(input[:header_byte], ::Integer, context: "#{context}[:header_byte]")
-        Hearth::Validator.validate_types!(input[:header_short], ::Integer, context: "#{context}[:header_short]")
-        Hearth::Validator.validate_types!(input[:header_integer], ::Integer, context: "#{context}[:header_integer]")
-        Hearth::Validator.validate_types!(input[:header_long], ::Integer, context: "#{context}[:header_long]")
-        Hearth::Validator.validate_types!(input[:header_float], ::Float, context: "#{context}[:header_float]")
-        Hearth::Validator.validate_types!(input[:header_double], ::Float, context: "#{context}[:header_double]")
-        Hearth::Validator.validate_types!(input[:header_true_bool], ::TrueClass, ::FalseClass, context: "#{context}[:header_true_bool]")
-        Hearth::Validator.validate_types!(input[:header_false_bool], ::TrueClass, ::FalseClass, context: "#{context}[:header_false_bool]")
-        StringList.validate!(input[:header_string_list], context: "#{context}[:header_string_list]") unless input[:header_string_list].nil?
-        StringSet.validate!(input[:header_string_set], context: "#{context}[:header_string_set]") unless input[:header_string_set].nil?
-        IntegerList.validate!(input[:header_integer_list], context: "#{context}[:header_integer_list]") unless input[:header_integer_list].nil?
-        BooleanList.validate!(input[:header_boolean_list], context: "#{context}[:header_boolean_list]") unless input[:header_boolean_list].nil?
-        TimestampList.validate!(input[:header_timestamp_list], context: "#{context}[:header_timestamp_list]") unless input[:header_timestamp_list].nil?
-        Hearth::Validator.validate_types!(input[:header_enum], ::String, context: "#{context}[:header_enum]")
-        FooEnumList.validate!(input[:header_enum_list], context: "#{context}[:header_enum_list]") unless input[:header_enum_list].nil?
-        Hearth::Validator.validate_types!(input[:header_integer_enum], ::Integer, context: "#{context}[:header_integer_enum]")
-        IntegerEnumList.validate!(input[:header_integer_enum_list], context: "#{context}[:header_integer_enum_list]") unless input[:header_integer_enum_list].nil?
+        Hearth::Validator.validate_types!(input.header_string, ::String, context: "#{context}[:header_string]")
+        Hearth::Validator.validate_types!(input.header_byte, ::Integer, context: "#{context}[:header_byte]")
+        Hearth::Validator.validate_types!(input.header_short, ::Integer, context: "#{context}[:header_short]")
+        Hearth::Validator.validate_types!(input.header_integer, ::Integer, context: "#{context}[:header_integer]")
+        Hearth::Validator.validate_types!(input.header_long, ::Integer, context: "#{context}[:header_long]")
+        Hearth::Validator.validate_types!(input.header_float, ::Float, context: "#{context}[:header_float]")
+        Hearth::Validator.validate_types!(input.header_double, ::Float, context: "#{context}[:header_double]")
+        Hearth::Validator.validate_types!(input.header_true_bool, ::TrueClass, ::FalseClass, context: "#{context}[:header_true_bool]")
+        Hearth::Validator.validate_types!(input.header_false_bool, ::TrueClass, ::FalseClass, context: "#{context}[:header_false_bool]")
+        StringList.validate!(input.header_string_list, context: "#{context}[:header_string_list]") unless input.header_string_list.nil?
+        StringSet.validate!(input.header_string_set, context: "#{context}[:header_string_set]") unless input.header_string_set.nil?
+        IntegerList.validate!(input.header_integer_list, context: "#{context}[:header_integer_list]") unless input.header_integer_list.nil?
+        BooleanList.validate!(input.header_boolean_list, context: "#{context}[:header_boolean_list]") unless input.header_boolean_list.nil?
+        TimestampList.validate!(input.header_timestamp_list, context: "#{context}[:header_timestamp_list]") unless input.header_timestamp_list.nil?
+        Hearth::Validator.validate_types!(input.header_enum, ::String, context: "#{context}[:header_enum]")
+        FooEnumList.validate!(input.header_enum_list, context: "#{context}[:header_enum_list]") unless input.header_enum_list.nil?
+        Hearth::Validator.validate_types!(input.header_integer_enum, ::Integer, context: "#{context}[:header_integer_enum]")
+        IntegerEnumList.validate!(input.header_integer_enum_list, context: "#{context}[:header_integer_enum_list]") unless input.header_integer_enum_list.nil?
       end
     end
 
@@ -753,8 +753,8 @@ class IntegerEnumMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::Integer, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::Integer, context: "#{context}['#{key}']")
         end
       end
     end
@@ -789,175 +789,175 @@ def self.validate!(input, context:)
     class InvalidGreeting
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::InvalidGreeting, context: context)
-        Hearth::Validator.validate_types!(input[:message], ::String, context: "#{context}[:message]")
+        Hearth::Validator.validate_types!(input.message, ::String, context: "#{context}[:message]")
       end
     end
 
     class JsonBlobsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonBlobsInput, context: context)
-        Hearth::Validator.validate_types!(input[:data], ::String, context: "#{context}[:data]")
+        Hearth::Validator.validate_types!(input.data, ::String, context: "#{context}[:data]")
       end
     end
 
     class JsonBlobsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonBlobsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:data], ::String, context: "#{context}[:data]")
+        Hearth::Validator.validate_types!(input.data, ::String, context: "#{context}[:data]")
       end
     end
 
     class JsonEnumsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonEnumsInput, context: context)
-        Hearth::Validator.validate_types!(input[:foo_enum1], ::String, context: "#{context}[:foo_enum1]")
-        Hearth::Validator.validate_types!(input[:foo_enum2], ::String, context: "#{context}[:foo_enum2]")
-        Hearth::Validator.validate_types!(input[:foo_enum3], ::String, context: "#{context}[:foo_enum3]")
-        FooEnumList.validate!(input[:foo_enum_list], context: "#{context}[:foo_enum_list]") unless input[:foo_enum_list].nil?
-        FooEnumSet.validate!(input[:foo_enum_set], context: "#{context}[:foo_enum_set]") unless input[:foo_enum_set].nil?
-        FooEnumMap.validate!(input[:foo_enum_map], context: "#{context}[:foo_enum_map]") unless input[:foo_enum_map].nil?
+        Hearth::Validator.validate_types!(input.foo_enum1, ::String, context: "#{context}[:foo_enum1]")
+        Hearth::Validator.validate_types!(input.foo_enum2, ::String, context: "#{context}[:foo_enum2]")
+        Hearth::Validator.validate_types!(input.foo_enum3, ::String, context: "#{context}[:foo_enum3]")
+        FooEnumList.validate!(input.foo_enum_list, context: "#{context}[:foo_enum_list]") unless input.foo_enum_list.nil?
+        FooEnumSet.validate!(input.foo_enum_set, context: "#{context}[:foo_enum_set]") unless input.foo_enum_set.nil?
+        FooEnumMap.validate!(input.foo_enum_map, context: "#{context}[:foo_enum_map]") unless input.foo_enum_map.nil?
       end
     end
 
     class JsonEnumsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonEnumsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:foo_enum1], ::String, context: "#{context}[:foo_enum1]")
-        Hearth::Validator.validate_types!(input[:foo_enum2], ::String, context: "#{context}[:foo_enum2]")
-        Hearth::Validator.validate_types!(input[:foo_enum3], ::String, context: "#{context}[:foo_enum3]")
-        FooEnumList.validate!(input[:foo_enum_list], context: "#{context}[:foo_enum_list]") unless input[:foo_enum_list].nil?
-        FooEnumSet.validate!(input[:foo_enum_set], context: "#{context}[:foo_enum_set]") unless input[:foo_enum_set].nil?
-        FooEnumMap.validate!(input[:foo_enum_map], context: "#{context}[:foo_enum_map]") unless input[:foo_enum_map].nil?
+        Hearth::Validator.validate_types!(input.foo_enum1, ::String, context: "#{context}[:foo_enum1]")
+        Hearth::Validator.validate_types!(input.foo_enum2, ::String, context: "#{context}[:foo_enum2]")
+        Hearth::Validator.validate_types!(input.foo_enum3, ::String, context: "#{context}[:foo_enum3]")
+        FooEnumList.validate!(input.foo_enum_list, context: "#{context}[:foo_enum_list]") unless input.foo_enum_list.nil?
+        FooEnumSet.validate!(input.foo_enum_set, context: "#{context}[:foo_enum_set]") unless input.foo_enum_set.nil?
+        FooEnumMap.validate!(input.foo_enum_map, context: "#{context}[:foo_enum_map]") unless input.foo_enum_map.nil?
       end
     end
 
     class JsonIntEnumsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonIntEnumsInput, context: context)
-        Hearth::Validator.validate_types!(input[:integer_enum1], ::Integer, context: "#{context}[:integer_enum1]")
-        Hearth::Validator.validate_types!(input[:integer_enum2], ::Integer, context: "#{context}[:integer_enum2]")
-        Hearth::Validator.validate_types!(input[:integer_enum3], ::Integer, context: "#{context}[:integer_enum3]")
-        IntegerEnumList.validate!(input[:integer_enum_list], context: "#{context}[:integer_enum_list]") unless input[:integer_enum_list].nil?
-        IntegerEnumSet.validate!(input[:integer_enum_set], context: "#{context}[:integer_enum_set]") unless input[:integer_enum_set].nil?
-        IntegerEnumMap.validate!(input[:integer_enum_map], context: "#{context}[:integer_enum_map]") unless input[:integer_enum_map].nil?
+        Hearth::Validator.validate_types!(input.integer_enum1, ::Integer, context: "#{context}[:integer_enum1]")
+        Hearth::Validator.validate_types!(input.integer_enum2, ::Integer, context: "#{context}[:integer_enum2]")
+        Hearth::Validator.validate_types!(input.integer_enum3, ::Integer, context: "#{context}[:integer_enum3]")
+        IntegerEnumList.validate!(input.integer_enum_list, context: "#{context}[:integer_enum_list]") unless input.integer_enum_list.nil?
+        IntegerEnumSet.validate!(input.integer_enum_set, context: "#{context}[:integer_enum_set]") unless input.integer_enum_set.nil?
+        IntegerEnumMap.validate!(input.integer_enum_map, context: "#{context}[:integer_enum_map]") unless input.integer_enum_map.nil?
       end
     end
 
     class JsonIntEnumsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonIntEnumsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:integer_enum1], ::Integer, context: "#{context}[:integer_enum1]")
-        Hearth::Validator.validate_types!(input[:integer_enum2], ::Integer, context: "#{context}[:integer_enum2]")
-        Hearth::Validator.validate_types!(input[:integer_enum3], ::Integer, context: "#{context}[:integer_enum3]")
-        IntegerEnumList.validate!(input[:integer_enum_list], context: "#{context}[:integer_enum_list]") unless input[:integer_enum_list].nil?
-        IntegerEnumSet.validate!(input[:integer_enum_set], context: "#{context}[:integer_enum_set]") unless input[:integer_enum_set].nil?
-        IntegerEnumMap.validate!(input[:integer_enum_map], context: "#{context}[:integer_enum_map]") unless input[:integer_enum_map].nil?
+        Hearth::Validator.validate_types!(input.integer_enum1, ::Integer, context: "#{context}[:integer_enum1]")
+        Hearth::Validator.validate_types!(input.integer_enum2, ::Integer, context: "#{context}[:integer_enum2]")
+        Hearth::Validator.validate_types!(input.integer_enum3, ::Integer, context: "#{context}[:integer_enum3]")
+        IntegerEnumList.validate!(input.integer_enum_list, context: "#{context}[:integer_enum_list]") unless input.integer_enum_list.nil?
+        IntegerEnumSet.validate!(input.integer_enum_set, context: "#{context}[:integer_enum_set]") unless input.integer_enum_set.nil?
+        IntegerEnumMap.validate!(input.integer_enum_map, context: "#{context}[:integer_enum_map]") unless input.integer_enum_map.nil?
       end
     end
 
     class JsonListsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonListsInput, context: context)
-        StringList.validate!(input[:string_list], context: "#{context}[:string_list]") unless input[:string_list].nil?
-        StringSet.validate!(input[:string_set], context: "#{context}[:string_set]") unless input[:string_set].nil?
-        IntegerList.validate!(input[:integer_list], context: "#{context}[:integer_list]") unless input[:integer_list].nil?
-        BooleanList.validate!(input[:boolean_list], context: "#{context}[:boolean_list]") unless input[:boolean_list].nil?
-        TimestampList.validate!(input[:timestamp_list], context: "#{context}[:timestamp_list]") unless input[:timestamp_list].nil?
-        FooEnumList.validate!(input[:enum_list], context: "#{context}[:enum_list]") unless input[:enum_list].nil?
-        IntegerEnumList.validate!(input[:int_enum_list], context: "#{context}[:int_enum_list]") unless input[:int_enum_list].nil?
-        NestedStringList.validate!(input[:nested_string_list], context: "#{context}[:nested_string_list]") unless input[:nested_string_list].nil?
-        StructureList.validate!(input[:structure_list], context: "#{context}[:structure_list]") unless input[:structure_list].nil?
+        StringList.validate!(input.string_list, context: "#{context}[:string_list]") unless input.string_list.nil?
+        StringSet.validate!(input.string_set, context: "#{context}[:string_set]") unless input.string_set.nil?
+        IntegerList.validate!(input.integer_list, context: "#{context}[:integer_list]") unless input.integer_list.nil?
+        BooleanList.validate!(input.boolean_list, context: "#{context}[:boolean_list]") unless input.boolean_list.nil?
+        TimestampList.validate!(input.timestamp_list, context: "#{context}[:timestamp_list]") unless input.timestamp_list.nil?
+        FooEnumList.validate!(input.enum_list, context: "#{context}[:enum_list]") unless input.enum_list.nil?
+        IntegerEnumList.validate!(input.int_enum_list, context: "#{context}[:int_enum_list]") unless input.int_enum_list.nil?
+        NestedStringList.validate!(input.nested_string_list, context: "#{context}[:nested_string_list]") unless input.nested_string_list.nil?
+        StructureList.validate!(input.structure_list, context: "#{context}[:structure_list]") unless input.structure_list.nil?
       end
     end
 
     class JsonListsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonListsOutput, context: context)
-        StringList.validate!(input[:string_list], context: "#{context}[:string_list]") unless input[:string_list].nil?
-        StringSet.validate!(input[:string_set], context: "#{context}[:string_set]") unless input[:string_set].nil?
-        IntegerList.validate!(input[:integer_list], context: "#{context}[:integer_list]") unless input[:integer_list].nil?
-        BooleanList.validate!(input[:boolean_list], context: "#{context}[:boolean_list]") unless input[:boolean_list].nil?
-        TimestampList.validate!(input[:timestamp_list], context: "#{context}[:timestamp_list]") unless input[:timestamp_list].nil?
-        FooEnumList.validate!(input[:enum_list], context: "#{context}[:enum_list]") unless input[:enum_list].nil?
-        IntegerEnumList.validate!(input[:int_enum_list], context: "#{context}[:int_enum_list]") unless input[:int_enum_list].nil?
-        NestedStringList.validate!(input[:nested_string_list], context: "#{context}[:nested_string_list]") unless input[:nested_string_list].nil?
-        StructureList.validate!(input[:structure_list], context: "#{context}[:structure_list]") unless input[:structure_list].nil?
+        StringList.validate!(input.string_list, context: "#{context}[:string_list]") unless input.string_list.nil?
+        StringSet.validate!(input.string_set, context: "#{context}[:string_set]") unless input.string_set.nil?
+        IntegerList.validate!(input.integer_list, context: "#{context}[:integer_list]") unless input.integer_list.nil?
+        BooleanList.validate!(input.boolean_list, context: "#{context}[:boolean_list]") unless input.boolean_list.nil?
+        TimestampList.validate!(input.timestamp_list, context: "#{context}[:timestamp_list]") unless input.timestamp_list.nil?
+        FooEnumList.validate!(input.enum_list, context: "#{context}[:enum_list]") unless input.enum_list.nil?
+        IntegerEnumList.validate!(input.int_enum_list, context: "#{context}[:int_enum_list]") unless input.int_enum_list.nil?
+        NestedStringList.validate!(input.nested_string_list, context: "#{context}[:nested_string_list]") unless input.nested_string_list.nil?
+        StructureList.validate!(input.structure_list, context: "#{context}[:structure_list]") unless input.structure_list.nil?
       end
     end
 
     class JsonMapsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonMapsInput, context: context)
-        DenseStructMap.validate!(input[:dense_struct_map], context: "#{context}[:dense_struct_map]") unless input[:dense_struct_map].nil?
-        DenseNumberMap.validate!(input[:dense_number_map], context: "#{context}[:dense_number_map]") unless input[:dense_number_map].nil?
-        DenseBooleanMap.validate!(input[:dense_boolean_map], context: "#{context}[:dense_boolean_map]") unless input[:dense_boolean_map].nil?
-        DenseStringMap.validate!(input[:dense_string_map], context: "#{context}[:dense_string_map]") unless input[:dense_string_map].nil?
-        DenseSetMap.validate!(input[:dense_set_map], context: "#{context}[:dense_set_map]") unless input[:dense_set_map].nil?
+        DenseStructMap.validate!(input.dense_struct_map, context: "#{context}[:dense_struct_map]") unless input.dense_struct_map.nil?
+        DenseNumberMap.validate!(input.dense_number_map, context: "#{context}[:dense_number_map]") unless input.dense_number_map.nil?
+        DenseBooleanMap.validate!(input.dense_boolean_map, context: "#{context}[:dense_boolean_map]") unless input.dense_boolean_map.nil?
+        DenseStringMap.validate!(input.dense_string_map, context: "#{context}[:dense_string_map]") unless input.dense_string_map.nil?
+        DenseSetMap.validate!(input.dense_set_map, context: "#{context}[:dense_set_map]") unless input.dense_set_map.nil?
       end
     end
 
     class JsonMapsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonMapsOutput, context: context)
-        DenseStructMap.validate!(input[:dense_struct_map], context: "#{context}[:dense_struct_map]") unless input[:dense_struct_map].nil?
-        DenseNumberMap.validate!(input[:dense_number_map], context: "#{context}[:dense_number_map]") unless input[:dense_number_map].nil?
-        DenseBooleanMap.validate!(input[:dense_boolean_map], context: "#{context}[:dense_boolean_map]") unless input[:dense_boolean_map].nil?
-        DenseStringMap.validate!(input[:dense_string_map], context: "#{context}[:dense_string_map]") unless input[:dense_string_map].nil?
-        DenseSetMap.validate!(input[:dense_set_map], context: "#{context}[:dense_set_map]") unless input[:dense_set_map].nil?
+        DenseStructMap.validate!(input.dense_struct_map, context: "#{context}[:dense_struct_map]") unless input.dense_struct_map.nil?
+        DenseNumberMap.validate!(input.dense_number_map, context: "#{context}[:dense_number_map]") unless input.dense_number_map.nil?
+        DenseBooleanMap.validate!(input.dense_boolean_map, context: "#{context}[:dense_boolean_map]") unless input.dense_boolean_map.nil?
+        DenseStringMap.validate!(input.dense_string_map, context: "#{context}[:dense_string_map]") unless input.dense_string_map.nil?
+        DenseSetMap.validate!(input.dense_set_map, context: "#{context}[:dense_set_map]") unless input.dense_set_map.nil?
       end
     end
 
     class JsonTimestampsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonTimestampsInput, context: context)
-        Hearth::Validator.validate_types!(input[:normal], ::Time, context: "#{context}[:normal]")
-        Hearth::Validator.validate_types!(input[:date_time], ::Time, context: "#{context}[:date_time]")
-        Hearth::Validator.validate_types!(input[:date_time_on_target], ::Time, context: "#{context}[:date_time_on_target]")
-        Hearth::Validator.validate_types!(input[:epoch_seconds], ::Time, context: "#{context}[:epoch_seconds]")
-        Hearth::Validator.validate_types!(input[:epoch_seconds_on_target], ::Time, context: "#{context}[:epoch_seconds_on_target]")
-        Hearth::Validator.validate_types!(input[:http_date], ::Time, context: "#{context}[:http_date]")
-        Hearth::Validator.validate_types!(input[:http_date_on_target], ::Time, context: "#{context}[:http_date_on_target]")
+        Hearth::Validator.validate_types!(input.normal, ::Time, context: "#{context}[:normal]")
+        Hearth::Validator.validate_types!(input.date_time, ::Time, context: "#{context}[:date_time]")
+        Hearth::Validator.validate_types!(input.date_time_on_target, ::Time, context: "#{context}[:date_time_on_target]")
+        Hearth::Validator.validate_types!(input.epoch_seconds, ::Time, context: "#{context}[:epoch_seconds]")
+        Hearth::Validator.validate_types!(input.epoch_seconds_on_target, ::Time, context: "#{context}[:epoch_seconds_on_target]")
+        Hearth::Validator.validate_types!(input.http_date, ::Time, context: "#{context}[:http_date]")
+        Hearth::Validator.validate_types!(input.http_date_on_target, ::Time, context: "#{context}[:http_date_on_target]")
       end
     end
 
     class JsonTimestampsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonTimestampsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:normal], ::Time, context: "#{context}[:normal]")
-        Hearth::Validator.validate_types!(input[:date_time], ::Time, context: "#{context}[:date_time]")
-        Hearth::Validator.validate_types!(input[:date_time_on_target], ::Time, context: "#{context}[:date_time_on_target]")
-        Hearth::Validator.validate_types!(input[:epoch_seconds], ::Time, context: "#{context}[:epoch_seconds]")
-        Hearth::Validator.validate_types!(input[:epoch_seconds_on_target], ::Time, context: "#{context}[:epoch_seconds_on_target]")
-        Hearth::Validator.validate_types!(input[:http_date], ::Time, context: "#{context}[:http_date]")
-        Hearth::Validator.validate_types!(input[:http_date_on_target], ::Time, context: "#{context}[:http_date_on_target]")
+        Hearth::Validator.validate_types!(input.normal, ::Time, context: "#{context}[:normal]")
+        Hearth::Validator.validate_types!(input.date_time, ::Time, context: "#{context}[:date_time]")
+        Hearth::Validator.validate_types!(input.date_time_on_target, ::Time, context: "#{context}[:date_time_on_target]")
+        Hearth::Validator.validate_types!(input.epoch_seconds, ::Time, context: "#{context}[:epoch_seconds]")
+        Hearth::Validator.validate_types!(input.epoch_seconds_on_target, ::Time, context: "#{context}[:epoch_seconds_on_target]")
+        Hearth::Validator.validate_types!(input.http_date, ::Time, context: "#{context}[:http_date]")
+        Hearth::Validator.validate_types!(input.http_date_on_target, ::Time, context: "#{context}[:http_date_on_target]")
       end
     end
 
     class JsonUnionsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonUnionsInput, context: context)
-        MyUnion.validate!(input[:contents], context: "#{context}[:contents]") unless input[:contents].nil?
+        MyUnion.validate!(input.contents, context: "#{context}[:contents]") unless input.contents.nil?
       end
     end
 
     class JsonUnionsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::JsonUnionsOutput, context: context)
-        MyUnion.validate!(input[:contents], context: "#{context}[:contents]") unless input[:contents].nil?
+        MyUnion.validate!(input.contents, context: "#{context}[:contents]") unless input.contents.nil?
       end
     end
 
     class MediaTypeHeaderInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::MediaTypeHeaderInput, context: context)
-        Hearth::Validator.validate_types!(input[:json], ::String, context: "#{context}[:json]")
+        Hearth::Validator.validate_types!(input.json, ::String, context: "#{context}[:json]")
       end
     end
 
     class MediaTypeHeaderOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::MediaTypeHeaderOutput, context: context)
-        Hearth::Validator.validate_types!(input[:json], ::String, context: "#{context}[:json]")
+        Hearth::Validator.validate_types!(input.json, ::String, context: "#{context}[:json]")
       end
     end
 
@@ -985,9 +985,7 @@ def self.validate!(input, context:)
         when Types::MyUnion::RenamedStructureValue
           RenamedGreeting.validate!(input.__getobj__, context: context) unless input.__getobj__.nil?
         else
-          raise ArgumentError,
-                "Expected #{context} to be a union member of "\
-                "Types::MyUnion, got #{input.class}."
+          raise ArgumentError, "Expected #{context} to be a union member of Types::MyUnion, got #{input.class}."
         end
       end
 
@@ -1055,8 +1053,8 @@ def self.validate!(input, context:)
     class NestedPayload
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::NestedPayload, context: context)
-        Hearth::Validator.validate_types!(input[:greeting], ::String, context: "#{context}[:greeting]")
-        Hearth::Validator.validate_types!(input[:name], ::String, context: "#{context}[:name]")
+        Hearth::Validator.validate_types!(input.greeting, ::String, context: "#{context}[:greeting]")
+        Hearth::Validator.validate_types!(input.name, ::String, context: "#{context}[:name]")
       end
     end
 
@@ -1096,44 +1094,44 @@ def self.validate!(input, context:)
     class NullAndEmptyHeadersClientInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::NullAndEmptyHeadersClientInput, context: context)
-        Hearth::Validator.validate_types!(input[:a], ::String, context: "#{context}[:a]")
-        Hearth::Validator.validate_types!(input[:b], ::String, context: "#{context}[:b]")
-        StringList.validate!(input[:c], context: "#{context}[:c]") unless input[:c].nil?
+        Hearth::Validator.validate_types!(input.a, ::String, context: "#{context}[:a]")
+        Hearth::Validator.validate_types!(input.b, ::String, context: "#{context}[:b]")
+        StringList.validate!(input.c, context: "#{context}[:c]") unless input.c.nil?
       end
     end
 
     class NullAndEmptyHeadersClientOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::NullAndEmptyHeadersClientOutput, context: context)
-        Hearth::Validator.validate_types!(input[:a], ::String, context: "#{context}[:a]")
-        Hearth::Validator.validate_types!(input[:b], ::String, context: "#{context}[:b]")
-        StringList.validate!(input[:c], context: "#{context}[:c]") unless input[:c].nil?
+        Hearth::Validator.validate_types!(input.a, ::String, context: "#{context}[:a]")
+        Hearth::Validator.validate_types!(input.b, ::String, context: "#{context}[:b]")
+        StringList.validate!(input.c, context: "#{context}[:c]") unless input.c.nil?
       end
     end
 
     class NullAndEmptyHeadersServerInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::NullAndEmptyHeadersServerInput, context: context)
-        Hearth::Validator.validate_types!(input[:a], ::String, context: "#{context}[:a]")
-        Hearth::Validator.validate_types!(input[:b], ::String, context: "#{context}[:b]")
-        StringList.validate!(input[:c], context: "#{context}[:c]") unless input[:c].nil?
+        Hearth::Validator.validate_types!(input.a, ::String, context: "#{context}[:a]")
+        Hearth::Validator.validate_types!(input.b, ::String, context: "#{context}[:b]")
+        StringList.validate!(input.c, context: "#{context}[:c]") unless input.c.nil?
       end
     end
 
     class NullAndEmptyHeadersServerOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::NullAndEmptyHeadersServerOutput, context: context)
-        Hearth::Validator.validate_types!(input[:a], ::String, context: "#{context}[:a]")
-        Hearth::Validator.validate_types!(input[:b], ::String, context: "#{context}[:b]")
-        StringList.validate!(input[:c], context: "#{context}[:c]") unless input[:c].nil?
+        Hearth::Validator.validate_types!(input.a, ::String, context: "#{context}[:a]")
+        Hearth::Validator.validate_types!(input.b, ::String, context: "#{context}[:b]")
+        StringList.validate!(input.c, context: "#{context}[:c]") unless input.c.nil?
       end
     end
 
     class OmitsNullSerializesEmptyStringInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::OmitsNullSerializesEmptyStringInput, context: context)
-        Hearth::Validator.validate_types!(input[:null_value], ::String, context: "#{context}[:null_value]")
-        Hearth::Validator.validate_types!(input[:empty_string], ::String, context: "#{context}[:empty_string]")
+        Hearth::Validator.validate_types!(input.null_value, ::String, context: "#{context}[:null_value]")
+        Hearth::Validator.validate_types!(input.empty_string, ::String, context: "#{context}[:empty_string]")
       end
     end
 
@@ -1146,13 +1144,13 @@ def self.validate!(input, context:)
     class OmitsSerializingEmptyListsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::OmitsSerializingEmptyListsInput, context: context)
-        StringList.validate!(input[:query_string_list], context: "#{context}[:query_string_list]") unless input[:query_string_list].nil?
-        IntegerList.validate!(input[:query_integer_list], context: "#{context}[:query_integer_list]") unless input[:query_integer_list].nil?
-        DoubleList.validate!(input[:query_double_list], context: "#{context}[:query_double_list]") unless input[:query_double_list].nil?
-        BooleanList.validate!(input[:query_boolean_list], context: "#{context}[:query_boolean_list]") unless input[:query_boolean_list].nil?
-        TimestampList.validate!(input[:query_timestamp_list], context: "#{context}[:query_timestamp_list]") unless input[:query_timestamp_list].nil?
-        FooEnumList.validate!(input[:query_enum_list], context: "#{context}[:query_enum_list]") unless input[:query_enum_list].nil?
-        IntegerEnumList.validate!(input[:query_integer_enum_list], context: "#{context}[:query_integer_enum_list]") unless input[:query_integer_enum_list].nil?
+        StringList.validate!(input.query_string_list, context: "#{context}[:query_string_list]") unless input.query_string_list.nil?
+        IntegerList.validate!(input.query_integer_list, context: "#{context}[:query_integer_list]") unless input.query_integer_list.nil?
+        DoubleList.validate!(input.query_double_list, context: "#{context}[:query_double_list]") unless input.query_double_list.nil?
+        BooleanList.validate!(input.query_boolean_list, context: "#{context}[:query_boolean_list]") unless input.query_boolean_list.nil?
+        TimestampList.validate!(input.query_timestamp_list, context: "#{context}[:query_timestamp_list]") unless input.query_timestamp_list.nil?
+        FooEnumList.validate!(input.query_enum_list, context: "#{context}[:query_enum_list]") unless input.query_enum_list.nil?
+        IntegerEnumList.validate!(input.query_integer_enum_list, context: "#{context}[:query_integer_enum_list]") unless input.query_integer_enum_list.nil?
       end
     end
 
@@ -1165,69 +1163,69 @@ def self.validate!(input, context:)
     class OperationWithDefaultsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::OperationWithDefaultsInput, context: context)
-        Defaults.validate!(input[:defaults], context: "#{context}[:defaults]") unless input[:defaults].nil?
-        ClientOptionalDefaults.validate!(input[:client_optional_defaults], context: "#{context}[:client_optional_defaults]") unless input[:client_optional_defaults].nil?
-        Hearth::Validator.validate_types!(input[:top_level_default], ::String, context: "#{context}[:top_level_default]")
-        Hearth::Validator.validate_types!(input[:other_top_level_default], ::Integer, context: "#{context}[:other_top_level_default]")
+        Defaults.validate!(input.defaults, context: "#{context}[:defaults]") unless input.defaults.nil?
+        ClientOptionalDefaults.validate!(input.client_optional_defaults, context: "#{context}[:client_optional_defaults]") unless input.client_optional_defaults.nil?
+        Hearth::Validator.validate_types!(input.top_level_default, ::String, context: "#{context}[:top_level_default]")
+        Hearth::Validator.validate_types!(input.other_top_level_default, ::Integer, context: "#{context}[:other_top_level_default]")
       end
     end
 
     class OperationWithDefaultsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::OperationWithDefaultsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:default_string], ::String, context: "#{context}[:default_string]")
-        Hearth::Validator.validate_types!(input[:default_boolean], ::TrueClass, ::FalseClass, context: "#{context}[:default_boolean]")
-        TestStringList.validate!(input[:default_list], context: "#{context}[:default_list]") unless input[:default_list].nil?
-        Document.validate!(input[:default_document_map], context: "#{context}[:default_document_map]") unless input[:default_document_map].nil?
-        Document.validate!(input[:default_document_string], context: "#{context}[:default_document_string]") unless input[:default_document_string].nil?
-        Document.validate!(input[:default_document_boolean], context: "#{context}[:default_document_boolean]") unless input[:default_document_boolean].nil?
-        Document.validate!(input[:default_document_list], context: "#{context}[:default_document_list]") unless input[:default_document_list].nil?
-        Document.validate!(input[:default_null_document], context: "#{context}[:default_null_document]") unless input[:default_null_document].nil?
-        Hearth::Validator.validate_types!(input[:default_timestamp], ::Time, context: "#{context}[:default_timestamp]")
-        Hearth::Validator.validate_types!(input[:default_blob], ::String, context: "#{context}[:default_blob]")
-        Hearth::Validator.validate_types!(input[:default_byte], ::Integer, context: "#{context}[:default_byte]")
-        Hearth::Validator.validate_types!(input[:default_short], ::Integer, context: "#{context}[:default_short]")
-        Hearth::Validator.validate_types!(input[:default_integer], ::Integer, context: "#{context}[:default_integer]")
-        Hearth::Validator.validate_types!(input[:default_long], ::Integer, context: "#{context}[:default_long]")
-        Hearth::Validator.validate_types!(input[:default_float], ::Float, context: "#{context}[:default_float]")
-        Hearth::Validator.validate_types!(input[:default_double], ::Float, context: "#{context}[:default_double]")
-        TestStringMap.validate!(input[:default_map], context: "#{context}[:default_map]") unless input[:default_map].nil?
-        Hearth::Validator.validate_types!(input[:default_enum], ::String, context: "#{context}[:default_enum]")
-        Hearth::Validator.validate_types!(input[:default_int_enum], ::Integer, context: "#{context}[:default_int_enum]")
-        Hearth::Validator.validate_types!(input[:empty_string], ::String, context: "#{context}[:empty_string]")
-        Hearth::Validator.validate_types!(input[:false_boolean], ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean]")
-        Hearth::Validator.validate_types!(input[:empty_blob], ::String, context: "#{context}[:empty_blob]")
-        Hearth::Validator.validate_types!(input[:zero_byte], ::Integer, context: "#{context}[:zero_byte]")
-        Hearth::Validator.validate_types!(input[:zero_short], ::Integer, context: "#{context}[:zero_short]")
-        Hearth::Validator.validate_types!(input[:zero_integer], ::Integer, context: "#{context}[:zero_integer]")
-        Hearth::Validator.validate_types!(input[:zero_long], ::Integer, context: "#{context}[:zero_long]")
-        Hearth::Validator.validate_types!(input[:zero_float], ::Float, context: "#{context}[:zero_float]")
-        Hearth::Validator.validate_types!(input[:zero_double], ::Float, context: "#{context}[:zero_double]")
+        Hearth::Validator.validate_types!(input.default_string, ::String, context: "#{context}[:default_string]")
+        Hearth::Validator.validate_types!(input.default_boolean, ::TrueClass, ::FalseClass, context: "#{context}[:default_boolean]")
+        TestStringList.validate!(input.default_list, context: "#{context}[:default_list]") unless input.default_list.nil?
+        Document.validate!(input.default_document_map, context: "#{context}[:default_document_map]") unless input.default_document_map.nil?
+        Document.validate!(input.default_document_string, context: "#{context}[:default_document_string]") unless input.default_document_string.nil?
+        Document.validate!(input.default_document_boolean, context: "#{context}[:default_document_boolean]") unless input.default_document_boolean.nil?
+        Document.validate!(input.default_document_list, context: "#{context}[:default_document_list]") unless input.default_document_list.nil?
+        Document.validate!(input.default_null_document, context: "#{context}[:default_null_document]") unless input.default_null_document.nil?
+        Hearth::Validator.validate_types!(input.default_timestamp, ::Time, context: "#{context}[:default_timestamp]")
+        Hearth::Validator.validate_types!(input.default_blob, ::String, context: "#{context}[:default_blob]")
+        Hearth::Validator.validate_types!(input.default_byte, ::Integer, context: "#{context}[:default_byte]")
+        Hearth::Validator.validate_types!(input.default_short, ::Integer, context: "#{context}[:default_short]")
+        Hearth::Validator.validate_types!(input.default_integer, ::Integer, context: "#{context}[:default_integer]")
+        Hearth::Validator.validate_types!(input.default_long, ::Integer, context: "#{context}[:default_long]")
+        Hearth::Validator.validate_types!(input.default_float, ::Float, context: "#{context}[:default_float]")
+        Hearth::Validator.validate_types!(input.default_double, ::Float, context: "#{context}[:default_double]")
+        TestStringMap.validate!(input.default_map, context: "#{context}[:default_map]") unless input.default_map.nil?
+        Hearth::Validator.validate_types!(input.default_enum, ::String, context: "#{context}[:default_enum]")
+        Hearth::Validator.validate_types!(input.default_int_enum, ::Integer, context: "#{context}[:default_int_enum]")
+        Hearth::Validator.validate_types!(input.empty_string, ::String, context: "#{context}[:empty_string]")
+        Hearth::Validator.validate_types!(input.false_boolean, ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean]")
+        Hearth::Validator.validate_types!(input.empty_blob, ::String, context: "#{context}[:empty_blob]")
+        Hearth::Validator.validate_types!(input.zero_byte, ::Integer, context: "#{context}[:zero_byte]")
+        Hearth::Validator.validate_types!(input.zero_short, ::Integer, context: "#{context}[:zero_short]")
+        Hearth::Validator.validate_types!(input.zero_integer, ::Integer, context: "#{context}[:zero_integer]")
+        Hearth::Validator.validate_types!(input.zero_long, ::Integer, context: "#{context}[:zero_long]")
+        Hearth::Validator.validate_types!(input.zero_float, ::Float, context: "#{context}[:zero_float]")
+        Hearth::Validator.validate_types!(input.zero_double, ::Float, context: "#{context}[:zero_double]")
       end
     end
 
     class OperationWithNestedStructureInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::OperationWithNestedStructureInput, context: context)
-        Hearth::Validator.validate_required!(input[:top_level], context: "#{context}[:top_level]")
-        TopLevel.validate!(input[:top_level], context: "#{context}[:top_level]") unless input[:top_level].nil?
+        Hearth::Validator.validate_required!(input.top_level, context: "#{context}[:top_level]")
+        TopLevel.validate!(input.top_level, context: "#{context}[:top_level]") unless input.top_level.nil?
       end
     end
 
     class OperationWithNestedStructureOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::OperationWithNestedStructureOutput, context: context)
-        Hearth::Validator.validate_required!(input[:dialog], context: "#{context}[:dialog]")
-        Dialog.validate!(input[:dialog], context: "#{context}[:dialog]") unless input[:dialog].nil?
-        DialogList.validate!(input[:dialog_list], context: "#{context}[:dialog_list]") unless input[:dialog_list].nil?
-        DialogMap.validate!(input[:dialog_map], context: "#{context}[:dialog_map]") unless input[:dialog_map].nil?
+        Hearth::Validator.validate_required!(input.dialog, context: "#{context}[:dialog]")
+        Dialog.validate!(input.dialog, context: "#{context}[:dialog]") unless input.dialog.nil?
+        DialogList.validate!(input.dialog_list, context: "#{context}[:dialog_list]") unless input.dialog_list.nil?
+        DialogMap.validate!(input.dialog_map, context: "#{context}[:dialog_map]") unless input.dialog_map.nil?
       end
     end
 
     class PayloadConfig
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::PayloadConfig, context: context)
-        Hearth::Validator.validate_types!(input[:data], ::Integer, context: "#{context}[:data]")
+        Hearth::Validator.validate_types!(input.data, ::Integer, context: "#{context}[:data]")
       end
     end
 
@@ -1237,9 +1235,7 @@ def self.validate!(input, context:)
         when Types::PlayerAction::Quit
           Unit.validate!(input.__getobj__, context: context) unless input.__getobj__.nil?
         else
-          raise ArgumentError,
-                "Expected #{context} to be a union member of "\
-                "Types::PlayerAction, got #{input.class}."
+          raise ArgumentError, "Expected #{context} to be a union member of Types::PlayerAction, got #{input.class}."
         end
       end
 
@@ -1253,38 +1249,38 @@ def self.validate!(input, context:)
     class PostPlayerActionInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::PostPlayerActionInput, context: context)
-        PlayerAction.validate!(input[:action], context: "#{context}[:action]") unless input[:action].nil?
+        PlayerAction.validate!(input.action, context: "#{context}[:action]") unless input.action.nil?
       end
     end
 
     class PostPlayerActionOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::PostPlayerActionOutput, context: context)
-        Hearth::Validator.validate_required!(input[:action], context: "#{context}[:action]")
-        PlayerAction.validate!(input[:action], context: "#{context}[:action]") unless input[:action].nil?
+        Hearth::Validator.validate_required!(input.action, context: "#{context}[:action]")
+        PlayerAction.validate!(input.action, context: "#{context}[:action]") unless input.action.nil?
       end
     end
 
     class PostUnionWithJsonNameInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::PostUnionWithJsonNameInput, context: context)
-        UnionWithJsonName.validate!(input[:value], context: "#{context}[:value]") unless input[:value].nil?
+        UnionWithJsonName.validate!(input.value, context: "#{context}[:value]") unless input.value.nil?
       end
     end
 
     class PostUnionWithJsonNameOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::PostUnionWithJsonNameOutput, context: context)
-        Hearth::Validator.validate_required!(input[:value], context: "#{context}[:value]")
-        UnionWithJsonName.validate!(input[:value], context: "#{context}[:value]") unless input[:value].nil?
+        Hearth::Validator.validate_required!(input.value, context: "#{context}[:value]")
+        UnionWithJsonName.validate!(input.value, context: "#{context}[:value]") unless input.value.nil?
       end
     end
 
     class PutWithContentEncodingInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::PutWithContentEncodingInput, context: context)
-        Hearth::Validator.validate_types!(input[:encoding], ::String, context: "#{context}[:encoding]")
-        Hearth::Validator.validate_types!(input[:data], ::String, context: "#{context}[:data]")
+        Hearth::Validator.validate_types!(input.encoding, ::String, context: "#{context}[:encoding]")
+        Hearth::Validator.validate_types!(input.data, ::String, context: "#{context}[:data]")
       end
     end
 
@@ -1297,7 +1293,7 @@ def self.validate!(input, context:)
     class QueryIdempotencyTokenAutoFillInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::QueryIdempotencyTokenAutoFillInput, context: context)
-        Hearth::Validator.validate_types!(input[:token], ::String, context: "#{context}[:token]")
+        Hearth::Validator.validate_types!(input.token, ::String, context: "#{context}[:token]")
       end
     end
 
@@ -1310,8 +1306,8 @@ def self.validate!(input, context:)
     class QueryParamsAsStringListMapInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::QueryParamsAsStringListMapInput, context: context)
-        Hearth::Validator.validate_types!(input[:qux], ::String, context: "#{context}[:qux]")
-        StringListMap.validate!(input[:foo], context: "#{context}[:foo]") unless input[:foo].nil?
+        Hearth::Validator.validate_types!(input.qux, ::String, context: "#{context}[:qux]")
+        StringListMap.validate!(input.foo, context: "#{context}[:foo]") unless input.foo.nil?
       end
     end
 
@@ -1324,8 +1320,8 @@ def self.validate!(input, context:)
     class QueryPrecedenceInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::QueryPrecedenceInput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        StringMap.validate!(input[:baz], context: "#{context}[:baz]") unless input[:baz].nil?
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        StringMap.validate!(input.baz, context: "#{context}[:baz]") unless input.baz.nil?
       end
     end
 
@@ -1338,62 +1334,62 @@ def self.validate!(input, context:)
     class RecursiveShapesInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RecursiveShapesInput, context: context)
-        RecursiveShapesInputOutputNested1.validate!(input[:nested], context: "#{context}[:nested]") unless input[:nested].nil?
+        RecursiveShapesInputOutputNested1.validate!(input.nested, context: "#{context}[:nested]") unless input.nested.nil?
       end
     end
 
     class RecursiveShapesInputOutputNested1
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RecursiveShapesInputOutputNested1, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        RecursiveShapesInputOutputNested2.validate!(input[:nested], context: "#{context}[:nested]") unless input[:nested].nil?
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        RecursiveShapesInputOutputNested2.validate!(input.nested, context: "#{context}[:nested]") unless input.nested.nil?
       end
     end
 
     class RecursiveShapesInputOutputNested2
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RecursiveShapesInputOutputNested2, context: context)
-        Hearth::Validator.validate_types!(input[:bar], ::String, context: "#{context}[:bar]")
-        RecursiveShapesInputOutputNested1.validate!(input[:recursive_member], context: "#{context}[:recursive_member]") unless input[:recursive_member].nil?
+        Hearth::Validator.validate_types!(input.bar, ::String, context: "#{context}[:bar]")
+        RecursiveShapesInputOutputNested1.validate!(input.recursive_member, context: "#{context}[:recursive_member]") unless input.recursive_member.nil?
       end
     end
 
     class RecursiveShapesOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RecursiveShapesOutput, context: context)
-        RecursiveShapesInputOutputNested1.validate!(input[:nested], context: "#{context}[:nested]") unless input[:nested].nil?
+        RecursiveShapesInputOutputNested1.validate!(input.nested, context: "#{context}[:nested]") unless input.nested.nil?
       end
     end
 
     class SimpleScalarPropertiesInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::SimpleScalarPropertiesInput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        Hearth::Validator.validate_types!(input[:string_value], ::String, context: "#{context}[:string_value]")
-        Hearth::Validator.validate_types!(input[:true_boolean_value], ::TrueClass, ::FalseClass, context: "#{context}[:true_boolean_value]")
-        Hearth::Validator.validate_types!(input[:false_boolean_value], ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean_value]")
-        Hearth::Validator.validate_types!(input[:byte_value], ::Integer, context: "#{context}[:byte_value]")
-        Hearth::Validator.validate_types!(input[:short_value], ::Integer, context: "#{context}[:short_value]")
-        Hearth::Validator.validate_types!(input[:integer_value], ::Integer, context: "#{context}[:integer_value]")
-        Hearth::Validator.validate_types!(input[:long_value], ::Integer, context: "#{context}[:long_value]")
-        Hearth::Validator.validate_types!(input[:float_value], ::Float, context: "#{context}[:float_value]")
-        Hearth::Validator.validate_types!(input[:double_value], ::Float, context: "#{context}[:double_value]")
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        Hearth::Validator.validate_types!(input.string_value, ::String, context: "#{context}[:string_value]")
+        Hearth::Validator.validate_types!(input.true_boolean_value, ::TrueClass, ::FalseClass, context: "#{context}[:true_boolean_value]")
+        Hearth::Validator.validate_types!(input.false_boolean_value, ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean_value]")
+        Hearth::Validator.validate_types!(input.byte_value, ::Integer, context: "#{context}[:byte_value]")
+        Hearth::Validator.validate_types!(input.short_value, ::Integer, context: "#{context}[:short_value]")
+        Hearth::Validator.validate_types!(input.integer_value, ::Integer, context: "#{context}[:integer_value]")
+        Hearth::Validator.validate_types!(input.long_value, ::Integer, context: "#{context}[:long_value]")
+        Hearth::Validator.validate_types!(input.float_value, ::Float, context: "#{context}[:float_value]")
+        Hearth::Validator.validate_types!(input.double_value, ::Float, context: "#{context}[:double_value]")
       end
     end
 
     class SimpleScalarPropertiesOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::SimpleScalarPropertiesOutput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        Hearth::Validator.validate_types!(input[:string_value], ::String, context: "#{context}[:string_value]")
-        Hearth::Validator.validate_types!(input[:true_boolean_value], ::TrueClass, ::FalseClass, context: "#{context}[:true_boolean_value]")
-        Hearth::Validator.validate_types!(input[:false_boolean_value], ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean_value]")
-        Hearth::Validator.validate_types!(input[:byte_value], ::Integer, context: "#{context}[:byte_value]")
-        Hearth::Validator.validate_types!(input[:short_value], ::Integer, context: "#{context}[:short_value]")
-        Hearth::Validator.validate_types!(input[:integer_value], ::Integer, context: "#{context}[:integer_value]")
-        Hearth::Validator.validate_types!(input[:long_value], ::Integer, context: "#{context}[:long_value]")
-        Hearth::Validator.validate_types!(input[:float_value], ::Float, context: "#{context}[:float_value]")
-        Hearth::Validator.validate_types!(input[:double_value], ::Float, context: "#{context}[:double_value]")
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        Hearth::Validator.validate_types!(input.string_value, ::String, context: "#{context}[:string_value]")
+        Hearth::Validator.validate_types!(input.true_boolean_value, ::TrueClass, ::FalseClass, context: "#{context}[:true_boolean_value]")
+        Hearth::Validator.validate_types!(input.false_boolean_value, ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean_value]")
+        Hearth::Validator.validate_types!(input.byte_value, ::Integer, context: "#{context}[:byte_value]")
+        Hearth::Validator.validate_types!(input.short_value, ::Integer, context: "#{context}[:short_value]")
+        Hearth::Validator.validate_types!(input.integer_value, ::Integer, context: "#{context}[:integer_value]")
+        Hearth::Validator.validate_types!(input.long_value, ::Integer, context: "#{context}[:long_value]")
+        Hearth::Validator.validate_types!(input.float_value, ::Float, context: "#{context}[:float_value]")
+        Hearth::Validator.validate_types!(input.double_value, ::Float, context: "#{context}[:double_value]")
       end
     end
 
@@ -1401,8 +1397,8 @@ class SparseBooleanMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::TrueClass, ::FalseClass, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::TrueClass, ::FalseClass, context: "#{context}['#{key}']")
         end
       end
     end
@@ -1410,36 +1406,36 @@ def self.validate!(input, context:)
     class SparseJsonListsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::SparseJsonListsInput, context: context)
-        SparseStringList.validate!(input[:sparse_string_list], context: "#{context}[:sparse_string_list]") unless input[:sparse_string_list].nil?
+        SparseStringList.validate!(input.sparse_string_list, context: "#{context}[:sparse_string_list]") unless input.sparse_string_list.nil?
       end
     end
 
     class SparseJsonListsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::SparseJsonListsOutput, context: context)
-        SparseStringList.validate!(input[:sparse_string_list], context: "#{context}[:sparse_string_list]") unless input[:sparse_string_list].nil?
+        SparseStringList.validate!(input.sparse_string_list, context: "#{context}[:sparse_string_list]") unless input.sparse_string_list.nil?
       end
     end
 
     class SparseJsonMapsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::SparseJsonMapsInput, context: context)
-        SparseStructMap.validate!(input[:sparse_struct_map], context: "#{context}[:sparse_struct_map]") unless input[:sparse_struct_map].nil?
-        SparseNumberMap.validate!(input[:sparse_number_map], context: "#{context}[:sparse_number_map]") unless input[:sparse_number_map].nil?
-        SparseBooleanMap.validate!(input[:sparse_boolean_map], context: "#{context}[:sparse_boolean_map]") unless input[:sparse_boolean_map].nil?
-        SparseStringMap.validate!(input[:sparse_string_map], context: "#{context}[:sparse_string_map]") unless input[:sparse_string_map].nil?
-        SparseSetMap.validate!(input[:sparse_set_map], context: "#{context}[:sparse_set_map]") unless input[:sparse_set_map].nil?
+        SparseStructMap.validate!(input.sparse_struct_map, context: "#{context}[:sparse_struct_map]") unless input.sparse_struct_map.nil?
+        SparseNumberMap.validate!(input.sparse_number_map, context: "#{context}[:sparse_number_map]") unless input.sparse_number_map.nil?
+        SparseBooleanMap.validate!(input.sparse_boolean_map, context: "#{context}[:sparse_boolean_map]") unless input.sparse_boolean_map.nil?
+        SparseStringMap.validate!(input.sparse_string_map, context: "#{context}[:sparse_string_map]") unless input.sparse_string_map.nil?
+        SparseSetMap.validate!(input.sparse_set_map, context: "#{context}[:sparse_set_map]") unless input.sparse_set_map.nil?
       end
     end
 
     class SparseJsonMapsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::SparseJsonMapsOutput, context: context)
-        SparseStructMap.validate!(input[:sparse_struct_map], context: "#{context}[:sparse_struct_map]") unless input[:sparse_struct_map].nil?
-        SparseNumberMap.validate!(input[:sparse_number_map], context: "#{context}[:sparse_number_map]") unless input[:sparse_number_map].nil?
-        SparseBooleanMap.validate!(input[:sparse_boolean_map], context: "#{context}[:sparse_boolean_map]") unless input[:sparse_boolean_map].nil?
-        SparseStringMap.validate!(input[:sparse_string_map], context: "#{context}[:sparse_string_map]") unless input[:sparse_string_map].nil?
-        SparseSetMap.validate!(input[:sparse_set_map], context: "#{context}[:sparse_set_map]") unless input[:sparse_set_map].nil?
+        SparseStructMap.validate!(input.sparse_struct_map, context: "#{context}[:sparse_struct_map]") unless input.sparse_struct_map.nil?
+        SparseNumberMap.validate!(input.sparse_number_map, context: "#{context}[:sparse_number_map]") unless input.sparse_number_map.nil?
+        SparseBooleanMap.validate!(input.sparse_boolean_map, context: "#{context}[:sparse_boolean_map]") unless input.sparse_boolean_map.nil?
+        SparseStringMap.validate!(input.sparse_string_map, context: "#{context}[:sparse_string_map]") unless input.sparse_string_map.nil?
+        SparseSetMap.validate!(input.sparse_set_map, context: "#{context}[:sparse_set_map]") unless input.sparse_set_map.nil?
       end
     end
 
@@ -1447,8 +1443,8 @@ class SparseNumberMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::Integer, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::Integer, context: "#{context}['#{key}']")
         end
       end
     end
@@ -1457,8 +1453,8 @@ class SparseSetMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          StringSet.validate!(value, context: "#{context}[:#{key}]") unless value.nil?
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          StringSet.validate!(value, context: "#{context}['#{key}']") unless value.nil?
         end
       end
     end
@@ -1476,8 +1472,8 @@ class SparseStringMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::String, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::String, context: "#{context}['#{key}']")
         end
       end
     end
@@ -1486,8 +1482,8 @@ class SparseStructMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          GreetingStruct.validate!(value, context: "#{context}[:#{key}]") unless value.nil?
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          GreetingStruct.validate!(value, context: "#{context}['#{key}']") unless value.nil?
         end
       end
     end
@@ -1495,9 +1491,9 @@ def self.validate!(input, context:)
     class StreamingTraitsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::StreamingTraitsInput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        unless input[:blob].respond_to?(:read) || input[:blob].respond_to?(:readpartial)
-          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input[:blob].class}"
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        unless input.blob.respond_to?(:read) || input.blob.respond_to?(:readpartial)
+          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input.blob.class}"
         end
       end
     end
@@ -1505,9 +1501,9 @@ def self.validate!(input, context:)
     class StreamingTraitsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::StreamingTraitsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        unless input[:blob].respond_to?(:read) || input[:blob].respond_to?(:readpartial)
-          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input[:blob].class}"
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        unless input.blob.respond_to?(:read) || input.blob.respond_to?(:readpartial)
+          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input.blob.class}"
         end
       end
     end
@@ -1515,12 +1511,12 @@ def self.validate!(input, context:)
     class StreamingTraitsRequireLengthInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::StreamingTraitsRequireLengthInput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        unless input[:blob].respond_to?(:read) || input[:blob].respond_to?(:readpartial)
-          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input[:blob].class}"
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        unless input.blob.respond_to?(:read) || input.blob.respond_to?(:readpartial)
+          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input.blob.class}"
         end
 
-        unless input[:blob].respond_to?(:size)
+        unless input.blob.respond_to?(:size)
           raise ArgumentError, "Expected #{context} to respond_to(:size)"
         end
       end
@@ -1535,9 +1531,9 @@ def self.validate!(input, context:)
     class StreamingTraitsWithMediaTypeInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::StreamingTraitsWithMediaTypeInput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        unless input[:blob].respond_to?(:read) || input[:blob].respond_to?(:readpartial)
-          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input[:blob].class}"
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        unless input.blob.respond_to?(:read) || input.blob.respond_to?(:readpartial)
+          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input.blob.class}"
         end
       end
     end
@@ -1545,9 +1541,9 @@ def self.validate!(input, context:)
     class StreamingTraitsWithMediaTypeOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::StreamingTraitsWithMediaTypeOutput, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        unless input[:blob].respond_to?(:read) || input[:blob].respond_to?(:readpartial)
-          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input[:blob].class}"
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        unless input.blob.respond_to?(:read) || input.blob.respond_to?(:readpartial)
+          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input.blob.class}"
         end
       end
     end
@@ -1565,8 +1561,8 @@ class StringListMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          StringList.validate!(value, context: "#{context}[:#{key}]") unless value.nil?
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          StringList.validate!(value, context: "#{context}['#{key}']") unless value.nil?
         end
       end
     end
@@ -1575,8 +1571,8 @@ class StringMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::String, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::String, context: "#{context}['#{key}']")
         end
       end
     end
@@ -1602,77 +1598,77 @@ def self.validate!(input, context:)
     class StructureListMember
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::StructureListMember, context: context)
-        Hearth::Validator.validate_types!(input[:a], ::String, context: "#{context}[:a]")
-        Hearth::Validator.validate_types!(input[:b], ::String, context: "#{context}[:b]")
+        Hearth::Validator.validate_types!(input.a, ::String, context: "#{context}[:a]")
+        Hearth::Validator.validate_types!(input.b, ::String, context: "#{context}[:b]")
       end
     end
 
     class TestBodyStructureInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::TestBodyStructureInput, context: context)
-        Hearth::Validator.validate_types!(input[:test_id], ::String, context: "#{context}[:test_id]")
-        TestConfig.validate!(input[:test_config], context: "#{context}[:test_config]") unless input[:test_config].nil?
+        Hearth::Validator.validate_types!(input.test_id, ::String, context: "#{context}[:test_id]")
+        TestConfig.validate!(input.test_config, context: "#{context}[:test_config]") unless input.test_config.nil?
       end
     end
 
     class TestBodyStructureOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::TestBodyStructureOutput, context: context)
-        Hearth::Validator.validate_types!(input[:test_id], ::String, context: "#{context}[:test_id]")
-        TestConfig.validate!(input[:test_config], context: "#{context}[:test_config]") unless input[:test_config].nil?
+        Hearth::Validator.validate_types!(input.test_id, ::String, context: "#{context}[:test_id]")
+        TestConfig.validate!(input.test_config, context: "#{context}[:test_config]") unless input.test_config.nil?
       end
     end
 
     class TestConfig
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::TestConfig, context: context)
-        Hearth::Validator.validate_types!(input[:timeout], ::Integer, context: "#{context}[:timeout]")
+        Hearth::Validator.validate_types!(input.timeout, ::Integer, context: "#{context}[:timeout]")
       end
     end
 
     class TestNoPayloadInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::TestNoPayloadInput, context: context)
-        Hearth::Validator.validate_types!(input[:test_id], ::String, context: "#{context}[:test_id]")
+        Hearth::Validator.validate_types!(input.test_id, ::String, context: "#{context}[:test_id]")
       end
     end
 
     class TestNoPayloadOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::TestNoPayloadOutput, context: context)
-        Hearth::Validator.validate_types!(input[:test_id], ::String, context: "#{context}[:test_id]")
+        Hearth::Validator.validate_types!(input.test_id, ::String, context: "#{context}[:test_id]")
       end
     end
 
     class TestPayloadBlobInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::TestPayloadBlobInput, context: context)
-        Hearth::Validator.validate_types!(input[:content_type], ::String, context: "#{context}[:content_type]")
-        Hearth::Validator.validate_types!(input[:data], ::String, context: "#{context}[:data]")
+        Hearth::Validator.validate_types!(input.content_type, ::String, context: "#{context}[:content_type]")
+        Hearth::Validator.validate_types!(input.data, ::String, context: "#{context}[:data]")
       end
     end
 
     class TestPayloadBlobOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::TestPayloadBlobOutput, context: context)
-        Hearth::Validator.validate_types!(input[:content_type], ::String, context: "#{context}[:content_type]")
-        Hearth::Validator.validate_types!(input[:data], ::String, context: "#{context}[:data]")
+        Hearth::Validator.validate_types!(input.content_type, ::String, context: "#{context}[:content_type]")
+        Hearth::Validator.validate_types!(input.data, ::String, context: "#{context}[:data]")
       end
     end
 
     class TestPayloadStructureInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::TestPayloadStructureInput, context: context)
-        Hearth::Validator.validate_types!(input[:test_id], ::String, context: "#{context}[:test_id]")
-        PayloadConfig.validate!(input[:payload_config], context: "#{context}[:payload_config]") unless input[:payload_config].nil?
+        Hearth::Validator.validate_types!(input.test_id, ::String, context: "#{context}[:test_id]")
+        PayloadConfig.validate!(input.payload_config, context: "#{context}[:payload_config]") unless input.payload_config.nil?
       end
     end
 
     class TestPayloadStructureOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::TestPayloadStructureOutput, context: context)
-        Hearth::Validator.validate_types!(input[:test_id], ::String, context: "#{context}[:test_id]")
-        PayloadConfig.validate!(input[:payload_config], context: "#{context}[:payload_config]") unless input[:payload_config].nil?
+        Hearth::Validator.validate_types!(input.test_id, ::String, context: "#{context}[:test_id]")
+        PayloadConfig.validate!(input.payload_config, context: "#{context}[:payload_config]") unless input.payload_config.nil?
       end
     end
 
@@ -1689,8 +1685,8 @@ class TestStringMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::String, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::String, context: "#{context}['#{key}']")
         end
       end
     end
@@ -1698,26 +1694,26 @@ def self.validate!(input, context:)
     class TimestampFormatHeadersInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::TimestampFormatHeadersInput, context: context)
-        Hearth::Validator.validate_types!(input[:member_epoch_seconds], ::Time, context: "#{context}[:member_epoch_seconds]")
-        Hearth::Validator.validate_types!(input[:member_http_date], ::Time, context: "#{context}[:member_http_date]")
-        Hearth::Validator.validate_types!(input[:member_date_time], ::Time, context: "#{context}[:member_date_time]")
-        Hearth::Validator.validate_types!(input[:default_format], ::Time, context: "#{context}[:default_format]")
-        Hearth::Validator.validate_types!(input[:target_epoch_seconds], ::Time, context: "#{context}[:target_epoch_seconds]")
-        Hearth::Validator.validate_types!(input[:target_http_date], ::Time, context: "#{context}[:target_http_date]")
-        Hearth::Validator.validate_types!(input[:target_date_time], ::Time, context: "#{context}[:target_date_time]")
+        Hearth::Validator.validate_types!(input.member_epoch_seconds, ::Time, context: "#{context}[:member_epoch_seconds]")
+        Hearth::Validator.validate_types!(input.member_http_date, ::Time, context: "#{context}[:member_http_date]")
+        Hearth::Validator.validate_types!(input.member_date_time, ::Time, context: "#{context}[:member_date_time]")
+        Hearth::Validator.validate_types!(input.default_format, ::Time, context: "#{context}[:default_format]")
+        Hearth::Validator.validate_types!(input.target_epoch_seconds, ::Time, context: "#{context}[:target_epoch_seconds]")
+        Hearth::Validator.validate_types!(input.target_http_date, ::Time, context: "#{context}[:target_http_date]")
+        Hearth::Validator.validate_types!(input.target_date_time, ::Time, context: "#{context}[:target_date_time]")
       end
     end
 
     class TimestampFormatHeadersOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::TimestampFormatHeadersOutput, context: context)
-        Hearth::Validator.validate_types!(input[:member_epoch_seconds], ::Time, context: "#{context}[:member_epoch_seconds]")
-        Hearth::Validator.validate_types!(input[:member_http_date], ::Time, context: "#{context}[:member_http_date]")
-        Hearth::Validator.validate_types!(input[:member_date_time], ::Time, context: "#{context}[:member_date_time]")
-        Hearth::Validator.validate_types!(input[:default_format], ::Time, context: "#{context}[:default_format]")
-        Hearth::Validator.validate_types!(input[:target_epoch_seconds], ::Time, context: "#{context}[:target_epoch_seconds]")
-        Hearth::Validator.validate_types!(input[:target_http_date], ::Time, context: "#{context}[:target_http_date]")
-        Hearth::Validator.validate_types!(input[:target_date_time], ::Time, context: "#{context}[:target_date_time]")
+        Hearth::Validator.validate_types!(input.member_epoch_seconds, ::Time, context: "#{context}[:member_epoch_seconds]")
+        Hearth::Validator.validate_types!(input.member_http_date, ::Time, context: "#{context}[:member_http_date]")
+        Hearth::Validator.validate_types!(input.member_date_time, ::Time, context: "#{context}[:member_date_time]")
+        Hearth::Validator.validate_types!(input.default_format, ::Time, context: "#{context}[:default_format]")
+        Hearth::Validator.validate_types!(input.target_epoch_seconds, ::Time, context: "#{context}[:target_epoch_seconds]")
+        Hearth::Validator.validate_types!(input.target_http_date, ::Time, context: "#{context}[:target_http_date]")
+        Hearth::Validator.validate_types!(input.target_date_time, ::Time, context: "#{context}[:target_date_time]")
       end
     end
 
@@ -1733,10 +1729,10 @@ def self.validate!(input, context:)
     class TopLevel
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::TopLevel, context: context)
-        Hearth::Validator.validate_required!(input[:dialog], context: "#{context}[:dialog]")
-        Dialog.validate!(input[:dialog], context: "#{context}[:dialog]") unless input[:dialog].nil?
-        DialogList.validate!(input[:dialog_list], context: "#{context}[:dialog_list]") unless input[:dialog_list].nil?
-        DialogMap.validate!(input[:dialog_map], context: "#{context}[:dialog_map]") unless input[:dialog_map].nil?
+        Hearth::Validator.validate_required!(input.dialog, context: "#{context}[:dialog]")
+        Dialog.validate!(input.dialog, context: "#{context}[:dialog]") unless input.dialog.nil?
+        DialogList.validate!(input.dialog_list, context: "#{context}[:dialog_list]") unless input.dialog_list.nil?
+        DialogMap.validate!(input.dialog_map, context: "#{context}[:dialog_map]") unless input.dialog_map.nil?
       end
     end
 
@@ -1746,9 +1742,7 @@ def self.validate!(input, context:)
         when Types::UnionPayload::Greeting
           Hearth::Validator.validate_types!(input.__getobj__, ::String, context: context)
         else
-          raise ArgumentError,
-                "Expected #{context} to be a union member of "\
-                "Types::UnionPayload, got #{input.class}."
+          raise ArgumentError, "Expected #{context} to be a union member of Types::UnionPayload, got #{input.class}."
         end
       end
 
@@ -1769,9 +1763,7 @@ def self.validate!(input, context:)
         when Types::UnionWithJsonName::Baz
           Hearth::Validator.validate_types!(input.__getobj__, ::String, context: context)
         else
-          raise ArgumentError,
-                "Expected #{context} to be a union member of "\
-                "Types::UnionWithJsonName, got #{input.class}."
+          raise ArgumentError, "Expected #{context} to be a union member of Types::UnionWithJsonName, got #{input.class}."
         end
       end
 
diff --git a/codegen/projections/rails_json/sig/rails_json/client.rbs b/codegen/projections/rails_json/sig/rails_json/client.rbs
index d7528eada..66074cce0 100644
--- a/codegen/projections/rails_json/sig/rails_json/client.rbs
+++ b/codegen/projections/rails_json/sig/rails_json/client.rbs
@@ -524,21 +524,21 @@ module RailsJson
       (?Types::StreamingTraitsInput params, ?::Hash[::Symbol, untyped] options)  ?{ (::String) -> Hearth::BlockIO } -> Hearth::Output[Types::StreamingTraitsOutput] |
       (
         ?foo: ::String,
-        ?blob: ::String
+        ?blob: (Hearth::_ReadableIO | Hearth::_WritableIO)
       ) ?{ (::String) -> Hearth::BlockIO } -> Hearth::Output[Types::StreamingTraitsOutput]
 
     def streaming_traits_require_length: (?::Hash[::Symbol, untyped] params, ?::Hash[::Symbol, untyped] options)  -> Hearth::Output[Types::StreamingTraitsRequireLengthOutput] |
       (?Types::StreamingTraitsRequireLengthInput params, ?::Hash[::Symbol, untyped] options)  -> Hearth::Output[Types::StreamingTraitsRequireLengthOutput] |
       (
         ?foo: ::String,
-        ?blob: ::String
+        ?blob: (Hearth::_ReadableIO | Hearth::_WritableIO)
       ) -> Hearth::Output[Types::StreamingTraitsRequireLengthOutput]
 
     def streaming_traits_with_media_type: (?::Hash[::Symbol, untyped] params, ?::Hash[::Symbol, untyped] options)  ?{ (::String) -> Hearth::BlockIO } -> Hearth::Output[Types::StreamingTraitsWithMediaTypeOutput] |
       (?Types::StreamingTraitsWithMediaTypeInput params, ?::Hash[::Symbol, untyped] options)  ?{ (::String) -> Hearth::BlockIO } -> Hearth::Output[Types::StreamingTraitsWithMediaTypeOutput] |
       (
         ?foo: ::String,
-        ?blob: ::String
+        ?blob: (Hearth::_ReadableIO | Hearth::_WritableIO)
       ) ?{ (::String) -> Hearth::BlockIO } -> Hearth::Output[Types::StreamingTraitsWithMediaTypeOutput]
 
     def test_body_structure: (?::Hash[::Symbol, untyped] params, ?::Hash[::Symbol, untyped] options)  -> Hearth::Output[Types::TestBodyStructureOutput] |
diff --git a/codegen/projections/rails_json/sig/rails_json/types.rbs b/codegen/projections/rails_json/sig/rails_json/types.rbs
index fcc97a6ba..62d9fee19 100644
--- a/codegen/projections/rails_json/sig/rails_json/types.rbs
+++ b/codegen/projections/rails_json/sig/rails_json/types.rbs
@@ -10,179 +10,179 @@
 module RailsJson
   module Types
 
-    class AllQueryStringTypesInput < ::Struct[untyped]
+    class AllQueryStringTypesInput
       include Hearth::Structure
-      attr_accessor query_string (): ::String
-      attr_accessor query_string_list (): ::Array[::String]
-      attr_accessor query_string_set (): ::Array[::String]
-      attr_accessor query_byte (): ::Integer
-      attr_accessor query_short (): ::Integer
-      attr_accessor query_integer (): ::Integer
-      attr_accessor query_integer_list (): ::Array[::Integer]
-      attr_accessor query_integer_set (): ::Array[::Integer]
-      attr_accessor query_long (): ::Integer
-      attr_accessor query_float (): ::Float
-      attr_accessor query_double (): ::Float
-      attr_accessor query_double_list (): ::Array[::Float]
-      attr_accessor query_boolean (): bool
-      attr_accessor query_boolean_list (): ::Array[bool]
-      attr_accessor query_timestamp (): ::Time
-      attr_accessor query_timestamp_list (): ::Array[::Time]
-      attr_accessor query_enum (): ::String
-      attr_accessor query_enum_list (): ::Array[::String]
-      attr_accessor query_integer_enum (): ::Integer
-      attr_accessor query_integer_enum_list (): ::Array[::Integer]
-      attr_accessor query_params_map_of_string_list (): ::Hash[::String, ::Array[::String]]
+      attr_accessor query_string (): ::String?
+      attr_accessor query_string_list (): ::Array[::String]?
+      attr_accessor query_string_set (): ::Array[::String]?
+      attr_accessor query_byte (): ::Integer?
+      attr_accessor query_short (): ::Integer?
+      attr_accessor query_integer (): ::Integer?
+      attr_accessor query_integer_list (): ::Array[::Integer]?
+      attr_accessor query_integer_set (): ::Array[::Integer]?
+      attr_accessor query_long (): ::Integer?
+      attr_accessor query_float (): ::Float?
+      attr_accessor query_double (): ::Float?
+      attr_accessor query_double_list (): ::Array[::Float]?
+      attr_accessor query_boolean (): bool?
+      attr_accessor query_boolean_list (): ::Array[bool]?
+      attr_accessor query_timestamp (): ::Time?
+      attr_accessor query_timestamp_list (): ::Array[::Time]?
+      attr_accessor query_enum (): ::String?
+      attr_accessor query_enum_list (): ::Array[::String]?
+      attr_accessor query_integer_enum (): ::Integer?
+      attr_accessor query_integer_enum_list (): ::Array[::Integer]?
+      attr_accessor query_params_map_of_string_list (): ::Hash[::String, ::Array[::String]]?
     end
 
-    class AllQueryStringTypesOutput < ::Struct[untyped]
+    class AllQueryStringTypesOutput
       include Hearth::Structure
     end
 
-    class ClientOptionalDefaults < ::Struct[untyped]
+    class ClientOptionalDefaults
       include Hearth::Structure
-      attr_accessor member (): ::Integer
+      attr_accessor member (): ::Integer?
     end
 
-    class ComplexError < ::Struct[untyped]
+    class ComplexError
       include Hearth::Structure
-      attr_accessor header (): ::String
-      attr_accessor top_level (): ::String
-      attr_accessor nested (): Types::ComplexNestedErrorData
+      attr_accessor header (): ::String?
+      attr_accessor top_level (): ::String?
+      attr_accessor nested (): Types::ComplexNestedErrorData?
     end
 
-    class ComplexNestedErrorData < ::Struct[untyped]
+    class ComplexNestedErrorData
       include Hearth::Structure
-      attr_accessor foo (): ::String
+      attr_accessor foo (): ::String?
     end
 
-    class ConstantAndVariableQueryStringInput < ::Struct[untyped]
+    class ConstantAndVariableQueryStringInput
       include Hearth::Structure
-      attr_accessor baz (): ::String
-      attr_accessor maybe_set (): ::String
+      attr_accessor baz (): ::String?
+      attr_accessor maybe_set (): ::String?
     end
 
-    class ConstantAndVariableQueryStringOutput < ::Struct[untyped]
+    class ConstantAndVariableQueryStringOutput
       include Hearth::Structure
     end
 
-    class ConstantQueryStringInput < ::Struct[untyped]
+    class ConstantQueryStringInput
       include Hearth::Structure
       attr_accessor hello (): ::String
     end
 
-    class ConstantQueryStringOutput < ::Struct[untyped]
+    class ConstantQueryStringOutput
       include Hearth::Structure
     end
 
-    class DatetimeOffsetsInput < ::Struct[untyped]
+    class DatetimeOffsetsInput
       include Hearth::Structure
     end
 
-    class DatetimeOffsetsOutput < ::Struct[untyped]
+    class DatetimeOffsetsOutput
       include Hearth::Structure
-      attr_accessor datetime (): ::Time
+      attr_accessor datetime (): ::Time?
     end
 
-    class Defaults < ::Struct[untyped]
+    class Defaults
       include Hearth::Structure
-      attr_accessor default_string (): ::String
-      attr_accessor default_boolean (): bool
-      attr_accessor default_list (): ::Array[::String]
-      attr_accessor default_document_map (): Hearth::document
-      attr_accessor default_document_string (): Hearth::document
-      attr_accessor default_document_boolean (): Hearth::document
-      attr_accessor default_document_list (): Hearth::document
-      attr_accessor default_null_document (): Hearth::document
-      attr_accessor default_timestamp (): ::Time
-      attr_accessor default_blob (): ::String
-      attr_accessor default_byte (): ::Integer
-      attr_accessor default_short (): ::Integer
-      attr_accessor default_integer (): ::Integer
-      attr_accessor default_long (): ::Integer
-      attr_accessor default_float (): ::Float
-      attr_accessor default_double (): ::Float
-      attr_accessor default_map (): ::Hash[::String, ::String]
-      attr_accessor default_enum (): ::String
-      attr_accessor default_int_enum (): ::Integer
-      attr_accessor empty_string (): ::String
-      attr_accessor false_boolean (): bool
-      attr_accessor empty_blob (): ::String
-      attr_accessor zero_byte (): ::Integer
-      attr_accessor zero_short (): ::Integer
-      attr_accessor zero_integer (): ::Integer
-      attr_accessor zero_long (): ::Integer
-      attr_accessor zero_float (): ::Float
-      attr_accessor zero_double (): ::Float
+      attr_accessor default_string (): ::String?
+      attr_accessor default_boolean (): bool?
+      attr_accessor default_list (): ::Array[::String]?
+      attr_accessor default_document_map (): Hearth::document?
+      attr_accessor default_document_string (): Hearth::document?
+      attr_accessor default_document_boolean (): Hearth::document?
+      attr_accessor default_document_list (): Hearth::document?
+      attr_accessor default_null_document (): Hearth::document?
+      attr_accessor default_timestamp (): ::Time?
+      attr_accessor default_blob (): ::String?
+      attr_accessor default_byte (): ::Integer?
+      attr_accessor default_short (): ::Integer?
+      attr_accessor default_integer (): ::Integer?
+      attr_accessor default_long (): ::Integer?
+      attr_accessor default_float (): ::Float?
+      attr_accessor default_double (): ::Float?
+      attr_accessor default_map (): ::Hash[::String, ::String]?
+      attr_accessor default_enum (): ::String?
+      attr_accessor default_int_enum (): ::Integer?
+      attr_accessor empty_string (): ::String?
+      attr_accessor false_boolean (): bool?
+      attr_accessor empty_blob (): ::String?
+      attr_accessor zero_byte (): ::Integer?
+      attr_accessor zero_short (): ::Integer?
+      attr_accessor zero_integer (): ::Integer?
+      attr_accessor zero_long (): ::Integer?
+      attr_accessor zero_float (): ::Float?
+      attr_accessor zero_double (): ::Float?
     end
 
-    class Dialog < ::Struct[untyped]
+    class Dialog
       include Hearth::Structure
-      attr_accessor language (): ::String
-      attr_accessor greeting (): ::String
-      attr_accessor farewell (): Types::Farewell
+      attr_accessor language (): ::String?
+      attr_accessor greeting (): ::String?
+      attr_accessor farewell (): Types::Farewell?
     end
 
-    class DocumentTypeAsMapValueInput < ::Struct[untyped]
+    class DocumentTypeAsMapValueInput
       include Hearth::Structure
-      attr_accessor doc_valued_map (): ::Hash[::String, Hearth::document]
+      attr_accessor doc_valued_map (): ::Hash[::String, Hearth::document]?
     end
 
-    class DocumentTypeAsMapValueOutput < ::Struct[untyped]
+    class DocumentTypeAsMapValueOutput
       include Hearth::Structure
-      attr_accessor doc_valued_map (): ::Hash[::String, Hearth::document]
+      attr_accessor doc_valued_map (): ::Hash[::String, Hearth::document]?
     end
 
-    class DocumentTypeAsPayloadInput < ::Struct[untyped]
+    class DocumentTypeAsPayloadInput
       include Hearth::Structure
-      attr_accessor document_value (): Hearth::document
+      attr_accessor document_value (): Hearth::document?
     end
 
-    class DocumentTypeAsPayloadOutput < ::Struct[untyped]
+    class DocumentTypeAsPayloadOutput
       include Hearth::Structure
-      attr_accessor document_value (): Hearth::document
+      attr_accessor document_value (): Hearth::document?
     end
 
-    class DocumentTypeInput < ::Struct[untyped]
+    class DocumentTypeInput
       include Hearth::Structure
-      attr_accessor string_value (): ::String
-      attr_accessor document_value (): Hearth::document
+      attr_accessor string_value (): ::String?
+      attr_accessor document_value (): Hearth::document?
     end
 
-    class DocumentTypeOutput < ::Struct[untyped]
+    class DocumentTypeOutput
       include Hearth::Structure
-      attr_accessor string_value (): ::String
-      attr_accessor document_value (): Hearth::document
+      attr_accessor string_value (): ::String?
+      attr_accessor document_value (): Hearth::document?
     end
 
-    class EmptyInputAndEmptyOutputInput < ::Struct[untyped]
+    class EmptyInputAndEmptyOutputInput
       include Hearth::Structure
     end
 
-    class EmptyInputAndEmptyOutputOutput < ::Struct[untyped]
+    class EmptyInputAndEmptyOutputOutput
       include Hearth::Structure
     end
 
-    class EndpointOperationInput < ::Struct[untyped]
+    class EndpointOperationInput
       include Hearth::Structure
     end
 
-    class EndpointOperationOutput < ::Struct[untyped]
+    class EndpointOperationOutput
       include Hearth::Structure
     end
 
-    class EndpointWithHostLabelOperationInput < ::Struct[untyped]
+    class EndpointWithHostLabelOperationInput
       include Hearth::Structure
       attr_accessor label (): ::String
     end
 
-    class EndpointWithHostLabelOperationOutput < ::Struct[untyped]
+    class EndpointWithHostLabelOperationOutput
       include Hearth::Structure
     end
 
-    class Farewell < ::Struct[untyped]
+    class Farewell
       include Hearth::Structure
-      attr_accessor phrase (): ::String
+      attr_accessor phrase (): ::String?
     end
 
     module FooEnum
@@ -197,143 +197,143 @@ module RailsJson
       ZERO: ::String
     end
 
-    class FractionalSecondsInput < ::Struct[untyped]
+    class FractionalSecondsInput
       include Hearth::Structure
     end
 
-    class FractionalSecondsOutput < ::Struct[untyped]
+    class FractionalSecondsOutput
       include Hearth::Structure
-      attr_accessor datetime (): ::Time
+      attr_accessor datetime (): ::Time?
     end
 
-    class GreetingStruct < ::Struct[untyped]
+    class GreetingStruct
       include Hearth::Structure
-      attr_accessor hi (): ::String
+      attr_accessor hi (): ::String?
     end
 
-    class GreetingWithErrorsInput < ::Struct[untyped]
+    class GreetingWithErrorsInput
       include Hearth::Structure
     end
 
-    class GreetingWithErrorsOutput < ::Struct[untyped]
+    class GreetingWithErrorsOutput
       include Hearth::Structure
-      attr_accessor greeting (): ::String
+      attr_accessor greeting (): ::String?
     end
 
-    class HostWithPathOperationInput < ::Struct[untyped]
+    class HostWithPathOperationInput
       include Hearth::Structure
     end
 
-    class HostWithPathOperationOutput < ::Struct[untyped]
+    class HostWithPathOperationOutput
       include Hearth::Structure
     end
 
-    class HttpChecksumRequiredInput < ::Struct[untyped]
+    class HttpChecksumRequiredInput
       include Hearth::Structure
-      attr_accessor foo (): ::String
+      attr_accessor foo (): ::String?
     end
 
-    class HttpChecksumRequiredOutput < ::Struct[untyped]
+    class HttpChecksumRequiredOutput
       include Hearth::Structure
-      attr_accessor foo (): ::String
+      attr_accessor foo (): ::String?
     end
 
-    class HttpEnumPayloadInput < ::Struct[untyped]
+    class HttpEnumPayloadInput
       include Hearth::Structure
-      attr_accessor payload (): ::String
+      attr_accessor payload (): ::String?
     end
 
-    class HttpEnumPayloadOutput < ::Struct[untyped]
+    class HttpEnumPayloadOutput
       include Hearth::Structure
-      attr_accessor payload (): ::String
+      attr_accessor payload (): ::String?
     end
 
-    class HttpPayloadTraitsInput < ::Struct[untyped]
+    class HttpPayloadTraitsInput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor blob (): ::String
+      attr_accessor foo (): ::String?
+      attr_accessor blob (): ::String?
     end
 
-    class HttpPayloadTraitsOutput < ::Struct[untyped]
+    class HttpPayloadTraitsOutput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor blob (): ::String
+      attr_accessor foo (): ::String?
+      attr_accessor blob (): ::String?
     end
 
-    class HttpPayloadTraitsWithMediaTypeInput < ::Struct[untyped]
+    class HttpPayloadTraitsWithMediaTypeInput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor blob (): ::String
+      attr_accessor foo (): ::String?
+      attr_accessor blob (): ::String?
     end
 
-    class HttpPayloadTraitsWithMediaTypeOutput < ::Struct[untyped]
+    class HttpPayloadTraitsWithMediaTypeOutput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor blob (): ::String
+      attr_accessor foo (): ::String?
+      attr_accessor blob (): ::String?
     end
 
-    class HttpPayloadWithStructureInput < ::Struct[untyped]
+    class HttpPayloadWithStructureInput
       include Hearth::Structure
-      attr_accessor nested (): Types::NestedPayload
+      attr_accessor nested (): Types::NestedPayload?
     end
 
-    class HttpPayloadWithStructureOutput < ::Struct[untyped]
+    class HttpPayloadWithStructureOutput
       include Hearth::Structure
-      attr_accessor nested (): Types::NestedPayload
+      attr_accessor nested (): Types::NestedPayload?
     end
 
-    class HttpPayloadWithUnionInput < ::Struct[untyped]
+    class HttpPayloadWithUnionInput
       include Hearth::Structure
-      attr_accessor nested (): Types::UnionPayload
+      attr_accessor nested (): Types::UnionPayload?
     end
 
-    class HttpPayloadWithUnionOutput < ::Struct[untyped]
+    class HttpPayloadWithUnionOutput
       include Hearth::Structure
-      attr_accessor nested (): Types::UnionPayload
+      attr_accessor nested (): Types::UnionPayload?
     end
 
-    class HttpPrefixHeadersInResponseInput < ::Struct[untyped]
+    class HttpPrefixHeadersInResponseInput
       include Hearth::Structure
     end
 
-    class HttpPrefixHeadersInResponseOutput < ::Struct[untyped]
+    class HttpPrefixHeadersInResponseOutput
       include Hearth::Structure
-      attr_accessor prefix_headers (): ::Hash[::String, ::String]
+      attr_accessor prefix_headers (): ::Hash[::String, ::String]?
     end
 
-    class HttpPrefixHeadersInput < ::Struct[untyped]
+    class HttpPrefixHeadersInput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor foo_map (): ::Hash[::String, ::String]
+      attr_accessor foo (): ::String?
+      attr_accessor foo_map (): ::Hash[::String, ::String]?
     end
 
-    class HttpPrefixHeadersOutput < ::Struct[untyped]
+    class HttpPrefixHeadersOutput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor foo_map (): ::Hash[::String, ::String]
+      attr_accessor foo (): ::String?
+      attr_accessor foo_map (): ::Hash[::String, ::String]?
     end
 
-    class HttpRequestWithFloatLabelsInput < ::Struct[untyped]
+    class HttpRequestWithFloatLabelsInput
       include Hearth::Structure
       attr_accessor float (): ::Float
       attr_accessor double (): ::Float
     end
 
-    class HttpRequestWithFloatLabelsOutput < ::Struct[untyped]
+    class HttpRequestWithFloatLabelsOutput
       include Hearth::Structure
     end
 
-    class HttpRequestWithGreedyLabelInPathInput < ::Struct[untyped]
+    class HttpRequestWithGreedyLabelInPathInput
       include Hearth::Structure
       attr_accessor foo (): ::String
       attr_accessor baz (): ::String
     end
 
-    class HttpRequestWithGreedyLabelInPathOutput < ::Struct[untyped]
+    class HttpRequestWithGreedyLabelInPathOutput
       include Hearth::Structure
     end
 
-    class HttpRequestWithLabelsAndTimestampFormatInput < ::Struct[untyped]
+    class HttpRequestWithLabelsAndTimestampFormatInput
       include Hearth::Structure
       attr_accessor member_epoch_seconds (): ::Time
       attr_accessor member_http_date (): ::Time
@@ -344,11 +344,11 @@ module RailsJson
       attr_accessor target_date_time (): ::Time
     end
 
-    class HttpRequestWithLabelsAndTimestampFormatOutput < ::Struct[untyped]
+    class HttpRequestWithLabelsAndTimestampFormatOutput
       include Hearth::Structure
     end
 
-    class HttpRequestWithLabelsInput < ::Struct[untyped]
+    class HttpRequestWithLabelsInput
       include Hearth::Structure
       attr_accessor string (): ::String
       attr_accessor short (): ::Integer
@@ -360,89 +360,89 @@ module RailsJson
       attr_accessor timestamp (): ::Time
     end
 
-    class HttpRequestWithLabelsOutput < ::Struct[untyped]
+    class HttpRequestWithLabelsOutput
       include Hearth::Structure
     end
 
-    class HttpRequestWithRegexLiteralInput < ::Struct[untyped]
+    class HttpRequestWithRegexLiteralInput
       include Hearth::Structure
       attr_accessor str (): ::String
     end
 
-    class HttpRequestWithRegexLiteralOutput < ::Struct[untyped]
+    class HttpRequestWithRegexLiteralOutput
       include Hearth::Structure
     end
 
-    class HttpResponseCodeInput < ::Struct[untyped]
+    class HttpResponseCodeInput
       include Hearth::Structure
     end
 
-    class HttpResponseCodeOutput < ::Struct[untyped]
+    class HttpResponseCodeOutput
       include Hearth::Structure
-      attr_accessor status (): ::Integer
+      attr_accessor status (): ::Integer?
     end
 
-    class HttpStringPayloadInput < ::Struct[untyped]
+    class HttpStringPayloadInput
       include Hearth::Structure
-      attr_accessor payload (): ::String
+      attr_accessor payload (): ::String?
     end
 
-    class HttpStringPayloadOutput < ::Struct[untyped]
+    class HttpStringPayloadOutput
       include Hearth::Structure
-      attr_accessor payload (): ::String
+      attr_accessor payload (): ::String?
     end
 
-    class IgnoreQueryParamsInResponseInput < ::Struct[untyped]
+    class IgnoreQueryParamsInResponseInput
       include Hearth::Structure
     end
 
-    class IgnoreQueryParamsInResponseOutput < ::Struct[untyped]
+    class IgnoreQueryParamsInResponseOutput
       include Hearth::Structure
-      attr_accessor baz (): ::String
+      attr_accessor baz (): ::String?
     end
 
-    class InputAndOutputWithHeadersInput < ::Struct[untyped]
-      include Hearth::Structure
-      attr_accessor header_string (): ::String
-      attr_accessor header_byte (): ::Integer
-      attr_accessor header_short (): ::Integer
-      attr_accessor header_integer (): ::Integer
-      attr_accessor header_long (): ::Integer
-      attr_accessor header_float (): ::Float
-      attr_accessor header_double (): ::Float
-      attr_accessor header_true_bool (): bool
-      attr_accessor header_false_bool (): bool
-      attr_accessor header_string_list (): ::Array[::String]
-      attr_accessor header_string_set (): ::Array[::String]
-      attr_accessor header_integer_list (): ::Array[::Integer]
-      attr_accessor header_boolean_list (): ::Array[bool]
-      attr_accessor header_timestamp_list (): ::Array[::Time]
-      attr_accessor header_enum (): ::String
-      attr_accessor header_enum_list (): ::Array[::String]
-      attr_accessor header_integer_enum (): ::Integer
-      attr_accessor header_integer_enum_list (): ::Array[::Integer]
-    end
-
-    class InputAndOutputWithHeadersOutput < ::Struct[untyped]
-      include Hearth::Structure
-      attr_accessor header_string (): ::String
-      attr_accessor header_byte (): ::Integer
-      attr_accessor header_short (): ::Integer
-      attr_accessor header_integer (): ::Integer
-      attr_accessor header_long (): ::Integer
-      attr_accessor header_float (): ::Float
-      attr_accessor header_double (): ::Float
-      attr_accessor header_true_bool (): bool
-      attr_accessor header_false_bool (): bool
-      attr_accessor header_string_list (): ::Array[::String]
-      attr_accessor header_string_set (): ::Array[::String]
-      attr_accessor header_integer_list (): ::Array[::Integer]
-      attr_accessor header_boolean_list (): ::Array[bool]
-      attr_accessor header_timestamp_list (): ::Array[::Time]
-      attr_accessor header_enum (): ::String
-      attr_accessor header_enum_list (): ::Array[::String]
-      attr_accessor header_integer_enum (): ::Integer
-      attr_accessor header_integer_enum_list (): ::Array[::Integer]
+    class InputAndOutputWithHeadersInput
+      include Hearth::Structure
+      attr_accessor header_string (): ::String?
+      attr_accessor header_byte (): ::Integer?
+      attr_accessor header_short (): ::Integer?
+      attr_accessor header_integer (): ::Integer?
+      attr_accessor header_long (): ::Integer?
+      attr_accessor header_float (): ::Float?
+      attr_accessor header_double (): ::Float?
+      attr_accessor header_true_bool (): bool?
+      attr_accessor header_false_bool (): bool?
+      attr_accessor header_string_list (): ::Array[::String]?
+      attr_accessor header_string_set (): ::Array[::String]?
+      attr_accessor header_integer_list (): ::Array[::Integer]?
+      attr_accessor header_boolean_list (): ::Array[bool]?
+      attr_accessor header_timestamp_list (): ::Array[::Time]?
+      attr_accessor header_enum (): ::String?
+      attr_accessor header_enum_list (): ::Array[::String]?
+      attr_accessor header_integer_enum (): ::Integer?
+      attr_accessor header_integer_enum_list (): ::Array[::Integer]?
+    end
+
+    class InputAndOutputWithHeadersOutput
+      include Hearth::Structure
+      attr_accessor header_string (): ::String?
+      attr_accessor header_byte (): ::Integer?
+      attr_accessor header_short (): ::Integer?
+      attr_accessor header_integer (): ::Integer?
+      attr_accessor header_long (): ::Integer?
+      attr_accessor header_float (): ::Float?
+      attr_accessor header_double (): ::Float?
+      attr_accessor header_true_bool (): bool?
+      attr_accessor header_false_bool (): bool?
+      attr_accessor header_string_list (): ::Array[::String]?
+      attr_accessor header_string_set (): ::Array[::String]?
+      attr_accessor header_integer_list (): ::Array[::Integer]?
+      attr_accessor header_boolean_list (): ::Array[bool]?
+      attr_accessor header_timestamp_list (): ::Array[::Time]?
+      attr_accessor header_enum (): ::String?
+      attr_accessor header_enum_list (): ::Array[::String]?
+      attr_accessor header_integer_enum (): ::Integer?
+      attr_accessor header_integer_enum_list (): ::Array[::Integer]?
     end
 
     module IntegerEnum
@@ -453,145 +453,145 @@ module RailsJson
       C: ::Numeric
     end
 
-    class InvalidGreeting < ::Struct[untyped]
+    class InvalidGreeting
       include Hearth::Structure
-      attr_accessor message (): ::String
+      attr_accessor message (): ::String?
     end
 
-    class JsonBlobsInput < ::Struct[untyped]
+    class JsonBlobsInput
       include Hearth::Structure
-      attr_accessor data (): ::String
+      attr_accessor data (): ::String?
     end
 
-    class JsonBlobsOutput < ::Struct[untyped]
+    class JsonBlobsOutput
       include Hearth::Structure
-      attr_accessor data (): ::String
+      attr_accessor data (): ::String?
     end
 
-    class JsonEnumsInput < ::Struct[untyped]
+    class JsonEnumsInput
       include Hearth::Structure
-      attr_accessor foo_enum1 (): ::String
-      attr_accessor foo_enum2 (): ::String
-      attr_accessor foo_enum3 (): ::String
-      attr_accessor foo_enum_list (): ::Array[::String]
-      attr_accessor foo_enum_set (): ::Array[::String]
-      attr_accessor foo_enum_map (): ::Hash[::String, ::String]
+      attr_accessor foo_enum1 (): ::String?
+      attr_accessor foo_enum2 (): ::String?
+      attr_accessor foo_enum3 (): ::String?
+      attr_accessor foo_enum_list (): ::Array[::String]?
+      attr_accessor foo_enum_set (): ::Array[::String]?
+      attr_accessor foo_enum_map (): ::Hash[::String, ::String]?
     end
 
-    class JsonEnumsOutput < ::Struct[untyped]
+    class JsonEnumsOutput
       include Hearth::Structure
-      attr_accessor foo_enum1 (): ::String
-      attr_accessor foo_enum2 (): ::String
-      attr_accessor foo_enum3 (): ::String
-      attr_accessor foo_enum_list (): ::Array[::String]
-      attr_accessor foo_enum_set (): ::Array[::String]
-      attr_accessor foo_enum_map (): ::Hash[::String, ::String]
+      attr_accessor foo_enum1 (): ::String?
+      attr_accessor foo_enum2 (): ::String?
+      attr_accessor foo_enum3 (): ::String?
+      attr_accessor foo_enum_list (): ::Array[::String]?
+      attr_accessor foo_enum_set (): ::Array[::String]?
+      attr_accessor foo_enum_map (): ::Hash[::String, ::String]?
     end
 
-    class JsonIntEnumsInput < ::Struct[untyped]
+    class JsonIntEnumsInput
       include Hearth::Structure
-      attr_accessor integer_enum1 (): ::Integer
-      attr_accessor integer_enum2 (): ::Integer
-      attr_accessor integer_enum3 (): ::Integer
-      attr_accessor integer_enum_list (): ::Array[::Integer]
-      attr_accessor integer_enum_set (): ::Array[::Integer]
-      attr_accessor integer_enum_map (): ::Hash[::String, ::Integer]
+      attr_accessor integer_enum1 (): ::Integer?
+      attr_accessor integer_enum2 (): ::Integer?
+      attr_accessor integer_enum3 (): ::Integer?
+      attr_accessor integer_enum_list (): ::Array[::Integer]?
+      attr_accessor integer_enum_set (): ::Array[::Integer]?
+      attr_accessor integer_enum_map (): ::Hash[::String, ::Integer]?
     end
 
-    class JsonIntEnumsOutput < ::Struct[untyped]
+    class JsonIntEnumsOutput
       include Hearth::Structure
-      attr_accessor integer_enum1 (): ::Integer
-      attr_accessor integer_enum2 (): ::Integer
-      attr_accessor integer_enum3 (): ::Integer
-      attr_accessor integer_enum_list (): ::Array[::Integer]
-      attr_accessor integer_enum_set (): ::Array[::Integer]
-      attr_accessor integer_enum_map (): ::Hash[::String, ::Integer]
+      attr_accessor integer_enum1 (): ::Integer?
+      attr_accessor integer_enum2 (): ::Integer?
+      attr_accessor integer_enum3 (): ::Integer?
+      attr_accessor integer_enum_list (): ::Array[::Integer]?
+      attr_accessor integer_enum_set (): ::Array[::Integer]?
+      attr_accessor integer_enum_map (): ::Hash[::String, ::Integer]?
     end
 
-    class JsonListsInput < ::Struct[untyped]
+    class JsonListsInput
       include Hearth::Structure
-      attr_accessor string_list (): ::Array[::String]
-      attr_accessor string_set (): ::Array[::String]
-      attr_accessor integer_list (): ::Array[::Integer]
-      attr_accessor boolean_list (): ::Array[bool]
-      attr_accessor timestamp_list (): ::Array[::Time]
-      attr_accessor enum_list (): ::Array[::String]
-      attr_accessor int_enum_list (): ::Array[::Integer]
-      attr_accessor nested_string_list (): ::Array[::Array[::String]]
-      attr_accessor structure_list (): ::Array[Types::StructureListMember]
+      attr_accessor string_list (): ::Array[::String]?
+      attr_accessor string_set (): ::Array[::String]?
+      attr_accessor integer_list (): ::Array[::Integer]?
+      attr_accessor boolean_list (): ::Array[bool]?
+      attr_accessor timestamp_list (): ::Array[::Time]?
+      attr_accessor enum_list (): ::Array[::String]?
+      attr_accessor int_enum_list (): ::Array[::Integer]?
+      attr_accessor nested_string_list (): ::Array[::Array[::String]]?
+      attr_accessor structure_list (): ::Array[Types::StructureListMember]?
     end
 
-    class JsonListsOutput < ::Struct[untyped]
+    class JsonListsOutput
       include Hearth::Structure
-      attr_accessor string_list (): ::Array[::String]
-      attr_accessor string_set (): ::Array[::String]
-      attr_accessor integer_list (): ::Array[::Integer]
-      attr_accessor boolean_list (): ::Array[bool]
-      attr_accessor timestamp_list (): ::Array[::Time]
-      attr_accessor enum_list (): ::Array[::String]
-      attr_accessor int_enum_list (): ::Array[::Integer]
-      attr_accessor nested_string_list (): ::Array[::Array[::String]]
-      attr_accessor structure_list (): ::Array[Types::StructureListMember]
+      attr_accessor string_list (): ::Array[::String]?
+      attr_accessor string_set (): ::Array[::String]?
+      attr_accessor integer_list (): ::Array[::Integer]?
+      attr_accessor boolean_list (): ::Array[bool]?
+      attr_accessor timestamp_list (): ::Array[::Time]?
+      attr_accessor enum_list (): ::Array[::String]?
+      attr_accessor int_enum_list (): ::Array[::Integer]?
+      attr_accessor nested_string_list (): ::Array[::Array[::String]]?
+      attr_accessor structure_list (): ::Array[Types::StructureListMember]?
     end
 
-    class JsonMapsInput < ::Struct[untyped]
+    class JsonMapsInput
       include Hearth::Structure
-      attr_accessor dense_struct_map (): ::Hash[::String, Types::GreetingStruct]
-      attr_accessor dense_number_map (): ::Hash[::String, ::Integer]
-      attr_accessor dense_boolean_map (): ::Hash[::String, bool]
-      attr_accessor dense_string_map (): ::Hash[::String, ::String]
-      attr_accessor dense_set_map (): ::Hash[::String, ::Array[::String]]
+      attr_accessor dense_struct_map (): ::Hash[::String, Types::GreetingStruct]?
+      attr_accessor dense_number_map (): ::Hash[::String, ::Integer]?
+      attr_accessor dense_boolean_map (): ::Hash[::String, bool]?
+      attr_accessor dense_string_map (): ::Hash[::String, ::String]?
+      attr_accessor dense_set_map (): ::Hash[::String, ::Array[::String]]?
     end
 
-    class JsonMapsOutput < ::Struct[untyped]
+    class JsonMapsOutput
       include Hearth::Structure
-      attr_accessor dense_struct_map (): ::Hash[::String, Types::GreetingStruct]
-      attr_accessor dense_number_map (): ::Hash[::String, ::Integer]
-      attr_accessor dense_boolean_map (): ::Hash[::String, bool]
-      attr_accessor dense_string_map (): ::Hash[::String, ::String]
-      attr_accessor dense_set_map (): ::Hash[::String, ::Array[::String]]
+      attr_accessor dense_struct_map (): ::Hash[::String, Types::GreetingStruct]?
+      attr_accessor dense_number_map (): ::Hash[::String, ::Integer]?
+      attr_accessor dense_boolean_map (): ::Hash[::String, bool]?
+      attr_accessor dense_string_map (): ::Hash[::String, ::String]?
+      attr_accessor dense_set_map (): ::Hash[::String, ::Array[::String]]?
     end
 
-    class JsonTimestampsInput < ::Struct[untyped]
+    class JsonTimestampsInput
       include Hearth::Structure
-      attr_accessor normal (): ::Time
-      attr_accessor date_time (): ::Time
-      attr_accessor date_time_on_target (): ::Time
-      attr_accessor epoch_seconds (): ::Time
-      attr_accessor epoch_seconds_on_target (): ::Time
-      attr_accessor http_date (): ::Time
-      attr_accessor http_date_on_target (): ::Time
+      attr_accessor normal (): ::Time?
+      attr_accessor date_time (): ::Time?
+      attr_accessor date_time_on_target (): ::Time?
+      attr_accessor epoch_seconds (): ::Time?
+      attr_accessor epoch_seconds_on_target (): ::Time?
+      attr_accessor http_date (): ::Time?
+      attr_accessor http_date_on_target (): ::Time?
     end
 
-    class JsonTimestampsOutput < ::Struct[untyped]
+    class JsonTimestampsOutput
       include Hearth::Structure
-      attr_accessor normal (): ::Time
-      attr_accessor date_time (): ::Time
-      attr_accessor date_time_on_target (): ::Time
-      attr_accessor epoch_seconds (): ::Time
-      attr_accessor epoch_seconds_on_target (): ::Time
-      attr_accessor http_date (): ::Time
-      attr_accessor http_date_on_target (): ::Time
+      attr_accessor normal (): ::Time?
+      attr_accessor date_time (): ::Time?
+      attr_accessor date_time_on_target (): ::Time?
+      attr_accessor epoch_seconds (): ::Time?
+      attr_accessor epoch_seconds_on_target (): ::Time?
+      attr_accessor http_date (): ::Time?
+      attr_accessor http_date_on_target (): ::Time?
     end
 
-    class JsonUnionsInput < ::Struct[untyped]
+    class JsonUnionsInput
       include Hearth::Structure
-      attr_accessor contents (): Types::MyUnion
+      attr_accessor contents (): Types::MyUnion?
     end
 
-    class JsonUnionsOutput < ::Struct[untyped]
+    class JsonUnionsOutput
       include Hearth::Structure
-      attr_accessor contents (): Types::MyUnion
+      attr_accessor contents (): Types::MyUnion?
     end
 
-    class MediaTypeHeaderInput < ::Struct[untyped]
+    class MediaTypeHeaderInput
       include Hearth::Structure
-      attr_accessor json (): ::String
+      attr_accessor json (): ::String?
     end
 
-    class MediaTypeHeaderOutput < ::Struct[untyped]
+    class MediaTypeHeaderOutput
       include Hearth::Structure
-      attr_accessor json (): ::String
+      attr_accessor json (): ::String?
     end
 
     class MyUnion < Hearth::Union
@@ -651,136 +651,136 @@ module RailsJson
       end
     end
 
-    class NestedPayload < ::Struct[untyped]
+    class NestedPayload
       include Hearth::Structure
-      attr_accessor greeting (): ::String
-      attr_accessor name (): ::String
+      attr_accessor greeting (): ::String?
+      attr_accessor name (): ::String?
     end
 
-    class NoInputAndNoOutputInput < ::Struct[untyped]
+    class NoInputAndNoOutputInput
       include Hearth::Structure
     end
 
-    class NoInputAndNoOutputOutput < ::Struct[untyped]
+    class NoInputAndNoOutputOutput
       include Hearth::Structure
     end
 
-    class NoInputAndOutputInput < ::Struct[untyped]
+    class NoInputAndOutputInput
       include Hearth::Structure
     end
 
-    class NoInputAndOutputOutput < ::Struct[untyped]
+    class NoInputAndOutputOutput
       include Hearth::Structure
     end
 
-    class NullAndEmptyHeadersClientInput < ::Struct[untyped]
+    class NullAndEmptyHeadersClientInput
       include Hearth::Structure
-      attr_accessor a (): ::String
-      attr_accessor b (): ::String
-      attr_accessor c (): ::Array[::String]
+      attr_accessor a (): ::String?
+      attr_accessor b (): ::String?
+      attr_accessor c (): ::Array[::String]?
     end
 
-    class NullAndEmptyHeadersClientOutput < ::Struct[untyped]
+    class NullAndEmptyHeadersClientOutput
       include Hearth::Structure
-      attr_accessor a (): ::String
-      attr_accessor b (): ::String
-      attr_accessor c (): ::Array[::String]
+      attr_accessor a (): ::String?
+      attr_accessor b (): ::String?
+      attr_accessor c (): ::Array[::String]?
     end
 
-    class NullAndEmptyHeadersServerInput < ::Struct[untyped]
+    class NullAndEmptyHeadersServerInput
       include Hearth::Structure
-      attr_accessor a (): ::String
-      attr_accessor b (): ::String
-      attr_accessor c (): ::Array[::String]
+      attr_accessor a (): ::String?
+      attr_accessor b (): ::String?
+      attr_accessor c (): ::Array[::String]?
     end
 
-    class NullAndEmptyHeadersServerOutput < ::Struct[untyped]
+    class NullAndEmptyHeadersServerOutput
       include Hearth::Structure
-      attr_accessor a (): ::String
-      attr_accessor b (): ::String
-      attr_accessor c (): ::Array[::String]
+      attr_accessor a (): ::String?
+      attr_accessor b (): ::String?
+      attr_accessor c (): ::Array[::String]?
     end
 
-    class OmitsNullSerializesEmptyStringInput < ::Struct[untyped]
+    class OmitsNullSerializesEmptyStringInput
       include Hearth::Structure
-      attr_accessor null_value (): ::String
-      attr_accessor empty_string (): ::String
+      attr_accessor null_value (): ::String?
+      attr_accessor empty_string (): ::String?
     end
 
-    class OmitsNullSerializesEmptyStringOutput < ::Struct[untyped]
+    class OmitsNullSerializesEmptyStringOutput
       include Hearth::Structure
     end
 
-    class OmitsSerializingEmptyListsInput < ::Struct[untyped]
+    class OmitsSerializingEmptyListsInput
       include Hearth::Structure
-      attr_accessor query_string_list (): ::Array[::String]
-      attr_accessor query_integer_list (): ::Array[::Integer]
-      attr_accessor query_double_list (): ::Array[::Float]
-      attr_accessor query_boolean_list (): ::Array[bool]
-      attr_accessor query_timestamp_list (): ::Array[::Time]
-      attr_accessor query_enum_list (): ::Array[::String]
-      attr_accessor query_integer_enum_list (): ::Array[::Integer]
+      attr_accessor query_string_list (): ::Array[::String]?
+      attr_accessor query_integer_list (): ::Array[::Integer]?
+      attr_accessor query_double_list (): ::Array[::Float]?
+      attr_accessor query_boolean_list (): ::Array[bool]?
+      attr_accessor query_timestamp_list (): ::Array[::Time]?
+      attr_accessor query_enum_list (): ::Array[::String]?
+      attr_accessor query_integer_enum_list (): ::Array[::Integer]?
     end
 
-    class OmitsSerializingEmptyListsOutput < ::Struct[untyped]
+    class OmitsSerializingEmptyListsOutput
       include Hearth::Structure
     end
 
-    class OperationWithDefaultsInput < ::Struct[untyped]
+    class OperationWithDefaultsInput
       include Hearth::Structure
-      attr_accessor defaults (): Types::Defaults
-      attr_accessor client_optional_defaults (): Types::ClientOptionalDefaults
-      attr_accessor top_level_default (): ::String
-      attr_accessor other_top_level_default (): ::Integer
+      attr_accessor defaults (): Types::Defaults?
+      attr_accessor client_optional_defaults (): Types::ClientOptionalDefaults?
+      attr_accessor top_level_default (): ::String?
+      attr_accessor other_top_level_default (): ::Integer?
     end
 
-    class OperationWithDefaultsOutput < ::Struct[untyped]
+    class OperationWithDefaultsOutput
       include Hearth::Structure
-      attr_accessor default_string (): ::String
-      attr_accessor default_boolean (): bool
-      attr_accessor default_list (): ::Array[::String]
-      attr_accessor default_document_map (): Hearth::document
-      attr_accessor default_document_string (): Hearth::document
-      attr_accessor default_document_boolean (): Hearth::document
-      attr_accessor default_document_list (): Hearth::document
-      attr_accessor default_null_document (): Hearth::document
-      attr_accessor default_timestamp (): ::Time
-      attr_accessor default_blob (): ::String
-      attr_accessor default_byte (): ::Integer
-      attr_accessor default_short (): ::Integer
-      attr_accessor default_integer (): ::Integer
-      attr_accessor default_long (): ::Integer
-      attr_accessor default_float (): ::Float
-      attr_accessor default_double (): ::Float
-      attr_accessor default_map (): ::Hash[::String, ::String]
-      attr_accessor default_enum (): ::String
-      attr_accessor default_int_enum (): ::Integer
-      attr_accessor empty_string (): ::String
-      attr_accessor false_boolean (): bool
-      attr_accessor empty_blob (): ::String
-      attr_accessor zero_byte (): ::Integer
-      attr_accessor zero_short (): ::Integer
-      attr_accessor zero_integer (): ::Integer
-      attr_accessor zero_long (): ::Integer
-      attr_accessor zero_float (): ::Float
-      attr_accessor zero_double (): ::Float
+      attr_accessor default_string (): ::String?
+      attr_accessor default_boolean (): bool?
+      attr_accessor default_list (): ::Array[::String]?
+      attr_accessor default_document_map (): Hearth::document?
+      attr_accessor default_document_string (): Hearth::document?
+      attr_accessor default_document_boolean (): Hearth::document?
+      attr_accessor default_document_list (): Hearth::document?
+      attr_accessor default_null_document (): Hearth::document?
+      attr_accessor default_timestamp (): ::Time?
+      attr_accessor default_blob (): ::String?
+      attr_accessor default_byte (): ::Integer?
+      attr_accessor default_short (): ::Integer?
+      attr_accessor default_integer (): ::Integer?
+      attr_accessor default_long (): ::Integer?
+      attr_accessor default_float (): ::Float?
+      attr_accessor default_double (): ::Float?
+      attr_accessor default_map (): ::Hash[::String, ::String]?
+      attr_accessor default_enum (): ::String?
+      attr_accessor default_int_enum (): ::Integer?
+      attr_accessor empty_string (): ::String?
+      attr_accessor false_boolean (): bool?
+      attr_accessor empty_blob (): ::String?
+      attr_accessor zero_byte (): ::Integer?
+      attr_accessor zero_short (): ::Integer?
+      attr_accessor zero_integer (): ::Integer?
+      attr_accessor zero_long (): ::Integer?
+      attr_accessor zero_float (): ::Float?
+      attr_accessor zero_double (): ::Float?
     end
 
-    class OperationWithNestedStructureInput < ::Struct[untyped]
+    class OperationWithNestedStructureInput
       include Hearth::Structure
       attr_accessor top_level (): Types::TopLevel
     end
 
-    class OperationWithNestedStructureOutput < ::Struct[untyped]
+    class OperationWithNestedStructureOutput
       include Hearth::Structure
       attr_accessor dialog (): Types::Dialog
-      attr_accessor dialog_list (): ::Array[Types::Dialog]
-      attr_accessor dialog_map (): ::Hash[::String, Types::Dialog]
+      attr_accessor dialog_list (): ::Array[Types::Dialog]?
+      attr_accessor dialog_map (): ::Hash[::String, Types::Dialog]?
     end
 
-    class PayloadConfig < ::Struct[untyped]
+    class PayloadConfig
       include Hearth::Structure
-      attr_accessor data (): ::Integer
+      attr_accessor data (): ::Integer?
     end
 
     class PlayerAction < Hearth::Union
@@ -795,207 +795,207 @@ module RailsJson
       end
     end
 
-    class PostPlayerActionInput < ::Struct[untyped]
+    class PostPlayerActionInput
       include Hearth::Structure
-      attr_accessor action (): Types::PlayerAction
+      attr_accessor action (): Types::PlayerAction?
     end
 
-    class PostPlayerActionOutput < ::Struct[untyped]
+    class PostPlayerActionOutput
       include Hearth::Structure
       attr_accessor action (): Types::PlayerAction
     end
 
-    class PostUnionWithJsonNameInput < ::Struct[untyped]
+    class PostUnionWithJsonNameInput
       include Hearth::Structure
-      attr_accessor value (): Types::UnionWithJsonName
+      attr_accessor value (): Types::UnionWithJsonName?
     end
 
-    class PostUnionWithJsonNameOutput < ::Struct[untyped]
+    class PostUnionWithJsonNameOutput
       include Hearth::Structure
       attr_accessor value (): Types::UnionWithJsonName
     end
 
-    class PutWithContentEncodingInput < ::Struct[untyped]
+    class PutWithContentEncodingInput
       include Hearth::Structure
-      attr_accessor encoding (): ::String
-      attr_accessor data (): ::String
+      attr_accessor encoding (): ::String?
+      attr_accessor data (): ::String?
     end
 
-    class PutWithContentEncodingOutput < ::Struct[untyped]
+    class PutWithContentEncodingOutput
       include Hearth::Structure
     end
 
-    class QueryIdempotencyTokenAutoFillInput < ::Struct[untyped]
+    class QueryIdempotencyTokenAutoFillInput
       include Hearth::Structure
-      attr_accessor token (): ::String
+      attr_accessor token (): ::String?
     end
 
-    class QueryIdempotencyTokenAutoFillOutput < ::Struct[untyped]
+    class QueryIdempotencyTokenAutoFillOutput
       include Hearth::Structure
     end
 
-    class QueryParamsAsStringListMapInput < ::Struct[untyped]
+    class QueryParamsAsStringListMapInput
       include Hearth::Structure
-      attr_accessor qux (): ::String
-      attr_accessor foo (): ::Hash[::String, ::Array[::String]]
+      attr_accessor qux (): ::String?
+      attr_accessor foo (): ::Hash[::String, ::Array[::String]]?
     end
 
-    class QueryParamsAsStringListMapOutput < ::Struct[untyped]
+    class QueryParamsAsStringListMapOutput
       include Hearth::Structure
     end
 
-    class QueryPrecedenceInput < ::Struct[untyped]
+    class QueryPrecedenceInput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor baz (): ::Hash[::String, ::String]
+      attr_accessor foo (): ::String?
+      attr_accessor baz (): ::Hash[::String, ::String]?
     end
 
-    class QueryPrecedenceOutput < ::Struct[untyped]
+    class QueryPrecedenceOutput
       include Hearth::Structure
     end
 
-    class RecursiveShapesInput < ::Struct[untyped]
+    class RecursiveShapesInput
       include Hearth::Structure
-      attr_accessor nested (): Types::RecursiveShapesInputOutputNested1
+      attr_accessor nested (): Types::RecursiveShapesInputOutputNested1?
     end
 
-    class RecursiveShapesInputOutputNested1 < ::Struct[untyped]
+    class RecursiveShapesInputOutputNested1
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor nested (): Types::RecursiveShapesInputOutputNested2
+      attr_accessor foo (): ::String?
+      attr_accessor nested (): Types::RecursiveShapesInputOutputNested2?
     end
 
-    class RecursiveShapesInputOutputNested2 < ::Struct[untyped]
+    class RecursiveShapesInputOutputNested2
       include Hearth::Structure
-      attr_accessor bar (): ::String
-      attr_accessor recursive_member (): Types::RecursiveShapesInputOutputNested1
+      attr_accessor bar (): ::String?
+      attr_accessor recursive_member (): Types::RecursiveShapesInputOutputNested1?
     end
 
-    class RecursiveShapesOutput < ::Struct[untyped]
+    class RecursiveShapesOutput
       include Hearth::Structure
-      attr_accessor nested (): Types::RecursiveShapesInputOutputNested1
+      attr_accessor nested (): Types::RecursiveShapesInputOutputNested1?
     end
 
-    class RenamedGreeting < ::Struct[untyped]
+    class RenamedGreeting
       include Hearth::Structure
-      attr_accessor salutation (): ::String
+      attr_accessor salutation (): ::String?
     end
 
-    class SimpleScalarPropertiesInput < ::Struct[untyped]
+    class SimpleScalarPropertiesInput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor string_value (): ::String
-      attr_accessor true_boolean_value (): bool
-      attr_accessor false_boolean_value (): bool
-      attr_accessor byte_value (): ::Integer
-      attr_accessor short_value (): ::Integer
-      attr_accessor integer_value (): ::Integer
-      attr_accessor long_value (): ::Integer
-      attr_accessor float_value (): ::Float
-      attr_accessor double_value (): ::Float
+      attr_accessor foo (): ::String?
+      attr_accessor string_value (): ::String?
+      attr_accessor true_boolean_value (): bool?
+      attr_accessor false_boolean_value (): bool?
+      attr_accessor byte_value (): ::Integer?
+      attr_accessor short_value (): ::Integer?
+      attr_accessor integer_value (): ::Integer?
+      attr_accessor long_value (): ::Integer?
+      attr_accessor float_value (): ::Float?
+      attr_accessor double_value (): ::Float?
     end
 
-    class SimpleScalarPropertiesOutput < ::Struct[untyped]
+    class SimpleScalarPropertiesOutput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor string_value (): ::String
-      attr_accessor true_boolean_value (): bool
-      attr_accessor false_boolean_value (): bool
-      attr_accessor byte_value (): ::Integer
-      attr_accessor short_value (): ::Integer
-      attr_accessor integer_value (): ::Integer
-      attr_accessor long_value (): ::Integer
-      attr_accessor float_value (): ::Float
-      attr_accessor double_value (): ::Float
+      attr_accessor foo (): ::String?
+      attr_accessor string_value (): ::String?
+      attr_accessor true_boolean_value (): bool?
+      attr_accessor false_boolean_value (): bool?
+      attr_accessor byte_value (): ::Integer?
+      attr_accessor short_value (): ::Integer?
+      attr_accessor integer_value (): ::Integer?
+      attr_accessor long_value (): ::Integer?
+      attr_accessor float_value (): ::Float?
+      attr_accessor double_value (): ::Float?
     end
 
-    class SparseJsonListsInput < ::Struct[untyped]
+    class SparseJsonListsInput
       include Hearth::Structure
-      attr_accessor sparse_string_list (): ::Array[::String]
+      attr_accessor sparse_string_list (): ::Array[::String?]?
     end
 
-    class SparseJsonListsOutput < ::Struct[untyped]
+    class SparseJsonListsOutput
       include Hearth::Structure
-      attr_accessor sparse_string_list (): ::Array[::String]
+      attr_accessor sparse_string_list (): ::Array[::String?]?
     end
 
-    class SparseJsonMapsInput < ::Struct[untyped]
+    class SparseJsonMapsInput
       include Hearth::Structure
-      attr_accessor sparse_struct_map (): ::Hash[::String, Types::GreetingStruct]
-      attr_accessor sparse_number_map (): ::Hash[::String, ::Integer]
-      attr_accessor sparse_boolean_map (): ::Hash[::String, bool]
-      attr_accessor sparse_string_map (): ::Hash[::String, ::String]
-      attr_accessor sparse_set_map (): ::Hash[::String, ::Array[::String]]
+      attr_accessor sparse_struct_map (): ::Hash[::String, Types::GreetingStruct?]?
+      attr_accessor sparse_number_map (): ::Hash[::String, ::Integer?]?
+      attr_accessor sparse_boolean_map (): ::Hash[::String, bool?]?
+      attr_accessor sparse_string_map (): ::Hash[::String, ::String?]?
+      attr_accessor sparse_set_map (): ::Hash[::String, ::Array[::String]?]?
     end
 
-    class SparseJsonMapsOutput < ::Struct[untyped]
+    class SparseJsonMapsOutput
       include Hearth::Structure
-      attr_accessor sparse_struct_map (): ::Hash[::String, Types::GreetingStruct]
-      attr_accessor sparse_number_map (): ::Hash[::String, ::Integer]
-      attr_accessor sparse_boolean_map (): ::Hash[::String, bool]
-      attr_accessor sparse_string_map (): ::Hash[::String, ::String]
-      attr_accessor sparse_set_map (): ::Hash[::String, ::Array[::String]]
+      attr_accessor sparse_struct_map (): ::Hash[::String, Types::GreetingStruct?]?
+      attr_accessor sparse_number_map (): ::Hash[::String, ::Integer?]?
+      attr_accessor sparse_boolean_map (): ::Hash[::String, bool?]?
+      attr_accessor sparse_string_map (): ::Hash[::String, ::String?]?
+      attr_accessor sparse_set_map (): ::Hash[::String, ::Array[::String]?]?
     end
 
-    class StreamingTraitsInput < ::Struct[untyped]
+    class StreamingTraitsInput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor blob (): ::String
+      attr_accessor foo (): ::String?
+      attr_accessor blob (): (Hearth::_ReadableIO | Hearth::_WritableIO)?
     end
 
-    class StreamingTraitsOutput < ::Struct[untyped]
+    class StreamingTraitsOutput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor blob (): ::String
+      attr_accessor foo (): ::String?
+      attr_accessor blob (): (Hearth::_ReadableIO | Hearth::_WritableIO)?
     end
 
-    class StreamingTraitsRequireLengthInput < ::Struct[untyped]
+    class StreamingTraitsRequireLengthInput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor blob (): ::String
+      attr_accessor foo (): ::String?
+      attr_accessor blob (): (Hearth::_ReadableIO | Hearth::_WritableIO)?
     end
 
-    class StreamingTraitsRequireLengthOutput < ::Struct[untyped]
+    class StreamingTraitsRequireLengthOutput
       include Hearth::Structure
     end
 
-    class StreamingTraitsWithMediaTypeInput < ::Struct[untyped]
+    class StreamingTraitsWithMediaTypeInput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor blob (): ::String
+      attr_accessor foo (): ::String?
+      attr_accessor blob (): (Hearth::_ReadableIO | Hearth::_WritableIO)?
     end
 
-    class StreamingTraitsWithMediaTypeOutput < ::Struct[untyped]
+    class StreamingTraitsWithMediaTypeOutput
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor blob (): ::String
+      attr_accessor foo (): ::String?
+      attr_accessor blob (): (Hearth::_ReadableIO | Hearth::_WritableIO)?
     end
 
     module StringEnum
       V: ::String
     end
 
-    class StructureListMember < ::Struct[untyped]
+    class StructureListMember
       include Hearth::Structure
-      attr_accessor a (): ::String
-      attr_accessor b (): ::String
+      attr_accessor a (): ::String?
+      attr_accessor b (): ::String?
     end
 
-    class TestBodyStructureInput < ::Struct[untyped]
+    class TestBodyStructureInput
       include Hearth::Structure
-      attr_accessor test_id (): ::String
-      attr_accessor test_config (): Types::TestConfig
+      attr_accessor test_id (): ::String?
+      attr_accessor test_config (): Types::TestConfig?
     end
 
-    class TestBodyStructureOutput < ::Struct[untyped]
+    class TestBodyStructureOutput
       include Hearth::Structure
-      attr_accessor test_id (): ::String
-      attr_accessor test_config (): Types::TestConfig
+      attr_accessor test_id (): ::String?
+      attr_accessor test_config (): Types::TestConfig?
     end
 
-    class TestConfig < ::Struct[untyped]
+    class TestConfig
       include Hearth::Structure
-      attr_accessor timeout (): ::Integer
+      attr_accessor timeout (): ::Integer?
     end
 
     module TestEnum
@@ -1012,67 +1012,67 @@ module RailsJson
       TWO: ::Numeric
     end
 
-    class TestNoPayloadInput < ::Struct[untyped]
+    class TestNoPayloadInput
       include Hearth::Structure
-      attr_accessor test_id (): ::String
+      attr_accessor test_id (): ::String?
     end
 
-    class TestNoPayloadOutput < ::Struct[untyped]
+    class TestNoPayloadOutput
       include Hearth::Structure
-      attr_accessor test_id (): ::String
+      attr_accessor test_id (): ::String?
     end
 
-    class TestPayloadBlobInput < ::Struct[untyped]
+    class TestPayloadBlobInput
       include Hearth::Structure
-      attr_accessor content_type (): ::String
-      attr_accessor data (): ::String
+      attr_accessor content_type (): ::String?
+      attr_accessor data (): ::String?
     end
 
-    class TestPayloadBlobOutput < ::Struct[untyped]
+    class TestPayloadBlobOutput
       include Hearth::Structure
-      attr_accessor content_type (): ::String
-      attr_accessor data (): ::String
+      attr_accessor content_type (): ::String?
+      attr_accessor data (): ::String?
     end
 
-    class TestPayloadStructureInput < ::Struct[untyped]
+    class TestPayloadStructureInput
       include Hearth::Structure
-      attr_accessor test_id (): ::String
-      attr_accessor payload_config (): Types::PayloadConfig
+      attr_accessor test_id (): ::String?
+      attr_accessor payload_config (): Types::PayloadConfig?
     end
 
-    class TestPayloadStructureOutput < ::Struct[untyped]
+    class TestPayloadStructureOutput
       include Hearth::Structure
-      attr_accessor test_id (): ::String
-      attr_accessor payload_config (): Types::PayloadConfig
+      attr_accessor test_id (): ::String?
+      attr_accessor payload_config (): Types::PayloadConfig?
     end
 
-    class TimestampFormatHeadersInput < ::Struct[untyped]
+    class TimestampFormatHeadersInput
       include Hearth::Structure
-      attr_accessor member_epoch_seconds (): ::Time
-      attr_accessor member_http_date (): ::Time
-      attr_accessor member_date_time (): ::Time
-      attr_accessor default_format (): ::Time
-      attr_accessor target_epoch_seconds (): ::Time
-      attr_accessor target_http_date (): ::Time
-      attr_accessor target_date_time (): ::Time
+      attr_accessor member_epoch_seconds (): ::Time?
+      attr_accessor member_http_date (): ::Time?
+      attr_accessor member_date_time (): ::Time?
+      attr_accessor default_format (): ::Time?
+      attr_accessor target_epoch_seconds (): ::Time?
+      attr_accessor target_http_date (): ::Time?
+      attr_accessor target_date_time (): ::Time?
     end
 
-    class TimestampFormatHeadersOutput < ::Struct[untyped]
+    class TimestampFormatHeadersOutput
       include Hearth::Structure
-      attr_accessor member_epoch_seconds (): ::Time
-      attr_accessor member_http_date (): ::Time
-      attr_accessor member_date_time (): ::Time
-      attr_accessor default_format (): ::Time
-      attr_accessor target_epoch_seconds (): ::Time
-      attr_accessor target_http_date (): ::Time
-      attr_accessor target_date_time (): ::Time
+      attr_accessor member_epoch_seconds (): ::Time?
+      attr_accessor member_http_date (): ::Time?
+      attr_accessor member_date_time (): ::Time?
+      attr_accessor default_format (): ::Time?
+      attr_accessor target_epoch_seconds (): ::Time?
+      attr_accessor target_http_date (): ::Time?
+      attr_accessor target_date_time (): ::Time?
     end
 
-    class TopLevel < ::Struct[untyped]
+    class TopLevel
       include Hearth::Structure
       attr_accessor dialog (): Types::Dialog
-      attr_accessor dialog_list (): ::Array[Types::Dialog]
-      attr_accessor dialog_map (): ::Hash[::String, Types::Dialog]
+      attr_accessor dialog_list (): ::Array[Types::Dialog]?
+      attr_accessor dialog_map (): ::Hash[::String, Types::Dialog]?
     end
 
     class UnionPayload < Hearth::Union
@@ -1109,15 +1109,15 @@ module RailsJson
       end
     end
 
-    class Unit < ::Struct[untyped]
+    class Unit
       include Hearth::Structure
     end
 
-    class UnitInputAndOutputInput < ::Struct[untyped]
+    class UnitInputAndOutputInput
       include Hearth::Structure
     end
 
-    class UnitInputAndOutputOutput < ::Struct[untyped]
+    class UnitInputAndOutputOutput
       include Hearth::Structure
     end
 
diff --git a/codegen/projections/rails_json/spec/protocol_spec.rb b/codegen/projections/rails_json/spec/protocol_spec.rb
index 5055f5571..91bc08244 100644
--- a/codegen/projections/rails_json/spec/protocol_spec.rb
+++ b/codegen/projections/rails_json/spec/protocol_spec.rb
@@ -7862,7 +7862,7 @@ module RailsJson
       describe 'requests' do
 
         # Serializes a blob in the HTTP payload
-        it 'RailsJsonStreamingTraitsWithBlob' do
+        it 'RailsJsonStreamingTraitsWithBlob', rbs_test: :skip do
           proc = proc do |context|
             request = context.request
             expect(request.http_method).to eq('POST')
@@ -7879,7 +7879,7 @@ module RailsJson
         end
 
         # Serializes an empty blob in the HTTP payload
-        it 'RailsJsonStreamingTraitsWithNoBlobBody' do
+        it 'RailsJsonStreamingTraitsWithNoBlobBody', rbs_test: :skip do
           proc = proc do |context|
             request = context.request
             expect(request.http_method).to eq('POST')
@@ -7899,7 +7899,7 @@ module RailsJson
       describe 'responses' do
 
         # Serializes a blob in the HTTP payload
-        it 'RailsJsonStreamingTraitsWithBlob' do
+        it 'RailsJsonStreamingTraitsWithBlob', rbs_test: :skip do
           response = Hearth::HTTP::Response.new
           response.status = 200
           response.headers['Content-Type'] = 'application/octet-stream'
@@ -7919,7 +7919,7 @@ module RailsJson
         end
 
         # Serializes an empty blob in the HTTP payload
-        it 'RailsJsonStreamingTraitsWithNoBlobBody' do
+        it 'RailsJsonStreamingTraitsWithNoBlobBody', rbs_test: :skip do
           response = Hearth::HTTP::Response.new
           response.status = 200
           response.headers['X-Foo'] = 'Foo'
@@ -7941,7 +7941,7 @@ module RailsJson
       describe 'stubs' do
 
         # Serializes a blob in the HTTP payload
-        it 'stubs RailsJsonStreamingTraitsWithBlob' do
+        it 'stubs RailsJsonStreamingTraitsWithBlob', rbs_test: :skip do
           proc = proc do |context|
             expect(context.response.status).to eq(200)
           end
@@ -7962,7 +7962,7 @@ module RailsJson
         end
 
         # Serializes an empty blob in the HTTP payload
-        it 'stubs RailsJsonStreamingTraitsWithNoBlobBody' do
+        it 'stubs RailsJsonStreamingTraitsWithNoBlobBody', rbs_test: :skip do
           proc = proc do |context|
             expect(context.response.status).to eq(200)
           end
@@ -7989,7 +7989,7 @@ module RailsJson
       describe 'requests' do
 
         # Serializes a blob in the HTTP payload with a required length
-        it 'RailsJsonStreamingTraitsRequireLengthWithBlob' do
+        it 'RailsJsonStreamingTraitsRequireLengthWithBlob', rbs_test: :skip do
           proc = proc do |context|
             request = context.request
             expect(request.http_method).to eq('POST')
@@ -8007,7 +8007,7 @@ module RailsJson
         end
 
         # Serializes an empty blob in the HTTP payload
-        it 'RailsJsonStreamingTraitsRequireLengthWithNoBlobBody' do
+        it 'RailsJsonStreamingTraitsRequireLengthWithNoBlobBody', rbs_test: :skip do
           proc = proc do |context|
             request = context.request
             expect(request.http_method).to eq('POST')
@@ -8031,7 +8031,7 @@ module RailsJson
       describe 'requests' do
 
         # Serializes a blob in the HTTP payload with a content-type
-        it 'RailsJsonStreamingTraitsWithMediaTypeWithBlob' do
+        it 'RailsJsonStreamingTraitsWithMediaTypeWithBlob', rbs_test: :skip do
           proc = proc do |context|
             request = context.request
             expect(request.http_method).to eq('POST')
@@ -8052,7 +8052,7 @@ module RailsJson
       describe 'responses' do
 
         # Serializes a blob in the HTTP payload with a content-type
-        it 'RailsJsonStreamingTraitsWithMediaTypeWithBlob' do
+        it 'RailsJsonStreamingTraitsWithMediaTypeWithBlob', rbs_test: :skip do
           response = Hearth::HTTP::Response.new
           response.status = 200
           response.headers['Content-Type'] = 'text/plain'
@@ -8076,7 +8076,7 @@ module RailsJson
       describe 'stubs' do
 
         # Serializes a blob in the HTTP payload with a content-type
-        it 'stubs RailsJsonStreamingTraitsWithMediaTypeWithBlob' do
+        it 'stubs RailsJsonStreamingTraitsWithMediaTypeWithBlob', rbs_test: :skip do
           proc = proc do |context|
             expect(context.response.status).to eq(200)
           end
diff --git a/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/builders.rb b/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/builders.rb
index f5b742740..6118f4d9e 100644
--- a/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/builders.rb
+++ b/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/builders.rb
@@ -36,7 +36,7 @@ def self.build(input)
     class ClientOptionalDefaults
       def self.build(input)
         data = {}
-        data['member'] = input[:member] unless input[:member].nil?
+        data['member'] = input.member unless input.member.nil?
         data
       end
     end
@@ -44,29 +44,29 @@ def self.build(input)
     class Defaults
       def self.build(input)
         data = {}
-        data['defaultString'] = input[:default_string] unless input[:default_string].nil?
-        data['defaultBoolean'] = input[:default_boolean] unless input[:default_boolean].nil?
-        data['defaultList'] = TestStringList.build(input[:default_list]) unless input[:default_list].nil?
-        data['defaultTimestamp'] = input[:default_timestamp] unless input[:default_timestamp].nil?
-        data['defaultBlob'] = ((String === input[:default_blob] ? input[:default_blob] : input[:default_blob].read).encode(Encoding::BINARY)) unless input[:default_blob].nil?
-        data['defaultByte'] = input[:default_byte] unless input[:default_byte].nil?
-        data['defaultShort'] = input[:default_short] unless input[:default_short].nil?
-        data['defaultInteger'] = input[:default_integer] unless input[:default_integer].nil?
-        data['defaultLong'] = input[:default_long] unless input[:default_long].nil?
-        data['defaultFloat'] = input[:default_float] unless input[:default_float].nil?
-        data['defaultDouble'] = input[:default_double] unless input[:default_double].nil?
-        data['defaultMap'] = TestStringMap.build(input[:default_map]) unless input[:default_map].nil?
-        data['defaultEnum'] = input[:default_enum] unless input[:default_enum].nil?
-        data['defaultIntEnum'] = input[:default_int_enum] unless input[:default_int_enum].nil?
-        data['emptyString'] = input[:empty_string] unless input[:empty_string].nil?
-        data['falseBoolean'] = input[:false_boolean] unless input[:false_boolean].nil?
-        data['emptyBlob'] = ((String === input[:empty_blob] ? input[:empty_blob] : input[:empty_blob].read).encode(Encoding::BINARY)) unless input[:empty_blob].nil?
-        data['zeroByte'] = input[:zero_byte] unless input[:zero_byte].nil?
-        data['zeroShort'] = input[:zero_short] unless input[:zero_short].nil?
-        data['zeroInteger'] = input[:zero_integer] unless input[:zero_integer].nil?
-        data['zeroLong'] = input[:zero_long] unless input[:zero_long].nil?
-        data['zeroFloat'] = input[:zero_float] unless input[:zero_float].nil?
-        data['zeroDouble'] = input[:zero_double] unless input[:zero_double].nil?
+        data['defaultString'] = input.default_string unless input.default_string.nil?
+        data['defaultBoolean'] = input.default_boolean unless input.default_boolean.nil?
+        data['defaultList'] = TestStringList.build(input.default_list) unless input.default_list.nil?
+        data['defaultTimestamp'] = input.default_timestamp unless input.default_timestamp.nil?
+        data['defaultBlob'] = ((String === input.default_blob ? input.default_blob : input.default_blob.read).encode(Encoding::BINARY)) unless input.default_blob.nil?
+        data['defaultByte'] = input.default_byte unless input.default_byte.nil?
+        data['defaultShort'] = input.default_short unless input.default_short.nil?
+        data['defaultInteger'] = input.default_integer unless input.default_integer.nil?
+        data['defaultLong'] = input.default_long unless input.default_long.nil?
+        data['defaultFloat'] = input.default_float unless input.default_float.nil?
+        data['defaultDouble'] = input.default_double unless input.default_double.nil?
+        data['defaultMap'] = TestStringMap.build(input.default_map) unless input.default_map.nil?
+        data['defaultEnum'] = input.default_enum unless input.default_enum.nil?
+        data['defaultIntEnum'] = input.default_int_enum unless input.default_int_enum.nil?
+        data['emptyString'] = input.empty_string unless input.empty_string.nil?
+        data['falseBoolean'] = input.false_boolean unless input.false_boolean.nil?
+        data['emptyBlob'] = ((String === input.empty_blob ? input.empty_blob : input.empty_blob.read).encode(Encoding::BINARY)) unless input.empty_blob.nil?
+        data['zeroByte'] = input.zero_byte unless input.zero_byte.nil?
+        data['zeroShort'] = input.zero_short unless input.zero_short.nil?
+        data['zeroInteger'] = input.zero_integer unless input.zero_integer.nil?
+        data['zeroLong'] = input.zero_long unless input.zero_long.nil?
+        data['zeroFloat'] = input.zero_float unless input.zero_float.nil?
+        data['zeroDouble'] = input.zero_double unless input.zero_double.nil?
         data
       end
     end
@@ -163,7 +163,7 @@ def self.build(http_req, input:)
     class GreetingStruct
       def self.build(input)
         data = {}
-        data['hi'] = input[:hi] unless input[:hi].nil?
+        data['hi'] = input.hi unless input.hi.nil?
         data
       end
     end
@@ -222,10 +222,10 @@ def self.build(http_req, input:)
         http_req.append_path('/service/RpcV2Protocol/operation/OperationWithDefaults')
         http_req.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
         data = {}
-        data['defaults'] = Defaults.build(input[:defaults]) unless input[:defaults].nil?
-        data['clientOptionalDefaults'] = ClientOptionalDefaults.build(input[:client_optional_defaults]) unless input[:client_optional_defaults].nil?
-        data['topLevelDefault'] = input[:top_level_default] unless input[:top_level_default].nil?
-        data['otherTopLevelDefault'] = input[:other_top_level_default] unless input[:other_top_level_default].nil?
+        data['defaults'] = Defaults.build(input.defaults) unless input.defaults.nil?
+        data['clientOptionalDefaults'] = ClientOptionalDefaults.build(input.client_optional_defaults) unless input.client_optional_defaults.nil?
+        data['topLevelDefault'] = input.top_level_default unless input.top_level_default.nil?
+        data['otherTopLevelDefault'] = input.other_top_level_default unless input.other_top_level_default.nil?
         http_req.headers['Content-Type'] = 'application/cbor'
         http_req.body = ::StringIO.new(Hearth::CBOR.encode(data))
       end
@@ -237,7 +237,7 @@ def self.build(http_req, input:)
         http_req.append_path('/service/RpcV2Protocol/operation/OptionalInputOutput')
         http_req.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
         data = {}
-        data['value'] = input[:value] unless input[:value].nil?
+        data['value'] = input.value unless input.value.nil?
         http_req.headers['Content-Type'] = 'application/cbor'
         http_req.body = ::StringIO.new(Hearth::CBOR.encode(data))
       end
@@ -249,7 +249,7 @@ def self.build(http_req, input:)
         http_req.append_path('/service/RpcV2Protocol/operation/RecursiveShapes')
         http_req.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
         data = {}
-        data['nested'] = RecursiveShapesInputOutputNested1.build(input[:nested]) unless input[:nested].nil?
+        data['nested'] = RecursiveShapesInputOutputNested1.build(input.nested) unless input.nested.nil?
         http_req.headers['Content-Type'] = 'application/cbor'
         http_req.body = ::StringIO.new(Hearth::CBOR.encode(data))
       end
@@ -258,8 +258,8 @@ def self.build(http_req, input:)
     class RecursiveShapesInputOutputNested1
       def self.build(input)
         data = {}
-        data['foo'] = input[:foo] unless input[:foo].nil?
-        data['nested'] = RecursiveShapesInputOutputNested2.build(input[:nested]) unless input[:nested].nil?
+        data['foo'] = input.foo unless input.foo.nil?
+        data['nested'] = RecursiveShapesInputOutputNested2.build(input.nested) unless input.nested.nil?
         data
       end
     end
@@ -267,8 +267,8 @@ def self.build(input)
     class RecursiveShapesInputOutputNested2
       def self.build(input)
         data = {}
-        data['bar'] = input[:bar] unless input[:bar].nil?
-        data['recursiveMember'] = RecursiveShapesInputOutputNested1.build(input[:recursive_member]) unless input[:recursive_member].nil?
+        data['bar'] = input.bar unless input.bar.nil?
+        data['recursiveMember'] = RecursiveShapesInputOutputNested1.build(input.recursive_member) unless input.recursive_member.nil?
         data
       end
     end
@@ -279,11 +279,11 @@ def self.build(http_req, input:)
         http_req.append_path('/service/RpcV2Protocol/operation/RpcV2CborDenseMaps')
         http_req.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
         data = {}
-        data['denseStructMap'] = DenseStructMap.build(input[:dense_struct_map]) unless input[:dense_struct_map].nil?
-        data['denseNumberMap'] = DenseNumberMap.build(input[:dense_number_map]) unless input[:dense_number_map].nil?
-        data['denseBooleanMap'] = DenseBooleanMap.build(input[:dense_boolean_map]) unless input[:dense_boolean_map].nil?
-        data['denseStringMap'] = DenseStringMap.build(input[:dense_string_map]) unless input[:dense_string_map].nil?
-        data['denseSetMap'] = DenseSetMap.build(input[:dense_set_map]) unless input[:dense_set_map].nil?
+        data['denseStructMap'] = DenseStructMap.build(input.dense_struct_map) unless input.dense_struct_map.nil?
+        data['denseNumberMap'] = DenseNumberMap.build(input.dense_number_map) unless input.dense_number_map.nil?
+        data['denseBooleanMap'] = DenseBooleanMap.build(input.dense_boolean_map) unless input.dense_boolean_map.nil?
+        data['denseStringMap'] = DenseStringMap.build(input.dense_string_map) unless input.dense_string_map.nil?
+        data['denseSetMap'] = DenseSetMap.build(input.dense_set_map) unless input.dense_set_map.nil?
         http_req.headers['Content-Type'] = 'application/cbor'
         http_req.body = ::StringIO.new(Hearth::CBOR.encode(data))
       end
@@ -295,16 +295,16 @@ def self.build(http_req, input:)
         http_req.append_path('/service/RpcV2Protocol/operation/RpcV2CborLists')
         http_req.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
         data = {}
-        data['stringList'] = StringList.build(input[:string_list]) unless input[:string_list].nil?
-        data['stringSet'] = StringSet.build(input[:string_set]) unless input[:string_set].nil?
-        data['integerList'] = IntegerList.build(input[:integer_list]) unless input[:integer_list].nil?
-        data['booleanList'] = BooleanList.build(input[:boolean_list]) unless input[:boolean_list].nil?
-        data['timestampList'] = TimestampList.build(input[:timestamp_list]) unless input[:timestamp_list].nil?
-        data['enumList'] = FooEnumList.build(input[:enum_list]) unless input[:enum_list].nil?
-        data['intEnumList'] = IntegerEnumList.build(input[:int_enum_list]) unless input[:int_enum_list].nil?
-        data['nestedStringList'] = NestedStringList.build(input[:nested_string_list]) unless input[:nested_string_list].nil?
-        data['structureList'] = StructureList.build(input[:structure_list]) unless input[:structure_list].nil?
-        data['blobList'] = BlobList.build(input[:blob_list]) unless input[:blob_list].nil?
+        data['stringList'] = StringList.build(input.string_list) unless input.string_list.nil?
+        data['stringSet'] = StringSet.build(input.string_set) unless input.string_set.nil?
+        data['integerList'] = IntegerList.build(input.integer_list) unless input.integer_list.nil?
+        data['booleanList'] = BooleanList.build(input.boolean_list) unless input.boolean_list.nil?
+        data['timestampList'] = TimestampList.build(input.timestamp_list) unless input.timestamp_list.nil?
+        data['enumList'] = FooEnumList.build(input.enum_list) unless input.enum_list.nil?
+        data['intEnumList'] = IntegerEnumList.build(input.int_enum_list) unless input.int_enum_list.nil?
+        data['nestedStringList'] = NestedStringList.build(input.nested_string_list) unless input.nested_string_list.nil?
+        data['structureList'] = StructureList.build(input.structure_list) unless input.structure_list.nil?
+        data['blobList'] = BlobList.build(input.blob_list) unless input.blob_list.nil?
         http_req.headers['Content-Type'] = 'application/cbor'
         http_req.body = ::StringIO.new(Hearth::CBOR.encode(data))
       end
@@ -316,11 +316,11 @@ def self.build(http_req, input:)
         http_req.append_path('/service/RpcV2Protocol/operation/RpcV2CborSparseMaps')
         http_req.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
         data = {}
-        data['sparseStructMap'] = SparseStructMap.build(input[:sparse_struct_map]) unless input[:sparse_struct_map].nil?
-        data['sparseNumberMap'] = SparseNumberMap.build(input[:sparse_number_map]) unless input[:sparse_number_map].nil?
-        data['sparseBooleanMap'] = SparseBooleanMap.build(input[:sparse_boolean_map]) unless input[:sparse_boolean_map].nil?
-        data['sparseStringMap'] = SparseStringMap.build(input[:sparse_string_map]) unless input[:sparse_string_map].nil?
-        data['sparseSetMap'] = SparseSetMap.build(input[:sparse_set_map]) unless input[:sparse_set_map].nil?
+        data['sparseStructMap'] = SparseStructMap.build(input.sparse_struct_map) unless input.sparse_struct_map.nil?
+        data['sparseNumberMap'] = SparseNumberMap.build(input.sparse_number_map) unless input.sparse_number_map.nil?
+        data['sparseBooleanMap'] = SparseBooleanMap.build(input.sparse_boolean_map) unless input.sparse_boolean_map.nil?
+        data['sparseStringMap'] = SparseStringMap.build(input.sparse_string_map) unless input.sparse_string_map.nil?
+        data['sparseSetMap'] = SparseSetMap.build(input.sparse_set_map) unless input.sparse_set_map.nil?
         http_req.headers['Content-Type'] = 'application/cbor'
         http_req.body = ::StringIO.new(Hearth::CBOR.encode(data))
       end
@@ -332,16 +332,16 @@ def self.build(http_req, input:)
         http_req.append_path('/service/RpcV2Protocol/operation/SimpleScalarProperties')
         http_req.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
         data = {}
-        data['trueBooleanValue'] = input[:true_boolean_value] unless input[:true_boolean_value].nil?
-        data['falseBooleanValue'] = input[:false_boolean_value] unless input[:false_boolean_value].nil?
-        data['byteValue'] = input[:byte_value] unless input[:byte_value].nil?
-        data['doubleValue'] = input[:double_value] unless input[:double_value].nil?
-        data['floatValue'] = input[:float_value] unless input[:float_value].nil?
-        data['integerValue'] = input[:integer_value] unless input[:integer_value].nil?
-        data['longValue'] = input[:long_value] unless input[:long_value].nil?
-        data['shortValue'] = input[:short_value] unless input[:short_value].nil?
-        data['stringValue'] = input[:string_value] unless input[:string_value].nil?
-        data['blobValue'] = ((String === input[:blob_value] ? input[:blob_value] : input[:blob_value].read).encode(Encoding::BINARY)) unless input[:blob_value].nil?
+        data['trueBooleanValue'] = input.true_boolean_value unless input.true_boolean_value.nil?
+        data['falseBooleanValue'] = input.false_boolean_value unless input.false_boolean_value.nil?
+        data['byteValue'] = input.byte_value unless input.byte_value.nil?
+        data['doubleValue'] = input.double_value unless input.double_value.nil?
+        data['floatValue'] = input.float_value unless input.float_value.nil?
+        data['integerValue'] = input.integer_value unless input.integer_value.nil?
+        data['longValue'] = input.long_value unless input.long_value.nil?
+        data['shortValue'] = input.short_value unless input.short_value.nil?
+        data['stringValue'] = input.string_value unless input.string_value.nil?
+        data['blobValue'] = ((String === input.blob_value ? input.blob_value : input.blob_value.read).encode(Encoding::BINARY)) unless input.blob_value.nil?
         http_req.headers['Content-Type'] = 'application/cbor'
         http_req.body = ::StringIO.new(Hearth::CBOR.encode(data))
       end
@@ -363,8 +363,8 @@ def self.build(http_req, input:)
         http_req.append_path('/service/RpcV2Protocol/operation/SparseNullsOperation')
         http_req.headers['Smithy-Protocol'] = 'rpc-v2-cbor'
         data = {}
-        data['sparseStringList'] = SparseStringList.build(input[:sparse_string_list]) unless input[:sparse_string_list].nil?
-        data['sparseStringMap'] = SparseStringMap.build(input[:sparse_string_map]) unless input[:sparse_string_map].nil?
+        data['sparseStringList'] = SparseStringList.build(input.sparse_string_list) unless input.sparse_string_list.nil?
+        data['sparseStringMap'] = SparseStringMap.build(input.sparse_string_map) unless input.sparse_string_map.nil?
         http_req.headers['Content-Type'] = 'application/cbor'
         http_req.body = ::StringIO.new(Hearth::CBOR.encode(data))
       end
@@ -453,8 +453,8 @@ def self.build(input)
     class StructureListMember
       def self.build(input)
         data = {}
-        data['a'] = input[:a] unless input[:a].nil?
-        data['b'] = input[:b] unless input[:b].nil?
+        data['a'] = input.a unless input.a.nil?
+        data['b'] = input.b unless input.b.nil?
         data
       end
     end
diff --git a/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/stubs.rb b/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/stubs.rb
index 6cfa6f48d..06b106253 100644
--- a/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/stubs.rb
+++ b/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/stubs.rb
@@ -71,8 +71,8 @@ def self.stub(http_resp, stub:)
         http_resp.status = 400
         data = {}
         data['__type'] = 'ComplexError'
-        data['TopLevel'] = stub[:top_level] unless stub[:top_level].nil?
-        data['Nested'] = ComplexNestedErrorData.stub(stub[:nested]) unless stub[:nested].nil?
+        data['TopLevel'] = stub.top_level unless stub.top_level.nil?
+        data['Nested'] = ComplexNestedErrorData.stub(stub.nested) unless stub.nested.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
       end
     end
@@ -89,7 +89,7 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::ComplexNestedErrorData.new
         data = {}
-        data['Foo'] = stub[:foo] unless stub[:foo].nil?
+        data['Foo'] = stub.foo unless stub.foo.nil?
         data
       end
     end
@@ -99,7 +99,7 @@ def self.default(visited = [])
         return nil if visited.include?('DenseBooleanMap')
         visited = visited + ['DenseBooleanMap']
         {
-          key: false
+          'key' => false
         }
       end
 
@@ -118,7 +118,7 @@ def self.default(visited = [])
         return nil if visited.include?('DenseNumberMap')
         visited = visited + ['DenseNumberMap']
         {
-          key: 1
+          'key' => 1
         }
       end
 
@@ -137,7 +137,7 @@ def self.default(visited = [])
         return nil if visited.include?('DenseSetMap')
         visited = visited + ['DenseSetMap']
         {
-          key: StringSet.default(visited)
+          'key' => StringSet.default(visited)
         }
       end
 
@@ -156,7 +156,7 @@ def self.default(visited = [])
         return nil if visited.include?('DenseStringMap')
         visited = visited + ['DenseStringMap']
         {
-          key: 'value'
+          'key' => 'value'
         }
       end
 
@@ -175,7 +175,7 @@ def self.default(visited = [])
         return nil if visited.include?('DenseStructMap')
         visited = visited + ['DenseStructMap']
         {
-          key: GreetingStruct.default(visited)
+          'key' => GreetingStruct.default(visited)
         }
       end
 
@@ -227,7 +227,7 @@ def self.default(visited = [])
 
       def self.stub(http_resp, stub:)
         data = {}
-        data['value'] = stub[:value] unless stub[:value].nil?
+        data['value'] = stub.value unless stub.value.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
         http_resp.status = 200
       end
@@ -269,7 +269,7 @@ def self.default(visited = [])
 
       def self.stub(http_resp, stub:)
         data = {}
-        data['datetime'] = stub[:datetime] unless stub[:datetime].nil?
+        data['datetime'] = stub.datetime unless stub.datetime.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
         http_resp.status = 200
       end
@@ -287,7 +287,7 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::GreetingStruct.new
         data = {}
-        data['hi'] = stub[:hi] unless stub[:hi].nil?
+        data['hi'] = stub.hi unless stub.hi.nil?
         data
       end
     end
@@ -309,7 +309,7 @@ def self.default(visited = [])
 
       def self.stub(http_resp, stub:)
         data = {}
-        data['greeting'] = stub[:greeting] unless stub[:greeting].nil?
+        data['greeting'] = stub.greeting unless stub.greeting.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
         http_resp.status = 200
       end
@@ -372,7 +372,7 @@ def self.stub(http_resp, stub:)
         http_resp.status = 400
         data = {}
         data['__type'] = 'InvalidGreeting'
-        data['Message'] = stub[:message] unless stub[:message].nil?
+        data['Message'] = stub.message unless stub.message.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
       end
     end
@@ -456,29 +456,29 @@ def self.default(visited = [])
 
       def self.stub(http_resp, stub:)
         data = {}
-        data['defaultString'] = stub[:default_string] unless stub[:default_string].nil?
-        data['defaultBoolean'] = stub[:default_boolean] unless stub[:default_boolean].nil?
-        data['defaultList'] = TestStringList.stub(stub[:default_list]) unless stub[:default_list].nil?
-        data['defaultTimestamp'] = stub[:default_timestamp] unless stub[:default_timestamp].nil?
-        data['defaultBlob'] = ((String === stub[:default_blob] ? stub[:default_blob] : stub[:default_blob].read).encode(Encoding::BINARY)) unless stub[:default_blob].nil?
-        data['defaultByte'] = stub[:default_byte] unless stub[:default_byte].nil?
-        data['defaultShort'] = stub[:default_short] unless stub[:default_short].nil?
-        data['defaultInteger'] = stub[:default_integer] unless stub[:default_integer].nil?
-        data['defaultLong'] = stub[:default_long] unless stub[:default_long].nil?
-        data['defaultFloat'] = stub[:default_float] unless stub[:default_float].nil?
-        data['defaultDouble'] = stub[:default_double] unless stub[:default_double].nil?
-        data['defaultMap'] = TestStringMap.stub(stub[:default_map]) unless stub[:default_map].nil?
-        data['defaultEnum'] = stub[:default_enum] unless stub[:default_enum].nil?
-        data['defaultIntEnum'] = stub[:default_int_enum] unless stub[:default_int_enum].nil?
-        data['emptyString'] = stub[:empty_string] unless stub[:empty_string].nil?
-        data['falseBoolean'] = stub[:false_boolean] unless stub[:false_boolean].nil?
-        data['emptyBlob'] = ((String === stub[:empty_blob] ? stub[:empty_blob] : stub[:empty_blob].read).encode(Encoding::BINARY)) unless stub[:empty_blob].nil?
-        data['zeroByte'] = stub[:zero_byte] unless stub[:zero_byte].nil?
-        data['zeroShort'] = stub[:zero_short] unless stub[:zero_short].nil?
-        data['zeroInteger'] = stub[:zero_integer] unless stub[:zero_integer].nil?
-        data['zeroLong'] = stub[:zero_long] unless stub[:zero_long].nil?
-        data['zeroFloat'] = stub[:zero_float] unless stub[:zero_float].nil?
-        data['zeroDouble'] = stub[:zero_double] unless stub[:zero_double].nil?
+        data['defaultString'] = stub.default_string unless stub.default_string.nil?
+        data['defaultBoolean'] = stub.default_boolean unless stub.default_boolean.nil?
+        data['defaultList'] = TestStringList.stub(stub.default_list) unless stub.default_list.nil?
+        data['defaultTimestamp'] = stub.default_timestamp unless stub.default_timestamp.nil?
+        data['defaultBlob'] = ((String === stub.default_blob ? stub.default_blob : stub.default_blob.read).encode(Encoding::BINARY)) unless stub.default_blob.nil?
+        data['defaultByte'] = stub.default_byte unless stub.default_byte.nil?
+        data['defaultShort'] = stub.default_short unless stub.default_short.nil?
+        data['defaultInteger'] = stub.default_integer unless stub.default_integer.nil?
+        data['defaultLong'] = stub.default_long unless stub.default_long.nil?
+        data['defaultFloat'] = stub.default_float unless stub.default_float.nil?
+        data['defaultDouble'] = stub.default_double unless stub.default_double.nil?
+        data['defaultMap'] = TestStringMap.stub(stub.default_map) unless stub.default_map.nil?
+        data['defaultEnum'] = stub.default_enum unless stub.default_enum.nil?
+        data['defaultIntEnum'] = stub.default_int_enum unless stub.default_int_enum.nil?
+        data['emptyString'] = stub.empty_string unless stub.empty_string.nil?
+        data['falseBoolean'] = stub.false_boolean unless stub.false_boolean.nil?
+        data['emptyBlob'] = ((String === stub.empty_blob ? stub.empty_blob : stub.empty_blob.read).encode(Encoding::BINARY)) unless stub.empty_blob.nil?
+        data['zeroByte'] = stub.zero_byte unless stub.zero_byte.nil?
+        data['zeroShort'] = stub.zero_short unless stub.zero_short.nil?
+        data['zeroInteger'] = stub.zero_integer unless stub.zero_integer.nil?
+        data['zeroLong'] = stub.zero_long unless stub.zero_long.nil?
+        data['zeroFloat'] = stub.zero_float unless stub.zero_float.nil?
+        data['zeroDouble'] = stub.zero_double unless stub.zero_double.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
         http_resp.status = 200
       end
@@ -501,7 +501,7 @@ def self.default(visited = [])
 
       def self.stub(http_resp, stub:)
         data = {}
-        data['value'] = stub[:value] unless stub[:value].nil?
+        data['value'] = stub.value unless stub.value.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
         http_resp.status = 200
       end
@@ -524,7 +524,7 @@ def self.default(visited = [])
 
       def self.stub(http_resp, stub:)
         data = {}
-        data['nested'] = RecursiveShapesInputOutputNested1.stub(stub[:nested]) unless stub[:nested].nil?
+        data['nested'] = RecursiveShapesInputOutputNested1.stub(stub.nested) unless stub.nested.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
         http_resp.status = 200
       end
@@ -543,8 +543,8 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::RecursiveShapesInputOutputNested1.new
         data = {}
-        data['foo'] = stub[:foo] unless stub[:foo].nil?
-        data['nested'] = RecursiveShapesInputOutputNested2.stub(stub[:nested]) unless stub[:nested].nil?
+        data['foo'] = stub.foo unless stub.foo.nil?
+        data['nested'] = RecursiveShapesInputOutputNested2.stub(stub.nested) unless stub.nested.nil?
         data
       end
     end
@@ -562,8 +562,8 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::RecursiveShapesInputOutputNested2.new
         data = {}
-        data['bar'] = stub[:bar] unless stub[:bar].nil?
-        data['recursiveMember'] = RecursiveShapesInputOutputNested1.stub(stub[:recursive_member]) unless stub[:recursive_member].nil?
+        data['bar'] = stub.bar unless stub.bar.nil?
+        data['recursiveMember'] = RecursiveShapesInputOutputNested1.stub(stub.recursive_member) unless stub.recursive_member.nil?
         data
       end
     end
@@ -589,11 +589,11 @@ def self.default(visited = [])
 
       def self.stub(http_resp, stub:)
         data = {}
-        data['denseStructMap'] = DenseStructMap.stub(stub[:dense_struct_map]) unless stub[:dense_struct_map].nil?
-        data['denseNumberMap'] = DenseNumberMap.stub(stub[:dense_number_map]) unless stub[:dense_number_map].nil?
-        data['denseBooleanMap'] = DenseBooleanMap.stub(stub[:dense_boolean_map]) unless stub[:dense_boolean_map].nil?
-        data['denseStringMap'] = DenseStringMap.stub(stub[:dense_string_map]) unless stub[:dense_string_map].nil?
-        data['denseSetMap'] = DenseSetMap.stub(stub[:dense_set_map]) unless stub[:dense_set_map].nil?
+        data['denseStructMap'] = DenseStructMap.stub(stub.dense_struct_map) unless stub.dense_struct_map.nil?
+        data['denseNumberMap'] = DenseNumberMap.stub(stub.dense_number_map) unless stub.dense_number_map.nil?
+        data['denseBooleanMap'] = DenseBooleanMap.stub(stub.dense_boolean_map) unless stub.dense_boolean_map.nil?
+        data['denseStringMap'] = DenseStringMap.stub(stub.dense_string_map) unless stub.dense_string_map.nil?
+        data['denseSetMap'] = DenseSetMap.stub(stub.dense_set_map) unless stub.dense_set_map.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
         http_resp.status = 200
       end
@@ -625,16 +625,16 @@ def self.default(visited = [])
 
       def self.stub(http_resp, stub:)
         data = {}
-        data['stringList'] = StringList.stub(stub[:string_list]) unless stub[:string_list].nil?
-        data['stringSet'] = StringSet.stub(stub[:string_set]) unless stub[:string_set].nil?
-        data['integerList'] = IntegerList.stub(stub[:integer_list]) unless stub[:integer_list].nil?
-        data['booleanList'] = BooleanList.stub(stub[:boolean_list]) unless stub[:boolean_list].nil?
-        data['timestampList'] = TimestampList.stub(stub[:timestamp_list]) unless stub[:timestamp_list].nil?
-        data['enumList'] = FooEnumList.stub(stub[:enum_list]) unless stub[:enum_list].nil?
-        data['intEnumList'] = IntegerEnumList.stub(stub[:int_enum_list]) unless stub[:int_enum_list].nil?
-        data['nestedStringList'] = NestedStringList.stub(stub[:nested_string_list]) unless stub[:nested_string_list].nil?
-        data['structureList'] = StructureList.stub(stub[:structure_list]) unless stub[:structure_list].nil?
-        data['blobList'] = BlobList.stub(stub[:blob_list]) unless stub[:blob_list].nil?
+        data['stringList'] = StringList.stub(stub.string_list) unless stub.string_list.nil?
+        data['stringSet'] = StringSet.stub(stub.string_set) unless stub.string_set.nil?
+        data['integerList'] = IntegerList.stub(stub.integer_list) unless stub.integer_list.nil?
+        data['booleanList'] = BooleanList.stub(stub.boolean_list) unless stub.boolean_list.nil?
+        data['timestampList'] = TimestampList.stub(stub.timestamp_list) unless stub.timestamp_list.nil?
+        data['enumList'] = FooEnumList.stub(stub.enum_list) unless stub.enum_list.nil?
+        data['intEnumList'] = IntegerEnumList.stub(stub.int_enum_list) unless stub.int_enum_list.nil?
+        data['nestedStringList'] = NestedStringList.stub(stub.nested_string_list) unless stub.nested_string_list.nil?
+        data['structureList'] = StructureList.stub(stub.structure_list) unless stub.structure_list.nil?
+        data['blobList'] = BlobList.stub(stub.blob_list) unless stub.blob_list.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
         http_resp.status = 200
       end
@@ -661,11 +661,11 @@ def self.default(visited = [])
 
       def self.stub(http_resp, stub:)
         data = {}
-        data['sparseStructMap'] = SparseStructMap.stub(stub[:sparse_struct_map]) unless stub[:sparse_struct_map].nil?
-        data['sparseNumberMap'] = SparseNumberMap.stub(stub[:sparse_number_map]) unless stub[:sparse_number_map].nil?
-        data['sparseBooleanMap'] = SparseBooleanMap.stub(stub[:sparse_boolean_map]) unless stub[:sparse_boolean_map].nil?
-        data['sparseStringMap'] = SparseStringMap.stub(stub[:sparse_string_map]) unless stub[:sparse_string_map].nil?
-        data['sparseSetMap'] = SparseSetMap.stub(stub[:sparse_set_map]) unless stub[:sparse_set_map].nil?
+        data['sparseStructMap'] = SparseStructMap.stub(stub.sparse_struct_map) unless stub.sparse_struct_map.nil?
+        data['sparseNumberMap'] = SparseNumberMap.stub(stub.sparse_number_map) unless stub.sparse_number_map.nil?
+        data['sparseBooleanMap'] = SparseBooleanMap.stub(stub.sparse_boolean_map) unless stub.sparse_boolean_map.nil?
+        data['sparseStringMap'] = SparseStringMap.stub(stub.sparse_string_map) unless stub.sparse_string_map.nil?
+        data['sparseSetMap'] = SparseSetMap.stub(stub.sparse_set_map) unless stub.sparse_set_map.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
         http_resp.status = 200
       end
@@ -697,16 +697,16 @@ def self.default(visited = [])
 
       def self.stub(http_resp, stub:)
         data = {}
-        data['trueBooleanValue'] = stub[:true_boolean_value] unless stub[:true_boolean_value].nil?
-        data['falseBooleanValue'] = stub[:false_boolean_value] unless stub[:false_boolean_value].nil?
-        data['byteValue'] = stub[:byte_value] unless stub[:byte_value].nil?
-        data['doubleValue'] = stub[:double_value] unless stub[:double_value].nil?
-        data['floatValue'] = stub[:float_value] unless stub[:float_value].nil?
-        data['integerValue'] = stub[:integer_value] unless stub[:integer_value].nil?
-        data['longValue'] = stub[:long_value] unless stub[:long_value].nil?
-        data['shortValue'] = stub[:short_value] unless stub[:short_value].nil?
-        data['stringValue'] = stub[:string_value] unless stub[:string_value].nil?
-        data['blobValue'] = ((String === stub[:blob_value] ? stub[:blob_value] : stub[:blob_value].read).encode(Encoding::BINARY)) unless stub[:blob_value].nil?
+        data['trueBooleanValue'] = stub.true_boolean_value unless stub.true_boolean_value.nil?
+        data['falseBooleanValue'] = stub.false_boolean_value unless stub.false_boolean_value.nil?
+        data['byteValue'] = stub.byte_value unless stub.byte_value.nil?
+        data['doubleValue'] = stub.double_value unless stub.double_value.nil?
+        data['floatValue'] = stub.float_value unless stub.float_value.nil?
+        data['integerValue'] = stub.integer_value unless stub.integer_value.nil?
+        data['longValue'] = stub.long_value unless stub.long_value.nil?
+        data['shortValue'] = stub.short_value unless stub.short_value.nil?
+        data['stringValue'] = stub.string_value unless stub.string_value.nil?
+        data['blobValue'] = ((String === stub.blob_value ? stub.blob_value : stub.blob_value.read).encode(Encoding::BINARY)) unless stub.blob_value.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
         http_resp.status = 200
       end
@@ -717,7 +717,7 @@ def self.default(visited = [])
         return nil if visited.include?('SparseBooleanMap')
         visited = visited + ['SparseBooleanMap']
         {
-          key: false
+          'key' => false
         }
       end
 
@@ -749,8 +749,8 @@ def self.default(visited = [])
 
       def self.stub(http_resp, stub:)
         data = {}
-        data['sparseStringList'] = SparseStringList.stub(stub[:sparse_string_list]) unless stub[:sparse_string_list].nil?
-        data['sparseStringMap'] = SparseStringMap.stub(stub[:sparse_string_map]) unless stub[:sparse_string_map].nil?
+        data['sparseStringList'] = SparseStringList.stub(stub.sparse_string_list) unless stub.sparse_string_list.nil?
+        data['sparseStringMap'] = SparseStringMap.stub(stub.sparse_string_map) unless stub.sparse_string_map.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
         http_resp.status = 200
       end
@@ -761,7 +761,7 @@ def self.default(visited = [])
         return nil if visited.include?('SparseNumberMap')
         visited = visited + ['SparseNumberMap']
         {
-          key: 1
+          'key' => 1
         }
       end
 
@@ -780,7 +780,7 @@ def self.default(visited = [])
         return nil if visited.include?('SparseSetMap')
         visited = visited + ['SparseSetMap']
         {
-          key: StringSet.default(visited)
+          'key' => StringSet.default(visited)
         }
       end
 
@@ -818,7 +818,7 @@ def self.default(visited = [])
         return nil if visited.include?('SparseStringMap')
         visited = visited + ['SparseStringMap']
         {
-          key: 'value'
+          'key' => 'value'
         }
       end
 
@@ -837,7 +837,7 @@ def self.default(visited = [])
         return nil if visited.include?('SparseStructMap')
         visited = visited + ['SparseStructMap']
         {
-          key: GreetingStruct.default(visited)
+          'key' => GreetingStruct.default(visited)
         }
       end
 
@@ -921,8 +921,8 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::StructureListMember.new
         data = {}
-        data['a'] = stub[:a] unless stub[:a].nil?
-        data['b'] = stub[:b] unless stub[:b].nil?
+        data['a'] = stub.a unless stub.a.nil?
+        data['b'] = stub.b unless stub.b.nil?
         data
       end
     end
@@ -951,7 +951,7 @@ def self.default(visited = [])
         return nil if visited.include?('TestStringMap')
         visited = visited + ['TestStringMap']
         {
-          key: 'value'
+          'key' => 'value'
         }
       end
 
@@ -1004,8 +1004,8 @@ def self.stub(http_resp, stub:)
         http_resp.status = 400
         data = {}
         data['__type'] = 'ValidationException'
-        data['message'] = stub[:message] unless stub[:message].nil?
-        data['fieldList'] = ValidationExceptionFieldList.stub(stub[:field_list]) unless stub[:field_list].nil?
+        data['message'] = stub.message unless stub.message.nil?
+        data['fieldList'] = ValidationExceptionFieldList.stub(stub.field_list) unless stub.field_list.nil?
         http_resp.body = ::StringIO.new(Hearth::CBOR.encode(data))
       end
     end
@@ -1023,8 +1023,8 @@ def self.default(visited = [])
       def self.stub(stub)
         stub ||= Types::ValidationExceptionField.new
         data = {}
-        data['path'] = stub[:path] unless stub[:path].nil?
-        data['message'] = stub[:message] unless stub[:message].nil?
+        data['path'] = stub.path unless stub.path.nil?
+        data['message'] = stub.message unless stub.message.nil?
         data
       end
     end
diff --git a/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/types.rb b/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/types.rb
index 67a4059d8..43a200f25 100644
--- a/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/types.rb
+++ b/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/types.rb
@@ -15,11 +15,14 @@ module Types
     #   @option params [Integer] :member
     # @!attribute member
     #   @return [Integer]
-    ClientOptionalDefaults = ::Struct.new(
-      :member,
-      keyword_init: true
-    ) do
+    class ClientOptionalDefaults
       include Hearth::Structure
+
+      MEMBERS = %i[
+        member
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # This error is thrown when a request is invalid.
@@ -31,12 +34,15 @@ module Types
     #   @return [String]
     # @!attribute nested
     #   @return [ComplexNestedErrorData]
-    ComplexError = ::Struct.new(
-      :top_level,
-      :nested,
-      keyword_init: true
-    ) do
+    class ComplexError
       include Hearth::Structure
+
+      MEMBERS = %i[
+        top_level
+        nested
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -44,11 +50,14 @@ module Types
     #   @option params [String] :foo
     # @!attribute foo
     #   @return [String]
-    ComplexNestedErrorData = ::Struct.new(
-      :foo,
-      keyword_init: true
-    ) do
+    class ComplexNestedErrorData
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -123,34 +132,37 @@ module Types
     #   @return [Float]
     # @!attribute zero_double
     #   @return [Float]
-    Defaults = ::Struct.new(
-      :default_string,
-      :default_boolean,
-      :default_list,
-      :default_timestamp,
-      :default_blob,
-      :default_byte,
-      :default_short,
-      :default_integer,
-      :default_long,
-      :default_float,
-      :default_double,
-      :default_map,
-      :default_enum,
-      :default_int_enum,
-      :empty_string,
-      :false_boolean,
-      :empty_blob,
-      :zero_byte,
-      :zero_short,
-      :zero_integer,
-      :zero_long,
-      :zero_float,
-      :zero_double,
-      keyword_init: true
-    ) do
+    class Defaults
       include Hearth::Structure
 
+      MEMBERS = %i[
+        default_string
+        default_boolean
+        default_list
+        default_timestamp
+        default_blob
+        default_byte
+        default_short
+        default_integer
+        default_long
+        default_float
+        default_double
+        default_map
+        default_enum
+        default_int_enum
+        empty_string
+        false_boolean
+        empty_blob
+        zero_byte
+        zero_short
+        zero_integer
+        zero_long
+        zero_float
+        zero_double
+      ].freeze
+
+      attr_accessor(*MEMBERS)
+
       private
 
       def _defaults
@@ -184,29 +196,32 @@ def _defaults
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    EmptyInputOutputInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class EmptyInputOutputInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    EmptyInputOutputOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class EmptyInputOutputOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    Float16Input = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class Float16Input
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -214,11 +229,14 @@ def _defaults
     #   @option params [Float] :value
     # @!attribute value
     #   @return [Float]
-    Float16Output = ::Struct.new(
-      :value,
-      keyword_init: true
-    ) do
+    class Float16Output
       include Hearth::Structure
+
+      MEMBERS = %i[
+        value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # Enum constants for FooEnum
@@ -236,11 +254,12 @@ module FooEnum
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    FractionalSecondsInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class FractionalSecondsInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -248,11 +267,14 @@ module FooEnum
     #   @option params [Time] :datetime
     # @!attribute datetime
     #   @return [Time]
-    FractionalSecondsOutput = ::Struct.new(
-      :datetime,
-      keyword_init: true
-    ) do
+    class FractionalSecondsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        datetime
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -260,20 +282,24 @@ module FooEnum
     #   @option params [String] :hi
     # @!attribute hi
     #   @return [String]
-    GreetingStruct = ::Struct.new(
-      :hi,
-      keyword_init: true
-    ) do
+    class GreetingStruct
       include Hearth::Structure
+
+      MEMBERS = %i[
+        hi
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    GreetingWithErrorsInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class GreetingWithErrorsInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -281,11 +307,14 @@ module FooEnum
     #   @option params [String] :greeting
     # @!attribute greeting
     #   @return [String]
-    GreetingWithErrorsOutput = ::Struct.new(
-      :greeting,
-      keyword_init: true
-    ) do
+    class GreetingWithErrorsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        greeting
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # Enum constants for IntegerEnum
@@ -303,29 +332,34 @@ module IntegerEnum
     #   @option params [String] :message
     # @!attribute message
     #   @return [String]
-    InvalidGreeting = ::Struct.new(
-      :message,
-      keyword_init: true
-    ) do
+    class InvalidGreeting
       include Hearth::Structure
+
+      MEMBERS = %i[
+        message
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    NoInputOutputInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class NoInputOutputInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    NoInputOutputOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class NoInputOutputOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -342,14 +376,17 @@ module IntegerEnum
     #   @return [String]
     # @!attribute other_top_level_default
     #   @return [Integer]
-    OperationWithDefaultsInput = ::Struct.new(
-      :defaults,
-      :client_optional_defaults,
-      :top_level_default,
-      :other_top_level_default,
-      keyword_init: true
-    ) do
+    class OperationWithDefaultsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        defaults
+        client_optional_defaults
+        top_level_default
+        other_top_level_default
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -424,34 +461,37 @@ module IntegerEnum
     #   @return [Float]
     # @!attribute zero_double
     #   @return [Float]
-    OperationWithDefaultsOutput = ::Struct.new(
-      :default_string,
-      :default_boolean,
-      :default_list,
-      :default_timestamp,
-      :default_blob,
-      :default_byte,
-      :default_short,
-      :default_integer,
-      :default_long,
-      :default_float,
-      :default_double,
-      :default_map,
-      :default_enum,
-      :default_int_enum,
-      :empty_string,
-      :false_boolean,
-      :empty_blob,
-      :zero_byte,
-      :zero_short,
-      :zero_integer,
-      :zero_long,
-      :zero_float,
-      :zero_double,
-      keyword_init: true
-    ) do
+    class OperationWithDefaultsOutput
       include Hearth::Structure
 
+      MEMBERS = %i[
+        default_string
+        default_boolean
+        default_list
+        default_timestamp
+        default_blob
+        default_byte
+        default_short
+        default_integer
+        default_long
+        default_float
+        default_double
+        default_map
+        default_enum
+        default_int_enum
+        empty_string
+        false_boolean
+        empty_blob
+        zero_byte
+        zero_short
+        zero_integer
+        zero_long
+        zero_float
+        zero_double
+      ].freeze
+
+      attr_accessor(*MEMBERS)
+
       private
 
       def _defaults
@@ -488,11 +528,14 @@ def _defaults
     #   @option params [String] :value
     # @!attribute value
     #   @return [String]
-    OptionalInputOutputInput = ::Struct.new(
-      :value,
-      keyword_init: true
-    ) do
+    class OptionalInputOutputInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -500,11 +543,14 @@ def _defaults
     #   @option params [String] :value
     # @!attribute value
     #   @return [String]
-    OptionalInputOutputOutput = ::Struct.new(
-      :value,
-      keyword_init: true
-    ) do
+    class OptionalInputOutputOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -512,11 +558,14 @@ def _defaults
     #   @option params [RecursiveShapesInputOutputNested1] :nested
     # @!attribute nested
     #   @return [RecursiveShapesInputOutputNested1]
-    RecursiveShapesInput = ::Struct.new(
-      :nested,
-      keyword_init: true
-    ) do
+    class RecursiveShapesInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        nested
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -527,12 +576,15 @@ def _defaults
     #   @return [String]
     # @!attribute nested
     #   @return [RecursiveShapesInputOutputNested2]
-    RecursiveShapesInputOutputNested1 = ::Struct.new(
-      :foo,
-      :nested,
-      keyword_init: true
-    ) do
+    class RecursiveShapesInputOutputNested1
       include Hearth::Structure
+
+      MEMBERS = %i[
+        foo
+        nested
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -543,12 +595,15 @@ def _defaults
     #   @return [String]
     # @!attribute recursive_member
     #   @return [RecursiveShapesInputOutputNested1]
-    RecursiveShapesInputOutputNested2 = ::Struct.new(
-      :bar,
-      :recursive_member,
-      keyword_init: true
-    ) do
+    class RecursiveShapesInputOutputNested2
       include Hearth::Structure
+
+      MEMBERS = %i[
+        bar
+        recursive_member
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -556,11 +611,14 @@ def _defaults
     #   @option params [RecursiveShapesInputOutputNested1] :nested
     # @!attribute nested
     #   @return [RecursiveShapesInputOutputNested1]
-    RecursiveShapesOutput = ::Struct.new(
-      :nested,
-      keyword_init: true
-    ) do
+    class RecursiveShapesOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        nested
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -580,15 +638,18 @@ def _defaults
     #   @return [Hash<String, String>]
     # @!attribute dense_set_map
     #   @return [Hash<String, Array<String>>]
-    RpcV2CborDenseMapsInput = ::Struct.new(
-      :dense_struct_map,
-      :dense_number_map,
-      :dense_boolean_map,
-      :dense_string_map,
-      :dense_set_map,
-      keyword_init: true
-    ) do
+    class RpcV2CborDenseMapsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        dense_struct_map
+        dense_number_map
+        dense_boolean_map
+        dense_string_map
+        dense_set_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -608,15 +669,18 @@ def _defaults
     #   @return [Hash<String, String>]
     # @!attribute dense_set_map
     #   @return [Hash<String, Array<String>>]
-    RpcV2CborDenseMapsOutput = ::Struct.new(
-      :dense_struct_map,
-      :dense_number_map,
-      :dense_boolean_map,
-      :dense_string_map,
-      :dense_set_map,
-      keyword_init: true
-    ) do
+    class RpcV2CborDenseMapsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        dense_struct_map
+        dense_number_map
+        dense_boolean_map
+        dense_string_map
+        dense_set_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -652,20 +716,23 @@ def _defaults
     #   @return [Array<StructureListMember>]
     # @!attribute blob_list
     #   @return [Array<String>]
-    RpcV2CborListsInput = ::Struct.new(
-      :string_list,
-      :string_set,
-      :integer_list,
-      :boolean_list,
-      :timestamp_list,
-      :enum_list,
-      :int_enum_list,
-      :nested_string_list,
-      :structure_list,
-      :blob_list,
-      keyword_init: true
-    ) do
+    class RpcV2CborListsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        string_list
+        string_set
+        integer_list
+        boolean_list
+        timestamp_list
+        enum_list
+        int_enum_list
+        nested_string_list
+        structure_list
+        blob_list
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -701,20 +768,23 @@ def _defaults
     #   @return [Array<StructureListMember>]
     # @!attribute blob_list
     #   @return [Array<String>]
-    RpcV2CborListsOutput = ::Struct.new(
-      :string_list,
-      :string_set,
-      :integer_list,
-      :boolean_list,
-      :timestamp_list,
-      :enum_list,
-      :int_enum_list,
-      :nested_string_list,
-      :structure_list,
-      :blob_list,
-      keyword_init: true
-    ) do
+    class RpcV2CborListsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        string_list
+        string_set
+        integer_list
+        boolean_list
+        timestamp_list
+        enum_list
+        int_enum_list
+        nested_string_list
+        structure_list
+        blob_list
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -734,15 +804,18 @@ def _defaults
     #   @return [Hash<String, String>]
     # @!attribute sparse_set_map
     #   @return [Hash<String, Array<String>>]
-    RpcV2CborSparseMapsInput = ::Struct.new(
-      :sparse_struct_map,
-      :sparse_number_map,
-      :sparse_boolean_map,
-      :sparse_string_map,
-      :sparse_set_map,
-      keyword_init: true
-    ) do
+    class RpcV2CborSparseMapsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        sparse_struct_map
+        sparse_number_map
+        sparse_boolean_map
+        sparse_string_map
+        sparse_set_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -762,15 +835,18 @@ def _defaults
     #   @return [Hash<String, String>]
     # @!attribute sparse_set_map
     #   @return [Hash<String, Array<String>>]
-    RpcV2CborSparseMapsOutput = ::Struct.new(
-      :sparse_struct_map,
-      :sparse_number_map,
-      :sparse_boolean_map,
-      :sparse_string_map,
-      :sparse_set_map,
-      keyword_init: true
-    ) do
+    class RpcV2CborSparseMapsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        sparse_struct_map
+        sparse_number_map
+        sparse_boolean_map
+        sparse_string_map
+        sparse_set_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -805,20 +881,23 @@ def _defaults
     #   @return [String]
     # @!attribute blob_value
     #   @return [String]
-    SimpleScalarPropertiesInput = ::Struct.new(
-      :true_boolean_value,
-      :false_boolean_value,
-      :byte_value,
-      :double_value,
-      :float_value,
-      :integer_value,
-      :long_value,
-      :short_value,
-      :string_value,
-      :blob_value,
-      keyword_init: true
-    ) do
+    class SimpleScalarPropertiesInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        true_boolean_value
+        false_boolean_value
+        byte_value
+        double_value
+        float_value
+        integer_value
+        long_value
+        short_value
+        string_value
+        blob_value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -853,20 +932,23 @@ def _defaults
     #   @return [String]
     # @!attribute blob_value
     #   @return [String]
-    SimpleScalarPropertiesOutput = ::Struct.new(
-      :true_boolean_value,
-      :false_boolean_value,
-      :byte_value,
-      :double_value,
-      :float_value,
-      :integer_value,
-      :long_value,
-      :short_value,
-      :string_value,
-      :blob_value,
-      keyword_init: true
-    ) do
+    class SimpleScalarPropertiesOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        true_boolean_value
+        false_boolean_value
+        byte_value
+        double_value
+        float_value
+        integer_value
+        long_value
+        short_value
+        string_value
+        blob_value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -877,12 +959,15 @@ def _defaults
     #   @return [Array<String>]
     # @!attribute sparse_string_map
     #   @return [Hash<String, String>]
-    SparseNullsOperationInput = ::Struct.new(
-      :sparse_string_list,
-      :sparse_string_map,
-      keyword_init: true
-    ) do
+    class SparseNullsOperationInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        sparse_string_list
+        sparse_string_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -893,12 +978,15 @@ def _defaults
     #   @return [Array<String>]
     # @!attribute sparse_string_map
     #   @return [Hash<String, String>]
-    SparseNullsOperationOutput = ::Struct.new(
-      :sparse_string_list,
-      :sparse_string_map,
-      keyword_init: true
-    ) do
+    class SparseNullsOperationOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        sparse_string_list
+        sparse_string_map
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -909,12 +997,15 @@ def _defaults
     #   @return [String]
     # @!attribute b
     #   @return [String]
-    StructureListMember = ::Struct.new(
-      :a,
-      :b,
-      keyword_init: true
-    ) do
+    class StructureListMember
       include Hearth::Structure
+
+      MEMBERS = %i[
+        a
+        b
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # Enum constants for TestEnum
@@ -947,12 +1038,15 @@ module TestIntEnum
     #   A list of specific failures encountered while validating the input.
     #   A member can appear in this list more than once if it failed to satisfy multiple constraints.
     #   @return [Array<ValidationExceptionField>]
-    ValidationException = ::Struct.new(
-      :message,
-      :field_list,
-      keyword_init: true
-    ) do
+    class ValidationException
       include Hearth::Structure
+
+      MEMBERS = %i[
+        message
+        field_list
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # Describes one specific validation failure for an input member.
@@ -966,12 +1060,15 @@ module TestIntEnum
     # @!attribute message
     #   A detailed description of the validation failure.
     #   @return [String]
-    ValidationExceptionField = ::Struct.new(
-      :path,
-      :message,
-      keyword_init: true
-    ) do
+    class ValidationExceptionField
       include Hearth::Structure
+
+      MEMBERS = %i[
+        path
+        message
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
   end
diff --git a/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/validators.rb b/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/validators.rb
index 27b308939..7e89c9087 100644
--- a/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/validators.rb
+++ b/codegen/projections/rpcv2_cbor/lib/rpcv2_cbor/validators.rb
@@ -34,51 +34,51 @@ def self.validate!(input, context:)
     class ClientOptionalDefaults
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::ClientOptionalDefaults, context: context)
-        Hearth::Validator.validate_types!(input[:member], ::Integer, context: "#{context}[:member]")
+        Hearth::Validator.validate_types!(input.member, ::Integer, context: "#{context}[:member]")
       end
     end
 
     class ComplexError
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::ComplexError, context: context)
-        Hearth::Validator.validate_types!(input[:top_level], ::String, context: "#{context}[:top_level]")
-        ComplexNestedErrorData.validate!(input[:nested], context: "#{context}[:nested]") unless input[:nested].nil?
+        Hearth::Validator.validate_types!(input.top_level, ::String, context: "#{context}[:top_level]")
+        ComplexNestedErrorData.validate!(input.nested, context: "#{context}[:nested]") unless input.nested.nil?
       end
     end
 
     class ComplexNestedErrorData
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::ComplexNestedErrorData, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
       end
     end
 
     class Defaults
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::Defaults, context: context)
-        Hearth::Validator.validate_types!(input[:default_string], ::String, context: "#{context}[:default_string]")
-        Hearth::Validator.validate_types!(input[:default_boolean], ::TrueClass, ::FalseClass, context: "#{context}[:default_boolean]")
-        TestStringList.validate!(input[:default_list], context: "#{context}[:default_list]") unless input[:default_list].nil?
-        Hearth::Validator.validate_types!(input[:default_timestamp], ::Time, context: "#{context}[:default_timestamp]")
-        Hearth::Validator.validate_types!(input[:default_blob], ::String, context: "#{context}[:default_blob]")
-        Hearth::Validator.validate_types!(input[:default_byte], ::Integer, context: "#{context}[:default_byte]")
-        Hearth::Validator.validate_types!(input[:default_short], ::Integer, context: "#{context}[:default_short]")
-        Hearth::Validator.validate_types!(input[:default_integer], ::Integer, context: "#{context}[:default_integer]")
-        Hearth::Validator.validate_types!(input[:default_long], ::Integer, context: "#{context}[:default_long]")
-        Hearth::Validator.validate_types!(input[:default_float], ::Float, context: "#{context}[:default_float]")
-        Hearth::Validator.validate_types!(input[:default_double], ::Float, context: "#{context}[:default_double]")
-        TestStringMap.validate!(input[:default_map], context: "#{context}[:default_map]") unless input[:default_map].nil?
-        Hearth::Validator.validate_types!(input[:default_enum], ::String, context: "#{context}[:default_enum]")
-        Hearth::Validator.validate_types!(input[:default_int_enum], ::Integer, context: "#{context}[:default_int_enum]")
-        Hearth::Validator.validate_types!(input[:empty_string], ::String, context: "#{context}[:empty_string]")
-        Hearth::Validator.validate_types!(input[:false_boolean], ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean]")
-        Hearth::Validator.validate_types!(input[:empty_blob], ::String, context: "#{context}[:empty_blob]")
-        Hearth::Validator.validate_types!(input[:zero_byte], ::Integer, context: "#{context}[:zero_byte]")
-        Hearth::Validator.validate_types!(input[:zero_short], ::Integer, context: "#{context}[:zero_short]")
-        Hearth::Validator.validate_types!(input[:zero_integer], ::Integer, context: "#{context}[:zero_integer]")
-        Hearth::Validator.validate_types!(input[:zero_long], ::Integer, context: "#{context}[:zero_long]")
-        Hearth::Validator.validate_types!(input[:zero_float], ::Float, context: "#{context}[:zero_float]")
-        Hearth::Validator.validate_types!(input[:zero_double], ::Float, context: "#{context}[:zero_double]")
+        Hearth::Validator.validate_types!(input.default_string, ::String, context: "#{context}[:default_string]")
+        Hearth::Validator.validate_types!(input.default_boolean, ::TrueClass, ::FalseClass, context: "#{context}[:default_boolean]")
+        TestStringList.validate!(input.default_list, context: "#{context}[:default_list]") unless input.default_list.nil?
+        Hearth::Validator.validate_types!(input.default_timestamp, ::Time, context: "#{context}[:default_timestamp]")
+        Hearth::Validator.validate_types!(input.default_blob, ::String, context: "#{context}[:default_blob]")
+        Hearth::Validator.validate_types!(input.default_byte, ::Integer, context: "#{context}[:default_byte]")
+        Hearth::Validator.validate_types!(input.default_short, ::Integer, context: "#{context}[:default_short]")
+        Hearth::Validator.validate_types!(input.default_integer, ::Integer, context: "#{context}[:default_integer]")
+        Hearth::Validator.validate_types!(input.default_long, ::Integer, context: "#{context}[:default_long]")
+        Hearth::Validator.validate_types!(input.default_float, ::Float, context: "#{context}[:default_float]")
+        Hearth::Validator.validate_types!(input.default_double, ::Float, context: "#{context}[:default_double]")
+        TestStringMap.validate!(input.default_map, context: "#{context}[:default_map]") unless input.default_map.nil?
+        Hearth::Validator.validate_types!(input.default_enum, ::String, context: "#{context}[:default_enum]")
+        Hearth::Validator.validate_types!(input.default_int_enum, ::Integer, context: "#{context}[:default_int_enum]")
+        Hearth::Validator.validate_types!(input.empty_string, ::String, context: "#{context}[:empty_string]")
+        Hearth::Validator.validate_types!(input.false_boolean, ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean]")
+        Hearth::Validator.validate_types!(input.empty_blob, ::String, context: "#{context}[:empty_blob]")
+        Hearth::Validator.validate_types!(input.zero_byte, ::Integer, context: "#{context}[:zero_byte]")
+        Hearth::Validator.validate_types!(input.zero_short, ::Integer, context: "#{context}[:zero_short]")
+        Hearth::Validator.validate_types!(input.zero_integer, ::Integer, context: "#{context}[:zero_integer]")
+        Hearth::Validator.validate_types!(input.zero_long, ::Integer, context: "#{context}[:zero_long]")
+        Hearth::Validator.validate_types!(input.zero_float, ::Float, context: "#{context}[:zero_float]")
+        Hearth::Validator.validate_types!(input.zero_double, ::Float, context: "#{context}[:zero_double]")
       end
     end
 
@@ -86,8 +86,8 @@ class DenseBooleanMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::TrueClass, ::FalseClass, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::TrueClass, ::FalseClass, context: "#{context}['#{key}']")
         end
       end
     end
@@ -96,8 +96,8 @@ class DenseNumberMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::Integer, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::Integer, context: "#{context}['#{key}']")
         end
       end
     end
@@ -106,8 +106,8 @@ class DenseSetMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          StringSet.validate!(value, context: "#{context}[:#{key}]") unless value.nil?
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          StringSet.validate!(value, context: "#{context}['#{key}']") unless value.nil?
         end
       end
     end
@@ -116,8 +116,8 @@ class DenseStringMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::String, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::String, context: "#{context}['#{key}']")
         end
       end
     end
@@ -126,8 +126,8 @@ class DenseStructMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          GreetingStruct.validate!(value, context: "#{context}[:#{key}]") unless value.nil?
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          GreetingStruct.validate!(value, context: "#{context}['#{key}']") unless value.nil?
         end
       end
     end
@@ -153,7 +153,7 @@ def self.validate!(input, context:)
     class Float16Output
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::Float16Output, context: context)
-        Hearth::Validator.validate_types!(input[:value], ::Float, context: "#{context}[:value]")
+        Hearth::Validator.validate_types!(input.value, ::Float, context: "#{context}[:value]")
       end
     end
 
@@ -175,14 +175,14 @@ def self.validate!(input, context:)
     class FractionalSecondsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::FractionalSecondsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:datetime], ::Time, context: "#{context}[:datetime]")
+        Hearth::Validator.validate_types!(input.datetime, ::Time, context: "#{context}[:datetime]")
       end
     end
 
     class GreetingStruct
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::GreetingStruct, context: context)
-        Hearth::Validator.validate_types!(input[:hi], ::String, context: "#{context}[:hi]")
+        Hearth::Validator.validate_types!(input.hi, ::String, context: "#{context}[:hi]")
       end
     end
 
@@ -195,7 +195,7 @@ def self.validate!(input, context:)
     class GreetingWithErrorsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::GreetingWithErrorsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:greeting], ::String, context: "#{context}[:greeting]")
+        Hearth::Validator.validate_types!(input.greeting, ::String, context: "#{context}[:greeting]")
       end
     end
 
@@ -220,7 +220,7 @@ def self.validate!(input, context:)
     class InvalidGreeting
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::InvalidGreeting, context: context)
-        Hearth::Validator.validate_types!(input[:message], ::String, context: "#{context}[:message]")
+        Hearth::Validator.validate_types!(input.message, ::String, context: "#{context}[:message]")
       end
     end
 
@@ -248,191 +248,191 @@ def self.validate!(input, context:)
     class OperationWithDefaultsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::OperationWithDefaultsInput, context: context)
-        Defaults.validate!(input[:defaults], context: "#{context}[:defaults]") unless input[:defaults].nil?
-        ClientOptionalDefaults.validate!(input[:client_optional_defaults], context: "#{context}[:client_optional_defaults]") unless input[:client_optional_defaults].nil?
-        Hearth::Validator.validate_types!(input[:top_level_default], ::String, context: "#{context}[:top_level_default]")
-        Hearth::Validator.validate_types!(input[:other_top_level_default], ::Integer, context: "#{context}[:other_top_level_default]")
+        Defaults.validate!(input.defaults, context: "#{context}[:defaults]") unless input.defaults.nil?
+        ClientOptionalDefaults.validate!(input.client_optional_defaults, context: "#{context}[:client_optional_defaults]") unless input.client_optional_defaults.nil?
+        Hearth::Validator.validate_types!(input.top_level_default, ::String, context: "#{context}[:top_level_default]")
+        Hearth::Validator.validate_types!(input.other_top_level_default, ::Integer, context: "#{context}[:other_top_level_default]")
       end
     end
 
     class OperationWithDefaultsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::OperationWithDefaultsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:default_string], ::String, context: "#{context}[:default_string]")
-        Hearth::Validator.validate_types!(input[:default_boolean], ::TrueClass, ::FalseClass, context: "#{context}[:default_boolean]")
-        TestStringList.validate!(input[:default_list], context: "#{context}[:default_list]") unless input[:default_list].nil?
-        Hearth::Validator.validate_types!(input[:default_timestamp], ::Time, context: "#{context}[:default_timestamp]")
-        Hearth::Validator.validate_types!(input[:default_blob], ::String, context: "#{context}[:default_blob]")
-        Hearth::Validator.validate_types!(input[:default_byte], ::Integer, context: "#{context}[:default_byte]")
-        Hearth::Validator.validate_types!(input[:default_short], ::Integer, context: "#{context}[:default_short]")
-        Hearth::Validator.validate_types!(input[:default_integer], ::Integer, context: "#{context}[:default_integer]")
-        Hearth::Validator.validate_types!(input[:default_long], ::Integer, context: "#{context}[:default_long]")
-        Hearth::Validator.validate_types!(input[:default_float], ::Float, context: "#{context}[:default_float]")
-        Hearth::Validator.validate_types!(input[:default_double], ::Float, context: "#{context}[:default_double]")
-        TestStringMap.validate!(input[:default_map], context: "#{context}[:default_map]") unless input[:default_map].nil?
-        Hearth::Validator.validate_types!(input[:default_enum], ::String, context: "#{context}[:default_enum]")
-        Hearth::Validator.validate_types!(input[:default_int_enum], ::Integer, context: "#{context}[:default_int_enum]")
-        Hearth::Validator.validate_types!(input[:empty_string], ::String, context: "#{context}[:empty_string]")
-        Hearth::Validator.validate_types!(input[:false_boolean], ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean]")
-        Hearth::Validator.validate_types!(input[:empty_blob], ::String, context: "#{context}[:empty_blob]")
-        Hearth::Validator.validate_types!(input[:zero_byte], ::Integer, context: "#{context}[:zero_byte]")
-        Hearth::Validator.validate_types!(input[:zero_short], ::Integer, context: "#{context}[:zero_short]")
-        Hearth::Validator.validate_types!(input[:zero_integer], ::Integer, context: "#{context}[:zero_integer]")
-        Hearth::Validator.validate_types!(input[:zero_long], ::Integer, context: "#{context}[:zero_long]")
-        Hearth::Validator.validate_types!(input[:zero_float], ::Float, context: "#{context}[:zero_float]")
-        Hearth::Validator.validate_types!(input[:zero_double], ::Float, context: "#{context}[:zero_double]")
+        Hearth::Validator.validate_types!(input.default_string, ::String, context: "#{context}[:default_string]")
+        Hearth::Validator.validate_types!(input.default_boolean, ::TrueClass, ::FalseClass, context: "#{context}[:default_boolean]")
+        TestStringList.validate!(input.default_list, context: "#{context}[:default_list]") unless input.default_list.nil?
+        Hearth::Validator.validate_types!(input.default_timestamp, ::Time, context: "#{context}[:default_timestamp]")
+        Hearth::Validator.validate_types!(input.default_blob, ::String, context: "#{context}[:default_blob]")
+        Hearth::Validator.validate_types!(input.default_byte, ::Integer, context: "#{context}[:default_byte]")
+        Hearth::Validator.validate_types!(input.default_short, ::Integer, context: "#{context}[:default_short]")
+        Hearth::Validator.validate_types!(input.default_integer, ::Integer, context: "#{context}[:default_integer]")
+        Hearth::Validator.validate_types!(input.default_long, ::Integer, context: "#{context}[:default_long]")
+        Hearth::Validator.validate_types!(input.default_float, ::Float, context: "#{context}[:default_float]")
+        Hearth::Validator.validate_types!(input.default_double, ::Float, context: "#{context}[:default_double]")
+        TestStringMap.validate!(input.default_map, context: "#{context}[:default_map]") unless input.default_map.nil?
+        Hearth::Validator.validate_types!(input.default_enum, ::String, context: "#{context}[:default_enum]")
+        Hearth::Validator.validate_types!(input.default_int_enum, ::Integer, context: "#{context}[:default_int_enum]")
+        Hearth::Validator.validate_types!(input.empty_string, ::String, context: "#{context}[:empty_string]")
+        Hearth::Validator.validate_types!(input.false_boolean, ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean]")
+        Hearth::Validator.validate_types!(input.empty_blob, ::String, context: "#{context}[:empty_blob]")
+        Hearth::Validator.validate_types!(input.zero_byte, ::Integer, context: "#{context}[:zero_byte]")
+        Hearth::Validator.validate_types!(input.zero_short, ::Integer, context: "#{context}[:zero_short]")
+        Hearth::Validator.validate_types!(input.zero_integer, ::Integer, context: "#{context}[:zero_integer]")
+        Hearth::Validator.validate_types!(input.zero_long, ::Integer, context: "#{context}[:zero_long]")
+        Hearth::Validator.validate_types!(input.zero_float, ::Float, context: "#{context}[:zero_float]")
+        Hearth::Validator.validate_types!(input.zero_double, ::Float, context: "#{context}[:zero_double]")
       end
     end
 
     class OptionalInputOutputInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::OptionalInputOutputInput, context: context)
-        Hearth::Validator.validate_types!(input[:value], ::String, context: "#{context}[:value]")
+        Hearth::Validator.validate_types!(input.value, ::String, context: "#{context}[:value]")
       end
     end
 
     class OptionalInputOutputOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::OptionalInputOutputOutput, context: context)
-        Hearth::Validator.validate_types!(input[:value], ::String, context: "#{context}[:value]")
+        Hearth::Validator.validate_types!(input.value, ::String, context: "#{context}[:value]")
       end
     end
 
     class RecursiveShapesInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RecursiveShapesInput, context: context)
-        RecursiveShapesInputOutputNested1.validate!(input[:nested], context: "#{context}[:nested]") unless input[:nested].nil?
+        RecursiveShapesInputOutputNested1.validate!(input.nested, context: "#{context}[:nested]") unless input.nested.nil?
       end
     end
 
     class RecursiveShapesInputOutputNested1
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RecursiveShapesInputOutputNested1, context: context)
-        Hearth::Validator.validate_types!(input[:foo], ::String, context: "#{context}[:foo]")
-        RecursiveShapesInputOutputNested2.validate!(input[:nested], context: "#{context}[:nested]") unless input[:nested].nil?
+        Hearth::Validator.validate_types!(input.foo, ::String, context: "#{context}[:foo]")
+        RecursiveShapesInputOutputNested2.validate!(input.nested, context: "#{context}[:nested]") unless input.nested.nil?
       end
     end
 
     class RecursiveShapesInputOutputNested2
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RecursiveShapesInputOutputNested2, context: context)
-        Hearth::Validator.validate_types!(input[:bar], ::String, context: "#{context}[:bar]")
-        RecursiveShapesInputOutputNested1.validate!(input[:recursive_member], context: "#{context}[:recursive_member]") unless input[:recursive_member].nil?
+        Hearth::Validator.validate_types!(input.bar, ::String, context: "#{context}[:bar]")
+        RecursiveShapesInputOutputNested1.validate!(input.recursive_member, context: "#{context}[:recursive_member]") unless input.recursive_member.nil?
       end
     end
 
     class RecursiveShapesOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RecursiveShapesOutput, context: context)
-        RecursiveShapesInputOutputNested1.validate!(input[:nested], context: "#{context}[:nested]") unless input[:nested].nil?
+        RecursiveShapesInputOutputNested1.validate!(input.nested, context: "#{context}[:nested]") unless input.nested.nil?
       end
     end
 
     class RpcV2CborDenseMapsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RpcV2CborDenseMapsInput, context: context)
-        DenseStructMap.validate!(input[:dense_struct_map], context: "#{context}[:dense_struct_map]") unless input[:dense_struct_map].nil?
-        DenseNumberMap.validate!(input[:dense_number_map], context: "#{context}[:dense_number_map]") unless input[:dense_number_map].nil?
-        DenseBooleanMap.validate!(input[:dense_boolean_map], context: "#{context}[:dense_boolean_map]") unless input[:dense_boolean_map].nil?
-        DenseStringMap.validate!(input[:dense_string_map], context: "#{context}[:dense_string_map]") unless input[:dense_string_map].nil?
-        DenseSetMap.validate!(input[:dense_set_map], context: "#{context}[:dense_set_map]") unless input[:dense_set_map].nil?
+        DenseStructMap.validate!(input.dense_struct_map, context: "#{context}[:dense_struct_map]") unless input.dense_struct_map.nil?
+        DenseNumberMap.validate!(input.dense_number_map, context: "#{context}[:dense_number_map]") unless input.dense_number_map.nil?
+        DenseBooleanMap.validate!(input.dense_boolean_map, context: "#{context}[:dense_boolean_map]") unless input.dense_boolean_map.nil?
+        DenseStringMap.validate!(input.dense_string_map, context: "#{context}[:dense_string_map]") unless input.dense_string_map.nil?
+        DenseSetMap.validate!(input.dense_set_map, context: "#{context}[:dense_set_map]") unless input.dense_set_map.nil?
       end
     end
 
     class RpcV2CborDenseMapsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RpcV2CborDenseMapsOutput, context: context)
-        DenseStructMap.validate!(input[:dense_struct_map], context: "#{context}[:dense_struct_map]") unless input[:dense_struct_map].nil?
-        DenseNumberMap.validate!(input[:dense_number_map], context: "#{context}[:dense_number_map]") unless input[:dense_number_map].nil?
-        DenseBooleanMap.validate!(input[:dense_boolean_map], context: "#{context}[:dense_boolean_map]") unless input[:dense_boolean_map].nil?
-        DenseStringMap.validate!(input[:dense_string_map], context: "#{context}[:dense_string_map]") unless input[:dense_string_map].nil?
-        DenseSetMap.validate!(input[:dense_set_map], context: "#{context}[:dense_set_map]") unless input[:dense_set_map].nil?
+        DenseStructMap.validate!(input.dense_struct_map, context: "#{context}[:dense_struct_map]") unless input.dense_struct_map.nil?
+        DenseNumberMap.validate!(input.dense_number_map, context: "#{context}[:dense_number_map]") unless input.dense_number_map.nil?
+        DenseBooleanMap.validate!(input.dense_boolean_map, context: "#{context}[:dense_boolean_map]") unless input.dense_boolean_map.nil?
+        DenseStringMap.validate!(input.dense_string_map, context: "#{context}[:dense_string_map]") unless input.dense_string_map.nil?
+        DenseSetMap.validate!(input.dense_set_map, context: "#{context}[:dense_set_map]") unless input.dense_set_map.nil?
       end
     end
 
     class RpcV2CborListsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RpcV2CborListsInput, context: context)
-        StringList.validate!(input[:string_list], context: "#{context}[:string_list]") unless input[:string_list].nil?
-        StringSet.validate!(input[:string_set], context: "#{context}[:string_set]") unless input[:string_set].nil?
-        IntegerList.validate!(input[:integer_list], context: "#{context}[:integer_list]") unless input[:integer_list].nil?
-        BooleanList.validate!(input[:boolean_list], context: "#{context}[:boolean_list]") unless input[:boolean_list].nil?
-        TimestampList.validate!(input[:timestamp_list], context: "#{context}[:timestamp_list]") unless input[:timestamp_list].nil?
-        FooEnumList.validate!(input[:enum_list], context: "#{context}[:enum_list]") unless input[:enum_list].nil?
-        IntegerEnumList.validate!(input[:int_enum_list], context: "#{context}[:int_enum_list]") unless input[:int_enum_list].nil?
-        NestedStringList.validate!(input[:nested_string_list], context: "#{context}[:nested_string_list]") unless input[:nested_string_list].nil?
-        StructureList.validate!(input[:structure_list], context: "#{context}[:structure_list]") unless input[:structure_list].nil?
-        BlobList.validate!(input[:blob_list], context: "#{context}[:blob_list]") unless input[:blob_list].nil?
+        StringList.validate!(input.string_list, context: "#{context}[:string_list]") unless input.string_list.nil?
+        StringSet.validate!(input.string_set, context: "#{context}[:string_set]") unless input.string_set.nil?
+        IntegerList.validate!(input.integer_list, context: "#{context}[:integer_list]") unless input.integer_list.nil?
+        BooleanList.validate!(input.boolean_list, context: "#{context}[:boolean_list]") unless input.boolean_list.nil?
+        TimestampList.validate!(input.timestamp_list, context: "#{context}[:timestamp_list]") unless input.timestamp_list.nil?
+        FooEnumList.validate!(input.enum_list, context: "#{context}[:enum_list]") unless input.enum_list.nil?
+        IntegerEnumList.validate!(input.int_enum_list, context: "#{context}[:int_enum_list]") unless input.int_enum_list.nil?
+        NestedStringList.validate!(input.nested_string_list, context: "#{context}[:nested_string_list]") unless input.nested_string_list.nil?
+        StructureList.validate!(input.structure_list, context: "#{context}[:structure_list]") unless input.structure_list.nil?
+        BlobList.validate!(input.blob_list, context: "#{context}[:blob_list]") unless input.blob_list.nil?
       end
     end
 
     class RpcV2CborListsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RpcV2CborListsOutput, context: context)
-        StringList.validate!(input[:string_list], context: "#{context}[:string_list]") unless input[:string_list].nil?
-        StringSet.validate!(input[:string_set], context: "#{context}[:string_set]") unless input[:string_set].nil?
-        IntegerList.validate!(input[:integer_list], context: "#{context}[:integer_list]") unless input[:integer_list].nil?
-        BooleanList.validate!(input[:boolean_list], context: "#{context}[:boolean_list]") unless input[:boolean_list].nil?
-        TimestampList.validate!(input[:timestamp_list], context: "#{context}[:timestamp_list]") unless input[:timestamp_list].nil?
-        FooEnumList.validate!(input[:enum_list], context: "#{context}[:enum_list]") unless input[:enum_list].nil?
-        IntegerEnumList.validate!(input[:int_enum_list], context: "#{context}[:int_enum_list]") unless input[:int_enum_list].nil?
-        NestedStringList.validate!(input[:nested_string_list], context: "#{context}[:nested_string_list]") unless input[:nested_string_list].nil?
-        StructureList.validate!(input[:structure_list], context: "#{context}[:structure_list]") unless input[:structure_list].nil?
-        BlobList.validate!(input[:blob_list], context: "#{context}[:blob_list]") unless input[:blob_list].nil?
+        StringList.validate!(input.string_list, context: "#{context}[:string_list]") unless input.string_list.nil?
+        StringSet.validate!(input.string_set, context: "#{context}[:string_set]") unless input.string_set.nil?
+        IntegerList.validate!(input.integer_list, context: "#{context}[:integer_list]") unless input.integer_list.nil?
+        BooleanList.validate!(input.boolean_list, context: "#{context}[:boolean_list]") unless input.boolean_list.nil?
+        TimestampList.validate!(input.timestamp_list, context: "#{context}[:timestamp_list]") unless input.timestamp_list.nil?
+        FooEnumList.validate!(input.enum_list, context: "#{context}[:enum_list]") unless input.enum_list.nil?
+        IntegerEnumList.validate!(input.int_enum_list, context: "#{context}[:int_enum_list]") unless input.int_enum_list.nil?
+        NestedStringList.validate!(input.nested_string_list, context: "#{context}[:nested_string_list]") unless input.nested_string_list.nil?
+        StructureList.validate!(input.structure_list, context: "#{context}[:structure_list]") unless input.structure_list.nil?
+        BlobList.validate!(input.blob_list, context: "#{context}[:blob_list]") unless input.blob_list.nil?
       end
     end
 
     class RpcV2CborSparseMapsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RpcV2CborSparseMapsInput, context: context)
-        SparseStructMap.validate!(input[:sparse_struct_map], context: "#{context}[:sparse_struct_map]") unless input[:sparse_struct_map].nil?
-        SparseNumberMap.validate!(input[:sparse_number_map], context: "#{context}[:sparse_number_map]") unless input[:sparse_number_map].nil?
-        SparseBooleanMap.validate!(input[:sparse_boolean_map], context: "#{context}[:sparse_boolean_map]") unless input[:sparse_boolean_map].nil?
-        SparseStringMap.validate!(input[:sparse_string_map], context: "#{context}[:sparse_string_map]") unless input[:sparse_string_map].nil?
-        SparseSetMap.validate!(input[:sparse_set_map], context: "#{context}[:sparse_set_map]") unless input[:sparse_set_map].nil?
+        SparseStructMap.validate!(input.sparse_struct_map, context: "#{context}[:sparse_struct_map]") unless input.sparse_struct_map.nil?
+        SparseNumberMap.validate!(input.sparse_number_map, context: "#{context}[:sparse_number_map]") unless input.sparse_number_map.nil?
+        SparseBooleanMap.validate!(input.sparse_boolean_map, context: "#{context}[:sparse_boolean_map]") unless input.sparse_boolean_map.nil?
+        SparseStringMap.validate!(input.sparse_string_map, context: "#{context}[:sparse_string_map]") unless input.sparse_string_map.nil?
+        SparseSetMap.validate!(input.sparse_set_map, context: "#{context}[:sparse_set_map]") unless input.sparse_set_map.nil?
       end
     end
 
     class RpcV2CborSparseMapsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RpcV2CborSparseMapsOutput, context: context)
-        SparseStructMap.validate!(input[:sparse_struct_map], context: "#{context}[:sparse_struct_map]") unless input[:sparse_struct_map].nil?
-        SparseNumberMap.validate!(input[:sparse_number_map], context: "#{context}[:sparse_number_map]") unless input[:sparse_number_map].nil?
-        SparseBooleanMap.validate!(input[:sparse_boolean_map], context: "#{context}[:sparse_boolean_map]") unless input[:sparse_boolean_map].nil?
-        SparseStringMap.validate!(input[:sparse_string_map], context: "#{context}[:sparse_string_map]") unless input[:sparse_string_map].nil?
-        SparseSetMap.validate!(input[:sparse_set_map], context: "#{context}[:sparse_set_map]") unless input[:sparse_set_map].nil?
+        SparseStructMap.validate!(input.sparse_struct_map, context: "#{context}[:sparse_struct_map]") unless input.sparse_struct_map.nil?
+        SparseNumberMap.validate!(input.sparse_number_map, context: "#{context}[:sparse_number_map]") unless input.sparse_number_map.nil?
+        SparseBooleanMap.validate!(input.sparse_boolean_map, context: "#{context}[:sparse_boolean_map]") unless input.sparse_boolean_map.nil?
+        SparseStringMap.validate!(input.sparse_string_map, context: "#{context}[:sparse_string_map]") unless input.sparse_string_map.nil?
+        SparseSetMap.validate!(input.sparse_set_map, context: "#{context}[:sparse_set_map]") unless input.sparse_set_map.nil?
       end
     end
 
     class SimpleScalarPropertiesInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::SimpleScalarPropertiesInput, context: context)
-        Hearth::Validator.validate_types!(input[:true_boolean_value], ::TrueClass, ::FalseClass, context: "#{context}[:true_boolean_value]")
-        Hearth::Validator.validate_types!(input[:false_boolean_value], ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean_value]")
-        Hearth::Validator.validate_types!(input[:byte_value], ::Integer, context: "#{context}[:byte_value]")
-        Hearth::Validator.validate_types!(input[:double_value], ::Float, context: "#{context}[:double_value]")
-        Hearth::Validator.validate_types!(input[:float_value], ::Float, context: "#{context}[:float_value]")
-        Hearth::Validator.validate_types!(input[:integer_value], ::Integer, context: "#{context}[:integer_value]")
-        Hearth::Validator.validate_types!(input[:long_value], ::Integer, context: "#{context}[:long_value]")
-        Hearth::Validator.validate_types!(input[:short_value], ::Integer, context: "#{context}[:short_value]")
-        Hearth::Validator.validate_types!(input[:string_value], ::String, context: "#{context}[:string_value]")
-        Hearth::Validator.validate_types!(input[:blob_value], ::String, context: "#{context}[:blob_value]")
+        Hearth::Validator.validate_types!(input.true_boolean_value, ::TrueClass, ::FalseClass, context: "#{context}[:true_boolean_value]")
+        Hearth::Validator.validate_types!(input.false_boolean_value, ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean_value]")
+        Hearth::Validator.validate_types!(input.byte_value, ::Integer, context: "#{context}[:byte_value]")
+        Hearth::Validator.validate_types!(input.double_value, ::Float, context: "#{context}[:double_value]")
+        Hearth::Validator.validate_types!(input.float_value, ::Float, context: "#{context}[:float_value]")
+        Hearth::Validator.validate_types!(input.integer_value, ::Integer, context: "#{context}[:integer_value]")
+        Hearth::Validator.validate_types!(input.long_value, ::Integer, context: "#{context}[:long_value]")
+        Hearth::Validator.validate_types!(input.short_value, ::Integer, context: "#{context}[:short_value]")
+        Hearth::Validator.validate_types!(input.string_value, ::String, context: "#{context}[:string_value]")
+        Hearth::Validator.validate_types!(input.blob_value, ::String, context: "#{context}[:blob_value]")
       end
     end
 
     class SimpleScalarPropertiesOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::SimpleScalarPropertiesOutput, context: context)
-        Hearth::Validator.validate_types!(input[:true_boolean_value], ::TrueClass, ::FalseClass, context: "#{context}[:true_boolean_value]")
-        Hearth::Validator.validate_types!(input[:false_boolean_value], ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean_value]")
-        Hearth::Validator.validate_types!(input[:byte_value], ::Integer, context: "#{context}[:byte_value]")
-        Hearth::Validator.validate_types!(input[:double_value], ::Float, context: "#{context}[:double_value]")
-        Hearth::Validator.validate_types!(input[:float_value], ::Float, context: "#{context}[:float_value]")
-        Hearth::Validator.validate_types!(input[:integer_value], ::Integer, context: "#{context}[:integer_value]")
-        Hearth::Validator.validate_types!(input[:long_value], ::Integer, context: "#{context}[:long_value]")
-        Hearth::Validator.validate_types!(input[:short_value], ::Integer, context: "#{context}[:short_value]")
-        Hearth::Validator.validate_types!(input[:string_value], ::String, context: "#{context}[:string_value]")
-        Hearth::Validator.validate_types!(input[:blob_value], ::String, context: "#{context}[:blob_value]")
+        Hearth::Validator.validate_types!(input.true_boolean_value, ::TrueClass, ::FalseClass, context: "#{context}[:true_boolean_value]")
+        Hearth::Validator.validate_types!(input.false_boolean_value, ::TrueClass, ::FalseClass, context: "#{context}[:false_boolean_value]")
+        Hearth::Validator.validate_types!(input.byte_value, ::Integer, context: "#{context}[:byte_value]")
+        Hearth::Validator.validate_types!(input.double_value, ::Float, context: "#{context}[:double_value]")
+        Hearth::Validator.validate_types!(input.float_value, ::Float, context: "#{context}[:float_value]")
+        Hearth::Validator.validate_types!(input.integer_value, ::Integer, context: "#{context}[:integer_value]")
+        Hearth::Validator.validate_types!(input.long_value, ::Integer, context: "#{context}[:long_value]")
+        Hearth::Validator.validate_types!(input.short_value, ::Integer, context: "#{context}[:short_value]")
+        Hearth::Validator.validate_types!(input.string_value, ::String, context: "#{context}[:string_value]")
+        Hearth::Validator.validate_types!(input.blob_value, ::String, context: "#{context}[:blob_value]")
       end
     end
 
@@ -440,8 +440,8 @@ class SparseBooleanMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::TrueClass, ::FalseClass, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::TrueClass, ::FalseClass, context: "#{context}['#{key}']")
         end
       end
     end
@@ -449,16 +449,16 @@ def self.validate!(input, context:)
     class SparseNullsOperationInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::SparseNullsOperationInput, context: context)
-        SparseStringList.validate!(input[:sparse_string_list], context: "#{context}[:sparse_string_list]") unless input[:sparse_string_list].nil?
-        SparseStringMap.validate!(input[:sparse_string_map], context: "#{context}[:sparse_string_map]") unless input[:sparse_string_map].nil?
+        SparseStringList.validate!(input.sparse_string_list, context: "#{context}[:sparse_string_list]") unless input.sparse_string_list.nil?
+        SparseStringMap.validate!(input.sparse_string_map, context: "#{context}[:sparse_string_map]") unless input.sparse_string_map.nil?
       end
     end
 
     class SparseNullsOperationOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::SparseNullsOperationOutput, context: context)
-        SparseStringList.validate!(input[:sparse_string_list], context: "#{context}[:sparse_string_list]") unless input[:sparse_string_list].nil?
-        SparseStringMap.validate!(input[:sparse_string_map], context: "#{context}[:sparse_string_map]") unless input[:sparse_string_map].nil?
+        SparseStringList.validate!(input.sparse_string_list, context: "#{context}[:sparse_string_list]") unless input.sparse_string_list.nil?
+        SparseStringMap.validate!(input.sparse_string_map, context: "#{context}[:sparse_string_map]") unless input.sparse_string_map.nil?
       end
     end
 
@@ -466,8 +466,8 @@ class SparseNumberMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::Integer, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::Integer, context: "#{context}['#{key}']")
         end
       end
     end
@@ -476,8 +476,8 @@ class SparseSetMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          StringSet.validate!(value, context: "#{context}[:#{key}]") unless value.nil?
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          StringSet.validate!(value, context: "#{context}['#{key}']") unless value.nil?
         end
       end
     end
@@ -495,8 +495,8 @@ class SparseStringMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::String, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::String, context: "#{context}['#{key}']")
         end
       end
     end
@@ -505,8 +505,8 @@ class SparseStructMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          GreetingStruct.validate!(value, context: "#{context}[:#{key}]") unless value.nil?
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          GreetingStruct.validate!(value, context: "#{context}['#{key}']") unless value.nil?
         end
       end
     end
@@ -541,8 +541,8 @@ def self.validate!(input, context:)
     class StructureListMember
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::StructureListMember, context: context)
-        Hearth::Validator.validate_types!(input[:a], ::String, context: "#{context}[:a]")
-        Hearth::Validator.validate_types!(input[:b], ::String, context: "#{context}[:b]")
+        Hearth::Validator.validate_types!(input.a, ::String, context: "#{context}[:a]")
+        Hearth::Validator.validate_types!(input.b, ::String, context: "#{context}[:b]")
       end
     end
 
@@ -559,8 +559,8 @@ class TestStringMap
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::String, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::String, context: "#{context}['#{key}']")
         end
       end
     end
@@ -577,19 +577,19 @@ def self.validate!(input, context:)
     class ValidationException
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::ValidationException, context: context)
-        Hearth::Validator.validate_required!(input[:message], context: "#{context}[:message]")
-        Hearth::Validator.validate_types!(input[:message], ::String, context: "#{context}[:message]")
-        ValidationExceptionFieldList.validate!(input[:field_list], context: "#{context}[:field_list]") unless input[:field_list].nil?
+        Hearth::Validator.validate_required!(input.message, context: "#{context}[:message]")
+        Hearth::Validator.validate_types!(input.message, ::String, context: "#{context}[:message]")
+        ValidationExceptionFieldList.validate!(input.field_list, context: "#{context}[:field_list]") unless input.field_list.nil?
       end
     end
 
     class ValidationExceptionField
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::ValidationExceptionField, context: context)
-        Hearth::Validator.validate_required!(input[:path], context: "#{context}[:path]")
-        Hearth::Validator.validate_types!(input[:path], ::String, context: "#{context}[:path]")
-        Hearth::Validator.validate_required!(input[:message], context: "#{context}[:message]")
-        Hearth::Validator.validate_types!(input[:message], ::String, context: "#{context}[:message]")
+        Hearth::Validator.validate_required!(input.path, context: "#{context}[:path]")
+        Hearth::Validator.validate_types!(input.path, ::String, context: "#{context}[:path]")
+        Hearth::Validator.validate_required!(input.message, context: "#{context}[:message]")
+        Hearth::Validator.validate_types!(input.message, ::String, context: "#{context}[:message]")
       end
     end
 
diff --git a/codegen/projections/rpcv2_cbor/sig/rpcv2_cbor/types.rbs b/codegen/projections/rpcv2_cbor/sig/rpcv2_cbor/types.rbs
index 1fbab3267..690288180 100644
--- a/codegen/projections/rpcv2_cbor/sig/rpcv2_cbor/types.rbs
+++ b/codegen/projections/rpcv2_cbor/sig/rpcv2_cbor/types.rbs
@@ -10,64 +10,64 @@
 module Rpcv2Cbor
   module Types
 
-    class ClientOptionalDefaults < ::Struct[untyped]
+    class ClientOptionalDefaults
       include Hearth::Structure
-      attr_accessor member (): ::Integer
+      attr_accessor member (): ::Integer?
     end
 
-    class ComplexError < ::Struct[untyped]
+    class ComplexError
       include Hearth::Structure
-      attr_accessor top_level (): ::String
-      attr_accessor nested (): Types::ComplexNestedErrorData
+      attr_accessor top_level (): ::String?
+      attr_accessor nested (): Types::ComplexNestedErrorData?
     end
 
-    class ComplexNestedErrorData < ::Struct[untyped]
+    class ComplexNestedErrorData
       include Hearth::Structure
-      attr_accessor foo (): ::String
+      attr_accessor foo (): ::String?
     end
 
-    class Defaults < ::Struct[untyped]
+    class Defaults
       include Hearth::Structure
-      attr_accessor default_string (): ::String
-      attr_accessor default_boolean (): bool
-      attr_accessor default_list (): ::Array[::String]
-      attr_accessor default_timestamp (): ::Time
-      attr_accessor default_blob (): ::String
-      attr_accessor default_byte (): ::Integer
-      attr_accessor default_short (): ::Integer
-      attr_accessor default_integer (): ::Integer
-      attr_accessor default_long (): ::Integer
-      attr_accessor default_float (): ::Float
-      attr_accessor default_double (): ::Float
-      attr_accessor default_map (): ::Hash[::String, ::String]
-      attr_accessor default_enum (): ::String
-      attr_accessor default_int_enum (): ::Integer
-      attr_accessor empty_string (): ::String
-      attr_accessor false_boolean (): bool
-      attr_accessor empty_blob (): ::String
-      attr_accessor zero_byte (): ::Integer
-      attr_accessor zero_short (): ::Integer
-      attr_accessor zero_integer (): ::Integer
-      attr_accessor zero_long (): ::Integer
-      attr_accessor zero_float (): ::Float
-      attr_accessor zero_double (): ::Float
+      attr_accessor default_string (): ::String?
+      attr_accessor default_boolean (): bool?
+      attr_accessor default_list (): ::Array[::String]?
+      attr_accessor default_timestamp (): ::Time?
+      attr_accessor default_blob (): ::String?
+      attr_accessor default_byte (): ::Integer?
+      attr_accessor default_short (): ::Integer?
+      attr_accessor default_integer (): ::Integer?
+      attr_accessor default_long (): ::Integer?
+      attr_accessor default_float (): ::Float?
+      attr_accessor default_double (): ::Float?
+      attr_accessor default_map (): ::Hash[::String, ::String]?
+      attr_accessor default_enum (): ::String?
+      attr_accessor default_int_enum (): ::Integer?
+      attr_accessor empty_string (): ::String?
+      attr_accessor false_boolean (): bool?
+      attr_accessor empty_blob (): ::String?
+      attr_accessor zero_byte (): ::Integer?
+      attr_accessor zero_short (): ::Integer?
+      attr_accessor zero_integer (): ::Integer?
+      attr_accessor zero_long (): ::Integer?
+      attr_accessor zero_float (): ::Float?
+      attr_accessor zero_double (): ::Float?
     end
 
-    class EmptyInputOutputInput < ::Struct[untyped]
+    class EmptyInputOutputInput
       include Hearth::Structure
     end
 
-    class EmptyInputOutputOutput < ::Struct[untyped]
+    class EmptyInputOutputOutput
       include Hearth::Structure
     end
 
-    class Float16Input < ::Struct[untyped]
+    class Float16Input
       include Hearth::Structure
     end
 
-    class Float16Output < ::Struct[untyped]
+    class Float16Output
       include Hearth::Structure
-      attr_accessor value (): ::Float
+      attr_accessor value (): ::Float?
     end
 
     module FooEnum
@@ -82,27 +82,27 @@ module Rpcv2Cbor
       ZERO: ::String
     end
 
-    class FractionalSecondsInput < ::Struct[untyped]
+    class FractionalSecondsInput
       include Hearth::Structure
     end
 
-    class FractionalSecondsOutput < ::Struct[untyped]
+    class FractionalSecondsOutput
       include Hearth::Structure
-      attr_accessor datetime (): ::Time
+      attr_accessor datetime (): ::Time?
     end
 
-    class GreetingStruct < ::Struct[untyped]
+    class GreetingStruct
       include Hearth::Structure
-      attr_accessor hi (): ::String
+      attr_accessor hi (): ::String?
     end
 
-    class GreetingWithErrorsInput < ::Struct[untyped]
+    class GreetingWithErrorsInput
       include Hearth::Structure
     end
 
-    class GreetingWithErrorsOutput < ::Struct[untyped]
+    class GreetingWithErrorsOutput
       include Hearth::Structure
-      attr_accessor greeting (): ::String
+      attr_accessor greeting (): ::String?
     end
 
     module IntegerEnum
@@ -113,194 +113,194 @@ module Rpcv2Cbor
       C: ::Numeric
     end
 
-    class InvalidGreeting < ::Struct[untyped]
+    class InvalidGreeting
       include Hearth::Structure
-      attr_accessor message (): ::String
+      attr_accessor message (): ::String?
     end
 
-    class NoInputOutputInput < ::Struct[untyped]
+    class NoInputOutputInput
       include Hearth::Structure
     end
 
-    class NoInputOutputOutput < ::Struct[untyped]
+    class NoInputOutputOutput
       include Hearth::Structure
     end
 
-    class OperationWithDefaultsInput < ::Struct[untyped]
+    class OperationWithDefaultsInput
       include Hearth::Structure
-      attr_accessor defaults (): Types::Defaults
-      attr_accessor client_optional_defaults (): Types::ClientOptionalDefaults
-      attr_accessor top_level_default (): ::String
-      attr_accessor other_top_level_default (): ::Integer
+      attr_accessor defaults (): Types::Defaults?
+      attr_accessor client_optional_defaults (): Types::ClientOptionalDefaults?
+      attr_accessor top_level_default (): ::String?
+      attr_accessor other_top_level_default (): ::Integer?
     end
 
-    class OperationWithDefaultsOutput < ::Struct[untyped]
+    class OperationWithDefaultsOutput
       include Hearth::Structure
-      attr_accessor default_string (): ::String
-      attr_accessor default_boolean (): bool
-      attr_accessor default_list (): ::Array[::String]
-      attr_accessor default_timestamp (): ::Time
-      attr_accessor default_blob (): ::String
-      attr_accessor default_byte (): ::Integer
-      attr_accessor default_short (): ::Integer
-      attr_accessor default_integer (): ::Integer
-      attr_accessor default_long (): ::Integer
-      attr_accessor default_float (): ::Float
-      attr_accessor default_double (): ::Float
-      attr_accessor default_map (): ::Hash[::String, ::String]
-      attr_accessor default_enum (): ::String
-      attr_accessor default_int_enum (): ::Integer
-      attr_accessor empty_string (): ::String
-      attr_accessor false_boolean (): bool
-      attr_accessor empty_blob (): ::String
-      attr_accessor zero_byte (): ::Integer
-      attr_accessor zero_short (): ::Integer
-      attr_accessor zero_integer (): ::Integer
-      attr_accessor zero_long (): ::Integer
-      attr_accessor zero_float (): ::Float
-      attr_accessor zero_double (): ::Float
+      attr_accessor default_string (): ::String?
+      attr_accessor default_boolean (): bool?
+      attr_accessor default_list (): ::Array[::String]?
+      attr_accessor default_timestamp (): ::Time?
+      attr_accessor default_blob (): ::String?
+      attr_accessor default_byte (): ::Integer?
+      attr_accessor default_short (): ::Integer?
+      attr_accessor default_integer (): ::Integer?
+      attr_accessor default_long (): ::Integer?
+      attr_accessor default_float (): ::Float?
+      attr_accessor default_double (): ::Float?
+      attr_accessor default_map (): ::Hash[::String, ::String]?
+      attr_accessor default_enum (): ::String?
+      attr_accessor default_int_enum (): ::Integer?
+      attr_accessor empty_string (): ::String?
+      attr_accessor false_boolean (): bool?
+      attr_accessor empty_blob (): ::String?
+      attr_accessor zero_byte (): ::Integer?
+      attr_accessor zero_short (): ::Integer?
+      attr_accessor zero_integer (): ::Integer?
+      attr_accessor zero_long (): ::Integer?
+      attr_accessor zero_float (): ::Float?
+      attr_accessor zero_double (): ::Float?
     end
 
-    class OptionalInputOutputInput < ::Struct[untyped]
+    class OptionalInputOutputInput
       include Hearth::Structure
-      attr_accessor value (): ::String
+      attr_accessor value (): ::String?
     end
 
-    class OptionalInputOutputOutput < ::Struct[untyped]
+    class OptionalInputOutputOutput
       include Hearth::Structure
-      attr_accessor value (): ::String
+      attr_accessor value (): ::String?
     end
 
-    class RecursiveShapesInput < ::Struct[untyped]
+    class RecursiveShapesInput
       include Hearth::Structure
-      attr_accessor nested (): Types::RecursiveShapesInputOutputNested1
+      attr_accessor nested (): Types::RecursiveShapesInputOutputNested1?
     end
 
-    class RecursiveShapesInputOutputNested1 < ::Struct[untyped]
+    class RecursiveShapesInputOutputNested1
       include Hearth::Structure
-      attr_accessor foo (): ::String
-      attr_accessor nested (): Types::RecursiveShapesInputOutputNested2
+      attr_accessor foo (): ::String?
+      attr_accessor nested (): Types::RecursiveShapesInputOutputNested2?
     end
 
-    class RecursiveShapesInputOutputNested2 < ::Struct[untyped]
+    class RecursiveShapesInputOutputNested2
       include Hearth::Structure
-      attr_accessor bar (): ::String
-      attr_accessor recursive_member (): Types::RecursiveShapesInputOutputNested1
+      attr_accessor bar (): ::String?
+      attr_accessor recursive_member (): Types::RecursiveShapesInputOutputNested1?
     end
 
-    class RecursiveShapesOutput < ::Struct[untyped]
+    class RecursiveShapesOutput
       include Hearth::Structure
-      attr_accessor nested (): Types::RecursiveShapesInputOutputNested1
+      attr_accessor nested (): Types::RecursiveShapesInputOutputNested1?
     end
 
-    class RpcV2CborDenseMapsInput < ::Struct[untyped]
+    class RpcV2CborDenseMapsInput
       include Hearth::Structure
-      attr_accessor dense_struct_map (): ::Hash[::String, Types::GreetingStruct]
-      attr_accessor dense_number_map (): ::Hash[::String, ::Integer]
-      attr_accessor dense_boolean_map (): ::Hash[::String, bool]
-      attr_accessor dense_string_map (): ::Hash[::String, ::String]
-      attr_accessor dense_set_map (): ::Hash[::String, ::Array[::String]]
+      attr_accessor dense_struct_map (): ::Hash[::String, Types::GreetingStruct]?
+      attr_accessor dense_number_map (): ::Hash[::String, ::Integer]?
+      attr_accessor dense_boolean_map (): ::Hash[::String, bool]?
+      attr_accessor dense_string_map (): ::Hash[::String, ::String]?
+      attr_accessor dense_set_map (): ::Hash[::String, ::Array[::String]]?
     end
 
-    class RpcV2CborDenseMapsOutput < ::Struct[untyped]
+    class RpcV2CborDenseMapsOutput
       include Hearth::Structure
-      attr_accessor dense_struct_map (): ::Hash[::String, Types::GreetingStruct]
-      attr_accessor dense_number_map (): ::Hash[::String, ::Integer]
-      attr_accessor dense_boolean_map (): ::Hash[::String, bool]
-      attr_accessor dense_string_map (): ::Hash[::String, ::String]
-      attr_accessor dense_set_map (): ::Hash[::String, ::Array[::String]]
+      attr_accessor dense_struct_map (): ::Hash[::String, Types::GreetingStruct]?
+      attr_accessor dense_number_map (): ::Hash[::String, ::Integer]?
+      attr_accessor dense_boolean_map (): ::Hash[::String, bool]?
+      attr_accessor dense_string_map (): ::Hash[::String, ::String]?
+      attr_accessor dense_set_map (): ::Hash[::String, ::Array[::String]]?
     end
 
-    class RpcV2CborListsInput < ::Struct[untyped]
+    class RpcV2CborListsInput
       include Hearth::Structure
-      attr_accessor string_list (): ::Array[::String]
-      attr_accessor string_set (): ::Array[::String]
-      attr_accessor integer_list (): ::Array[::Integer]
-      attr_accessor boolean_list (): ::Array[bool]
-      attr_accessor timestamp_list (): ::Array[::Time]
-      attr_accessor enum_list (): ::Array[::String]
-      attr_accessor int_enum_list (): ::Array[::Integer]
-      attr_accessor nested_string_list (): ::Array[::Array[::String]]
-      attr_accessor structure_list (): ::Array[Types::StructureListMember]
-      attr_accessor blob_list (): ::Array[::String]
+      attr_accessor string_list (): ::Array[::String]?
+      attr_accessor string_set (): ::Array[::String]?
+      attr_accessor integer_list (): ::Array[::Integer]?
+      attr_accessor boolean_list (): ::Array[bool]?
+      attr_accessor timestamp_list (): ::Array[::Time]?
+      attr_accessor enum_list (): ::Array[::String]?
+      attr_accessor int_enum_list (): ::Array[::Integer]?
+      attr_accessor nested_string_list (): ::Array[::Array[::String]]?
+      attr_accessor structure_list (): ::Array[Types::StructureListMember]?
+      attr_accessor blob_list (): ::Array[::String]?
     end
 
-    class RpcV2CborListsOutput < ::Struct[untyped]
+    class RpcV2CborListsOutput
       include Hearth::Structure
-      attr_accessor string_list (): ::Array[::String]
-      attr_accessor string_set (): ::Array[::String]
-      attr_accessor integer_list (): ::Array[::Integer]
-      attr_accessor boolean_list (): ::Array[bool]
-      attr_accessor timestamp_list (): ::Array[::Time]
-      attr_accessor enum_list (): ::Array[::String]
-      attr_accessor int_enum_list (): ::Array[::Integer]
-      attr_accessor nested_string_list (): ::Array[::Array[::String]]
-      attr_accessor structure_list (): ::Array[Types::StructureListMember]
-      attr_accessor blob_list (): ::Array[::String]
+      attr_accessor string_list (): ::Array[::String]?
+      attr_accessor string_set (): ::Array[::String]?
+      attr_accessor integer_list (): ::Array[::Integer]?
+      attr_accessor boolean_list (): ::Array[bool]?
+      attr_accessor timestamp_list (): ::Array[::Time]?
+      attr_accessor enum_list (): ::Array[::String]?
+      attr_accessor int_enum_list (): ::Array[::Integer]?
+      attr_accessor nested_string_list (): ::Array[::Array[::String]]?
+      attr_accessor structure_list (): ::Array[Types::StructureListMember]?
+      attr_accessor blob_list (): ::Array[::String]?
     end
 
-    class RpcV2CborSparseMapsInput < ::Struct[untyped]
+    class RpcV2CborSparseMapsInput
       include Hearth::Structure
-      attr_accessor sparse_struct_map (): ::Hash[::String, Types::GreetingStruct]
-      attr_accessor sparse_number_map (): ::Hash[::String, ::Integer]
-      attr_accessor sparse_boolean_map (): ::Hash[::String, bool]
-      attr_accessor sparse_string_map (): ::Hash[::String, ::String]
-      attr_accessor sparse_set_map (): ::Hash[::String, ::Array[::String]]
+      attr_accessor sparse_struct_map (): ::Hash[::String, Types::GreetingStruct?]?
+      attr_accessor sparse_number_map (): ::Hash[::String, ::Integer?]?
+      attr_accessor sparse_boolean_map (): ::Hash[::String, bool?]?
+      attr_accessor sparse_string_map (): ::Hash[::String, ::String?]?
+      attr_accessor sparse_set_map (): ::Hash[::String, ::Array[::String]?]?
     end
 
-    class RpcV2CborSparseMapsOutput < ::Struct[untyped]
+    class RpcV2CborSparseMapsOutput
       include Hearth::Structure
-      attr_accessor sparse_struct_map (): ::Hash[::String, Types::GreetingStruct]
-      attr_accessor sparse_number_map (): ::Hash[::String, ::Integer]
-      attr_accessor sparse_boolean_map (): ::Hash[::String, bool]
-      attr_accessor sparse_string_map (): ::Hash[::String, ::String]
-      attr_accessor sparse_set_map (): ::Hash[::String, ::Array[::String]]
+      attr_accessor sparse_struct_map (): ::Hash[::String, Types::GreetingStruct?]?
+      attr_accessor sparse_number_map (): ::Hash[::String, ::Integer?]?
+      attr_accessor sparse_boolean_map (): ::Hash[::String, bool?]?
+      attr_accessor sparse_string_map (): ::Hash[::String, ::String?]?
+      attr_accessor sparse_set_map (): ::Hash[::String, ::Array[::String]?]?
     end
 
-    class SimpleScalarPropertiesInput < ::Struct[untyped]
+    class SimpleScalarPropertiesInput
       include Hearth::Structure
-      attr_accessor true_boolean_value (): bool
-      attr_accessor false_boolean_value (): bool
-      attr_accessor byte_value (): ::Integer
-      attr_accessor double_value (): ::Float
-      attr_accessor float_value (): ::Float
-      attr_accessor integer_value (): ::Integer
-      attr_accessor long_value (): ::Integer
-      attr_accessor short_value (): ::Integer
-      attr_accessor string_value (): ::String
-      attr_accessor blob_value (): ::String
+      attr_accessor true_boolean_value (): bool?
+      attr_accessor false_boolean_value (): bool?
+      attr_accessor byte_value (): ::Integer?
+      attr_accessor double_value (): ::Float?
+      attr_accessor float_value (): ::Float?
+      attr_accessor integer_value (): ::Integer?
+      attr_accessor long_value (): ::Integer?
+      attr_accessor short_value (): ::Integer?
+      attr_accessor string_value (): ::String?
+      attr_accessor blob_value (): ::String?
     end
 
-    class SimpleScalarPropertiesOutput < ::Struct[untyped]
+    class SimpleScalarPropertiesOutput
       include Hearth::Structure
-      attr_accessor true_boolean_value (): bool
-      attr_accessor false_boolean_value (): bool
-      attr_accessor byte_value (): ::Integer
-      attr_accessor double_value (): ::Float
-      attr_accessor float_value (): ::Float
-      attr_accessor integer_value (): ::Integer
-      attr_accessor long_value (): ::Integer
-      attr_accessor short_value (): ::Integer
-      attr_accessor string_value (): ::String
-      attr_accessor blob_value (): ::String
+      attr_accessor true_boolean_value (): bool?
+      attr_accessor false_boolean_value (): bool?
+      attr_accessor byte_value (): ::Integer?
+      attr_accessor double_value (): ::Float?
+      attr_accessor float_value (): ::Float?
+      attr_accessor integer_value (): ::Integer?
+      attr_accessor long_value (): ::Integer?
+      attr_accessor short_value (): ::Integer?
+      attr_accessor string_value (): ::String?
+      attr_accessor blob_value (): ::String?
     end
 
-    class SparseNullsOperationInput < ::Struct[untyped]
+    class SparseNullsOperationInput
       include Hearth::Structure
-      attr_accessor sparse_string_list (): ::Array[::String]
-      attr_accessor sparse_string_map (): ::Hash[::String, ::String]
+      attr_accessor sparse_string_list (): ::Array[::String?]?
+      attr_accessor sparse_string_map (): ::Hash[::String, ::String?]?
     end
 
-    class SparseNullsOperationOutput < ::Struct[untyped]
+    class SparseNullsOperationOutput
       include Hearth::Structure
-      attr_accessor sparse_string_list (): ::Array[::String]
-      attr_accessor sparse_string_map (): ::Hash[::String, ::String]
+      attr_accessor sparse_string_list (): ::Array[::String?]?
+      attr_accessor sparse_string_map (): ::Hash[::String, ::String?]?
     end
 
-    class StructureListMember < ::Struct[untyped]
+    class StructureListMember
       include Hearth::Structure
-      attr_accessor a (): ::String
-      attr_accessor b (): ::String
+      attr_accessor a (): ::String?
+      attr_accessor b (): ::String?
     end
 
     module TestEnum
@@ -317,13 +317,13 @@ module Rpcv2Cbor
       TWO: ::Numeric
     end
 
-    class ValidationException < ::Struct[untyped]
+    class ValidationException
       include Hearth::Structure
       attr_accessor message (): ::String
-      attr_accessor field_list (): ::Array[Types::ValidationExceptionField]
+      attr_accessor field_list (): ::Array[Types::ValidationExceptionField]?
     end
 
-    class ValidationExceptionField < ::Struct[untyped]
+    class ValidationExceptionField
       include Hearth::Structure
       attr_accessor path (): ::String
       attr_accessor message (): ::String
diff --git a/codegen/projections/white_label/lib/white_label/builders.rb b/codegen/projections/white_label/lib/white_label/builders.rb
index dde58ada4..a5346ee54 100644
--- a/codegen/projections/white_label/lib/white_label/builders.rb
+++ b/codegen/projections/white_label/lib/white_label/builders.rb
@@ -113,13 +113,13 @@ def self.build(http_req, input:)
 
     class RequestCompression
       def self.build(http_req, input:)
-        http_req.body = StringIO.new(input[:body] || '')
+        http_req.body = StringIO.new(input.body || '')
       end
     end
 
     class RequestCompressionStreaming
       def self.build(http_req, input:)
-        http_req.body = input[:body]
+        http_req.body = input.body
         http_req.headers['Transfer-Encoding'] = 'chunked'
         http_req.headers['Content-Type'] = 'application/octet-stream'
       end
@@ -132,7 +132,7 @@ def self.build(http_req, input:)
 
     class Streaming
       def self.build(http_req, input:)
-        http_req.body = input[:stream]
+        http_req.body = input.stream
         http_req.headers['Transfer-Encoding'] = 'chunked'
         http_req.headers['Content-Type'] = 'application/octet-stream'
       end
@@ -140,7 +140,7 @@ def self.build(http_req, input:)
 
     class StreamingWithLength
       def self.build(http_req, input:)
-        http_req.body = input[:stream]
+        http_req.body = input.stream
         http_req.headers['Content-Type'] = 'application/octet-stream'
       end
     end
diff --git a/codegen/projections/white_label/lib/white_label/client.rb b/codegen/projections/white_label/lib/white_label/client.rb
index 0729b13d3..55a47230f 100644
--- a/codegen/projections/white_label/lib/white_label/client.rb
+++ b/codegen/projections/white_label/lib/white_label/client.rb
@@ -914,7 +914,7 @@ def resource_endpoint(params = {}, options = {})
     #   )
     # @example Response structure
     #   resp.data #=> Types::StreamingOutput
-    #   resp.data.stream #=> String
+    #   resp.data.stream #=> IO
     def streaming(params = {}, options = {}, &block)
       response_body = output_stream(options, &block)
       config = operation_config(options)
diff --git a/codegen/projections/white_label/lib/white_label/stubs.rb b/codegen/projections/white_label/lib/white_label/stubs.rb
index 8e3a775ca..6f1aac623 100644
--- a/codegen/projections/white_label/lib/white_label/stubs.rb
+++ b/codegen/projections/white_label/lib/white_label/stubs.rb
@@ -308,7 +308,7 @@ def self.default(visited = [])
         return nil if visited.include?('MapOfStrings')
         visited = visited + ['MapOfStrings']
         {
-          key: 'value'
+          'key' => 'value'
         }
       end
 
@@ -319,7 +319,7 @@ def self.default(visited = [])
         return nil if visited.include?('MapOfStructs')
         visited = visited + ['MapOfStructs']
         {
-          key: Struct.default(visited)
+          'key' => Struct.default(visited)
         }
       end
 
@@ -576,7 +576,7 @@ def self.default(visited = [])
       def self.stub(http_resp, stub:)
         data = {}
         http_resp.status = 200
-        IO.copy_stream(stub[:stream], http_resp.body)
+        IO.copy_stream(stub.stream, http_resp.body)
       end
     end
 
diff --git a/codegen/projections/white_label/lib/white_label/types.rb b/codegen/projections/white_label/lib/white_label/types.rb
index 1df0d000c..32a0c3967 100644
--- a/codegen/projections/white_label/lib/white_label/types.rb
+++ b/codegen/projections/white_label/lib/white_label/types.rb
@@ -15,47 +15,54 @@ module Types
     #   @option params [String] :message
     # @!attribute message
     #   @return [String]
-    ClientError = ::Struct.new(
-      :message,
-      keyword_init: true
-    ) do
+    class ClientError
       include Hearth::Structure
+
+      MEMBERS = %i[
+        message
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    CustomAuthInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class CustomAuthInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    CustomAuthOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class CustomAuthOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    DataplaneEndpointInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class DataplaneEndpointInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    DataplaneEndpointOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class DataplaneEndpointOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -139,33 +146,36 @@ module Types
     #   @return [Time]
     # @!attribute epoch_timestamp
     #   @return [Time]
-    Defaults = ::Struct.new(
-      :string,
-      :struct,
-      :un_required_number,
-      :un_required_bool,
-      :number,
-      :bool,
-      :hello,
-      :simple_enum,
-      :valued_enum,
-      :int_enum,
-      :null_document,
-      :string_document,
-      :boolean_document,
-      :numbers_document,
-      :list_document,
-      :map_document,
-      :list_of_strings,
-      :map_of_strings,
-      :iso8601_timestamp,
-      :epoch_timestamp,
-      keyword_init: true
-    ) do
+    class Defaults
       include Hearth::Structure
 
+      MEMBERS = %i[
+        string
+        struct
+        un_required_number
+        un_required_bool
+        number
+        bool
+        hello
+        simple_enum
+        valued_enum
+        int_enum
+        null_document
+        string_document
+        boolean_document
+        numbers_document
+        list_document
+        map_document
+        list_of_strings
+        map_of_strings
+        iso8601_timestamp
+        epoch_timestamp
+      ].freeze
+
+      attr_accessor(*MEMBERS)
+
       def to_s
-        "#<struct WhiteLabel::Types::Defaults "\
+        "#<WhiteLabel::Types::Defaults "\
           "string=#{string || 'nil'}, "\
           "struct=\"[SENSITIVE]\", "\
           "un_required_number=#{un_required_number || 'nil'}, "\
@@ -218,11 +228,14 @@ def _defaults
     #   @option params [Defaults] :defaults
     # @!attribute defaults
     #   @return [Defaults]
-    DefaultsTestInput = ::Struct.new(
-      :defaults,
-      keyword_init: true
-    ) do
+    class DefaultsTestInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        defaults
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -306,33 +319,36 @@ def _defaults
     #   @return [Time]
     # @!attribute epoch_timestamp
     #   @return [Time]
-    DefaultsTestOutput = ::Struct.new(
-      :string,
-      :struct,
-      :un_required_number,
-      :un_required_bool,
-      :number,
-      :bool,
-      :hello,
-      :simple_enum,
-      :valued_enum,
-      :int_enum,
-      :null_document,
-      :string_document,
-      :boolean_document,
-      :numbers_document,
-      :list_document,
-      :map_document,
-      :list_of_strings,
-      :map_of_strings,
-      :iso8601_timestamp,
-      :epoch_timestamp,
-      keyword_init: true
-    ) do
+    class DefaultsTestOutput
       include Hearth::Structure
 
+      MEMBERS = %i[
+        string
+        struct
+        un_required_number
+        un_required_bool
+        number
+        bool
+        hello
+        simple_enum
+        valued_enum
+        int_enum
+        null_document
+        string_document
+        boolean_document
+        numbers_document
+        list_document
+        map_document
+        list_of_strings
+        map_of_strings
+        iso8601_timestamp
+        epoch_timestamp
+      ].freeze
+
+      attr_accessor(*MEMBERS)
+
       def to_s
-        "#<struct WhiteLabel::Types::DefaultsTestOutput "\
+        "#<WhiteLabel::Types::DefaultsTestOutput "\
           "string=#{string || 'nil'}, "\
           "struct=\"[SENSITIVE]\", "\
           "un_required_number=#{un_required_number || 'nil'}, "\
@@ -382,20 +398,22 @@ def _defaults
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    EndpointOperationInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class EndpointOperationInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    EndpointOperationOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class EndpointOperationOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -403,92 +421,104 @@ def _defaults
     #   @option params [String] :label_member
     # @!attribute label_member
     #   @return [String]
-    EndpointWithHostLabelOperationInput = ::Struct.new(
-      :label_member,
-      keyword_init: true
-    ) do
+    class EndpointWithHostLabelOperationInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        label_member
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    EndpointWithHostLabelOperationOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class EndpointWithHostLabelOperationOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpApiKeyAuthInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpApiKeyAuthInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpApiKeyAuthOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpApiKeyAuthOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpBasicAuthInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpBasicAuthInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpBasicAuthOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpBasicAuthOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpBearerAuthInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpBearerAuthInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpBearerAuthOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpBearerAuthOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpDigestAuthInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpDigestAuthInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    HttpDigestAuthOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class HttpDigestAuthOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # Enum constants for IntEnumType
@@ -582,23 +612,26 @@ module IntEnumType
     #     This shape is meant for internal use only.
     #   @since today
     #   @return [Union]
-    KitchenSinkInput = ::Struct.new(
-      :string,
-      :simple_enum,
-      :valued_enum,
-      :struct,
-      :document,
-      :list_of_strings,
-      :list_of_structs,
-      :map_of_strings,
-      :map_of_structs,
-      :union,
-      keyword_init: true
-    ) do
+    class KitchenSinkInput
       include Hearth::Structure
 
+      MEMBERS = %i[
+        string
+        simple_enum
+        valued_enum
+        struct
+        document
+        list_of_strings
+        list_of_structs
+        map_of_strings
+        map_of_structs
+        union
+      ].freeze
+
+      attr_accessor(*MEMBERS)
+
       def to_s
-        "#<struct WhiteLabel::Types::KitchenSinkInput "\
+        "#<WhiteLabel::Types::KitchenSinkInput "\
           "string=#{string || 'nil'}, "\
           "simple_enum=#{simple_enum || 'nil'}, "\
           "valued_enum=#{valued_enum || 'nil'}, "\
@@ -694,23 +727,26 @@ def to_s
     #     This shape is meant for internal use only.
     #   @since today
     #   @return [Union]
-    KitchenSinkOutput = ::Struct.new(
-      :string,
-      :simple_enum,
-      :valued_enum,
-      :struct,
-      :document,
-      :list_of_strings,
-      :list_of_structs,
-      :map_of_strings,
-      :map_of_structs,
-      :union,
-      keyword_init: true
-    ) do
+    class KitchenSinkOutput
       include Hearth::Structure
 
+      MEMBERS = %i[
+        string
+        simple_enum
+        valued_enum
+        struct
+        document
+        list_of_strings
+        list_of_structs
+        map_of_strings
+        map_of_structs
+        union
+      ].freeze
+
+      attr_accessor(*MEMBERS)
+
       def to_s
-        "#<struct WhiteLabel::Types::KitchenSinkOutput "\
+        "#<WhiteLabel::Types::KitchenSinkOutput "\
           "string=#{string || 'nil'}, "\
           "simple_enum=#{simple_enum || 'nil'}, "\
           "valued_enum=#{valued_enum || 'nil'}, "\
@@ -729,11 +765,14 @@ def to_s
     #   @option params [String] :user_id
     # @!attribute user_id
     #   @return [String]
-    MixinTestInput = ::Struct.new(
-      :user_id,
-      keyword_init: true
-    ) do
+    class MixinTestInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        user_id
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -744,66 +783,75 @@ def to_s
     #   @return [String]
     # @!attribute user_id
     #   @return [String]
-    MixinTestOutput = ::Struct.new(
-      :username,
-      :user_id,
-      keyword_init: true
-    ) do
+    class MixinTestOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        username
+        user_id
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    NoAuthInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class NoAuthInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    NoAuthOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class NoAuthOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    OptionalAuthInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class OptionalAuthInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    OptionalAuthOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class OptionalAuthOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    OrderedAuthInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class OrderedAuthInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    OrderedAuthOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class OrderedAuthOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -811,11 +859,14 @@ def to_s
     #   @option params [String] :next_token
     # @!attribute next_token
     #   @return [String]
-    PaginatorsTestOperationInput = ::Struct.new(
-      :next_token,
-      keyword_init: true
-    ) do
+    class PaginatorsTestOperationInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        next_token
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -826,12 +877,15 @@ def to_s
     #   @return [String]
     # @!attribute items
     #   @return [Array<String>]
-    PaginatorsTestOperationOutput = ::Struct.new(
-      :next_token,
-      :items,
-      keyword_init: true
-    ) do
+    class PaginatorsTestOperationOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        next_token
+        items
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -839,11 +893,14 @@ def to_s
     #   @option params [String] :next_token
     # @!attribute next_token
     #   @return [String]
-    PaginatorsTestWithItemsInput = ::Struct.new(
-      :next_token,
-      keyword_init: true
-    ) do
+    class PaginatorsTestWithItemsInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        next_token
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -854,30 +911,35 @@ def to_s
     #   @return [String]
     # @!attribute items
     #   @return [Array<String>]
-    PaginatorsTestWithItemsOutput = ::Struct.new(
-      :next_token,
-      :items,
-      keyword_init: true
-    ) do
+    class PaginatorsTestWithItemsOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        next_token
+        items
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    RelativeMiddlewareInput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class RelativeMiddlewareInput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    RelativeMiddlewareOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class RelativeMiddlewareOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -885,41 +947,49 @@ def to_s
     #   @option params [String] :body
     # @!attribute body
     #   @return [String]
-    RequestCompressionInput = ::Struct.new(
-      :body,
-      keyword_init: true
-    ) do
+    class RequestCompressionInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        body
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    RequestCompressionOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class RequestCompressionOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    #   @option params [String] :body
+    #   @option params [IO] :body
     # @!attribute body
-    #   @return [String]
-    RequestCompressionStreamingInput = ::Struct.new(
-      :body,
-      keyword_init: true
-    ) do
+    #   @return [IO]
+    class RequestCompressionStreamingInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        body
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    RequestCompressionStreamingOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class RequestCompressionStreamingOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -927,20 +997,24 @@ def to_s
     #   @option params [String] :resource_url
     # @!attribute resource_url
     #   @return [String]
-    ResourceEndpointInput = ::Struct.new(
-      :resource_url,
-      keyword_init: true
-    ) do
+    class ResourceEndpointInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        resource_url
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    ResourceEndpointOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class ResourceEndpointOutput
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -948,20 +1022,24 @@ def to_s
     #   @option params [String] :member___123next_token
     # @!attribute member___123next_token
     #   @return [String]
-    ResultWrapper = ::Struct.new(
-      :member___123next_token,
-      keyword_init: true
-    ) do
+    class ResultWrapper
       include Hearth::Structure
+
+      MEMBERS = %i[
+        member___123next_token
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    ServerError = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class ServerError
       include Hearth::Structure
+
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # Enum constants for SimpleEnum
@@ -973,51 +1051,58 @@ module SimpleEnum
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    #   @option params [String] :stream
+    #   @option params [IO] :stream
     # @!attribute stream
-    #   @return [String]
-    StreamingInput = ::Struct.new(
-      :stream,
-      keyword_init: true
-    ) do
+    #   @return [IO]
+    class StreamingInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        stream
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    #   @option params [String] :stream
+    #   @option params [IO] :stream
     # @!attribute stream
-    #   @return [String]
-    StreamingOutput = ::Struct.new(
-      :stream,
-      keyword_init: true
-    ) do
+    #   @return [IO]
+    class StreamingOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        stream
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    #   @option params [String] :stream
+    #   @option params [IO] :stream
     # @!attribute stream
-    #   @return [String]
-    StreamingWithLengthInput = ::Struct.new(
-      :stream,
-      keyword_init: true
-    ) do
+    #   @return [IO]
+    class StreamingWithLengthInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        stream
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
     #   @param [Hash] params
-    StreamingWithLengthOutput = ::Struct.new(
-      nil,
-      keyword_init: true
-    ) do
+    class StreamingWithLengthOutput
       include Hearth::Structure
-    end
 
-    # @api private
-    class ::Struct; end
+      MEMBERS = [].freeze
+
+      attr_accessor(*MEMBERS)
+    end
 
     # This docstring should be different than KitchenSink struct member.
     # @deprecated
@@ -1038,14 +1123,17 @@ class ::Struct; end
     #   @option params [String] :value
     # @!attribute value
     #   @return [String]
-    Struct = ::Struct.new(
-      :value,
-      keyword_init: true
-    ) do
+    class Struct
       include Hearth::Structure
 
+      MEMBERS = %i[
+        value
+      ].freeze
+
+      attr_accessor(*MEMBERS)
+
       def to_s
-        "#<struct WhiteLabel::Types::Struct [SENSITIVE]>"
+        "#<WhiteLabel::Types::Struct [SENSITIVE]>"
       end
     end
 
@@ -1142,11 +1230,14 @@ module ValuedEnum
     #   @option params [String] :status
     # @!attribute status
     #   @return [String]
-    WaitersTestInput = ::Struct.new(
-      :status,
-      keyword_init: true
-    ) do
+    class WaitersTestInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        status
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1154,11 +1245,14 @@ module ValuedEnum
     #   @option params [String] :status
     # @!attribute status
     #   @return [String]
-    WaitersTestOutput = ::Struct.new(
-      :status,
-      keyword_init: true
-    ) do
+    class WaitersTestOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        status
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1166,11 +1260,14 @@ module ValuedEnum
     #   @option params [String] :member___next_token
     # @!attribute member___next_token
     #   @return [String]
-    Struct____PaginatorsTestWithBadNamesInput = ::Struct.new(
-      :member___next_token,
-      keyword_init: true
-    ) do
+    class Struct____PaginatorsTestWithBadNamesInput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        member___next_token
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
     # @!method initialize(params = {})
@@ -1181,12 +1278,15 @@ module ValuedEnum
     #   @return [ResultWrapper]
     # @!attribute member___items
     #   @return [Array<String>]
-    Struct____PaginatorsTestWithBadNamesOutput = ::Struct.new(
-      :member___wrapper,
-      :member___items,
-      keyword_init: true
-    ) do
+    class Struct____PaginatorsTestWithBadNamesOutput
       include Hearth::Structure
+
+      MEMBERS = %i[
+        member___wrapper
+        member___items
+      ].freeze
+
+      attr_accessor(*MEMBERS)
     end
 
   end
diff --git a/codegen/projections/white_label/lib/white_label/validators.rb b/codegen/projections/white_label/lib/white_label/validators.rb
index 62f642c72..7b48451ba 100644
--- a/codegen/projections/white_label/lib/white_label/validators.rb
+++ b/codegen/projections/white_label/lib/white_label/validators.rb
@@ -16,7 +16,7 @@ module Validators
     class ClientError
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::ClientError, context: context)
-        Hearth::Validator.validate_types!(input[:message], ::String, context: "#{context}[:message]")
+        Hearth::Validator.validate_types!(input.message, ::String, context: "#{context}[:message]")
       end
     end
 
@@ -47,91 +47,91 @@ def self.validate!(input, context:)
     class Defaults
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::Defaults, context: context)
-        Hearth::Validator.validate_types!(input[:string], ::String, context: "#{context}[:string]")
-        Struct.validate!(input[:struct], context: "#{context}[:struct]") unless input[:struct].nil?
-        Hearth::Validator.validate_types!(input[:un_required_number], ::Integer, context: "#{context}[:un_required_number]")
-        Hearth::Validator.validate_types!(input[:un_required_bool], ::TrueClass, ::FalseClass, context: "#{context}[:un_required_bool]")
-        Hearth::Validator.validate_required!(input[:number], context: "#{context}[:number]")
-        Hearth::Validator.validate_types!(input[:number], ::Integer, context: "#{context}[:number]")
-        Hearth::Validator.validate_required!(input[:bool], context: "#{context}[:bool]")
-        Hearth::Validator.validate_types!(input[:bool], ::TrueClass, ::FalseClass, context: "#{context}[:bool]")
-        Hearth::Validator.validate_required!(input[:hello], context: "#{context}[:hello]")
-        Hearth::Validator.validate_types!(input[:hello], ::String, context: "#{context}[:hello]")
-        Hearth::Validator.validate_required!(input[:simple_enum], context: "#{context}[:simple_enum]")
-        Hearth::Validator.validate_types!(input[:simple_enum], ::String, context: "#{context}[:simple_enum]")
-        Hearth::Validator.validate_required!(input[:valued_enum], context: "#{context}[:valued_enum]")
-        Hearth::Validator.validate_types!(input[:valued_enum], ::String, context: "#{context}[:valued_enum]")
-        Hearth::Validator.validate_required!(input[:int_enum], context: "#{context}[:int_enum]")
-        Hearth::Validator.validate_types!(input[:int_enum], ::Integer, context: "#{context}[:int_enum]")
-        Hearth::Validator.validate_required!(input[:null_document], context: "#{context}[:null_document]")
-        Document.validate!(input[:null_document], context: "#{context}[:null_document]") unless input[:null_document].nil?
-        Hearth::Validator.validate_required!(input[:string_document], context: "#{context}[:string_document]")
-        Document.validate!(input[:string_document], context: "#{context}[:string_document]") unless input[:string_document].nil?
-        Hearth::Validator.validate_required!(input[:boolean_document], context: "#{context}[:boolean_document]")
-        Document.validate!(input[:boolean_document], context: "#{context}[:boolean_document]") unless input[:boolean_document].nil?
-        Hearth::Validator.validate_required!(input[:numbers_document], context: "#{context}[:numbers_document]")
-        Document.validate!(input[:numbers_document], context: "#{context}[:numbers_document]") unless input[:numbers_document].nil?
-        Hearth::Validator.validate_required!(input[:list_document], context: "#{context}[:list_document]")
-        Document.validate!(input[:list_document], context: "#{context}[:list_document]") unless input[:list_document].nil?
-        Hearth::Validator.validate_required!(input[:map_document], context: "#{context}[:map_document]")
-        Document.validate!(input[:map_document], context: "#{context}[:map_document]") unless input[:map_document].nil?
-        Hearth::Validator.validate_required!(input[:list_of_strings], context: "#{context}[:list_of_strings]")
-        ListOfStrings.validate!(input[:list_of_strings], context: "#{context}[:list_of_strings]") unless input[:list_of_strings].nil?
-        Hearth::Validator.validate_required!(input[:map_of_strings], context: "#{context}[:map_of_strings]")
-        MapOfStrings.validate!(input[:map_of_strings], context: "#{context}[:map_of_strings]") unless input[:map_of_strings].nil?
-        Hearth::Validator.validate_required!(input[:iso8601_timestamp], context: "#{context}[:iso8601_timestamp]")
-        Hearth::Validator.validate_types!(input[:iso8601_timestamp], ::Time, context: "#{context}[:iso8601_timestamp]")
-        Hearth::Validator.validate_required!(input[:epoch_timestamp], context: "#{context}[:epoch_timestamp]")
-        Hearth::Validator.validate_types!(input[:epoch_timestamp], ::Time, context: "#{context}[:epoch_timestamp]")
+        Hearth::Validator.validate_types!(input.string, ::String, context: "#{context}[:string]")
+        Struct.validate!(input.struct, context: "#{context}[:struct]") unless input.struct.nil?
+        Hearth::Validator.validate_types!(input.un_required_number, ::Integer, context: "#{context}[:un_required_number]")
+        Hearth::Validator.validate_types!(input.un_required_bool, ::TrueClass, ::FalseClass, context: "#{context}[:un_required_bool]")
+        Hearth::Validator.validate_required!(input.number, context: "#{context}[:number]")
+        Hearth::Validator.validate_types!(input.number, ::Integer, context: "#{context}[:number]")
+        Hearth::Validator.validate_required!(input.bool, context: "#{context}[:bool]")
+        Hearth::Validator.validate_types!(input.bool, ::TrueClass, ::FalseClass, context: "#{context}[:bool]")
+        Hearth::Validator.validate_required!(input.hello, context: "#{context}[:hello]")
+        Hearth::Validator.validate_types!(input.hello, ::String, context: "#{context}[:hello]")
+        Hearth::Validator.validate_required!(input.simple_enum, context: "#{context}[:simple_enum]")
+        Hearth::Validator.validate_types!(input.simple_enum, ::String, context: "#{context}[:simple_enum]")
+        Hearth::Validator.validate_required!(input.valued_enum, context: "#{context}[:valued_enum]")
+        Hearth::Validator.validate_types!(input.valued_enum, ::String, context: "#{context}[:valued_enum]")
+        Hearth::Validator.validate_required!(input.int_enum, context: "#{context}[:int_enum]")
+        Hearth::Validator.validate_types!(input.int_enum, ::Integer, context: "#{context}[:int_enum]")
+        Hearth::Validator.validate_required!(input.null_document, context: "#{context}[:null_document]")
+        Document.validate!(input.null_document, context: "#{context}[:null_document]") unless input.null_document.nil?
+        Hearth::Validator.validate_required!(input.string_document, context: "#{context}[:string_document]")
+        Document.validate!(input.string_document, context: "#{context}[:string_document]") unless input.string_document.nil?
+        Hearth::Validator.validate_required!(input.boolean_document, context: "#{context}[:boolean_document]")
+        Document.validate!(input.boolean_document, context: "#{context}[:boolean_document]") unless input.boolean_document.nil?
+        Hearth::Validator.validate_required!(input.numbers_document, context: "#{context}[:numbers_document]")
+        Document.validate!(input.numbers_document, context: "#{context}[:numbers_document]") unless input.numbers_document.nil?
+        Hearth::Validator.validate_required!(input.list_document, context: "#{context}[:list_document]")
+        Document.validate!(input.list_document, context: "#{context}[:list_document]") unless input.list_document.nil?
+        Hearth::Validator.validate_required!(input.map_document, context: "#{context}[:map_document]")
+        Document.validate!(input.map_document, context: "#{context}[:map_document]") unless input.map_document.nil?
+        Hearth::Validator.validate_required!(input.list_of_strings, context: "#{context}[:list_of_strings]")
+        ListOfStrings.validate!(input.list_of_strings, context: "#{context}[:list_of_strings]") unless input.list_of_strings.nil?
+        Hearth::Validator.validate_required!(input.map_of_strings, context: "#{context}[:map_of_strings]")
+        MapOfStrings.validate!(input.map_of_strings, context: "#{context}[:map_of_strings]") unless input.map_of_strings.nil?
+        Hearth::Validator.validate_required!(input.iso8601_timestamp, context: "#{context}[:iso8601_timestamp]")
+        Hearth::Validator.validate_types!(input.iso8601_timestamp, ::Time, context: "#{context}[:iso8601_timestamp]")
+        Hearth::Validator.validate_required!(input.epoch_timestamp, context: "#{context}[:epoch_timestamp]")
+        Hearth::Validator.validate_types!(input.epoch_timestamp, ::Time, context: "#{context}[:epoch_timestamp]")
       end
     end
 
     class DefaultsTestInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::DefaultsTestInput, context: context)
-        Defaults.validate!(input[:defaults], context: "#{context}[:defaults]") unless input[:defaults].nil?
+        Defaults.validate!(input.defaults, context: "#{context}[:defaults]") unless input.defaults.nil?
       end
     end
 
     class DefaultsTestOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::DefaultsTestOutput, context: context)
-        Hearth::Validator.validate_types!(input[:string], ::String, context: "#{context}[:string]")
-        Struct.validate!(input[:struct], context: "#{context}[:struct]") unless input[:struct].nil?
-        Hearth::Validator.validate_types!(input[:un_required_number], ::Integer, context: "#{context}[:un_required_number]")
-        Hearth::Validator.validate_types!(input[:un_required_bool], ::TrueClass, ::FalseClass, context: "#{context}[:un_required_bool]")
-        Hearth::Validator.validate_required!(input[:number], context: "#{context}[:number]")
-        Hearth::Validator.validate_types!(input[:number], ::Integer, context: "#{context}[:number]")
-        Hearth::Validator.validate_required!(input[:bool], context: "#{context}[:bool]")
-        Hearth::Validator.validate_types!(input[:bool], ::TrueClass, ::FalseClass, context: "#{context}[:bool]")
-        Hearth::Validator.validate_required!(input[:hello], context: "#{context}[:hello]")
-        Hearth::Validator.validate_types!(input[:hello], ::String, context: "#{context}[:hello]")
-        Hearth::Validator.validate_required!(input[:simple_enum], context: "#{context}[:simple_enum]")
-        Hearth::Validator.validate_types!(input[:simple_enum], ::String, context: "#{context}[:simple_enum]")
-        Hearth::Validator.validate_required!(input[:valued_enum], context: "#{context}[:valued_enum]")
-        Hearth::Validator.validate_types!(input[:valued_enum], ::String, context: "#{context}[:valued_enum]")
-        Hearth::Validator.validate_required!(input[:int_enum], context: "#{context}[:int_enum]")
-        Hearth::Validator.validate_types!(input[:int_enum], ::Integer, context: "#{context}[:int_enum]")
-        Hearth::Validator.validate_required!(input[:null_document], context: "#{context}[:null_document]")
-        Document.validate!(input[:null_document], context: "#{context}[:null_document]") unless input[:null_document].nil?
-        Hearth::Validator.validate_required!(input[:string_document], context: "#{context}[:string_document]")
-        Document.validate!(input[:string_document], context: "#{context}[:string_document]") unless input[:string_document].nil?
-        Hearth::Validator.validate_required!(input[:boolean_document], context: "#{context}[:boolean_document]")
-        Document.validate!(input[:boolean_document], context: "#{context}[:boolean_document]") unless input[:boolean_document].nil?
-        Hearth::Validator.validate_required!(input[:numbers_document], context: "#{context}[:numbers_document]")
-        Document.validate!(input[:numbers_document], context: "#{context}[:numbers_document]") unless input[:numbers_document].nil?
-        Hearth::Validator.validate_required!(input[:list_document], context: "#{context}[:list_document]")
-        Document.validate!(input[:list_document], context: "#{context}[:list_document]") unless input[:list_document].nil?
-        Hearth::Validator.validate_required!(input[:map_document], context: "#{context}[:map_document]")
-        Document.validate!(input[:map_document], context: "#{context}[:map_document]") unless input[:map_document].nil?
-        Hearth::Validator.validate_required!(input[:list_of_strings], context: "#{context}[:list_of_strings]")
-        ListOfStrings.validate!(input[:list_of_strings], context: "#{context}[:list_of_strings]") unless input[:list_of_strings].nil?
-        Hearth::Validator.validate_required!(input[:map_of_strings], context: "#{context}[:map_of_strings]")
-        MapOfStrings.validate!(input[:map_of_strings], context: "#{context}[:map_of_strings]") unless input[:map_of_strings].nil?
-        Hearth::Validator.validate_required!(input[:iso8601_timestamp], context: "#{context}[:iso8601_timestamp]")
-        Hearth::Validator.validate_types!(input[:iso8601_timestamp], ::Time, context: "#{context}[:iso8601_timestamp]")
-        Hearth::Validator.validate_required!(input[:epoch_timestamp], context: "#{context}[:epoch_timestamp]")
-        Hearth::Validator.validate_types!(input[:epoch_timestamp], ::Time, context: "#{context}[:epoch_timestamp]")
+        Hearth::Validator.validate_types!(input.string, ::String, context: "#{context}[:string]")
+        Struct.validate!(input.struct, context: "#{context}[:struct]") unless input.struct.nil?
+        Hearth::Validator.validate_types!(input.un_required_number, ::Integer, context: "#{context}[:un_required_number]")
+        Hearth::Validator.validate_types!(input.un_required_bool, ::TrueClass, ::FalseClass, context: "#{context}[:un_required_bool]")
+        Hearth::Validator.validate_required!(input.number, context: "#{context}[:number]")
+        Hearth::Validator.validate_types!(input.number, ::Integer, context: "#{context}[:number]")
+        Hearth::Validator.validate_required!(input.bool, context: "#{context}[:bool]")
+        Hearth::Validator.validate_types!(input.bool, ::TrueClass, ::FalseClass, context: "#{context}[:bool]")
+        Hearth::Validator.validate_required!(input.hello, context: "#{context}[:hello]")
+        Hearth::Validator.validate_types!(input.hello, ::String, context: "#{context}[:hello]")
+        Hearth::Validator.validate_required!(input.simple_enum, context: "#{context}[:simple_enum]")
+        Hearth::Validator.validate_types!(input.simple_enum, ::String, context: "#{context}[:simple_enum]")
+        Hearth::Validator.validate_required!(input.valued_enum, context: "#{context}[:valued_enum]")
+        Hearth::Validator.validate_types!(input.valued_enum, ::String, context: "#{context}[:valued_enum]")
+        Hearth::Validator.validate_required!(input.int_enum, context: "#{context}[:int_enum]")
+        Hearth::Validator.validate_types!(input.int_enum, ::Integer, context: "#{context}[:int_enum]")
+        Hearth::Validator.validate_required!(input.null_document, context: "#{context}[:null_document]")
+        Document.validate!(input.null_document, context: "#{context}[:null_document]") unless input.null_document.nil?
+        Hearth::Validator.validate_required!(input.string_document, context: "#{context}[:string_document]")
+        Document.validate!(input.string_document, context: "#{context}[:string_document]") unless input.string_document.nil?
+        Hearth::Validator.validate_required!(input.boolean_document, context: "#{context}[:boolean_document]")
+        Document.validate!(input.boolean_document, context: "#{context}[:boolean_document]") unless input.boolean_document.nil?
+        Hearth::Validator.validate_required!(input.numbers_document, context: "#{context}[:numbers_document]")
+        Document.validate!(input.numbers_document, context: "#{context}[:numbers_document]") unless input.numbers_document.nil?
+        Hearth::Validator.validate_required!(input.list_document, context: "#{context}[:list_document]")
+        Document.validate!(input.list_document, context: "#{context}[:list_document]") unless input.list_document.nil?
+        Hearth::Validator.validate_required!(input.map_document, context: "#{context}[:map_document]")
+        Document.validate!(input.map_document, context: "#{context}[:map_document]") unless input.map_document.nil?
+        Hearth::Validator.validate_required!(input.list_of_strings, context: "#{context}[:list_of_strings]")
+        ListOfStrings.validate!(input.list_of_strings, context: "#{context}[:list_of_strings]") unless input.list_of_strings.nil?
+        Hearth::Validator.validate_required!(input.map_of_strings, context: "#{context}[:map_of_strings]")
+        MapOfStrings.validate!(input.map_of_strings, context: "#{context}[:map_of_strings]") unless input.map_of_strings.nil?
+        Hearth::Validator.validate_required!(input.iso8601_timestamp, context: "#{context}[:iso8601_timestamp]")
+        Hearth::Validator.validate_types!(input.iso8601_timestamp, ::Time, context: "#{context}[:iso8601_timestamp]")
+        Hearth::Validator.validate_required!(input.epoch_timestamp, context: "#{context}[:epoch_timestamp]")
+        Hearth::Validator.validate_types!(input.epoch_timestamp, ::Time, context: "#{context}[:epoch_timestamp]")
       end
     end
 
@@ -141,7 +141,7 @@ def self.validate!(input, context:)
         case input
         when ::Hash
           input.each do |k,v|
-            validate!(v, context: "#{context}[:#{k}]")
+            validate!(v, context: "#{context}['#{k}']")
           end
         when ::Array
           input.each_with_index do |v, i|
@@ -166,8 +166,8 @@ def self.validate!(input, context:)
     class EndpointWithHostLabelOperationInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::EndpointWithHostLabelOperationInput, context: context)
-        Hearth::Validator.validate_required!(input[:label_member], context: "#{context}[:label_member]")
-        Hearth::Validator.validate_types!(input[:label_member], ::String, context: "#{context}[:label_member]")
+        Hearth::Validator.validate_required!(input.label_member, context: "#{context}[:label_member]")
+        Hearth::Validator.validate_types!(input.label_member, ::String, context: "#{context}[:label_member]")
       end
     end
 
@@ -237,32 +237,32 @@ def self.validate!(input, context:)
     class KitchenSinkInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::KitchenSinkInput, context: context)
-        Hearth::Validator.validate_types!(input[:string], ::String, context: "#{context}[:string]")
-        Hearth::Validator.validate_types!(input[:simple_enum], ::String, context: "#{context}[:simple_enum]")
-        Hearth::Validator.validate_types!(input[:valued_enum], ::String, context: "#{context}[:valued_enum]")
-        Struct.validate!(input[:struct], context: "#{context}[:struct]") unless input[:struct].nil?
-        Document.validate!(input[:document], context: "#{context}[:document]") unless input[:document].nil?
-        ListOfStrings.validate!(input[:list_of_strings], context: "#{context}[:list_of_strings]") unless input[:list_of_strings].nil?
-        ListOfStructs.validate!(input[:list_of_structs], context: "#{context}[:list_of_structs]") unless input[:list_of_structs].nil?
-        MapOfStrings.validate!(input[:map_of_strings], context: "#{context}[:map_of_strings]") unless input[:map_of_strings].nil?
-        MapOfStructs.validate!(input[:map_of_structs], context: "#{context}[:map_of_structs]") unless input[:map_of_structs].nil?
-        Union.validate!(input[:union], context: "#{context}[:union]") unless input[:union].nil?
+        Hearth::Validator.validate_types!(input.string, ::String, context: "#{context}[:string]")
+        Hearth::Validator.validate_types!(input.simple_enum, ::String, context: "#{context}[:simple_enum]")
+        Hearth::Validator.validate_types!(input.valued_enum, ::String, context: "#{context}[:valued_enum]")
+        Struct.validate!(input.struct, context: "#{context}[:struct]") unless input.struct.nil?
+        Document.validate!(input.document, context: "#{context}[:document]") unless input.document.nil?
+        ListOfStrings.validate!(input.list_of_strings, context: "#{context}[:list_of_strings]") unless input.list_of_strings.nil?
+        ListOfStructs.validate!(input.list_of_structs, context: "#{context}[:list_of_structs]") unless input.list_of_structs.nil?
+        MapOfStrings.validate!(input.map_of_strings, context: "#{context}[:map_of_strings]") unless input.map_of_strings.nil?
+        MapOfStructs.validate!(input.map_of_structs, context: "#{context}[:map_of_structs]") unless input.map_of_structs.nil?
+        Union.validate!(input.union, context: "#{context}[:union]") unless input.union.nil?
       end
     end
 
     class KitchenSinkOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::KitchenSinkOutput, context: context)
-        Hearth::Validator.validate_types!(input[:string], ::String, context: "#{context}[:string]")
-        Hearth::Validator.validate_types!(input[:simple_enum], ::String, context: "#{context}[:simple_enum]")
-        Hearth::Validator.validate_types!(input[:valued_enum], ::String, context: "#{context}[:valued_enum]")
-        Struct.validate!(input[:struct], context: "#{context}[:struct]") unless input[:struct].nil?
-        Document.validate!(input[:document], context: "#{context}[:document]") unless input[:document].nil?
-        ListOfStrings.validate!(input[:list_of_strings], context: "#{context}[:list_of_strings]") unless input[:list_of_strings].nil?
-        ListOfStructs.validate!(input[:list_of_structs], context: "#{context}[:list_of_structs]") unless input[:list_of_structs].nil?
-        MapOfStrings.validate!(input[:map_of_strings], context: "#{context}[:map_of_strings]") unless input[:map_of_strings].nil?
-        MapOfStructs.validate!(input[:map_of_structs], context: "#{context}[:map_of_structs]") unless input[:map_of_structs].nil?
-        Union.validate!(input[:union], context: "#{context}[:union]") unless input[:union].nil?
+        Hearth::Validator.validate_types!(input.string, ::String, context: "#{context}[:string]")
+        Hearth::Validator.validate_types!(input.simple_enum, ::String, context: "#{context}[:simple_enum]")
+        Hearth::Validator.validate_types!(input.valued_enum, ::String, context: "#{context}[:valued_enum]")
+        Struct.validate!(input.struct, context: "#{context}[:struct]") unless input.struct.nil?
+        Document.validate!(input.document, context: "#{context}[:document]") unless input.document.nil?
+        ListOfStrings.validate!(input.list_of_strings, context: "#{context}[:list_of_strings]") unless input.list_of_strings.nil?
+        ListOfStructs.validate!(input.list_of_structs, context: "#{context}[:list_of_structs]") unless input.list_of_structs.nil?
+        MapOfStrings.validate!(input.map_of_strings, context: "#{context}[:map_of_strings]") unless input.map_of_strings.nil?
+        MapOfStructs.validate!(input.map_of_structs, context: "#{context}[:map_of_structs]") unless input.map_of_structs.nil?
+        Union.validate!(input.union, context: "#{context}[:union]") unless input.union.nil?
       end
     end
 
@@ -288,8 +288,8 @@ class MapOfStrings
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Hearth::Validator.validate_types!(value, ::String, context: "#{context}[:#{key}]")
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Hearth::Validator.validate_types!(value, ::String, context: "#{context}['#{key}']")
         end
       end
     end
@@ -298,8 +298,8 @@ class MapOfStructs
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, ::Hash, context: context)
         input.each do |key, value|
-          Hearth::Validator.validate_types!(key, ::String, ::Symbol, context: "#{context}.keys")
-          Struct.validate!(value, context: "#{context}[:#{key}]") unless value.nil?
+          Hearth::Validator.validate_types!(key, ::String, context: "#{context}.keys")
+          Struct.validate!(value, context: "#{context}['#{key}']") unless value.nil?
         end
       end
     end
@@ -307,15 +307,15 @@ def self.validate!(input, context:)
     class MixinTestInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::MixinTestInput, context: context)
-        Hearth::Validator.validate_types!(input[:user_id], ::String, context: "#{context}[:user_id]")
+        Hearth::Validator.validate_types!(input.user_id, ::String, context: "#{context}[:user_id]")
       end
     end
 
     class MixinTestOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::MixinTestOutput, context: context)
-        Hearth::Validator.validate_types!(input[:username], ::String, context: "#{context}[:username]")
-        Hearth::Validator.validate_types!(input[:user_id], ::String, context: "#{context}[:user_id]")
+        Hearth::Validator.validate_types!(input.username, ::String, context: "#{context}[:username]")
+        Hearth::Validator.validate_types!(input.user_id, ::String, context: "#{context}[:user_id]")
       end
     end
 
@@ -358,30 +358,30 @@ def self.validate!(input, context:)
     class PaginatorsTestOperationInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::PaginatorsTestOperationInput, context: context)
-        Hearth::Validator.validate_types!(input[:next_token], ::String, context: "#{context}[:next_token]")
+        Hearth::Validator.validate_types!(input.next_token, ::String, context: "#{context}[:next_token]")
       end
     end
 
     class PaginatorsTestOperationOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::PaginatorsTestOperationOutput, context: context)
-        Hearth::Validator.validate_types!(input[:next_token], ::String, context: "#{context}[:next_token]")
-        Items.validate!(input[:items], context: "#{context}[:items]") unless input[:items].nil?
+        Hearth::Validator.validate_types!(input.next_token, ::String, context: "#{context}[:next_token]")
+        Items.validate!(input.items, context: "#{context}[:items]") unless input.items.nil?
       end
     end
 
     class PaginatorsTestWithItemsInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::PaginatorsTestWithItemsInput, context: context)
-        Hearth::Validator.validate_types!(input[:next_token], ::String, context: "#{context}[:next_token]")
+        Hearth::Validator.validate_types!(input.next_token, ::String, context: "#{context}[:next_token]")
       end
     end
 
     class PaginatorsTestWithItemsOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::PaginatorsTestWithItemsOutput, context: context)
-        Hearth::Validator.validate_types!(input[:next_token], ::String, context: "#{context}[:next_token]")
-        Items.validate!(input[:items], context: "#{context}[:items]") unless input[:items].nil?
+        Hearth::Validator.validate_types!(input.next_token, ::String, context: "#{context}[:next_token]")
+        Items.validate!(input.items, context: "#{context}[:items]") unless input.items.nil?
       end
     end
 
@@ -400,7 +400,7 @@ def self.validate!(input, context:)
     class RequestCompressionInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RequestCompressionInput, context: context)
-        Hearth::Validator.validate_types!(input[:body], ::String, context: "#{context}[:body]")
+        Hearth::Validator.validate_types!(input.body, ::String, context: "#{context}[:body]")
       end
     end
 
@@ -413,9 +413,9 @@ def self.validate!(input, context:)
     class RequestCompressionStreamingInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::RequestCompressionStreamingInput, context: context)
-        Hearth::Validator.validate_required!(input[:body], context: "#{context}[:body]")
-        unless input[:body].respond_to?(:read) || input[:body].respond_to?(:readpartial)
-          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input[:body].class}"
+        Hearth::Validator.validate_required!(input.body, context: "#{context}[:body]")
+        unless input.body.respond_to?(:read) || input.body.respond_to?(:readpartial)
+          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input.body.class}"
         end
       end
     end
@@ -429,8 +429,8 @@ def self.validate!(input, context:)
     class ResourceEndpointInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::ResourceEndpointInput, context: context)
-        Hearth::Validator.validate_required!(input[:resource_url], context: "#{context}[:resource_url]")
-        Hearth::Validator.validate_types!(input[:resource_url], ::String, context: "#{context}[:resource_url]")
+        Hearth::Validator.validate_required!(input.resource_url, context: "#{context}[:resource_url]")
+        Hearth::Validator.validate_types!(input.resource_url, ::String, context: "#{context}[:resource_url]")
       end
     end
 
@@ -443,7 +443,7 @@ def self.validate!(input, context:)
     class ResultWrapper
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::ResultWrapper, context: context)
-        Hearth::Validator.validate_types!(input[:member___123next_token], ::String, context: "#{context}[:member___123next_token]")
+        Hearth::Validator.validate_types!(input.member___123next_token, ::String, context: "#{context}[:member___123next_token]")
       end
     end
 
@@ -456,9 +456,9 @@ def self.validate!(input, context:)
     class StreamingInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::StreamingInput, context: context)
-        Hearth::Validator.validate_required!(input[:stream], context: "#{context}[:stream]")
-        unless input[:stream].respond_to?(:read) || input[:stream].respond_to?(:readpartial)
-          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input[:stream].class}"
+        Hearth::Validator.validate_required!(input.stream, context: "#{context}[:stream]")
+        unless input.stream.respond_to?(:read) || input.stream.respond_to?(:readpartial)
+          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input.stream.class}"
         end
       end
     end
@@ -466,9 +466,9 @@ def self.validate!(input, context:)
     class StreamingOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::StreamingOutput, context: context)
-        Hearth::Validator.validate_required!(input[:stream], context: "#{context}[:stream]")
-        unless input[:stream].respond_to?(:read) || input[:stream].respond_to?(:readpartial)
-          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input[:stream].class}"
+        Hearth::Validator.validate_required!(input.stream, context: "#{context}[:stream]")
+        unless input.stream.respond_to?(:read) || input.stream.respond_to?(:readpartial)
+          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input.stream.class}"
         end
       end
     end
@@ -476,12 +476,12 @@ def self.validate!(input, context:)
     class StreamingWithLengthInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::StreamingWithLengthInput, context: context)
-        Hearth::Validator.validate_required!(input[:stream], context: "#{context}[:stream]")
-        unless input[:stream].respond_to?(:read) || input[:stream].respond_to?(:readpartial)
-          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input[:stream].class}"
+        Hearth::Validator.validate_required!(input.stream, context: "#{context}[:stream]")
+        unless input.stream.respond_to?(:read) || input.stream.respond_to?(:readpartial)
+          raise ArgumentError, "Expected #{context} to be an IO like object, got #{input.stream.class}"
         end
 
-        unless input[:stream].respond_to?(:size)
+        unless input.stream.respond_to?(:size)
           raise ArgumentError, "Expected #{context} to respond_to(:size)"
         end
       end
@@ -496,7 +496,7 @@ def self.validate!(input, context:)
     class Struct
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::Struct, context: context)
-        Hearth::Validator.validate_types!(input[:value], ::String, context: "#{context}[:value]")
+        Hearth::Validator.validate_types!(input.value, ::String, context: "#{context}[:value]")
       end
     end
 
@@ -508,9 +508,7 @@ def self.validate!(input, context:)
         when Types::Union::Struct
           Struct.validate!(input.__getobj__, context: context) unless input.__getobj__.nil?
         else
-          raise ArgumentError,
-                "Expected #{context} to be a union member of "\
-                "Types::Union, got #{input.class}."
+          raise ArgumentError, "Expected #{context} to be a union member of Types::Union, got #{input.class}."
         end
       end
 
@@ -530,29 +528,29 @@ def self.validate!(input, context:)
     class WaitersTestInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::WaitersTestInput, context: context)
-        Hearth::Validator.validate_types!(input[:status], ::String, context: "#{context}[:status]")
+        Hearth::Validator.validate_types!(input.status, ::String, context: "#{context}[:status]")
       end
     end
 
     class WaitersTestOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::WaitersTestOutput, context: context)
-        Hearth::Validator.validate_types!(input[:status], ::String, context: "#{context}[:status]")
+        Hearth::Validator.validate_types!(input.status, ::String, context: "#{context}[:status]")
       end
     end
 
     class Struct____PaginatorsTestWithBadNamesInput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::Struct____PaginatorsTestWithBadNamesInput, context: context)
-        Hearth::Validator.validate_types!(input[:member___next_token], ::String, context: "#{context}[:member___next_token]")
+        Hearth::Validator.validate_types!(input.member___next_token, ::String, context: "#{context}[:member___next_token]")
       end
     end
 
     class Struct____PaginatorsTestWithBadNamesOutput
       def self.validate!(input, context:)
         Hearth::Validator.validate_types!(input, Types::Struct____PaginatorsTestWithBadNamesOutput, context: context)
-        ResultWrapper.validate!(input[:member___wrapper], context: "#{context}[:member___wrapper]") unless input[:member___wrapper].nil?
-        Items.validate!(input[:member___items], context: "#{context}[:member___items]") unless input[:member___items].nil?
+        ResultWrapper.validate!(input.member___wrapper, context: "#{context}[:member___wrapper]") unless input.member___wrapper.nil?
+        Items.validate!(input.member___items, context: "#{context}[:member___items]") unless input.member___items.nil?
       end
     end
 
diff --git a/codegen/projections/white_label/sig/white_label/client.rbs b/codegen/projections/white_label/sig/white_label/client.rbs
index fd4873102..e194c8b5e 100644
--- a/codegen/projections/white_label/sig/white_label/client.rbs
+++ b/codegen/projections/white_label/sig/white_label/client.rbs
@@ -149,7 +149,7 @@ module WhiteLabel
     def request_compression_streaming: (?::Hash[::Symbol, untyped] params, ?::Hash[::Symbol, untyped] options)  -> Hearth::Output[Types::RequestCompressionStreamingOutput] |
       (?Types::RequestCompressionStreamingInput params, ?::Hash[::Symbol, untyped] options)  -> Hearth::Output[Types::RequestCompressionStreamingOutput] |
       (
-        body: ::String
+        body: (Hearth::_ReadableIO | Hearth::_WritableIO)
       ) -> Hearth::Output[Types::RequestCompressionStreamingOutput]
 
     def resource_endpoint: (?::Hash[::Symbol, untyped] params, ?::Hash[::Symbol, untyped] options)  -> Hearth::Output[Types::ResourceEndpointOutput] |
@@ -161,13 +161,13 @@ module WhiteLabel
     def streaming: (?::Hash[::Symbol, untyped] params, ?::Hash[::Symbol, untyped] options)  ?{ (::String) -> Hearth::BlockIO } -> Hearth::Output[Types::StreamingOutput] |
       (?Types::StreamingInput params, ?::Hash[::Symbol, untyped] options)  ?{ (::String) -> Hearth::BlockIO } -> Hearth::Output[Types::StreamingOutput] |
       (
-        stream: ::String
+        stream: (Hearth::_ReadableIO | Hearth::_WritableIO)
       ) ?{ (::String) -> Hearth::BlockIO } -> Hearth::Output[Types::StreamingOutput]
 
     def streaming_with_length: (?::Hash[::Symbol, untyped] params, ?::Hash[::Symbol, untyped] options)  -> Hearth::Output[Types::StreamingWithLengthOutput] |
       (?Types::StreamingWithLengthInput params, ?::Hash[::Symbol, untyped] options)  -> Hearth::Output[Types::StreamingWithLengthOutput] |
       (
-        stream: ::String
+        stream: (Hearth::_ReadableIO | Hearth::_WritableIO)
       ) -> Hearth::Output[Types::StreamingWithLengthOutput]
 
     def waiters_test: (?::Hash[::Symbol, untyped] params, ?::Hash[::Symbol, untyped] options)  -> Hearth::Output[Types::WaitersTestOutput] |
diff --git a/codegen/projections/white_label/sig/white_label/types.rbs b/codegen/projections/white_label/sig/white_label/types.rbs
index 461fd7649..2555aa372 100644
--- a/codegen/projections/white_label/sig/white_label/types.rbs
+++ b/codegen/projections/white_label/sig/white_label/types.rbs
@@ -10,33 +10,33 @@
 module WhiteLabel
   module Types
 
-    class ClientError < ::Struct[untyped]
+    class ClientError
       include Hearth::Structure
-      attr_accessor message (): ::String
+      attr_accessor message (): ::String?
     end
 
-    class CustomAuthInput < ::Struct[untyped]
+    class CustomAuthInput
       include Hearth::Structure
     end
 
-    class CustomAuthOutput < ::Struct[untyped]
+    class CustomAuthOutput
       include Hearth::Structure
     end
 
-    class DataplaneEndpointInput < ::Struct[untyped]
+    class DataplaneEndpointInput
       include Hearth::Structure
     end
 
-    class DataplaneEndpointOutput < ::Struct[untyped]
+    class DataplaneEndpointOutput
       include Hearth::Structure
     end
 
-    class Defaults < ::Struct[untyped]
+    class Defaults
       include Hearth::Structure
-      attr_accessor string (): ::String
-      attr_accessor struct (): Types::Struct
-      attr_accessor un_required_number (): ::Integer
-      attr_accessor un_required_bool (): bool
+      attr_accessor string (): ::String?
+      attr_accessor struct (): Types::Struct?
+      attr_accessor un_required_number (): ::Integer?
+      attr_accessor un_required_bool (): bool?
       attr_accessor number (): ::Integer
       attr_accessor bool (): bool
       attr_accessor hello (): ::String
@@ -55,17 +55,17 @@ module WhiteLabel
       attr_accessor epoch_timestamp (): ::Time
     end
 
-    class DefaultsTestInput < ::Struct[untyped]
+    class DefaultsTestInput
       include Hearth::Structure
-      attr_accessor defaults (): Types::Defaults
+      attr_accessor defaults (): Types::Defaults?
     end
 
-    class DefaultsTestOutput < ::Struct[untyped]
+    class DefaultsTestOutput
       include Hearth::Structure
-      attr_accessor string (): ::String
-      attr_accessor struct (): Types::Struct
-      attr_accessor un_required_number (): ::Integer
-      attr_accessor un_required_bool (): bool
+      attr_accessor string (): ::String?
+      attr_accessor struct (): Types::Struct?
+      attr_accessor un_required_number (): ::Integer?
+      attr_accessor un_required_bool (): bool?
       attr_accessor number (): ::Integer
       attr_accessor bool (): bool
       attr_accessor hello (): ::String
@@ -84,52 +84,52 @@ module WhiteLabel
       attr_accessor epoch_timestamp (): ::Time
     end
 
-    class EndpointOperationInput < ::Struct[untyped]
+    class EndpointOperationInput
       include Hearth::Structure
     end
 
-    class EndpointOperationOutput < ::Struct[untyped]
+    class EndpointOperationOutput
       include Hearth::Structure
     end
 
-    class EndpointWithHostLabelOperationInput < ::Struct[untyped]
+    class EndpointWithHostLabelOperationInput
       include Hearth::Structure
       attr_accessor label_member (): ::String
     end
 
-    class EndpointWithHostLabelOperationOutput < ::Struct[untyped]
+    class EndpointWithHostLabelOperationOutput
       include Hearth::Structure
     end
 
-    class HttpApiKeyAuthInput < ::Struct[untyped]
+    class HttpApiKeyAuthInput
       include Hearth::Structure
     end
 
-    class HttpApiKeyAuthOutput < ::Struct[untyped]
+    class HttpApiKeyAuthOutput
       include Hearth::Structure
     end
 
-    class HttpBasicAuthInput < ::Struct[untyped]
+    class HttpBasicAuthInput
       include Hearth::Structure
     end
 
-    class HttpBasicAuthOutput < ::Struct[untyped]
+    class HttpBasicAuthOutput
       include Hearth::Structure
     end
 
-    class HttpBearerAuthInput < ::Struct[untyped]
+    class HttpBearerAuthInput
       include Hearth::Structure
     end
 
-    class HttpBearerAuthOutput < ::Struct[untyped]
+    class HttpBearerAuthOutput
       include Hearth::Structure
     end
 
-    class HttpDigestAuthInput < ::Struct[untyped]
+    class HttpDigestAuthInput
       include Hearth::Structure
     end
 
-    class HttpDigestAuthOutput < ::Struct[untyped]
+    class HttpDigestAuthOutput
       include Hearth::Structure
     end
 
@@ -141,132 +141,132 @@ module WhiteLabel
       THREE: ::Numeric
     end
 
-    class KitchenSinkInput < ::Struct[untyped]
+    class KitchenSinkInput
       include Hearth::Structure
-      attr_accessor string (): ::String
-      attr_accessor simple_enum (): ::String
-      attr_accessor valued_enum (): ::String
-      attr_accessor struct (): Types::Struct
-      attr_accessor document (): Hearth::document
-      attr_accessor list_of_strings (): ::Array[::String]
-      attr_accessor list_of_structs (): ::Array[Types::Struct]
-      attr_accessor map_of_strings (): ::Hash[::String, ::String]
-      attr_accessor map_of_structs (): ::Hash[::String, Types::Struct]
-      attr_accessor union (): Types::Union
+      attr_accessor string (): ::String?
+      attr_accessor simple_enum (): ::String?
+      attr_accessor valued_enum (): ::String?
+      attr_accessor struct (): Types::Struct?
+      attr_accessor document (): Hearth::document?
+      attr_accessor list_of_strings (): ::Array[::String]?
+      attr_accessor list_of_structs (): ::Array[Types::Struct]?
+      attr_accessor map_of_strings (): ::Hash[::String, ::String]?
+      attr_accessor map_of_structs (): ::Hash[::String, Types::Struct]?
+      attr_accessor union (): Types::Union?
     end
 
-    class KitchenSinkOutput < ::Struct[untyped]
+    class KitchenSinkOutput
       include Hearth::Structure
-      attr_accessor string (): ::String
-      attr_accessor simple_enum (): ::String
-      attr_accessor valued_enum (): ::String
-      attr_accessor struct (): Types::Struct
-      attr_accessor document (): Hearth::document
-      attr_accessor list_of_strings (): ::Array[::String]
-      attr_accessor list_of_structs (): ::Array[Types::Struct]
-      attr_accessor map_of_strings (): ::Hash[::String, ::String]
-      attr_accessor map_of_structs (): ::Hash[::String, Types::Struct]
-      attr_accessor union (): Types::Union
+      attr_accessor string (): ::String?
+      attr_accessor simple_enum (): ::String?
+      attr_accessor valued_enum (): ::String?
+      attr_accessor struct (): Types::Struct?
+      attr_accessor document (): Hearth::document?
+      attr_accessor list_of_strings (): ::Array[::String]?
+      attr_accessor list_of_structs (): ::Array[Types::Struct]?
+      attr_accessor map_of_strings (): ::Hash[::String, ::String]?
+      attr_accessor map_of_structs (): ::Hash[::String, Types::Struct]?
+      attr_accessor union (): Types::Union?
     end
 
-    class MixinTestInput < ::Struct[untyped]
+    class MixinTestInput
       include Hearth::Structure
-      attr_accessor user_id (): ::String
+      attr_accessor user_id (): ::String?
     end
 
-    class MixinTestOutput < ::Struct[untyped]
+    class MixinTestOutput
       include Hearth::Structure
-      attr_accessor username (): ::String
-      attr_accessor user_id (): ::String
+      attr_accessor username (): ::String?
+      attr_accessor user_id (): ::String?
     end
 
-    class NoAuthInput < ::Struct[untyped]
+    class NoAuthInput
       include Hearth::Structure
     end
 
-    class NoAuthOutput < ::Struct[untyped]
+    class NoAuthOutput
       include Hearth::Structure
     end
 
-    class OptionalAuthInput < ::Struct[untyped]
+    class OptionalAuthInput
       include Hearth::Structure
     end
 
-    class OptionalAuthOutput < ::Struct[untyped]
+    class OptionalAuthOutput
       include Hearth::Structure
     end
 
-    class OrderedAuthInput < ::Struct[untyped]
+    class OrderedAuthInput
       include Hearth::Structure
     end
 
-    class OrderedAuthOutput < ::Struct[untyped]
+    class OrderedAuthOutput
       include Hearth::Structure
     end
 
-    class PaginatorsTestOperationInput < ::Struct[untyped]
+    class PaginatorsTestOperationInput
       include Hearth::Structure
-      attr_accessor next_token (): ::String
+      attr_accessor next_token (): ::String?
     end
 
-    class PaginatorsTestOperationOutput < ::Struct[untyped]
+    class PaginatorsTestOperationOutput
       include Hearth::Structure
-      attr_accessor next_token (): ::String
-      attr_accessor items (): ::Array[::String]
+      attr_accessor next_token (): ::String?
+      attr_accessor items (): ::Array[::String]?
     end
 
-    class PaginatorsTestWithItemsInput < ::Struct[untyped]
+    class PaginatorsTestWithItemsInput
       include Hearth::Structure
-      attr_accessor next_token (): ::String
+      attr_accessor next_token (): ::String?
     end
 
-    class PaginatorsTestWithItemsOutput < ::Struct[untyped]
+    class PaginatorsTestWithItemsOutput
       include Hearth::Structure
-      attr_accessor next_token (): ::String
-      attr_accessor items (): ::Array[::String]
+      attr_accessor next_token (): ::String?
+      attr_accessor items (): ::Array[::String]?
     end
 
-    class RelativeMiddlewareInput < ::Struct[untyped]
+    class RelativeMiddlewareInput
       include Hearth::Structure
     end
 
-    class RelativeMiddlewareOutput < ::Struct[untyped]
+    class RelativeMiddlewareOutput
       include Hearth::Structure
     end
 
-    class RequestCompressionInput < ::Struct[untyped]
+    class RequestCompressionInput
       include Hearth::Structure
-      attr_accessor body (): ::String
+      attr_accessor body (): ::String?
     end
 
-    class RequestCompressionOutput < ::Struct[untyped]
+    class RequestCompressionOutput
       include Hearth::Structure
     end
 
-    class RequestCompressionStreamingInput < ::Struct[untyped]
+    class RequestCompressionStreamingInput
       include Hearth::Structure
-      attr_accessor body (): ::String
+      attr_accessor body (): (Hearth::_ReadableIO | Hearth::_WritableIO)
     end
 
-    class RequestCompressionStreamingOutput < ::Struct[untyped]
+    class RequestCompressionStreamingOutput
       include Hearth::Structure
     end
 
-    class ResourceEndpointInput < ::Struct[untyped]
+    class ResourceEndpointInput
       include Hearth::Structure
       attr_accessor resource_url (): ::String
     end
 
-    class ResourceEndpointOutput < ::Struct[untyped]
+    class ResourceEndpointOutput
       include Hearth::Structure
     end
 
-    class ResultWrapper < ::Struct[untyped]
+    class ResultWrapper
       include Hearth::Structure
-      attr_accessor member___123next_token (): ::String
+      attr_accessor member___123next_token (): ::String?
     end
 
-    class ServerError < ::Struct[untyped]
+    class ServerError
       include Hearth::Structure
     end
 
@@ -276,28 +276,28 @@ module WhiteLabel
       NO: ::String
     end
 
-    class StreamingInput < ::Struct[untyped]
+    class StreamingInput
       include Hearth::Structure
-      attr_accessor stream (): ::String
+      attr_accessor stream (): (Hearth::_ReadableIO | Hearth::_WritableIO)
     end
 
-    class StreamingOutput < ::Struct[untyped]
+    class StreamingOutput
       include Hearth::Structure
-      attr_accessor stream (): ::String
+      attr_accessor stream (): (Hearth::_ReadableIO | Hearth::_WritableIO)
     end
 
-    class StreamingWithLengthInput < ::Struct[untyped]
+    class StreamingWithLengthInput
       include Hearth::Structure
-      attr_accessor stream (): ::String
+      attr_accessor stream (): (Hearth::_ReadableIO | Hearth::_WritableIO)
     end
 
-    class StreamingWithLengthOutput < ::Struct[untyped]
+    class StreamingWithLengthOutput
       include Hearth::Structure
     end
 
-    class Struct < ::Struct[untyped]
+    class Struct
       include Hearth::Structure
-      attr_accessor value (): ::String
+      attr_accessor value (): ::String?
     end
 
     class Union < Hearth::Union
@@ -323,25 +323,25 @@ module WhiteLabel
       NO: ::String
     end
 
-    class WaitersTestInput < ::Struct[untyped]
+    class WaitersTestInput
       include Hearth::Structure
-      attr_accessor status (): ::String
+      attr_accessor status (): ::String?
     end
 
-    class WaitersTestOutput < ::Struct[untyped]
+    class WaitersTestOutput
       include Hearth::Structure
-      attr_accessor status (): ::String
+      attr_accessor status (): ::String?
     end
 
-    class Struct____PaginatorsTestWithBadNamesInput < ::Struct[untyped]
+    class Struct____PaginatorsTestWithBadNamesInput
       include Hearth::Structure
-      attr_accessor member___next_token (): ::String
+      attr_accessor member___next_token (): ::String?
     end
 
-    class Struct____PaginatorsTestWithBadNamesOutput < ::Struct[untyped]
+    class Struct____PaginatorsTestWithBadNamesOutput
       include Hearth::Structure
-      attr_accessor member___wrapper (): Types::ResultWrapper
-      attr_accessor member___items (): ::Array[::String]
+      attr_accessor member___wrapper (): Types::ResultWrapper?
+      attr_accessor member___items (): ::Array[::String]?
     end
 
   end
diff --git a/codegen/projections/white_label/spec/endpoints_spec.rb b/codegen/projections/white_label/spec/endpoints_spec.rb
index 78c5ffb69..e969ff3e2 100644
--- a/codegen/projections/white_label/spec/endpoints_spec.rb
+++ b/codegen/projections/white_label/spec/endpoints_spec.rb
@@ -19,7 +19,7 @@ module WhiteLabel
     describe '#endpoint_with_host_label_operation' do
       let(:label) { 'input_label' }
 
-      it 'raises when missing host label member' do
+      it 'raises when missing host label member', rbs_test: :skip do
         expect { client.endpoint_with_host_label_operation }
           .to raise_error(
             ArgumentError,
diff --git a/codegen/projections/white_label/spec/params_spec.rb b/codegen/projections/white_label/spec/params_spec.rb
index 54b464d55..d3c51c446 100644
--- a/codegen/projections/white_label/spec/params_spec.rb
+++ b/codegen/projections/white_label/spec/params_spec.rb
@@ -33,14 +33,11 @@ module Params
     describe ListOfStructs do
       include_examples 'validates params', Array
 
-      let(:struct1) { Types::Struct.new }
-      let(:struct2) { Types::Struct.new }
-      let(:params) { [struct1, struct2] }
-
       it 'builds an array of complex elements' do
+        params = [{}, {}]
         data = ListOfStructs.build(params, context: 'params[:list_of_structs]')
         expect(data).to be_a(Array)
-        expect(data).to eq(params)
+        expect(data).to all(be_a(Types::Struct))
       end
     end
 
@@ -59,14 +56,11 @@ module Params
     describe MapOfStructs do
       include_examples 'validates params', Hash
 
-      let(:struct1) { Types::Struct.new }
-      let(:struct2) { Types::Struct.new }
-      let(:params) { { key: struct1, other_key: struct2 } }
-
       it 'builds a map of complex values' do
+        params = { key: {}, other_key: {} }
         data = MapOfStructs.build(params, context: 'params[:map_of_structs]')
         expect(data).to be_a(Hash)
-        expect(data).to eq(params)
+        expect(data.values).to all(be_a(Types::Struct))
       end
     end
 
@@ -76,31 +70,21 @@ module Params
       let(:params) do
         {
           string: 'simple string',
-          struct: struct,
-          document: { boolean: true },
+          struct: { value: 'struct value' },
+          document: { 'boolean' => true },
           list_of_strings: %w[dank memes],
-          list_of_structs: [struct],
-          map_of_strings: { key: 'value' },
-          map_of_structs: { key: struct },
+          list_of_structs: [{ value: 'struct value' }],
+          map_of_strings: { 'key' => 'value' },
+          map_of_structs: { 'key' => { value: 'struct value' } },
           union: { string: 'simple string' }
         }
       end
-      let(:struct) { Types::Struct.new(value: 'struct value') }
 
       it 'builds all member input' do
         data = KitchenSinkInput.build(params, context: 'params')
         expect(data).to be_a(Types::KitchenSinkInput)
-        expected = {
-          string: 'simple string',
-          struct: { value: 'struct value' },
-          document: { boolean: true },
-          list_of_strings: %w[dank memes],
-          list_of_structs: [{ value: 'struct value' }],
-          map_of_strings: { key: 'value' },
-          map_of_structs: { key: { value: 'struct value' } },
-          union: { string: 'simple string' }
-        }
-        expect(data.to_h).to eq(expected)
+        expect(data.struct).to be_a(Types::Struct)
+        expect(data.to_h).to eq(params)
       end
     end
 
@@ -167,11 +151,10 @@ module Params
       end
 
       it 'builds a union structure with complex data' do
-        struct = Types::Struct.new(value: 'simple struct')
-        params = { struct: struct }
+        params = { struct: { value: 'simple struct' } }
         data = Union.build(params, context: 'params[:union]')
         expect(data).to be_a(Types::Union)
-        expect(data.to_h).to eq(struct: { value: 'simple struct' })
+        expect(data.to_h).to eq(params)
       end
 
       it 'validates exactly one member' do
@@ -204,7 +187,7 @@ module Params
       end
 
       it 'does not convert a readable, io like object' do
-        stream = double('stream', read: 'chunk')
+        stream = StringIO.new('chunk')
         data = StreamingInput.build({ stream: stream }, context: 'params')
         expect(data).to be_a(Types::StreamingInput)
         expect(data.stream).to be(stream)
diff --git a/codegen/projections/white_label/spec/streaming_spec.rb b/codegen/projections/white_label/spec/streaming_spec.rb
index 0c6b4ea03..53382e415 100644
--- a/codegen/projections/white_label/spec/streaming_spec.rb
+++ b/codegen/projections/white_label/spec/streaming_spec.rb
@@ -14,7 +14,7 @@ module WhiteLabel
       end
 
       context 'block is provided' do
-        let(:block_io) { double('BlockIO') }
+        let(:block_io) { Hearth::BlockIO.new(-> {}) }
 
         it 'creates and uses a blockIO as the body' do
           expect(Hearth::BlockIO).to receive(:new).and_return(block_io)
@@ -30,7 +30,7 @@ module WhiteLabel
       end
 
       context 'output_stream is set' do
-        let(:output_stream) { double('OutputStream') }
+        let(:output_stream) { StringIO.new }
 
         it 'uses the output_stream as the body' do
           expect(Hearth::HTTP::Response)
@@ -44,7 +44,7 @@ module WhiteLabel
       end
 
       context 'parsers' do
-        let(:output_stream) { double('OutputStream') }
+        let(:output_stream) { StringIO.new }
 
         before do
           expect(output_stream).to receive(:write).and_return(0)
@@ -62,7 +62,7 @@ module WhiteLabel
       end
 
       context 'stubs' do
-        let(:output_stream) { double('OutputStream') }
+        let(:output_stream) { StringIO.new }
 
         it 'copies the stub to the output stream' do
           proc = proc do |context|
diff --git a/codegen/projections/white_label/spec/types_spec.rb b/codegen/projections/white_label/spec/types_spec.rb
index 9b52d93f1..e603f6b19 100644
--- a/codegen/projections/white_label/spec/types_spec.rb
+++ b/codegen/projections/white_label/spec/types_spec.rb
@@ -5,28 +5,15 @@
 module WhiteLabel
   module Types
     describe KitchenSinkInput do
-      let(:params) do
-        {
-          string: 'simple string',
-          struct: struct,
-          document: { boolean: true },
-          list_of_strings: %w[dank memes],
-          list_of_structs: [struct],
-          map_of_strings: { key: 'value' },
-          map_of_structs: { key: struct },
-          union: { string: 'simple string' }
-        }
-      end
-      let(:struct) { Types::Struct.new(value: 'struct value') }
-      subject { KitchenSinkInput.new(**params) }
-
-      it 'is a Ruby struct' do
-        expect(subject).to be_a(::Struct)
-      end
+      subject { KitchenSinkInput.new }
 
       it 'is a hearth structure' do
         expect(subject).to be_a(Hearth::Structure)
       end
+
+      it 'has a MEMBERS constant' do
+        expect(KitchenSinkInput::MEMBERS).to be_a(Array)
+      end
     end
 
     describe Union do
diff --git a/codegen/projections/white_label/spec/validators_spec.rb b/codegen/projections/white_label/spec/validators_spec.rb
index 2b148b8d4..0a1102a48 100644
--- a/codegen/projections/white_label/spec/validators_spec.rb
+++ b/codegen/projections/white_label/spec/validators_spec.rb
@@ -16,32 +16,32 @@ module Validators
 
       it 'validates a valid document' do
         document = {
-          boolean: true,
-          hash: { key: 'value' },
-          array: %w[dank memes],
-          integer: 420,
-          float: 69.69,
-          not_boolean: false
+          'hash' => { 'key' => 'value' },
+          'array' => %w[dank memes],
+          'string' => 'string',
+          'boolean' => true,
+          'integer' => 420,
+          'float' => 69.69
         }
         Document.validate!(document, context: 'input')
       end
 
       it 'raises when hash values are not document types' do
-        expect do
-          Document.validate!({ hash: { key: Set.new } }, context: 'input')
-        end
+        document = { 'hash' => { 'key' => Set.new } }
+        expect { Document.validate!(document, context: 'input') }
           .to raise_error(
             ArgumentError,
-            'Expected input[:hash][:key] to be in ' \
+            "Expected input['hash']['key'] to be in " \
             '[Hash, String, Array, TrueClass, FalseClass, Numeric], got Set.'
           )
       end
 
       it 'raises when array elements are not document types' do
-        expect { Document.validate!({ array: [Set.new] }, context: 'input') }
+        document = { 'array' => [Set.new] }
+        expect { Document.validate!(document, context: 'input') }
           .to raise_error(
             ArgumentError,
-            'Expected input[:array][0] to be in ' \
+            "Expected input['array'][0] to be in " \
             '[Hash, String, Array, TrueClass, FalseClass, Numeric], got Set.'
           )
       end
@@ -99,23 +99,22 @@ module Validators
       end
 
       it 'validates a hash of simple values' do
-        input = { key: 'value', other_key: 'other value' }
+        input = { 'key' => 'value', 'other_key' => 'other value' }
         MapOfStrings.validate!(input, context: 'input')
       end
 
-      it 'raises when key is not a string or symbol' do
-        input = { key: 'value', 4 => 'other value' }
+      it 'raises when key is not a String' do
+        input = { 'key' => 'value', 4 => 'other value' }
         expect { MapOfStrings.validate!(input, context: 'input') }
           .to raise_error(ArgumentError,
-                          'Expected input.keys to be in ' \
-                          '[String, Symbol], got Integer.')
+                          'Expected input.keys to be in [String], got Integer.')
       end
 
       it 'raises when value is not an expected type' do
-        input = { key: 'value', other_key: ['array element'] }
+        input = { 'key' => 'value', 'other_key' => ['array element'] }
         expect { MapOfStrings.validate!(input, context: 'input') }
           .to raise_error(ArgumentError,
-                          'Expected input[:other_key] to ' \
+                          "Expected input['other_key'] to " \
                           'be in [String], got Array.')
       end
     end
@@ -131,23 +130,22 @@ module Validators
       end
 
       it 'validates a hash of complex values' do
-        input = { key: struct1, other_key: struct2 }
+        input = { 'key' => struct1, 'other_key' => struct2 }
         MapOfStructs.validate!(input, context: 'input')
       end
 
       it 'raises when key is not a string or symbol' do
-        input = { key: struct1, 4 => struct2 }
+        input = { 'key' => struct1, 4 => struct2 }
         expect { MapOfStructs.validate!(input, context: 'input') }
           .to raise_error(ArgumentError,
-                          'Expected input.keys to be in ' \
-                          '[String, Symbol], got Integer.')
+                          'Expected input.keys to be in [String], got Integer.')
       end
 
       it 'raises when value is not an expected type' do
-        input = { key: struct1, other_key: 'struct_2' }
+        input = { 'key' => struct1, 'other_key' => 'struct_2' }
         expect { MapOfStructs.validate!(input, context: 'input') }
           .to raise_error(ArgumentError,
-                          'Expected input[:other_key] to be in ' \
+                          "Expected input['other_key'] to be in " \
                           '[WhiteLabel::Types::Struct], got String.')
       end
     end
@@ -156,19 +154,18 @@ module Validators
       let(:params) do
         {
           string: 'simple string',
-          struct: struct,
-          document: { boolean: true },
+          struct: { value: 'struct value' },
+          document: { 'boolean' => true },
           list_of_strings: %w[dank memes],
-          list_of_structs: [struct],
-          map_of_strings: { key: 'value' },
-          map_of_structs: { key: struct },
+          list_of_structs: [{ value: 'struct value' }],
+          map_of_strings: { 'key' => 'value' },
+          map_of_structs: { 'key' => { value: 'struct value' } },
           union: { string: 'simple string' }
         }
       end
-      let(:input) { Params::KitchenSinkInput.build(params, context: 'params') }
-      let(:struct) { Types::Struct.new(value: 'struct value') }
 
       it 'validates all member input' do
+        input = Params::KitchenSinkInput.build(params, context: 'params')
         KitchenSinkInput.validate!(input, context: 'input')
       end
     end
@@ -219,7 +216,7 @@ module Validators
     end
 
     describe StreamingInput do
-      it 'validates io like' do
+      it 'validates io like', rbs_test: :skip do
         expect do
           StreamingInput.validate!(
             Types::StreamingInput.new(stream: ''), context: 'input'
@@ -232,21 +229,24 @@ module Validators
 
     describe StreamingWithLengthInput do
       it 'validates responds_to(:size)' do
-        stream = double('stream', read: 'data')
+        rd, wr = IO.pipe
+        wr.puts 'data'
+        wr.close
         expect do
           StreamingWithLengthInput.validate!(
-            Types::StreamingWithLengthInput.new(stream: stream),
-            context: 'input'
+            Types::StreamingWithLengthInput.new(stream: rd), context: 'input'
           )
         end
-          .to raise_error(ArgumentError, 'Expected input to respond_to(:size)')
+          .to raise_error(ArgumentError,
+                          'Expected input to respond_to(:size)')
+        rd.close
       end
     end
 
     describe EndpointWithHostLabelOperationInput do
       let(:input) { Types::EndpointWithHostLabelOperationInput.new }
 
-      it 'validates required' do
+      it 'validates required', rbs_test: :skip do
         expect do
           EndpointWithHostLabelOperationInput.validate!(input, context: 'input')
         end
diff --git a/codegen/smithy-ruby-codegen-test-utils/src/main/java/software/amazon/smithy/ruby/codegen/protocol/generators/BuilderGenerator.java b/codegen/smithy-ruby-codegen-test-utils/src/main/java/software/amazon/smithy/ruby/codegen/protocol/generators/BuilderGenerator.java
index cf22618af..77dc1e30e 100644
--- a/codegen/smithy-ruby-codegen-test-utils/src/main/java/software/amazon/smithy/ruby/codegen/protocol/generators/BuilderGenerator.java
+++ b/codegen/smithy-ruby-codegen-test-utils/src/main/java/software/amazon/smithy/ruby/codegen/protocol/generators/BuilderGenerator.java
@@ -53,7 +53,7 @@ protected void renderOperationBuildMethod(OperationShape operation, Shape inputS
                 renderStreamingBodyBuilder(inputShape);
             } else {
                 // only works for String/Blob/Number data types
-                writer.write("http_req.body = StringIO.new(input[:$L] || '')",
+                writer.write("http_req.body = StringIO.new(input.$L || '')",
                         symbolProvider.toMemberName(httpPayloadMember.get()));
             }
         }
@@ -80,7 +80,4 @@ protected void renderUnionBuildMethod(UnionShape shape) {
     protected void renderMapBuildMethod(MapShape shape) {
 
     }
-
 }
-
-
diff --git a/codegen/smithy-ruby-codegen-test/integration-specs/endpoints_spec.rb b/codegen/smithy-ruby-codegen-test/integration-specs/endpoints_spec.rb
index 78c5ffb69..e969ff3e2 100644
--- a/codegen/smithy-ruby-codegen-test/integration-specs/endpoints_spec.rb
+++ b/codegen/smithy-ruby-codegen-test/integration-specs/endpoints_spec.rb
@@ -19,7 +19,7 @@ module WhiteLabel
     describe '#endpoint_with_host_label_operation' do
       let(:label) { 'input_label' }
 
-      it 'raises when missing host label member' do
+      it 'raises when missing host label member', rbs_test: :skip do
         expect { client.endpoint_with_host_label_operation }
           .to raise_error(
             ArgumentError,
diff --git a/codegen/smithy-ruby-codegen-test/integration-specs/params_spec.rb b/codegen/smithy-ruby-codegen-test/integration-specs/params_spec.rb
index 54b464d55..d3c51c446 100644
--- a/codegen/smithy-ruby-codegen-test/integration-specs/params_spec.rb
+++ b/codegen/smithy-ruby-codegen-test/integration-specs/params_spec.rb
@@ -33,14 +33,11 @@ module Params
     describe ListOfStructs do
       include_examples 'validates params', Array
 
-      let(:struct1) { Types::Struct.new }
-      let(:struct2) { Types::Struct.new }
-      let(:params) { [struct1, struct2] }
-
       it 'builds an array of complex elements' do
+        params = [{}, {}]
         data = ListOfStructs.build(params, context: 'params[:list_of_structs]')
         expect(data).to be_a(Array)
-        expect(data).to eq(params)
+        expect(data).to all(be_a(Types::Struct))
       end
     end
 
@@ -59,14 +56,11 @@ module Params
     describe MapOfStructs do
       include_examples 'validates params', Hash
 
-      let(:struct1) { Types::Struct.new }
-      let(:struct2) { Types::Struct.new }
-      let(:params) { { key: struct1, other_key: struct2 } }
-
       it 'builds a map of complex values' do
+        params = { key: {}, other_key: {} }
         data = MapOfStructs.build(params, context: 'params[:map_of_structs]')
         expect(data).to be_a(Hash)
-        expect(data).to eq(params)
+        expect(data.values).to all(be_a(Types::Struct))
       end
     end
 
@@ -76,31 +70,21 @@ module Params
       let(:params) do
         {
           string: 'simple string',
-          struct: struct,
-          document: { boolean: true },
+          struct: { value: 'struct value' },
+          document: { 'boolean' => true },
           list_of_strings: %w[dank memes],
-          list_of_structs: [struct],
-          map_of_strings: { key: 'value' },
-          map_of_structs: { key: struct },
+          list_of_structs: [{ value: 'struct value' }],
+          map_of_strings: { 'key' => 'value' },
+          map_of_structs: { 'key' => { value: 'struct value' } },
           union: { string: 'simple string' }
         }
       end
-      let(:struct) { Types::Struct.new(value: 'struct value') }
 
       it 'builds all member input' do
         data = KitchenSinkInput.build(params, context: 'params')
         expect(data).to be_a(Types::KitchenSinkInput)
-        expected = {
-          string: 'simple string',
-          struct: { value: 'struct value' },
-          document: { boolean: true },
-          list_of_strings: %w[dank memes],
-          list_of_structs: [{ value: 'struct value' }],
-          map_of_strings: { key: 'value' },
-          map_of_structs: { key: { value: 'struct value' } },
-          union: { string: 'simple string' }
-        }
-        expect(data.to_h).to eq(expected)
+        expect(data.struct).to be_a(Types::Struct)
+        expect(data.to_h).to eq(params)
       end
     end
 
@@ -167,11 +151,10 @@ module Params
       end
 
       it 'builds a union structure with complex data' do
-        struct = Types::Struct.new(value: 'simple struct')
-        params = { struct: struct }
+        params = { struct: { value: 'simple struct' } }
         data = Union.build(params, context: 'params[:union]')
         expect(data).to be_a(Types::Union)
-        expect(data.to_h).to eq(struct: { value: 'simple struct' })
+        expect(data.to_h).to eq(params)
       end
 
       it 'validates exactly one member' do
@@ -204,7 +187,7 @@ module Params
       end
 
       it 'does not convert a readable, io like object' do
-        stream = double('stream', read: 'chunk')
+        stream = StringIO.new('chunk')
         data = StreamingInput.build({ stream: stream }, context: 'params')
         expect(data).to be_a(Types::StreamingInput)
         expect(data.stream).to be(stream)
diff --git a/codegen/smithy-ruby-codegen-test/integration-specs/streaming_spec.rb b/codegen/smithy-ruby-codegen-test/integration-specs/streaming_spec.rb
index 0c6b4ea03..53382e415 100644
--- a/codegen/smithy-ruby-codegen-test/integration-specs/streaming_spec.rb
+++ b/codegen/smithy-ruby-codegen-test/integration-specs/streaming_spec.rb
@@ -14,7 +14,7 @@ module WhiteLabel
       end
 
       context 'block is provided' do
-        let(:block_io) { double('BlockIO') }
+        let(:block_io) { Hearth::BlockIO.new(-> {}) }
 
         it 'creates and uses a blockIO as the body' do
           expect(Hearth::BlockIO).to receive(:new).and_return(block_io)
@@ -30,7 +30,7 @@ module WhiteLabel
       end
 
       context 'output_stream is set' do
-        let(:output_stream) { double('OutputStream') }
+        let(:output_stream) { StringIO.new }
 
         it 'uses the output_stream as the body' do
           expect(Hearth::HTTP::Response)
@@ -44,7 +44,7 @@ module WhiteLabel
       end
 
       context 'parsers' do
-        let(:output_stream) { double('OutputStream') }
+        let(:output_stream) { StringIO.new }
 
         before do
           expect(output_stream).to receive(:write).and_return(0)
@@ -62,7 +62,7 @@ module WhiteLabel
       end
 
       context 'stubs' do
-        let(:output_stream) { double('OutputStream') }
+        let(:output_stream) { StringIO.new }
 
         it 'copies the stub to the output stream' do
           proc = proc do |context|
diff --git a/codegen/smithy-ruby-codegen-test/integration-specs/types_spec.rb b/codegen/smithy-ruby-codegen-test/integration-specs/types_spec.rb
index 9b52d93f1..e603f6b19 100644
--- a/codegen/smithy-ruby-codegen-test/integration-specs/types_spec.rb
+++ b/codegen/smithy-ruby-codegen-test/integration-specs/types_spec.rb
@@ -5,28 +5,15 @@
 module WhiteLabel
   module Types
     describe KitchenSinkInput do
-      let(:params) do
-        {
-          string: 'simple string',
-          struct: struct,
-          document: { boolean: true },
-          list_of_strings: %w[dank memes],
-          list_of_structs: [struct],
-          map_of_strings: { key: 'value' },
-          map_of_structs: { key: struct },
-          union: { string: 'simple string' }
-        }
-      end
-      let(:struct) { Types::Struct.new(value: 'struct value') }
-      subject { KitchenSinkInput.new(**params) }
-
-      it 'is a Ruby struct' do
-        expect(subject).to be_a(::Struct)
-      end
+      subject { KitchenSinkInput.new }
 
       it 'is a hearth structure' do
         expect(subject).to be_a(Hearth::Structure)
       end
+
+      it 'has a MEMBERS constant' do
+        expect(KitchenSinkInput::MEMBERS).to be_a(Array)
+      end
     end
 
     describe Union do
diff --git a/codegen/smithy-ruby-codegen-test/integration-specs/validators_spec.rb b/codegen/smithy-ruby-codegen-test/integration-specs/validators_spec.rb
index 2b148b8d4..0a1102a48 100644
--- a/codegen/smithy-ruby-codegen-test/integration-specs/validators_spec.rb
+++ b/codegen/smithy-ruby-codegen-test/integration-specs/validators_spec.rb
@@ -16,32 +16,32 @@ module Validators
 
       it 'validates a valid document' do
         document = {
-          boolean: true,
-          hash: { key: 'value' },
-          array: %w[dank memes],
-          integer: 420,
-          float: 69.69,
-          not_boolean: false
+          'hash' => { 'key' => 'value' },
+          'array' => %w[dank memes],
+          'string' => 'string',
+          'boolean' => true,
+          'integer' => 420,
+          'float' => 69.69
         }
         Document.validate!(document, context: 'input')
       end
 
       it 'raises when hash values are not document types' do
-        expect do
-          Document.validate!({ hash: { key: Set.new } }, context: 'input')
-        end
+        document = { 'hash' => { 'key' => Set.new } }
+        expect { Document.validate!(document, context: 'input') }
           .to raise_error(
             ArgumentError,
-            'Expected input[:hash][:key] to be in ' \
+            "Expected input['hash']['key'] to be in " \
             '[Hash, String, Array, TrueClass, FalseClass, Numeric], got Set.'
           )
       end
 
       it 'raises when array elements are not document types' do
-        expect { Document.validate!({ array: [Set.new] }, context: 'input') }
+        document = { 'array' => [Set.new] }
+        expect { Document.validate!(document, context: 'input') }
           .to raise_error(
             ArgumentError,
-            'Expected input[:array][0] to be in ' \
+            "Expected input['array'][0] to be in " \
             '[Hash, String, Array, TrueClass, FalseClass, Numeric], got Set.'
           )
       end
@@ -99,23 +99,22 @@ module Validators
       end
 
       it 'validates a hash of simple values' do
-        input = { key: 'value', other_key: 'other value' }
+        input = { 'key' => 'value', 'other_key' => 'other value' }
         MapOfStrings.validate!(input, context: 'input')
       end
 
-      it 'raises when key is not a string or symbol' do
-        input = { key: 'value', 4 => 'other value' }
+      it 'raises when key is not a String' do
+        input = { 'key' => 'value', 4 => 'other value' }
         expect { MapOfStrings.validate!(input, context: 'input') }
           .to raise_error(ArgumentError,
-                          'Expected input.keys to be in ' \
-                          '[String, Symbol], got Integer.')
+                          'Expected input.keys to be in [String], got Integer.')
       end
 
       it 'raises when value is not an expected type' do
-        input = { key: 'value', other_key: ['array element'] }
+        input = { 'key' => 'value', 'other_key' => ['array element'] }
         expect { MapOfStrings.validate!(input, context: 'input') }
           .to raise_error(ArgumentError,
-                          'Expected input[:other_key] to ' \
+                          "Expected input['other_key'] to " \
                           'be in [String], got Array.')
       end
     end
@@ -131,23 +130,22 @@ module Validators
       end
 
       it 'validates a hash of complex values' do
-        input = { key: struct1, other_key: struct2 }
+        input = { 'key' => struct1, 'other_key' => struct2 }
         MapOfStructs.validate!(input, context: 'input')
       end
 
       it 'raises when key is not a string or symbol' do
-        input = { key: struct1, 4 => struct2 }
+        input = { 'key' => struct1, 4 => struct2 }
         expect { MapOfStructs.validate!(input, context: 'input') }
           .to raise_error(ArgumentError,
-                          'Expected input.keys to be in ' \
-                          '[String, Symbol], got Integer.')
+                          'Expected input.keys to be in [String], got Integer.')
       end
 
       it 'raises when value is not an expected type' do
-        input = { key: struct1, other_key: 'struct_2' }
+        input = { 'key' => struct1, 'other_key' => 'struct_2' }
         expect { MapOfStructs.validate!(input, context: 'input') }
           .to raise_error(ArgumentError,
-                          'Expected input[:other_key] to be in ' \
+                          "Expected input['other_key'] to be in " \
                           '[WhiteLabel::Types::Struct], got String.')
       end
     end
@@ -156,19 +154,18 @@ module Validators
       let(:params) do
         {
           string: 'simple string',
-          struct: struct,
-          document: { boolean: true },
+          struct: { value: 'struct value' },
+          document: { 'boolean' => true },
           list_of_strings: %w[dank memes],
-          list_of_structs: [struct],
-          map_of_strings: { key: 'value' },
-          map_of_structs: { key: struct },
+          list_of_structs: [{ value: 'struct value' }],
+          map_of_strings: { 'key' => 'value' },
+          map_of_structs: { 'key' => { value: 'struct value' } },
           union: { string: 'simple string' }
         }
       end
-      let(:input) { Params::KitchenSinkInput.build(params, context: 'params') }
-      let(:struct) { Types::Struct.new(value: 'struct value') }
 
       it 'validates all member input' do
+        input = Params::KitchenSinkInput.build(params, context: 'params')
         KitchenSinkInput.validate!(input, context: 'input')
       end
     end
@@ -219,7 +216,7 @@ module Validators
     end
 
     describe StreamingInput do
-      it 'validates io like' do
+      it 'validates io like', rbs_test: :skip do
         expect do
           StreamingInput.validate!(
             Types::StreamingInput.new(stream: ''), context: 'input'
@@ -232,21 +229,24 @@ module Validators
 
     describe StreamingWithLengthInput do
       it 'validates responds_to(:size)' do
-        stream = double('stream', read: 'data')
+        rd, wr = IO.pipe
+        wr.puts 'data'
+        wr.close
         expect do
           StreamingWithLengthInput.validate!(
-            Types::StreamingWithLengthInput.new(stream: stream),
-            context: 'input'
+            Types::StreamingWithLengthInput.new(stream: rd), context: 'input'
           )
         end
-          .to raise_error(ArgumentError, 'Expected input to respond_to(:size)')
+          .to raise_error(ArgumentError,
+                          'Expected input to respond_to(:size)')
+        rd.close
       end
     end
 
     describe EndpointWithHostLabelOperationInput do
       let(:input) { Types::EndpointWithHostLabelOperationInput.new }
 
-      it 'validates required' do
+      it 'validates required', rbs_test: :skip do
         expect do
           EndpointWithHostLabelOperationInput.validate!(input, context: 'input')
         end
diff --git a/codegen/smithy-ruby-codegen-test/model/test-services/endpoints-string-array.smithy b/codegen/smithy-ruby-codegen-test/model/test-services/endpoints-string-array.smithy
index 268b069f6..6f84f5561 100644
--- a/codegen/smithy-ruby-codegen-test/model/test-services/endpoints-string-array.smithy
+++ b/codegen/smithy-ruby-codegen-test/model/test-services/endpoints-string-array.smithy
@@ -7,6 +7,7 @@ use smithy.rules#endpointTests
 use smithy.rules#staticContextParams
 use smithy.rules#operationContextParams
 
+@suppress(["UnstableTrait"])
 @endpointRuleSet({
     version: "1.0",
     parameters: {
@@ -138,6 +139,7 @@ operation NoBindingsOperation {
     input:= {}
 }
 
+@suppress(["UnstableTrait"])
 @staticContextParams(
     "stringArrayParam": {value: []}
 )
@@ -145,6 +147,7 @@ operation EmptyStaticContextOperation {
     input := {}
 }
 
+@suppress(["UnstableTrait"])
 @staticContextParams(
     "stringArrayParam": {value: ["staticValue1"]}
 )
@@ -152,6 +155,7 @@ operation StaticContextOperation {
     input := {}
 }
 
+@suppress(["UnstableTrait"])
 @operationContextParams(
     "stringArrayParam": {path: "nested.listOfObjects[*].key"}
 )
@@ -161,6 +165,7 @@ operation ListOfObjectsOperation {
     }
 }
 
+@suppress(["UnstableTrait"])
 @operationContextParams(
     "stringArrayParam": {path: "keys(map)"}
 )
diff --git a/codegen/smithy-ruby-codegen/CHANGELOG.md b/codegen/smithy-ruby-codegen/CHANGELOG.md
index 42793792f..5a0e4ef77 100644
--- a/codegen/smithy-ruby-codegen/CHANGELOG.md
+++ b/codegen/smithy-ruby-codegen/CHANGELOG.md
@@ -1,6 +1,7 @@
 Unreleased Changes
 ------------------
 
+* Issue - Remove `Struct` from generated Types.
 * Feature - Add support for stringArray Endpoint parameters + operationContextParams binding.
 * Issue - Update reserved member names for new Struct methods.
 * Feature - Add support for Smithy RPC v2 CBOR protocol.
diff --git a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/RubySymbolProvider.java b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/RubySymbolProvider.java
index 6d2445198..49ea96003 100644
--- a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/RubySymbolProvider.java
+++ b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/RubySymbolProvider.java
@@ -46,6 +46,8 @@
 import software.amazon.smithy.model.shapes.StructureShape;
 import software.amazon.smithy.model.shapes.TimestampShape;
 import software.amazon.smithy.model.shapes.UnionShape;
+import software.amazon.smithy.model.traits.SparseTrait;
+import software.amazon.smithy.model.traits.StreamingTrait;
 import software.amazon.smithy.utils.CaseUtils;
 import software.amazon.smithy.utils.SmithyUnstableApi;
 import software.amazon.smithy.utils.StringUtils;
@@ -106,30 +108,20 @@ private static ReservedWords rubyReservedNames() {
     }
 
     // Mark all instances methods of a class as reserved. Shape members are accessors of a class.
-    // Taken from "Struct.new.new.methods.sort" using Ruby 3.3
+    // Taken from "Object.new.methods.sort" using Ruby 3.3
     private static ReservedWords memberReservedNames() {
         ReservedWordsBuilder reservedNames = new ReservedWordsBuilder();
-        String[] reserved =
-                {"!", "!=", "!~", "<=>", "==", "===", "[]", "[]=", "__id__", "__send__", "all?", "any?", "chain",
-                        "chunk", "chunk_while", "class", "clone", "collect", "collect_concat", "compact", "count",
-                        "cycle", "deconstruct", "deconstruct_keys", "define_singleton_method", "detect", "dig",
-                        "display", "drop", "drop_while", "dup", "each", "each_cons", "each_entry", "each_pair",
-                        "each_slice", "each_with_index", "each_with_object", "entries", "enum_for", "eql?", "equal?",
-                        "extend", "filter", "filter_map", "find", "find_all", "find_index", "first", "flat_map",
-                        "freeze", "frozen?", "grep", "grep_v", "group_by", "hash", "include?", "inject",
-                        "inspect", "instance_eval", "instance_exec", "instance_of?", "instance_variable_defined?",
-                        "instance_variable_get", "instance_variable_set", "instance_variables", "is_a?", "itself",
-                        "kind_of?", "lazy", "length", "map", "max", "max_by", "member?", "members", "method",
-                        "methods", "min", "min_by", "minmax", "minmax_by", "nil?", "none?", "object_id", "one?",
-                        "partition", "pretty_inspect", "pretty_print", "pretty_print_cycle", "pretty_print_inspect",
-                        "pretty_print_instance_variables", "private_methods", "protected_methods", "public_method",
-                        "public_methods", "public_send", "reduce", "reject", "remove_instance_variable",
-                        "respond_to?", "reverse_each", "select", "send", "singleton_class", "singleton_method",
-                        "singleton_methods", "size", "slice_after", "slice_before", "slice_when", "sort", "sort_by",
-                        "sum", "take", "take_while", "tally", "tap", "then", "to_a", "to_enum", "to_h", "to_s",
-                        "to_set", "uniq", "values", "values_at", "yield_self", "zip"
-                };
-
+        String[] reserved = {
+                "!", "!=", "!~", "<=>", "==", "===", "__id__", "__send__", "class", "clone",
+                "define_singleton_method", "display", "dup", "enum_for", "eql?", "equal?", "extend",
+                "freeze", "frozen?", "hash", "inspect", "instance_eval", "instance_exec", "instance_of?",
+                "instance_variable_defined?", "instance_variable_get", "instance_variable_set", "instance_variables",
+                "is_a?", "itself", "kind_of?", "method", "methods", "nil?", "object_id", "pretty_inspect",
+                "pretty_print", "pretty_print_cycle", "pretty_print_inspect", "pretty_print_instance_variables",
+                "private_methods", "protected_methods", "public_method", "public_methods", "public_send",
+                "remove_instance_variable", "respond_to?", "send", "singleton_class", "singleton_method",
+                "singleton_methods", "tap", "then", "to_enum", "to_s", "yield_self"
+        };
         for (String w : reserved) {
             reservedNames.put(w, "member_" + w);
         }
@@ -179,7 +171,7 @@ private String getDefaultMemberName(MemberShape shape) {
     // Shape Names (generated Class names) should be PascalCase
     // they MUST start with a letter (no underscore or digit)
     // if they are a reserved word or start with an invalid character, they will be prefixed
-    // the prefix should be based on the type (eg Struct or Union, ect).
+    // the prefix should be based on the type (eg Structure or Union, ect).
     private String getDefaultShapeName(Shape shape, String prefix) {
         ServiceShape serviceShape =
                 model.expectShape(settings.getService(), ServiceShape.class);
@@ -227,7 +219,12 @@ public Symbol enumShape(EnumShape shape) {
 
     @Override
     public Symbol blobShape(BlobShape shape) {
-        return createSymbolBuilder(shape, "", "::String", "String").build();
+        if (shape.hasTrait(StreamingTrait.class)) {
+            return createSymbolBuilder(shape, "", "(Hearth::_ReadableIO | Hearth::_WritableIO)", "IO")
+                    .addDependency(RubyDependency.STRING_IO).build();
+        } else {
+            return createSymbolBuilder(shape, "", "::String", "String").build();
+        }
     }
 
     @Override
@@ -286,7 +283,11 @@ public Symbol timestampShape(TimestampShape shape) {
     @Override
     public Symbol listShape(ListShape shape) {
         Symbol member = toSymbol(model.expectShape(shape.getMember().getTarget()));
-        String rbsType = "::Array[" + member.getProperty("rbsType").get() + "]";
+        String rbsValue = member.getProperty("rbsType").get().toString();
+        if (shape.hasTrait(SparseTrait.class)) {
+            rbsValue += "?";
+        }
+        String rbsType = "::Array[" + rbsValue + "]";
         String docType = "Array<" + member.getProperty("docType").get() + ">";
         return createSymbolBuilder(shape, getDefaultShapeName(shape, "List__"), rbsType, docType, moduleName)
                 .definitionFile(DEFAULT_DEFINITION_FILE)
@@ -297,10 +298,12 @@ public Symbol listShape(ListShape shape) {
     public Symbol mapShape(MapShape shape) {
         Symbol key = toSymbol(model.expectShape(shape.getKey().getTarget()));
         Symbol value = toSymbol(model.expectShape(shape.getValue().getTarget()));
-        String rbsType
-                = "::Hash[" + key.getProperty("rbsType").get() + ", " + value.getProperty("rbsType").get() + "]";
-        String docType
-                = "Hash<" + key.getProperty("docType").get() + ", " + value.getProperty("docType").get() + ">";
+        String rbsValue = value.getProperty("rbsType").get().toString();
+        if (shape.hasTrait(SparseTrait.class)) {
+            rbsValue += "?";
+        }
+        String rbsType = "::Hash[" + key.getProperty("rbsType").get() + ", " + rbsValue + "]";
+        String docType = "Hash<" + key.getProperty("docType").get() + ", " + value.getProperty("docType").get() + ">";
         return createSymbolBuilder(shape, getDefaultShapeName(shape, "Map__"), rbsType, docType, moduleName)
                 .definitionFile(DEFAULT_DEFINITION_FILE)
                 .build();
diff --git a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/BuilderGeneratorBase.java b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/BuilderGeneratorBase.java
index d9479c960..9fd68767a 100644
--- a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/BuilderGeneratorBase.java
+++ b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/BuilderGeneratorBase.java
@@ -101,7 +101,7 @@ public BuilderGeneratorBase(GenerationContext context) {
      *     http_req.http_method = 'POST'
      *     http_req.append_path('/Operation')
      *     data = {}
-     *     data['timestamp'] = Hearth::TimeHelper.to_epoch_seconds(input[:timestamp]) unless input[:timestamp].nil?
+     *     data['timestamp'] = Hearth::TimeHelper.to_epoch_seconds(input.timestamp) unless input.timestamp.nil?
      *     http_req.body = StringIO.new(Hearth::JSON.dump(data))
      *   end
      *   #### END code generated by this method
@@ -124,7 +124,7 @@ public BuilderGeneratorBase(GenerationContext context) {
      *   #### START code generated by this method
      *   def self.build(input)
      *     data = {}
-     *     data[:value] = input[:value] unless input[:value].nil?
+     *     data[:value] = input.value unless input.value.nil?
      *     data
      *   end
      *   #### END code generated by this method
@@ -296,7 +296,7 @@ protected void renderStreamingBodyBuilder(Shape inputShape) {
 
         Shape target = model.expectShape(streamingMember.getTarget());
 
-        writer.write("http_req.body = input[:$L]", symbolProvider.toMemberName(streamingMember));
+        writer.write("http_req.body = input.$L", symbolProvider.toMemberName(streamingMember));
         if (!target.hasTrait(RequiresLengthTrait.class)) {
             writer.write("http_req.headers['Transfer-Encoding'] = 'chunked'");
         }
diff --git a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/HttpProtocolTestGenerator.java b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/HttpProtocolTestGenerator.java
index 67c8bdadf..d53d31141 100644
--- a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/HttpProtocolTestGenerator.java
+++ b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/HttpProtocolTestGenerator.java
@@ -146,7 +146,8 @@ private void renderResponseTests(OperationShape operation,
             writer
                     .write("")
                     .writeDocstring(documentation)
-                    .openBlock("it '$L'$L do", testCase.getId(), skipTest(operation, testCase.getId(), "response"))
+                    .openBlock("it '$L'$L$L do", testCase.getId(),
+                            skipTest(operation, testCase.getId(), "response"), skipRbsTest(outputShape))
                     .call(() -> renderResponseStubResponse(operation, testCase))
                     .call(() -> renderSkipBuild(operation))
                     .write("output = client.$L({}, "
@@ -179,8 +180,8 @@ private void renderResponseStubberTests(OperationShape operation,
             writer
                     .write("")
                     .writeDocstring(documentation)
-                    .openBlock("it 'stubs $L'$L do", testCase.getId(),
-                            skipTest(operation, testCase.getId(), "response"))
+                    .openBlock("it 'stubs $L'$L$L do", testCase.getId(),
+                            skipTest(operation, testCase.getId(), "response"), skipRbsTest(outputShape))
                     .call(() -> renderResponseStubInterceptor(testCase))
                     .write("interceptor = $T.new(read_after_transmit: proc)", Hearth.INTERCEPTOR)
                     .call(() -> renderSkipBuild(operation))
@@ -226,7 +227,8 @@ private void renderRequestTests(OperationShape operation, HttpRequestTestsTrait
             writer
                     .write("")
                     .writeDocstring(documentation)
-                    .openBlock("it '$L'$L do", testCase.getId(), skipTest(operation, testCase.getId(), "request"))
+                    .openBlock("it '$L'$L$L do", testCase.getId(),
+                            skipTest(operation, testCase.getId(), "request"), skipRbsTest(inputShape))
                     .call(() -> {
                         if (inputShape.members().stream().anyMatch((m) -> m.hasTrait(IdempotencyTokenTrait.class))) {
                             // auto generated tokens during protocol tests should always be this value
@@ -249,23 +251,6 @@ private void renderRequestTests(OperationShape operation, HttpRequestTestsTrait
         writer.closeBlock("\nend");
     }
 
-    // Shape should be an OperationShape or a StructureShape with error trait
-    private String skipTest(Shape shape, String testCaseId, String testType) {
-        if (shape.hasTrait(SkipTestsTrait.class)) {
-            Optional<SkipTest> skipTest = shape.expectTrait(SkipTestsTrait.class).skipTest(testCaseId, testType);
-            if (skipTest.isPresent()) {
-                if (skipTest.get().getId().equals(testCaseId)) {
-                    if (skipTest.get().getReason().isPresent()) {
-                        return writer.format(", skip: '$L' ", skipTest.get().getReason().get());
-                    } else {
-                        return ", skip: true ";
-                    }
-                }
-            }
-        }
-        return "";
-    }
-
     private void renderErrorTests(OperationShape operation) {
         String operationName = RubyFormatter.toSnakeCase(symbolProvider.toSymbol(operation).getName());
 
@@ -282,8 +267,8 @@ private void renderErrorTests(OperationShape operation) {
                     writer
                             .write("")
                             .writeDocstring(documentation)
-                            .openBlock("it '$L'$L do", testCase.getId(),
-                                    skipTest(error, testCase.getId(), "response"))
+                            .openBlock("it '$L'$L$L do", testCase.getId(),
+                                    skipTest(error, testCase.getId(), "response"), skipRbsTest(error))
                             .call(() -> renderResponseStubResponse(operation, testCase))
                             .call(() -> renderSkipBuild(operation))
                             .openBlock("begin")
@@ -301,8 +286,8 @@ private void renderErrorTests(OperationShape operation) {
                     writer
                             .write("")
                             .writeDocstring(documentation)
-                            .openBlock("it 'stubs $L'$L do", testCase.getId(),
-                                    skipTest(error, testCase.getId(), "response"))
+                            .openBlock("it 'stubs $L'$L$L do", testCase.getId(),
+                                    skipTest(error, testCase.getId(), "response"), skipRbsTest(error))
                             .write("client.stub_responses(:$L, error: { class: Errors::$L, data: $L })",
                                     operationName, error.getId().getName(),
                                     getRubyHashFromParams(error, testCase.getParams()))
@@ -325,6 +310,31 @@ private void renderErrorTests(OperationShape operation) {
         }
     }
 
+    // Shape should be an OperationShape or a StructureShape with error trait
+    private String skipTest(Shape shape, String testCaseId, String testType) {
+        if (shape.hasTrait(SkipTestsTrait.class)) {
+            Optional<SkipTest> skipTest = shape.expectTrait(SkipTestsTrait.class).skipTest(testCaseId, testType);
+            if (skipTest.isPresent()) {
+                if (skipTest.get().getId().equals(testCaseId)) {
+                    if (skipTest.get().getReason().isPresent()) {
+                        return writer.format(", skip: '$L' ", skipTest.get().getReason().get());
+                    } else {
+                        return ", skip: true ";
+                    }
+                }
+            }
+        }
+        return "";
+    }
+
+    // StringIO compare has a hack with renderStreamingParamReader
+    private String skipRbsTest(Shape shape) {
+        if (Streaming.isStreaming(model, shape)) {
+            return ", rbs_test: :skip";
+        }
+        return "";
+    }
+
     private String getRubyHashFromParams(Shape ioShape, ObjectNode params) {
         return ioShape.accept(new ParamsToHash(model, params, symbolProvider));
     }
diff --git a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/ParamsGenerator.java b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/ParamsGenerator.java
index 9b8d03d24..1f7554046 100644
--- a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/ParamsGenerator.java
+++ b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/ParamsGenerator.java
@@ -310,8 +310,7 @@ public Void blobShape(BlobShape shape) {
                 if (shape.hasTrait(StreamingTrait.class)) {
                     writer
                             .write("io = $L || StringIO.new", input)
-                            .openBlock("unless io.respond_to?(:read) "
-                                    + "|| io.respond_to?(:readpartial)")
+                            .openBlock("unless io.respond_to?(:read) || io.respond_to?(:readpartial)")
                             .write("io = StringIO.new(io)")
                             .closeBlock("end")
                             .write("$Lio", memberSetter);
diff --git a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/RestBuilderGeneratorBase.java b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/RestBuilderGeneratorBase.java
index 83c959f9d..686bf7837 100644
--- a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/RestBuilderGeneratorBase.java
+++ b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/RestBuilderGeneratorBase.java
@@ -81,7 +81,7 @@ public RestBuilderGeneratorBase(GenerationContext context) {
      *     http_req.append_path('/HttpPayloadTraits')
      *     #### START code generated by this method
      *     http_req.headers['Content-Type'] = 'application/octet-stream'
-     *     http_req.body = StringIO.new(input[:blob] || '')
+     *     http_req.body = StringIO.new(input.blob || '')
      *     #### END code generated by this method
      *   end
      * end
@@ -112,9 +112,9 @@ protected abstract void renderPayloadBodyBuilder(OperationShape operation, Shape
      *     http_req.headers['Content-Type'] = 'application/json'
      *     data = {}
      *     #### START code generated by this method
-     *     data[:simple_struct] = Builders::SimpleStruct.build(input[:simple_struct]) unless input[:simple_struct].nil?
-     *     data[:string] = input[:string] unless input[:string].nil?
-     *     data[:timestamp] = Hearth::TimeHelper.to_date_time(input[:timestamp]) unless input[:timestamp].nil?
+     *     data[:simple_struct] = Builders::SimpleStruct.build(input.simple_struct) unless input.simple_struct.nil?
+     *     data[:string] = input.string unless input.string.nil?
+     *     data[:timestamp] = Hearth::TimeHelper.to_date_time(input.timestamp) unless input.timestamp.nil?
      *     http_req.body = StringIO.new(Hearth::JSON.dump(data))
      *     #### END code generated by this method
      *   end
@@ -168,7 +168,7 @@ protected void renderQueryInputBuilder(Shape inputShape) {
         writer.write("params = $T.new", Hearth.QUERY_PARAM_LIST);
 
         for (MemberShape m : queryParamsMembers) {
-            String inputGetter = "input[:" + symbolProvider.toMemberName(m) + "]";
+            String inputGetter = "input." + symbolProvider.toMemberName(m);
             MapShape queryParamMap = model.expectShape(m.getTarget(), MapShape.class);
             Shape target = model.expectShape(queryParamMap.getValue().getTarget());
 
@@ -181,7 +181,7 @@ protected void renderQueryInputBuilder(Shape inputShape) {
 
         for (MemberShape m : queryMembers) {
             HttpQueryTrait queryTrait = m.expectTrait(HttpQueryTrait.class);
-            String inputGetter = "input[:" + symbolProvider.toMemberName(m) + "]";
+            String inputGetter = "input." + symbolProvider.toMemberName(m);
             Shape target = model.expectShape(m.getTarget());
             String setter = writer.format("params['$L'] = ", queryTrait.getValue());
             target.accept(new QueryMemberSerializer(m, setter, inputGetter));
@@ -202,9 +202,8 @@ protected void renderHeadersBuilder(Shape inputShape) {
 
         for (MemberShape m : headerMembers) {
             HttpHeaderTrait headerTrait = m.expectTrait(HttpHeaderTrait.class);
-            String symbolName = ":" + symbolProvider.toMemberName(m);
             String headerSetter = "http_req.headers['" + headerTrait.getValue() + "'] = ";
-            String valueGetter = "input[" + symbolName + "]";
+            String valueGetter = "input." + symbolProvider.toMemberName(m);
             model.expectShape(m.getTarget()).accept(new HeaderSerializer(m, headerSetter, valueGetter));
         }
     }
@@ -226,10 +225,10 @@ protected void renderPrefixHeadersBuilder(Shape inputShape) {
             MapShape targetShape = model.expectShape(m.getTarget(), MapShape.class);
             Shape valueShape = model.expectShape(targetShape.getValue().getTarget());
 
-            String symbolName = ":" + symbolProvider.toMemberName(m);
+            String memberName = symbolProvider.toMemberName(m);
             String headerSetter = "http_req.headers[\"" + prefix + "#{key}\"] = ";
             writer
-                    .openBlock("input[$L]&.each do |key, value|", symbolName)
+                    .openBlock("input.$L.each do |key, value|", memberName)
                     .call(() -> valueShape.accept(new HeaderSerializer(m, headerSetter, "value")))
                     .closeBlock("end");
         }
@@ -484,17 +483,17 @@ protected class LabelMemberSerializer extends ShapeVisitor.Default<String> {
 
         @Override
         protected String getDefault(Shape shape) {
-            String symbolName = ":" + symbolProvider.toMemberName(memberShape);
-            return "input[" + symbolName + "].to_s";
+            String memberName = symbolProvider.toMemberName(memberShape);
+            return "input." + memberName + ".to_s";
         }
 
         @Override
         public String timestampShape(TimestampShape shape) {
             // label values are serialized using RFC 3399 date-time by default
-            String symbolName = ":" + symbolProvider.toMemberName(memberShape);
+            String memberName = symbolProvider.toMemberName(memberShape);
             return (TimestampFormat.serializeTimestamp(
                     shape, memberShape,
-                    "input[" + symbolName + "]", TimestampFormatTrait.Format.DATE_TIME, true));
+                    "input." + memberName, TimestampFormatTrait.Format.DATE_TIME, true));
         }
     }
 
diff --git a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/RestStubsGeneratorBase.java b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/RestStubsGeneratorBase.java
index 246e276bb..66683808c 100644
--- a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/RestStubsGeneratorBase.java
+++ b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/RestStubsGeneratorBase.java
@@ -90,7 +90,7 @@ public RestStubsGeneratorBase(GenerationContext context) {
      *     http_resp.status = 200
      *     #### START code generated by this method
      *     http_resp.headers['Content-Type'] = 'application/octet-stream'
-     *     http_resp.body.write(stub[:blob] || '')
+     *     http_resp.body.write(stub.blob || '')
      *     #### END code generated by this method
      *   end
      * end
@@ -125,7 +125,7 @@ public RestStubsGeneratorBase(GenerationContext context) {
      *     http_resp.headers['Content-Type'] = 'application/json'
      *     data = {}
      *     ### START code generated by this method
-     *     data[:value] = stub[:value] unless stub[:value].nil?
+     *     data[:value] = stub.value unless stub.value.nil?
      *     #### END code generated by this method
      *     http_resp.body.write(Hearth::JSON.dump(data))
      *   end
@@ -219,9 +219,8 @@ protected void renderHeaderStubbers(Shape shape) {
 
         for (MemberShape m : headerMembers) {
             HttpHeaderTrait headerTrait = m.expectTrait(HttpHeaderTrait.class);
-            String symbolName = ":" + symbolProvider.toMemberName(m);
             String headerSetter = "http_resp.headers['" + headerTrait.getValue() + "'] = ";
-            String valueGetter = "stub[" + symbolName + "]";
+            String valueGetter = "stub." + symbolProvider.toMemberName(m);
             model.expectShape(m.getTarget()).accept(new HeaderSerializer(m, headerSetter, valueGetter));
         }
     }
@@ -240,10 +239,10 @@ protected void renderPrefixHeadersStubbers(Shape shape) {
             MapShape targetShape = model.expectShape(m.getTarget(), MapShape.class);
             Shape valueShape = model.expectShape(targetShape.getValue().getTarget());
 
-            String symbolName = ":" + symbolProvider.toMemberName(m);
+            String memberName = symbolProvider.toMemberName(m);
             String headerSetter = "http_resp.headers[\"" + prefix + "#{key}\"] = ";
             writer
-                    .openBlock("stub[$L]&.each do |key, value|", symbolName)
+                    .openBlock("stub.$L.each do |key, value|", memberName)
                     .call(() -> valueShape.accept(new HeaderSerializer(m, headerSetter, "value")))
                     .closeBlock("end");
         }
@@ -257,7 +256,7 @@ protected void renderResponseCodeStubber(Shape shape) {
 
         if (responseCodeMembers.size() == 1) {
             MemberShape responseCodeMember = responseCodeMembers.get(0);
-            writer.write("http_resp.status = stub[:$L]", symbolProvider.toMemberName(responseCodeMember));
+            writer.write("http_resp.status = stub.$L", symbolProvider.toMemberName(responseCodeMember));
         }
     }
 
@@ -266,7 +265,7 @@ protected void renderStreamingStub(Shape inputShape) {
                 .filter((m) -> m.getMemberTrait(model, StreamingTrait.class).isPresent())
                 .findFirst().get();
 
-        writer.write("IO.copy_stream(stub[:$L], http_resp.body)",
+        writer.write("IO.copy_stream(stub.$L, http_resp.body)",
                 symbolProvider.toMemberName(streamingMember));
     }
 
diff --git a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/StubsGeneratorBase.java b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/StubsGeneratorBase.java
index 478a9a7a9..39c8ba0f3 100644
--- a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/StubsGeneratorBase.java
+++ b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/StubsGeneratorBase.java
@@ -96,8 +96,8 @@ public StubsGeneratorBase(GenerationContext context) {
      * def self.stub(stub = {})
      *   stub ||= {}
      *   data = {}
-     *   data[:string_value] = stub[:string_value] unless stub[:string_value].nil?
-     *   data[:structure_value] = Stubs::GreetingStruct.stub(stub[:structure_value]) unless stub[:structure_value].nil?
+     *   data[:string_value] = stub.string_value unless stub.string_value.nil?
+     *   data[:structure_value] = Stubs::GreetingStruct.stub(stub.structure_value) unless stub.structure_value.nil?
      *   data
      * end
      * #### END code generated by this method
@@ -162,7 +162,7 @@ public StubsGeneratorBase(GenerationContext context) {
      * def self.stub(stub = {})
      *   stub ||= {}
      *   data = {}
-     *   data[:value] = stub[:value] unless stub[:value].nil?
+     *   data[:value] = stub.value unless stub.value.nil?
      *   data
      * end
      * #### END code generated by this method
@@ -184,7 +184,7 @@ public StubsGeneratorBase(GenerationContext context) {
      *   data = {}
      *   http_resp.status = 200
      *   http_resp.headers['Content-Type'] = 'application/json'
-     *   data['contents'] = Stubs::Contents.stub(stub[:contents]) unless stub[:contents].nil?
+     *   data['contents'] = Stubs::Contents.stub(stub.contents) unless stub.contents.nil?
      *   http_resp.body.write(Hearth::JSON.dump(data))
      * end
      * #### END code generated by this method
@@ -207,7 +207,7 @@ public StubsGeneratorBase(GenerationContext context) {
      *   data = {}
      *   http_resp.status = 400
      *   http_resp.headers['Content-Type'] = 'application/json'
-     *   data['message'] = stub[:message] unless stub[:message].nil?
+     *   data['message'] = stub.message unless stub.message.nil?
      *   http_resp.body.write(Hearth::JSON.dump(data))
      * end
      * #### END code generated by this method
@@ -400,7 +400,8 @@ public Void mapShape(MapShape shape) {
             String name = symbolProvider.toSymbol(shape).getName();
             Shape valueTarget = model.expectShape(shape.getValue().getTarget());
             String symbolName = symbolProvider.toMemberName(shape.getKey());
-            String dataSetter = symbolName + ": ";
+            // String dataSetter = symbolName + ": ";
+            String dataSetter = "'" + symbolName + "' => ";
 
             writer
                     .write("")
diff --git a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/ValidatorsGenerator.java b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/ValidatorsGenerator.java
index 24359cdbe..34a5e9861 100644
--- a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/ValidatorsGenerator.java
+++ b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/ValidatorsGenerator.java
@@ -49,6 +49,7 @@
 import software.amazon.smithy.ruby.codegen.GenerationContext;
 import software.amazon.smithy.ruby.codegen.Hearth;
 import software.amazon.smithy.ruby.codegen.RubyCodeWriter;
+import software.amazon.smithy.ruby.codegen.RubyFormatter;
 import software.amazon.smithy.ruby.codegen.RubyImportContainer;
 import software.amazon.smithy.ruby.codegen.RubySettings;
 import software.amazon.smithy.utils.SmithyInternalApi;
@@ -122,9 +123,9 @@ public Void structureShape(StructureShape structureShape) {
         private void renderValidatorsForStructureMembers(Collection<MemberShape> members) {
             members.forEach(member -> {
                 Shape target = model.expectShape(member.getTarget());
-                String symbolName = ":" + symbolProvider.toMemberName(member);
-                String input = "input[" + symbolName + "]";
-                String context = "\"#{context}[" + symbolName + "]\"";
+                String memberName = symbolProvider.toMemberName(member);
+                String input = "input." + memberName;
+                String context = "\"#{context}[" + RubyFormatter.asSymbol(memberName) + "]\"";
                 if (member.hasTrait(RequiredTrait.class)) {
                     writer.write("$T.validate_required!($L, context: $L)", Hearth.VALIDATOR, input, context);
                 }
@@ -142,9 +143,9 @@ public Void mapShape(MapShape mapShape) {
                 .openBlock("def self.validate!(input, context:)")
                 .write("$T.validate_types!(input, ::Hash, context: context)", Hearth.VALIDATOR)
                 .openBlock("input.each do |key, value|")
-                .write("$T.validate_types!(key, ::String, ::Symbol, context: \"#{context}.keys\")", Hearth.VALIDATOR)
+                .write("$T.validate_types!(key, ::String, context: \"#{context}.keys\")", Hearth.VALIDATOR)
                 .call(() -> valueTarget
-                    .accept(new MemberValidator(writer, symbolProvider, "value", "\"#{context}[:#{key}]\"", false)))
+                    .accept(new MemberValidator(writer, symbolProvider, "value", "\"#{context}['#{key}']\"", false)))
                 .closeBlock("end")
                 .closeBlock("end")
                 .closeBlock("end");
@@ -193,9 +194,8 @@ public Void unionShape(UnionShape unionShape) {
                     writer.dedent();
                 }))
                 .write("else")
-                .write("  raise ArgumentError,")
-                .write("        \"Expected #{context} to be a union member of \"\\")
-                .write("        \"Types::" + shapeName + ", got #{input.class}.\"")
+                .write("  raise ArgumentError, \"Expected #{context} to be a union member of Types::"
+                        + shapeName + ", got #{input.class}.\"")
                 .write("end") // end switch case
                 .closeBlock("end") // end validate method
                 .withQualifiedNamespace("Validators",
@@ -218,7 +218,7 @@ public Void documentShape(DocumentShape documentShape) {
                 .openBlock("when ::Hash")
                 .write("input.each do |k,v|")
                 .indent()
-                .write("validate!(v, context: \"#{context}[:#{k}]\")")
+                .write("validate!(v, context: \"#{context}['#{k}']\")")
                 .closeBlock("end")
                 .dedent()
                 .write("when ::Array")
diff --git a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/types/StructureGenerator.java b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/types/StructureGenerator.java
index 3a728df08..eca3a953b 100644
--- a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/types/StructureGenerator.java
+++ b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/generators/types/StructureGenerator.java
@@ -26,6 +26,7 @@
 import software.amazon.smithy.model.shapes.Shape;
 import software.amazon.smithy.model.shapes.ShapeVisitor;
 import software.amazon.smithy.model.shapes.StructureShape;
+import software.amazon.smithy.model.traits.RequiredTrait;
 import software.amazon.smithy.model.traits.SensitiveTrait;
 import software.amazon.smithy.ruby.codegen.GenerationContext;
 import software.amazon.smithy.ruby.codegen.Hearth;
@@ -56,32 +57,36 @@ protected String getModule() {
 
     public void render() {
         write(writer -> {
-            // a total hack so that any structures named Struct do not fail documentation parsing
-            if (shape.getId().getName().equals("Struct")) {
-                writer.apiPrivate().write("class ::Struct; end\n");
-            }
-
             new ShapeDocumentationGenerator(model, writer, symbolProvider, shape).render();
             renderInitializeMethodDocumentation(writer);
             renderAttributesDocumentation(writer);
 
-            String membersBlock = "nil";
+            String membersBlock;
             if (!shape.members().isEmpty()) {
                 membersBlock = shape
                         .members()
                         .stream()
-                        .map(memberShape -> RubyFormatter.asSymbol(symbolProvider.toMemberName(memberShape)))
-                        .collect(Collectors.joining(",\n"));
+                        .map(memberShape -> symbolProvider.toMemberName(memberShape))
+                        .collect(Collectors.joining("\n"));
+            } else {
+                membersBlock = "";
             }
-            membersBlock += ",";
 
             writer
-                    .openBlock("$T = ::Struct.new(", symbolProvider.toSymbol(shape))
-                    .write(membersBlock)
-                    .write("keyword_init: true")
-                    .closeBlock(") do")
-                    .indent()
+                    .openBlock("class $T", symbolProvider.toSymbol(shape))
                     .write("include $T", Hearth.STRUCTURE)
+                    .write("")
+                    .call(() -> {
+                        if (membersBlock.isBlank()) {
+                            writer.write("MEMBERS = [].freeze");
+                        } else {
+                            writer.openBlock("MEMBERS = %i[");
+                            writer.write(membersBlock);
+                            writer.closeBlock("].freeze");
+                        }
+                    })
+                    .write("")
+                    .write("attr_accessor(*MEMBERS)")
                     .call(() -> renderToSMethod(writer))
                     .call(() -> renderDefaultsMethod(writer))
                     .closeBlock("end\n");
@@ -90,13 +95,16 @@ public void render() {
         writeRbs(writer -> {
             String shapeName = symbolProvider.toSymbol(shape).getName();
             writer
-                    .openBlock("class $L < ::Struct[untyped]", shapeName)
+                    .openBlock("class $L", shapeName)
                     .write("include $L", Hearth.STRUCTURE)
                     .call(() -> {
                         shape.members().forEach(memberShape -> {
-                            String name = symbolProvider.toMemberName(memberShape);
-                            Symbol target = symbolProvider.toSymbol(model.expectShape(memberShape.getTarget()));
-                            writer.write("attr_accessor $L (): $L", name, target.getProperty("rbsType").get());
+                            String memberName = symbolProvider.toMemberName(memberShape);
+                            Shape target = model.expectShape(memberShape.getTarget());
+                            Symbol symbol = symbolProvider.toSymbol(target);
+                            String rbsType = symbol.getProperty("rbsType").get().toString();
+                            String required = memberShape.hasTrait(RequiredTrait.class) ? "" : "?";
+                            writer.write("attr_accessor $L (): $L$L", memberName, rbsType, required);
                         });
                     })
                     .closeBlock("end");
@@ -175,7 +183,7 @@ private void renderToSMethod(RubyCodeWriter writer) {
             // structure is itself sensitive
             writer
                     .openBlock("\ndef to_s")
-                    .write("\"#<struct $L [SENSITIVE]>\"", fullQualifiedShapeName)
+                    .write("\"#<$L [SENSITIVE]>\"", fullQualifiedShapeName)
                     .closeBlock("end");
         } else if (hasSensitiveMember) {
             // at least one member is sensitive
@@ -183,7 +191,7 @@ private void renderToSMethod(RubyCodeWriter writer) {
 
             writer
                     .openBlock("\ndef to_s")
-                    .write("\"#<struct $L \"\\", fullQualifiedShapeName)
+                    .write("\"#<$L \"\\", fullQualifiedShapeName)
                     .indent();
 
             while (iterator.hasNext()) {
diff --git a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/rpcv2cbor/generators/BuilderGenerator.java b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/rpcv2cbor/generators/BuilderGenerator.java
index 76c8a88d6..c3eff8136 100644
--- a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/rpcv2cbor/generators/BuilderGenerator.java
+++ b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/rpcv2cbor/generators/BuilderGenerator.java
@@ -49,12 +49,9 @@ private void renderMemberBuilders(Shape s) {
 
         serializeMembers.forEach((member) -> {
             Shape target = model.expectShape(member.getTarget());
-
-            String symbolName = ":" + symbolProvider.toMemberName(member);
             String dataName = "'" + member.getMemberName() + "'";
-
             String dataSetter = "data[" + dataName + "] = ";
-            String inputGetter = "input[" + symbolName + "]";
+            String inputGetter = "input." + symbolProvider.toMemberName(member);
             target.accept(new MemberSerializer(member, dataSetter, inputGetter, true));
         });
     }
diff --git a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/rpcv2cbor/generators/StubsGenerator.java b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/rpcv2cbor/generators/StubsGenerator.java
index c1e1a7e44..6ea462381 100644
--- a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/rpcv2cbor/generators/StubsGenerator.java
+++ b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/rpcv2cbor/generators/StubsGenerator.java
@@ -168,11 +168,9 @@ private void renderMemberStubbers(Shape s) {
 
         serializeMembers.forEach((member) -> {
             Shape target = model.expectShape(member.getTarget());
-
-            String symbolName = ":" + symbolProvider.toMemberName(member);
             String dataName = "'" + member.getMemberName() + "'";
             String dataSetter = "data[" + dataName + "] = ";
-            String inputGetter = "stub[" + symbolName + "]";
+            String inputGetter = "stub." + symbolProvider.toMemberName(member);
             target.accept(new MemberSerializer(member, dataSetter, inputGetter, true));
         });
     }
diff --git a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/util/DefaultValueRetriever.java b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/util/DefaultValueRetriever.java
index 0a9b6aafd..cf451f357 100644
--- a/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/util/DefaultValueRetriever.java
+++ b/codegen/smithy-ruby-codegen/src/main/java/software/amazon/smithy/ruby/codegen/util/DefaultValueRetriever.java
@@ -37,6 +37,7 @@
 import software.amazon.smithy.model.shapes.StringShape;
 import software.amazon.smithy.model.shapes.TimestampShape;
 import software.amazon.smithy.model.traits.DefaultTrait;
+import software.amazon.smithy.model.traits.StreamingTrait;
 
 /**
  * Default value constrains:
@@ -65,7 +66,11 @@ protected String getDefault(Shape shape) {
 
     @Override
     public String blobShape(BlobShape shape) {
-        return getDefaultString();
+        if (shape.hasTrait(StreamingTrait.class)) {
+            return "StringIO.new(" + getDefaultString() + ")";
+        } else {
+            return getDefaultString();
+        }
     }
 
     @Override
diff --git a/codegen/smithy-ruby-rails-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/railsjson/generators/BuilderGenerator.java b/codegen/smithy-ruby-rails-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/railsjson/generators/BuilderGenerator.java
index 1dfcdaca8..834722c99 100644
--- a/codegen/smithy-ruby-rails-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/railsjson/generators/BuilderGenerator.java
+++ b/codegen/smithy-ruby-rails-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/railsjson/generators/BuilderGenerator.java
@@ -73,7 +73,6 @@ private void renderMemberBuilders(Shape s) {
         serializeMembers.forEach((member) -> {
             Shape target = model.expectShape(member.getTarget());
 
-            String symbolName = ":" + symbolProvider.toMemberName(member);
             String dataName = RubyFormatter.asSymbol(member.getMemberName());
             if (member.hasTrait(JsonNameTrait.class)) {
                 dataName = "'" + member.expectTrait(JsonNameTrait.class).getValue() + "'";
@@ -81,9 +80,8 @@ private void renderMemberBuilders(Shape s) {
             if (member.hasTrait("smithy.ruby.protocols#nestedAttributes")) {
                 dataName = dataName + "_attributes";
             }
-
             String dataSetter = "data[" + dataName + "] = ";
-            String inputGetter = "input[" + symbolName + "]";
+            String inputGetter = "input." + symbolProvider.toMemberName(member);
             target.accept(new MemberSerializer(member, dataSetter, inputGetter, !s.hasTrait(SparseTrait.class)));
         });
     }
@@ -91,8 +89,7 @@ private void renderMemberBuilders(Shape s) {
     @Override
     protected void renderPayloadBodyBuilder(OperationShape operation, Shape inputShape, MemberShape payloadMember,
                                             Shape target) {
-        String symbolName = ":" + symbolProvider.toMemberName(payloadMember);
-        String inputGetter = "input[" + symbolName + "]";
+        String inputGetter = "input." + symbolProvider.toMemberName(payloadMember);
         if (target.hasTrait(StreamingTrait.class)) {
             renderStreamingBodyBuilder(inputShape);
         } else {
diff --git a/codegen/smithy-ruby-rails-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/railsjson/generators/StubsGenerator.java b/codegen/smithy-ruby-rails-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/railsjson/generators/StubsGenerator.java
index bd92b3e98..71c660354 100644
--- a/codegen/smithy-ruby-rails-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/railsjson/generators/StubsGenerator.java
+++ b/codegen/smithy-ruby-rails-codegen/src/main/java/software/amazon/smithy/ruby/codegen/protocol/railsjson/generators/StubsGenerator.java
@@ -124,8 +124,7 @@ protected void renderBodyStub(Shape outputShape) {
 
     @Override
     protected void renderPayloadBodyStub(Shape outputShape, MemberShape payloadMember, Shape target) {
-        String symbolName = ":" + symbolProvider.toMemberName(payloadMember);
-        String inputGetter = "stub[" + symbolName + "]";
+        String inputGetter = "stub." + symbolProvider.toMemberName(payloadMember);
         if (target.hasTrait(StreamingTrait.class)) {
             renderStreamingStub(outputShape);
         } else {
@@ -189,8 +188,7 @@ private void renderMemberStubbers(Shape s) {
         if (payload.isPresent()) {
             MemberShape member = payload.get();
             Shape target = model.expectShape(member.getTarget());
-            String symbolName = ":" + symbolProvider.toMemberName(member);
-            String inputGetter = "stub[" + symbolName + "]";
+            String inputGetter = "stub." + symbolProvider.toMemberName(member);
             target.accept(new MemberSerializer(member, "data = ", inputGetter, true));
             writer.write("data ||= {}");
         } else {
@@ -202,14 +200,12 @@ private void renderMemberStubbers(Shape s) {
 
             serializeMembers.forEach((member) -> {
                 Shape target = model.expectShape(member.getTarget());
-
-                String symbolName = ":" + symbolProvider.toMemberName(member);
                 String dataName = RubyFormatter.asSymbol(member.getMemberName());
                 if (member.hasTrait(JsonNameTrait.class)) {
                     dataName = "'" + member.expectTrait(JsonNameTrait.class).getValue() + "'";
                 }
                 String dataSetter = "data[" + dataName + "] = ";
-                String inputGetter = "stub[" + symbolName + "]";
+                String inputGetter = "stub." + symbolProvider.toMemberName(member);
                 target.accept(new MemberSerializer(member, dataSetter, inputGetter, true));
             });
         }
diff --git a/hearth/CHANGELOG.md b/hearth/CHANGELOG.md
index db43ec5f2..7c035b433 100644
--- a/hearth/CHANGELOG.md
+++ b/hearth/CHANGELOG.md
@@ -1,6 +1,7 @@
 Unreleased Changes
 ------------------
 
+* Issue - Remove `Struct` from generated Types.
 * Feature - Add `Hearth::Cbor.encode` and `Hearth::Cbor.decode`.
 * Issue - Fix query param `to_s` for empty arrays.
 * Feature - [Breaking Change] Add `config` to `Hearth::Context` and refactor `logger` and `interceptors` inside of it.
diff --git a/hearth/lib/hearth/middleware/host_prefix.rb b/hearth/lib/hearth/middleware/host_prefix.rb
index a1b69b9c1..e958fb279 100644
--- a/hearth/lib/hearth/middleware/host_prefix.rb
+++ b/hearth/lib/hearth/middleware/host_prefix.rb
@@ -11,7 +11,7 @@ class HostPrefix
       #  modify the host url.
       # @param [String] host_prefix The prefix for the host. It may contain
       #  labels populated by input (i.e. \\{foo.} would be populated by
-      #  input[:foo]).
+      #  input.foo).
       def initialize(app, disable_host_prefix:, host_prefix:)
         @app = app
         @disable_host_prefix = disable_host_prefix
@@ -38,7 +38,7 @@ def prefix_host(input, context)
       def apply_labels(host_prefix, input)
         host_prefix.gsub(/\{.+?}/) do |host_label|
           key = host_label.delete('{}')
-          value = input[key.to_sym]
+          value = input.send(key.to_sym)
           if value.nil? || value.empty?
             raise ArgumentError,
                   "Host label #{key} cannot be nil or empty."
diff --git a/hearth/lib/hearth/structure.rb b/hearth/lib/hearth/structure.rb
index e5f5a9cba..a6b2efec3 100644
--- a/hearth/lib/hearth/structure.rb
+++ b/hearth/lib/hearth/structure.rb
@@ -6,28 +6,34 @@ module Structure
     # Initializes the structure with the given options. If a member is
     # not provided, the default value is used.
     def initialize(options = {})
-      if respond_to?(:_defaults, true)
-        _defaults.each do |k, v|
-          options[k] = v unless options.include?(k)
+      if is_a?(Union)
+        super
+      else
+        if respond_to?(:_defaults, true)
+          _defaults.each do |k, v|
+            options[k] = v unless options.include?(k)
+          end
+        end
+        options.each do |k, v|
+          send("#{k}=", v)
         end
       end
-      super
     end
 
     # Deeply converts the Struct into a hash. Structure members that
     # are `nil` are omitted from the resultant hash.
     #
-    # @return [Hash, Structure]
+    # @return [Hash, Structure, Object]
     def to_h(obj = self)
       case obj
-      when Struct
-        _to_h_struct(obj)
+      when Union
+        obj.to_h
+      when Structure
+        _to_h_structure(obj)
       when Hash
         _to_h_hash(obj)
       when Array
         _to_h_array(obj)
-      when Union
-        obj.to_h
       else
         obj
       end
@@ -36,15 +42,16 @@ def to_h(obj = self)
 
     private
 
-    def _to_h_struct(obj)
-      obj.each_pair.with_object({}) do |(member, value), hash|
+    def _to_h_structure(obj)
+      obj.class::MEMBERS.each_with_object({}) do |member, hash|
+        value = obj.send(member)
         hash[member] = to_hash(value) unless value.nil?
       end
     end
 
     def _to_h_hash(obj)
-      obj.each.with_object({}) do |(key, value), hash|
-        hash[key] = to_hash(value)
+      obj.transform_values do |value|
+        to_hash(value)
       end
     end
 
diff --git a/hearth/lib/hearth/union.rb b/hearth/lib/hearth/union.rb
index e244ae7fe..5cbb1ddb4 100644
--- a/hearth/lib/hearth/union.rb
+++ b/hearth/lib/hearth/union.rb
@@ -5,6 +5,6 @@
 module Hearth
   # Top level class for all Union types
   class Union < ::SimpleDelegator
-    include Hearth::Structure
+    include Structure
   end
 end
diff --git a/hearth/lib/hearth/validator.rb b/hearth/lib/hearth/validator.rb
index a61964001..90bad2201 100755
--- a/hearth/lib/hearth/validator.rb
+++ b/hearth/lib/hearth/validator.rb
@@ -58,13 +58,13 @@ def self.validate_types!(value, *types, context:)
             "[#{types.map(&:to_s).join(', ')}], got #{value.class}."
     end
 
-    # Validate unknown parameters are not present for a given Struct.
-    # @param struct [Struct] The Struct to validate against.
+    # Validate unknown parameters are not present for a given Type.
+    # @param type [Structure] The Type to validate against.
     # @param params [Hash] The parameters to validate.
     # @param context [String] The context of the value being validated.
     # @raise [ArgumentError] Raises when unknown parameters are present.
-    def self.validate_unknown!(struct, params, context:)
-      unknown = params.keys - struct.members
+    def self.validate_unknown!(type, params, context:)
+      unknown = params.keys - type.class::MEMBERS
       return if unknown.empty?
 
       unknown = unknown.map { |key| "#{context}[:#{key}]" }
diff --git a/hearth/sig/lib/hearth/aliases.rbs b/hearth/sig/lib/hearth/aliases.rbs
index 1318d5555..1c73ae350 100644
--- a/hearth/sig/lib/hearth/aliases.rbs
+++ b/hearth/sig/lib/hearth/aliases.rbs
@@ -1,5 +1,5 @@
 module Hearth
-  type document = Hash[Symbol, document] | Array[document] | String | bool | Numeric
+  type document = Hash[String, document] | Array[document] | String | bool | Numeric | nil
 
   type stub = Structure | Response | { data: Hash[Symbol, untyped] } |
     { error: { class: Class, data: Hash[Symbol, untyped] } } | ApiError | Proc
diff --git a/hearth/sig/lib/hearth/interfaces.rbs b/hearth/sig/lib/hearth/interfaces.rbs
index 8cf5a36ee..a0ba277bd 100644
--- a/hearth/sig/lib/hearth/interfaces.rbs
+++ b/hearth/sig/lib/hearth/interfaces.rbs
@@ -84,4 +84,9 @@ module Hearth
   interface _WritableIO
     def write: (*_ToS) -> Integer
   end
+
+  interface _ReadableIO
+    def read: (*_ToS) -> String
+    def readpartial: (Integer, ?String) -> String
+  end
 end
diff --git a/hearth/sig/lib/hearth/request.rbs b/hearth/sig/lib/hearth/request.rbs
index b3bdc5858..5641e4a3d 100644
--- a/hearth/sig/lib/hearth/request.rbs
+++ b/hearth/sig/lib/hearth/request.rbs
@@ -1,6 +1,6 @@
 module Hearth
   class Request
-    def initialize: (?uri: URI, ?body: (IO | StringIO)) -> void
+    def initialize: (?uri: URI, ?body: _ReadableIO) -> void
 
     attr_accessor uri: URI
 
diff --git a/hearth/spec/hearth/structure_spec.rb b/hearth/spec/hearth/structure_spec.rb
index 62d66d67a..f835de22b 100644
--- a/hearth/spec/hearth/structure_spec.rb
+++ b/hearth/spec/hearth/structure_spec.rb
@@ -1,46 +1,39 @@
 # frozen_string_literal: true
 
 module Hearth
-  class MyUnion < Hearth::Union
-    class StringValue < MyUnion
-      def to_h
-        { string_value: super(__getobj__) }
-      end
-    end
-  end
+  class MyStructure
+    include Hearth::Structure
 
-  describe Structure do
-    let(:struct) do
-      Struct.new(
-        :struct_value,
-        :array_value,
-        :hash_value,
-        :value,
-        :union_value,
-        :some_object,
-        :default_value,
-        keyword_init: true
-      ) do
-        include Hearth::Structure
+    MEMBERS = %i[
+      struct_value
+      array_value
+      hash_value
+      value
+      union_value
+      some_object
+      default_value
+    ].freeze
 
-        private
+    attr_accessor(*MEMBERS)
 
-        def _defaults
-          {
-            default_value: 'default'
-          }
-        end
-      end
+    private
+
+    def _defaults
+      {
+        default_value: 'default'
+      }
     end
+  end
 
+  describe Structure do
     subject do
-      struct.new(
-        struct_value: struct.new(value: 'foo'),
+      MyStructure.new(
+        struct_value: MyStructure.new(value: 'foo'),
         array_value: [
-          struct.new(value: 'foo'),
-          struct.new(value: 'bar')
+          MyStructure.new(value: 'foo'),
+          MyStructure.new(value: 'bar')
         ],
-        hash_value: { key: struct.new(value: 'value') },
+        hash_value: { key: MyStructure.new(value: 'value') },
         value: 'value',
         union_value: MyUnion::StringValue.new('union'),
         some_object: Object.new
diff --git a/hearth/spec/hearth/union_spec.rb b/hearth/spec/hearth/union_spec.rb
index e72f9b24b..58875f651 100644
--- a/hearth/spec/hearth/union_spec.rb
+++ b/hearth/spec/hearth/union_spec.rb
@@ -1,6 +1,14 @@
 # frozen_string_literal: true
 
 module Hearth
+  class MyUnion < Hearth::Union
+    class StringValue < MyUnion
+      def to_h
+        { string_value: super(__getobj__) }
+      end
+    end
+  end
+
   describe Union do
     subject { MyUnion::StringValue.new('union') }
 
@@ -8,5 +16,11 @@ module Hearth
       expect(subject).to be_a(SimpleDelegator)
       expect(subject).to be_a(Structure)
     end
+
+    describe '#to_h' do
+      it 'serializes the value to a hash' do
+        expect(subject.to_h).to eq(string_value: 'union')
+      end
+    end
   end
 end
diff --git a/hearth/spec/hearth/validator_spec.rb b/hearth/spec/hearth/validator_spec.rb
index 523c01182..b944794a4 100644
--- a/hearth/spec/hearth/validator_spec.rb
+++ b/hearth/spec/hearth/validator_spec.rb
@@ -1,21 +1,26 @@
 # frozen_string_literal: true
 
 module Hearth
+  class MyType
+    include Hearth::Structure
+
+    MEMBERS = %i[foo].freeze
+
+    attr_accessor(*MEMBERS)
+  end
+
   describe Validator do
-    let(:input_type) { Struct.new(:foo, keyword_init: true) }
-    let(:input) { input_type.new(params) }
+    let(:input) { MyType.new(params) }
     let(:context) { 'input' }
 
-    subject { Validator }
-
     describe '.validate_range!' do
       context 'value is the within the expected range' do
         let(:params) { { foo: 10 } }
 
         it 'does not raise an error' do
           expect do
-            subject.validate_range!(
-              input[:foo],
+            Validator.validate_range!(
+              input.foo,
               min: 0,
               max: 10,
               context: context
@@ -29,8 +34,8 @@ module Hearth
 
         it 'raises an ArgumentError' do
           expect do
-            subject.validate_range!(
-              input[:foo],
+            Validator.validate_range!(
+              input.foo,
               min: 0,
               max: 10,
               context: context
@@ -49,7 +54,7 @@ module Hearth
 
         it 'does not raise an error' do
           expect do
-            subject.validate_required!(input[:foo], context: context)
+            Validator.validate_required!(input.foo, context: context)
           end.to_not raise_error
         end
       end
@@ -59,7 +64,7 @@ module Hearth
 
         it 'raises an ArgumentError' do
           expect do
-            subject.validate_required!(input[:foo], context: context)
+            Validator.validate_required!(input.foo, context: context)
           end.to raise_error(
             ArgumentError,
             "Expected #{context} to be set."
@@ -74,8 +79,8 @@ module Hearth
 
         it 'does not raise an error' do
           expect do
-            subject.validate_responds_to!(
-              input[:foo],
+            Validator.validate_responds_to!(
+              input.foo,
               :empty?,
               context: context
             )
@@ -88,8 +93,8 @@ module Hearth
 
         it 'raises an ArgumentError' do
           expect do
-            subject.validate_responds_to!(
-              input[:foo],
+            Validator.validate_responds_to!(
+              input.foo,
               :non_existent_method,
               context: context
             )
@@ -108,7 +113,7 @@ module Hearth
 
         it 'does not raise an error' do
           expect do
-            subject.validate_types!(input[:foo], String, context: context)
+            Validator.validate_types!(input.foo, String, context: context)
           end.to_not raise_error
         end
       end
@@ -118,7 +123,7 @@ module Hearth
 
         it 'does not raise an error' do
           expect do
-            subject.validate_types!(input[:foo], Numeric, context: context)
+            Validator.validate_types!(input.foo, Numeric, context: context)
           end.to_not raise_error
         end
       end
@@ -128,7 +133,7 @@ module Hearth
 
         it 'raises an ArgumentError' do
           expect do
-            subject.validate_types!(input[:foo], String, context: context)
+            Validator.validate_types!(input.foo, String, context: context)
           end.to raise_error(
             ArgumentError,
             "Expected #{context} to be in [String], got Array."
@@ -141,7 +146,7 @@ module Hearth
 
         it 'raises an ArgumentError when type is non-boolean' do
           expect do
-            subject.validate_types!(input[:foo], String, context: context)
+            Validator.validate_types!(input.foo, String, context: context)
           end.to raise_error(
             ArgumentError,
             "Expected #{context} to be in [String], got FalseClass."
@@ -154,7 +159,7 @@ module Hearth
 
         it 'does not raise an error' do
           expect do
-            subject.validate_types!(input[:foo], String, context: context)
+            Validator.validate_types!(input.foo, String, context: context)
           end.to_not raise_error
         end
       end
@@ -164,8 +169,8 @@ module Hearth
 
         it 'checks value against multiple args' do
           expect do
-            subject.validate_types!(
-              input[:foo],
+            Validator.validate_types!(
+              input.foo,
               TrueClass, FalseClass,
               context: context
             )
@@ -175,15 +180,14 @@ module Hearth
     end
 
     describe '.validate_unknown!' do
-      let(:struct_class) { Struct.new(:foo, :bar, keyword_init: true) }
-      let(:struct) { struct_class.new }
+      let(:input) { MyType.new }
 
       context 'all members are known' do
         let(:params) { { foo: 'bar' } }
 
         it 'does not raise an error' do
           expect do
-            subject.validate_unknown!(struct, params, context: context)
+            Validator.validate_unknown!(input, params, context: context)
           end.to_not raise_error
         end
       end
@@ -193,7 +197,7 @@ module Hearth
 
         it 'raises an ArgumentError' do
           expect do
-            subject.validate_unknown!(struct, params, context: context)
+            Validator.validate_unknown!(input, params, context: context)
           end.to raise_error(
             ArgumentError,
             'Unexpected members: [input[:baz]]'
@@ -206,7 +210,7 @@ module Hearth
 
         it 'raises an ArgumentError' do
           expect do
-            subject.validate_unknown!(struct, params, context: context)
+            Validator.validate_unknown!(input, params, context: context)
           end.to raise_error(
             ArgumentError,
             'Unexpected members: [input[:baz], input[:qux]]'