authlete_ruby_sdk 0.0.2.beta → 0.0.5.pre.beta

data/lib/authlete/verifiable_credentials.rb

@@ -39,8 +39,10 @@ module Authlete
     end
 
 
-    sig { params(vci_metadata_request: Models::Components::VciMetadataRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::VciMetadataApiResponse) }
-    def metadata(vci_metadata_request:, service_id:, timeout_ms: nil)
+
+
+    sig { params(vci_metadata_request: Models::Components::VciMetadataRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::VciMetadataApiResponse) }
+    def metadata(vci_metadata_request:, service_id:, timeout_ms: nil, http_headers: nil)
       # metadata - Get Verifiable Credential Issuer Metadata
       # Get verifiable credential issuer metadata
       request = Models::Operations::VciMetadataApiRequest.new(
@@ -61,7 +63,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         body = Utils.encode_form(form)
       elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
         body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
@@ -97,6 +99,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -194,8 +199,8 @@ module Authlete
     end
 
 
-    sig { params(vci_jwtissuer_request: Models::Components::VciJwtissuerRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::VciJwtissuerApiResponse) }
-    def jwt_issuer(vci_jwtissuer_request:, service_id:, timeout_ms: nil)
+    sig { params(vci_jwtissuer_request: Models::Components::VciJwtissuerRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::VciJwtissuerApiResponse) }
+    def jwt_issuer(vci_jwtissuer_request:, service_id:, timeout_ms: nil, http_headers: nil)
       # jwt_issuer - Get JWT Issuer Information
       # Get JWT issuer information for VCI
       request = Models::Operations::VciJwtissuerApiRequest.new(
@@ -216,7 +221,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         body = Utils.encode_form(form)
       elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
         body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
@@ -252,6 +257,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -349,8 +357,8 @@ module Authlete
     end
 
 
-    sig { params(vci_jwks_request: Models::Components::VciJwksRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::VciJwksApiResponse) }
-    def jwks(vci_jwks_request:, service_id:, timeout_ms: nil)
+    sig { params(vci_jwks_request: Models::Components::VciJwksRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::VciJwksApiResponse) }
+    def jwks(vci_jwks_request:, service_id:, timeout_ms: nil, http_headers: nil)
       # jwks - Get JSON Web Key Set
       # Get JSON Web Key Set for VCI
       request = Models::Operations::VciJwksApiRequest.new(
@@ -371,7 +379,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         body = Utils.encode_form(form)
       elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
         body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
@@ -407,6 +415,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -504,8 +515,8 @@ module Authlete
     end
 
 
-    sig { params(vci_offer_create_request: Models::Components::VciOfferCreateRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::VciOfferCreateApiResponse) }
-    def create_offer(vci_offer_create_request:, service_id:, timeout_ms: nil)
+    sig { params(vci_offer_create_request: Models::Components::VciOfferCreateRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::VciOfferCreateApiResponse) }
+    def create_offer(vci_offer_create_request:, service_id:, timeout_ms: nil, http_headers: nil)
       # create_offer - Create Credential Offer
       # Create a verifiable credential offer
       request = Models::Operations::VciOfferCreateApiRequest.new(
@@ -526,7 +537,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         body = Utils.encode_form(form)
       elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
         body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
@@ -562,6 +573,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -659,8 +673,8 @@ module Authlete
     end
 
 
-    sig { params(vci_offer_info_request: Models::Components::VciOfferInfoRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::VciOfferInfoApiResponse) }
-    def offer_info(vci_offer_info_request:, service_id:, timeout_ms: nil)
+    sig { params(vci_offer_info_request: Models::Components::VciOfferInfoRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::VciOfferInfoApiResponse) }
+    def offer_info(vci_offer_info_request:, service_id:, timeout_ms: nil, http_headers: nil)
       # offer_info - Get Credential Offer Information
       # Get information about a verifiable credential offer
       request = Models::Operations::VciOfferInfoApiRequest.new(
@@ -681,7 +695,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         body = Utils.encode_form(form)
       elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
         body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
@@ -717,6 +731,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -814,8 +831,8 @@ module Authlete
     end
 
 
-    sig { params(vci_single_parse_request: Models::Components::VciSingleParseRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::VciSingleParseApiResponse) }
-    def parse(vci_single_parse_request:, service_id:, timeout_ms: nil)
+    sig { params(vci_single_parse_request: Models::Components::VciSingleParseRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::VciSingleParseApiResponse) }
+    def parse(vci_single_parse_request:, service_id:, timeout_ms: nil, http_headers: nil)
       # parse - Parse Single Credential
       # Parse a single verifiable credential
       request = Models::Operations::VciSingleParseApiRequest.new(
@@ -836,7 +853,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         body = Utils.encode_form(form)
       elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
         body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
@@ -872,6 +889,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -969,8 +989,8 @@ module Authlete
     end
 
 
-    sig { params(vci_single_issue_request: Models::Components::VciSingleIssueRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::VciSingleIssueApiResponse) }
-    def issue_response(vci_single_issue_request:, service_id:, timeout_ms: nil)
+    sig { params(vci_single_issue_request: Models::Components::VciSingleIssueRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::VciSingleIssueApiResponse) }
+    def issue_response(vci_single_issue_request:, service_id:, timeout_ms: nil, http_headers: nil)
       # issue_response - Issue Single Credential
       # Issue a single verifiable credential
       request = Models::Operations::VciSingleIssueApiRequest.new(
@@ -991,7 +1011,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         body = Utils.encode_form(form)
       elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
         body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
@@ -1027,6 +1047,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -1124,8 +1147,8 @@ module Authlete
     end
 
 
-    sig { params(vci_batch_parse_request: Models::Components::VciBatchParseRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::VciBatchParseApiResponse) }
-    def batch_parse(vci_batch_parse_request:, service_id:, timeout_ms: nil)
+    sig { params(vci_batch_parse_request: Models::Components::VciBatchParseRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::VciBatchParseApiResponse) }
+    def batch_parse(vci_batch_parse_request:, service_id:, timeout_ms: nil, http_headers: nil)
       # batch_parse - Parse Batch Credentials
       # Parse multiple verifiable credentials in batch
       request = Models::Operations::VciBatchParseApiRequest.new(
@@ -1146,7 +1169,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         body = Utils.encode_form(form)
       elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
         body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
@@ -1182,6 +1205,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -1279,8 +1305,8 @@ module Authlete
     end
 
 
-    sig { params(vci_batch_issue_request: Models::Components::VciBatchIssueRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::VciBatchIssueApiResponse) }
-    def batch_issue(vci_batch_issue_request:, service_id:, timeout_ms: nil)
+    sig { params(vci_batch_issue_request: Models::Components::VciBatchIssueRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::VciBatchIssueApiResponse) }
+    def batch_issue(vci_batch_issue_request:, service_id:, timeout_ms: nil, http_headers: nil)
       # batch_issue - Issue Batch Credentials
       # Issue multiple verifiable credentials in batch
       request = Models::Operations::VciBatchIssueApiRequest.new(
@@ -1301,7 +1327,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         body = Utils.encode_form(form)
       elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
         body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
@@ -1337,6 +1363,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -1434,8 +1463,8 @@ module Authlete
     end
 
 
-    sig { params(vci_deferred_parse_request: Models::Components::VciDeferredParseRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::VciDeferredParseApiResponse) }
-    def deferred_parse(vci_deferred_parse_request:, service_id:, timeout_ms: nil)
+    sig { params(vci_deferred_parse_request: Models::Components::VciDeferredParseRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::VciDeferredParseApiResponse) }
+    def deferred_parse(vci_deferred_parse_request:, service_id:, timeout_ms: nil, http_headers: nil)
       # deferred_parse - Parse Deferred Credential
       # Parse a deferred verifiable credential
       request = Models::Operations::VciDeferredParseApiRequest.new(
@@ -1456,7 +1485,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         body = Utils.encode_form(form)
       elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
         body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
@@ -1492,6 +1521,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -1589,8 +1621,8 @@ module Authlete
     end
 
 
-    sig { params(vci_deferred_issue_request: Models::Components::VciDeferredIssueRequest, service_id: ::String, timeout_ms: T.nilable(Integer)).returns(Models::Operations::VciDeferredIssueApiResponse) }
-    def deferred_issue(vci_deferred_issue_request:, service_id:, timeout_ms: nil)
+    sig { params(vci_deferred_issue_request: Models::Components::VciDeferredIssueRequest, service_id: ::String, timeout_ms: T.nilable(Integer), http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])).returns(Models::Operations::VciDeferredIssueApiResponse) }
+    def deferred_issue(vci_deferred_issue_request:, service_id:, timeout_ms: nil, http_headers: nil)
       # deferred_issue - Issue Deferred Credential
       # Issue a deferred verifiable credential
       request = Models::Operations::VciDeferredIssueApiRequest.new(
@@ -1611,7 +1643,7 @@ module Authlete
       headers['content-type'] = req_content_type
       raise StandardError, 'request body is required' if data.nil? && form.nil?
 
-      if form
+      if form && !form.empty?
         body = Utils.encode_form(form)
       elsif Utils.match_content_type(req_content_type, 'application/x-www-form-urlencoded')
         body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
@@ -1647,6 +1679,9 @@ module Authlete
           req.headers.merge!(headers)
           req.options.timeout = timeout unless timeout.nil?
           Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
 
           @sdk_configuration.hooks.before_request(
             hook_ctx: SDKHooks::BeforeRequestHookContext.new(
@@ -1742,5 +1777,5 @@ module Authlete
 
       end
     end
-  end
+end
 end

data/lib/authlete_ruby_sdk.rb

@@ -24,6 +24,7 @@ module Authlete
   autoload :Federation, 'authlete/federation'
   autoload :HardwareSecurityKeys, 'authlete/hardware_security_keys'
   autoload :VerifiableCredentials, 'authlete/verifiable_credentials'
+  autoload :Lifecycle, 'authlete/lifecycle'
   autoload :AuthorizationManagement, 'authlete/authorization_management'
   autoload :NativeSso, 'authlete/native_sso'
   module Models

data/lib/crystalline/enum.rbi

@@ -0,0 +1,17 @@
+# typed: true
+
+module Crystalline
+  module Enum
+    mixes_in_class_methods(ClassMethods)
+
+    module ClassMethods
+      def enums(&blk); end
+      def open!; end
+      def open?; end
+      def deserialize(val); end
+    end
+
+    def serialize; end
+    def known?; end
+  end
+end

data/lib/crystalline/metadata_fields.rb

@@ -37,19 +37,30 @@ module Crystalline
       def unmarshal_single(field_type, value, format_metadata = nil)
         decoder = format_metadata.fetch(:decoder, nil)
 
-        if field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
+        # Delegate complex Crystalline types to unmarshal_json
+        if field_type.is_a?(Crystalline::DiscriminatedUnion) ||
+           Crystalline::Utils.arr?(field_type) ||
+           Crystalline::Utils.hash?(field_type) ||
+           Crystalline::Utils.union?(field_type)
+          return Crystalline.unmarshal_json(value, field_type)
+        elsif field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
           return field_type.from_dict(value)
         elsif field_type.to_s == 'Date'
           return Date.parse(value)
         elsif field_type.to_s == 'DateTime'
           return DateTime.parse(value)
         elsif field_type.to_s == 'Object'
-          # rubocop:disable Lint/SuppressedException
-          begin
-            value = JSON.parse(value)
-          rescue TypeError, JSON::ParserError
+          if value.is_a?(::String)
+            trimmed = value.lstrip
+            if trimmed.start_with?('{') || trimmed.start_with?('[')
+              # rubocop:disable Lint/SuppressedException
+              begin
+                value = JSON.parse(value)
+              rescue TypeError, JSON::ParserError
+              end
+              # rubocop:enable Lint/SuppressedException
+            end
           end
-          # rubocop:enable Lint/SuppressedException
           return value
         elsif field_type.to_s == 'Float'
           return value.to_f
@@ -65,12 +76,27 @@ module Crystalline
       def from_dict(d)
         to_build = {}
 
+        # Collect lookup keys for regular fields so we can identify additional properties later
+        known_keys = {}
+        additional_props_fields = []
         fields.each do |field|
+          format_metadata = field.metadata.fetch(:format_json, {})
+          if format_metadata.fetch(:additional_properties, false)
+            additional_props_fields << field
+          else
+            lookup = format_metadata.fetch(:letter_case, nil).call
+            known_keys[lookup] = true
+          end
+        end
+
+        # Process regular fields
+        (fields - additional_props_fields).each do |field|
           key = field.name
           format_metadata = field.metadata.fetch(:format_json, {})
+          field_type = field.type
+
           lookup = format_metadata.fetch(:letter_case, nil).call
           value = d[lookup]
-          field_type = field.type
           if ::Crystalline::Utils.nilable? field_type
             if value == 'null'
               to_build[key] = nil
@@ -78,13 +104,15 @@ module Crystalline
             end
             field_type = ::Crystalline::Utils.nilable_of(field_type)
           end
-          
+
           # If field is not nilable, and the value is not in the dict, raise a KeyError
           raise KeyError, "key #{lookup} not found in hash" if value.nil? && !::Crystalline::Utils.nilable?(field.type)
           # If field is nilable, and the value is not in the dict, just move to the next field
           next if value.nil?
 
-          if Crystalline::Utils.arr? field_type
+          if field_type.is_a?(Crystalline::DiscriminatedUnion)
+            to_build[key] = field_type.parse(value)
+          elsif Crystalline::Utils.arr? field_type
             inner_type = Crystalline::Utils.arr_of(field_type)
             unmarshalled_array = value.map { |f| unmarshal_single(inner_type, f, format_metadata) }
             to_build[key] = unmarshalled_array
@@ -112,17 +140,21 @@ module Crystalline
               union_types = Crystalline::Utils.get_union_types(field_type)
               union_types = union_types.sort_by { |klass| Crystalline.non_nilable_attr_count(klass) }
 
-              union_types.each do |union_type|
-                begin
-                  to_build[key] = Crystalline.unmarshal_json(value, union_type)
-                rescue TypeError
-                  next
-                rescue NoMethodError
-                  next
-                rescue KeyError
-                  next
+              if Crystalline.union_strategy == :populated_fields
+                to_build[key] = Crystalline.unmarshal_union_populated_fields(value, union_types)
+              else
+                union_types.each do |union_type|
+                  begin
+                    to_build[key] = Crystalline.unmarshal_json(value, union_type)
+                  rescue TypeError
+                    next
+                  rescue NoMethodError
+                    next
+                  rescue KeyError
+                    next
+                  end
+                  break
                 end
-                break
               end
             end
           elsif field_type.instance_of?(Class) && field_type.include?(::Crystalline::MetadataFields)
@@ -131,6 +163,32 @@ module Crystalline
             to_build[key] = unmarshal_single(field_type, value, format_metadata)
           end
         end
+
+        # Process additional properties fields: collect remaining keys from the dict
+        additional_props_fields.each do |field|
+          key = field.name
+          format_metadata = field.metadata.fetch(:format_json, {})
+          field_type = field.type
+
+          remaining = d.reject { |k, _| known_keys.key?(k) }
+          if remaining.empty?
+            next if ::Crystalline::Utils.nilable?(field.type)
+
+            raise KeyError, 'no additional properties found in hash'
+          end
+
+          inner_field_type = field_type
+          inner_field_type = ::Crystalline::Utils.nilable_of(inner_field_type) if ::Crystalline::Utils.nilable?(inner_field_type)
+          if Crystalline::Utils.hash?(inner_field_type)
+            val_type = Crystalline::Utils.hash_of(inner_field_type)
+            # rubocop:disable Style/HashTransformValues
+            to_build[key] = remaining.map { |k, v| [k, unmarshal_single(val_type, v, format_metadata)] }.to_h
+            # rubocop:enable Style/HashTransformValues
+          else
+            to_build[key] = remaining
+          end
+        end
+
         new(**to_build)
       end
     end
@@ -172,6 +230,8 @@ module Crystalline
       fields.sort_by(&:name).each do |field|
         format_json_meta = field.metadata[:format_json]
         required = !format_json_meta.nil? && format_json_meta.include?(:required)
+        is_additional_props = !format_json_meta.nil? && format_json_meta.fetch(:additional_properties, false)
+
         if !format_json_meta.nil? && format_json_meta.include?(:letter_case)
           key = format_json_meta[:letter_case].call(field.name)
         else
@@ -182,10 +242,13 @@ module Crystalline
         next if f.nil? && !required
         result[key] = nil if f.nil? && required
 
-        if f.is_a? Array
+        # Flatten additional properties into the parent object
+        if is_additional_props && f.is_a?(::Hash)
+          f.each { |k, v| result[k] = marshal_single(v) }
+        elsif f.is_a? ::Array
           result[key] = f.map { |o| marshal_single(o) }
-        elsif f.is_a? Hash
-          result[key] = f.map { |k, v| [k, marshal_single(v)] }
+        elsif f.is_a? ::Hash
+          result[key] = f.transform_values { |v| marshal_single(v) }
         else
           result[key] = marshal_single(f)
         end