dependabot-common 0.387.0 → 0.389.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1af9eae7cb945bd312cf8a9fee63b2f4e42adcbc3d137208e2043b659052013d
-  data.tar.gz: f815b9a6961d5ecbd9c77ffdf296a9a048dbfadf21fae5ddebc4bbd8db6fbd2b
+  metadata.gz: b9781413c952e486c9417d63fc70301e7ba10d4283555831df79a6e9b5f2067d
+  data.tar.gz: f54e1d3bda0a1126fefa4246c4a7f0f30951bf5995711b4b376fdd152a81352b
 SHA512:
-  metadata.gz: 34737076727da04d065d0163c93fe1058cfbb3a86d79d2cfef2be4cf126d2fd4d335e204087d3c337e2d97f5ec0220878a1110e139f553805c4d36574e33cb5d
-  data.tar.gz: 5885a478a01996a6f382b3c2bedb29ff59ca557c0316582f14e9136bd3881dac04d20874862bc76a93a16119653a85c868d3d08c65e8cabb9fff1ae257124323
+  metadata.gz: 48591da2ac8712a8f2db6f9a8cd8c7c5debe954fa1470d7e6a625f18d5249e668cf5d48a338813c4c9ffe080d43628bf168d1dc81e463fa8753fc4edb819568e
+  data.tar.gz: 276ee23ea7c643fb0daac14664c83dea4c4fd4070bda5d616278d94eb01cad4722bd32d022667e5f9affe802dcb986c1131dbcb4c5a5eebef359854f0b83d136

data/lib/dependabot/clients/github_release.rb

@@ -0,0 +1,61 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "sawyer"
+require "sorbet-runtime"
+require "time"
+
+module Dependabot
+  module Clients
+    # Typed view over the release fields returned by Octokit.
+    class GithubRelease < T::ImmutableStruct
+      extend T::Sig
+
+      const :id, T.nilable(Integer)
+      const :name, T.nilable(String)
+      const :tag_name, String
+      const :body, T.nilable(String)
+      const :html_url, T.nilable(String)
+      const :prerelease, T::Boolean
+      const :published_at, T.nilable(Time)
+
+      sig { params(resource: Sawyer::Resource).returns(T.nilable(GithubRelease)) }
+      def self.from_resource(resource)
+        tag_name = T.cast(resource[:tag_name], Object)
+        return unless tag_name.is_a?(String)
+
+        id = T.cast(resource[:id], Object)
+        prerelease = T.cast(resource[:prerelease], Object)
+
+        new(
+          id: id.is_a?(Integer) ? id : nil,
+          name: string_value(resource, :name),
+          tag_name: tag_name,
+          body: string_value(resource, :body),
+          html_url: string_value(resource, :html_url),
+          prerelease: prerelease == true,
+          published_at: time_value(resource, :published_at)
+        )
+      end
+
+      sig { params(resource: Sawyer::Resource, key: Symbol).returns(T.nilable(String)) }
+      def self.string_value(resource, key)
+        value = T.cast(resource[key], Object)
+        value.is_a?(String) ? value : nil
+      end
+      private_class_method :string_value
+
+      sig { params(resource: Sawyer::Resource, key: Symbol).returns(T.nilable(Time)) }
+      def self.time_value(resource, key)
+        value = T.cast(resource[key], Object)
+        return value if value.is_a?(Time)
+        return unless value.is_a?(String)
+
+        Time.parse(value)
+      rescue ArgumentError
+        nil
+      end
+      private_class_method :time_value
+    end
+  end
+end

data/lib/dependabot/dependency.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: strong
 # frozen_string_literal: true
 
 require "sorbet-runtime"
@@ -9,9 +9,17 @@ module Dependabot
   class Dependency
     extend T::Sig
 
+    Metadata = T.type_alias { T::Hash[Symbol, Object] }
+    ProductionCheck = T.type_alias do
+      T.proc.params(groups: T::Array[String]).returns(T::Boolean)
+    end
+    RequirementInput = T.type_alias { DependencyRequirement::Input }
+    ObjectHash = T.type_alias { DependencyRequirement::ObjectHash }
+    RequirementSource = T.type_alias { DependencyRequirement::Source }
+
     @production_checks = T.let(
       {},
-      T::Hash[String, T.proc.params(arg0: T::Array[T.untyped]).returns(T::Boolean)]
+      T::Hash[String, ProductionCheck]
     )
     @display_name_builders = T.let({}, T::Hash[String, T.proc.params(arg0: String).returns(String)])
     @name_normalisers = T.let({}, T::Hash[String, T.proc.params(arg0: String).returns(String)])
@@ -19,9 +27,13 @@ module Dependabot
       {},
       T::Hash[String, T.proc.params(arg0: Dependency).returns(T.nilable(String))]
     )
+    IDENTITY_NAME_NORMALISER = T.let(
+      ->(name) { name },
+      T.proc.params(name: String).returns(String)
+    )
 
     sig do
-      params(package_manager: String).returns(T.proc.params(arg0: T::Array[T.untyped]).returns(T::Boolean))
+      params(package_manager: String).returns(ProductionCheck)
     end
     def self.production_check_for_package_manager(package_manager)
       production_check = @production_checks[package_manager]
@@ -33,9 +45,9 @@ module Dependabot
     sig do
       params(
         package_manager: String,
-        production_check: T.proc.params(arg0: T::Array[T.untyped]).returns(T::Boolean)
+        production_check: ProductionCheck
       )
-        .returns(T.proc.params(arg0: T::Array[T.untyped]).returns(T::Boolean))
+        .returns(ProductionCheck)
     end
     def self.register_production_check(package_manager, production_check)
       @production_checks[package_manager] = production_check
@@ -53,7 +65,7 @@ module Dependabot
 
     sig { params(package_manager: String).returns(T.nilable(T.proc.params(arg0: String).returns(String))) }
     def self.name_normaliser_for_package_manager(package_manager)
-      @name_normalisers[package_manager] || ->(name) { name }
+      @name_normalisers[package_manager] || IDENTITY_NAME_NORMALISER
     end
 
     sig do
@@ -106,10 +118,10 @@ module Dependabot
     sig { returns(T.nilable(String)) }
     attr_accessor :directory
 
-    sig { returns(T.nilable(T::Array[T::Hash[Symbol, T.untyped]])) }
+    sig { returns(T.nilable(T::Array[Metadata])) }
     attr_reader :subdependency_metadata
 
-    sig { returns(T::Hash[Symbol, T.untyped]) }
+    sig { returns(Metadata) }
     attr_reader :metadata
 
     # Attribution metadata for group membership tracking
@@ -129,16 +141,16 @@ module Dependabot
     sig do
       params(
         name: String,
-        requirements: T::Array[T::Hash[T.any(Symbol, String), T.untyped]],
+        requirements: T::Array[RequirementInput],
         package_manager: String,
         # TODO: Make version a Dependabot::Version everywhere
         version: T.nilable(T.any(String, Dependabot::Version)),
         previous_version: T.nilable(String),
-        previous_requirements: T.nilable(T::Array[T::Hash[T.any(Symbol, String), T.untyped]]),
+        previous_requirements: T.nilable(T::Array[RequirementInput]),
         directory: T.nilable(String),
-        subdependency_metadata: T.nilable(T::Array[T::Hash[T.any(Symbol, String), String]]),
+        subdependency_metadata: T.nilable(T::Array[ObjectHash]),
         removed: T::Boolean,
-        metadata: T.nilable(T::Hash[T.any(Symbol, String), String])
+        metadata: T.nilable(ObjectHash)
       ).void
     end
     def initialize(
@@ -174,14 +186,16 @@ module Dependabot
       )
       @package_manager = package_manager
       @directory = directory
+      @subdependency_metadata = T.let(nil, T.nilable(T::Array[Metadata]))
       unless top_level? || subdependency_metadata == []
         @subdependency_metadata = T.let(
           subdependency_metadata&.map { |h| symbolize_keys(h) },
-          T.nilable(T::Array[T::Hash[Symbol, T.untyped]])
+          T.nilable(T::Array[Metadata])
         )
       end
       @removed = removed
-      @metadata = T.let(symbolize_keys(metadata || {}), T::Hash[Symbol, T.untyped])
+      @metadata = T.let(symbolize_keys(metadata || {}), Metadata)
+      @numeric_version = T.let(nil, T.nilable(Dependabot::Version))
       check_values
     end
     # rubocop:enable Metrics/PerceivedComplexity
@@ -203,7 +217,7 @@ module Dependabot
       @numeric_version ||= T.let(version_class.new(T.must(version)), T.nilable(Dependabot::Version))
     end
 
-    sig { returns(T::Hash[String, T.untyped]) }
+    sig { returns(T::Hash[String, Object]) }
     def to_h
       {
         "name" => name,
@@ -227,7 +241,12 @@ module Dependabot
     def production?
       return subdependency_production_check unless top_level?
 
-      groups = requirements.flat_map { |r| r.fetch(:groups).map(&:to_s) }
+      groups = requirements.flat_map do |requirement|
+        requirement_groups = requirement.groups
+        raise TypeError, "groups must be an array of strings or symbols" unless requirement_groups
+
+        requirement_groups.map(&:to_s)
+      end
 
       self.class
           .production_check_for_package_manager(package_manager)
@@ -277,7 +296,10 @@ module Dependabot
     sig { params(requirements: T::Array[Dependabot::DependencyRequirement]).returns(T.nilable(String)) }
     def docker_digest_from_reqs(requirements)
       requirements
-        .filter_map { |r| r.dig(:source, "digest") || r.dig(:source, :digest) }
+        .filter_map do |requirement|
+          source = requirement.source
+          optional_source_string(source, "digest") if source.is_a?(Hash)
+        end
         .first
     end
 
@@ -286,7 +308,8 @@ module Dependabot
       return nil if previous_requirements.nil?
 
       previous_refs = T.must(previous_requirements).filter_map do |r|
-        r.dig(:source, "ref") || r.dig(:source, :ref)
+        source = r.source
+        optional_source_string(source, "ref") if source.is_a?(Hash)
       end.uniq
       previous_refs.first if previous_refs.one?
     end
@@ -294,7 +317,8 @@ module Dependabot
     sig { returns(T.nilable(String)) }
     def new_ref
       new_refs = requirements.filter_map do |r|
-        r.dig(:source, "ref") || r.dig(:source, :ref)
+        source = r.source
+        optional_source_string(source, "ref") if source.is_a?(Hash)
       end.uniq
       new_refs.first if new_refs.one?
     end
@@ -308,10 +332,10 @@ module Dependabot
     # support this feature will return more than the current version.
     sig { returns(T::Array[T.nilable(String)]) }
     def all_versions
-      all_versions = metadata[:all_versions]
-      return [version].compact unless all_versions
+      versions = metadata_dependencies(:all_versions)
+      return [version].compact unless versions
 
-      all_versions.filter_map(&:version)
+      versions.filter_map(&:version)
     end
 
     # This dependency is being indirectly updated by an update to another
@@ -319,10 +343,63 @@ module Dependabot
     # surface it to the user in the PR.
     sig { returns(T.nilable(T::Boolean)) }
     def informational_only?
-      metadata[:information_only]
+      metadata_boolean(:information_only)
+    end
+
+    sig { params(key: Symbol).returns(T.nilable(String)) }
+    def metadata_string(key)
+      value = metadata[key]
+      return if value.nil?
+      return value if value.is_a?(String)
+
+      raise TypeError, "#{key} metadata must be a string or nil"
     end
 
-    sig { params(other: T.anything).returns(T::Boolean) }
+    sig { params(key: Symbol).returns(T.nilable(T::Array[String])) }
+    def metadata_string_array(key)
+      value = metadata[key]
+      return if value.nil?
+      raise TypeError, "#{key} metadata must be an array of strings or nil" unless value.is_a?(Array)
+
+      value.map do |raw_entry|
+        entry = T.cast(raw_entry, Object)
+        raise TypeError, "#{key} metadata must be an array of strings or nil" unless entry.is_a?(String)
+
+        entry
+      end
+    end
+
+    sig { params(key: Symbol).returns(T.nilable(T::Array[Dependency])) }
+    def metadata_dependencies(key)
+      value = metadata_array(key)
+      return unless value
+
+      value.map do |raw_dependency|
+        raise TypeError, "#{key} metadata must be an array of dependencies" unless raw_dependency.is_a?(Dependency)
+
+        raw_dependency
+      end
+    end
+
+    sig { params(key: Symbol).returns(T.nilable(T::Array[Object])) }
+    def metadata_array(key)
+      value = metadata[key]
+      return if value.nil?
+      raise TypeError, "#{key} metadata must be an array" unless value.is_a?(Array)
+
+      value.map { |entry| T.cast(entry, Object) }
+    end
+
+    sig { params(key: Symbol).returns(T.nilable(T::Boolean)) }
+    def metadata_boolean(key)
+      value = metadata[key]
+      return if value.nil?
+      return value if value == true || value == false
+
+      raise TypeError, "#{key} metadata must be a boolean or nil"
+    end
+
+    sig { params(other: Object).returns(T::Boolean) }
     def ==(other)
       case other
       when Dependency
@@ -337,7 +414,7 @@ module Dependabot
       to_h.hash
     end
 
-    sig { params(other: T.anything).returns(T::Boolean) }
+    sig { params(other: Object).returns(T::Boolean) }
     def eql?(other)
       self == other
     end
@@ -361,19 +438,27 @@ module Dependabot
       params(
         allowed_types: T.nilable(T::Array[String])
       )
-        .returns(T.nilable(T::Hash[T.any(String, Symbol), T.untyped]))
+        .returns(T.nilable(ObjectHash))
     end
     def source_details(allowed_types: nil)
       sources = all_sources.uniq.compact
-      sources.select! { |source| allowed_types.include?(source[:type].to_s) } if allowed_types
+      source_hashes = sources.map do |source|
+        raise TypeError, "source details must be a hash with string or symbol keys" unless source.is_a?(Hash)
+
+        source
+      end
+      if allowed_types
+        source_hashes.select! { |source| allowed_types.include?(optional_source_string(source, "type").to_s) }
+      end
 
       git = allowed_types == ["git"]
 
-      if (git && sources.map { |s| s[:url] }.uniq.count > 1) || (!git && sources.count > 1)
-        raise "Multiple sources! #{sources.join(', ')}"
+      if (git && source_hashes.map { |source| optional_source_string(source, "url") }.uniq.count > 1) ||
+         (!git && source_hashes.count > 1)
+        raise "Multiple sources! #{source_hashes.join(', ')}"
       end
 
-      sources.first
+      source_hashes.first
     end
 
     sig { returns(T.nilable(String)) }
@@ -381,15 +466,26 @@ module Dependabot
       details = source_details
       return "default" if details.nil?
 
-      details[:type] || details.fetch("type")
+      required_source_string(details, "type")
     end
 
-    sig { returns(T::Array[T::Hash[Symbol, T.untyped]]) }
+    sig do
+      params(
+        key: String,
+        allowed_types: T.nilable(T::Array[String])
+      ).returns(T.nilable(String))
+    end
+    def source_string(key, allowed_types: nil)
+      details = source_details(allowed_types: allowed_types)
+      optional_source_string(details, key) if details
+    end
+
+    sig { returns(T::Array[T.nilable(RequirementSource)]) }
     def all_sources
       if top_level?
-        requirements.map { |requirement| requirement.fetch(:source) }
+        requirements.map(&:source)
       elsif subdependency_metadata
-        T.must(subdependency_metadata).filter_map { |data| data[:source] }
+        T.must(subdependency_metadata).filter_map { |data| source_from_metadata(data) }
       else
         []
       end
@@ -461,7 +557,7 @@ module Dependabot
               "#{optional_keys.join(', ')}."
       end
 
-      return if requirement_fields.flatten.none? { |r| r[:requirement] == "" }
+      return if requirement_fields.flatten.none? { |r| r.requirement == "" }
 
       raise ArgumentError, "blank strings must not be provided as requirements"
     end
@@ -476,9 +572,44 @@ module Dependabot
       end
     end
 
-    sig { params(hash: T::Hash[T.any(Symbol, String), T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+    sig { params(hash: ObjectHash).returns(Metadata) }
     def symbolize_keys(hash)
       hash.keys.to_h { |k| [k.to_sym, hash[k]] }
     end
+
+    sig { params(metadata: Metadata).returns(T.nilable(RequirementSource)) }
+    def source_from_metadata(metadata)
+      raw_source = metadata[:source]
+      return if raw_source.nil?
+      return raw_source if raw_source.is_a?(String)
+      unless raw_source.is_a?(Hash)
+        raise TypeError, "source must be a string or hash with string or symbol keys, or nil"
+      end
+
+      raw_source.each_key do |raw_key|
+        key = T.cast(raw_key, Object)
+        next if key.is_a?(String) || key.is_a?(Symbol)
+
+        raise TypeError, "source must be a string or hash with string or symbol keys, or nil"
+      end
+      raw_source
+    end
+
+    sig { params(source: ObjectHash, key: String).returns(T.nilable(String)) }
+    def optional_source_string(source, key)
+      value = source[key.to_sym] || source[key]
+      return if value.nil?
+      return value if value.is_a?(String)
+
+      raise TypeError, "source #{key} must be a string or nil"
+    end
+
+    sig { params(source: ObjectHash, key: String).returns(String) }
+    def required_source_string(source, key)
+      raw_value = source.key?(key.to_sym) ? source[key.to_sym] : source.fetch(key)
+      return raw_value if raw_value.is_a?(String)
+
+      raise TypeError, "source #{key} must be a string"
+    end
   end
 end

data/lib/dependabot/dependency_graphers/generic.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: strong
 # frozen_string_literal: true
 
 require "sorbet-runtime"
@@ -32,7 +32,7 @@ module Dependabot
       # metadata, but in most cases this will be empty.
       sig { override.params(dependency: Dependabot::Dependency).returns(T::Array[String]) }
       def fetch_subdependencies(dependency)
-        dependency.metadata.fetch(:depends_on, [])
+        dependency.metadata_string_array(:depends_on) || []
       end
 
       # TODO: Delegate this to ecosystem-specific base classes

data/lib/dependabot/dependency_requirement.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: strong
 # frozen_string_literal: true
 
 require "sorbet-runtime"
@@ -33,18 +33,24 @@ module Dependabot
     extend T::Sig
     extend T::Generic
 
-    # The values of a requirement entry are heterogeneous and
-    # ecosystem-specific, so this bridge class is necessarily untyped at
-    # the Hash level; the typed readers below are the migration path.
-    # rubocop:disable Sorbet/ForbidTUntyped
+    Group = T.type_alias { T.any(String, Symbol) }
+    ObjectHash = T.type_alias { T::Hash[T.any(Symbol, String), Object] }
+    Requirement = T.type_alias { T.any(String, Symbol) }
+    Source = T.type_alias { T.any(String, ObjectHash) }
+    Input = T.type_alias { T.any(DependencyRequirement, ObjectHash) }
+
     K = type_member { { fixed: Symbol } }
+    # Hash-style access remains dynamic until ecosystem callers migrate to the
+    # typed readers. Keeping that compatibility here avoids a flag-day change.
+    # rubocop:disable Sorbet/ForbidTUntyped
     V = type_member { { fixed: T.untyped } }
     Elem = type_member { { fixed: [Symbol, T.untyped] } }
+    # rubocop:enable Sorbet/ForbidTUntyped
 
     # Builds a DependencyRequirement from a requirement hash, symbolising
     # top-level keys. Accepts both plain hashes and existing
     # DependencyRequirement instances and always returns a new instance.
-    sig { params(hash: T::Hash[T.any(Symbol, String), T.untyped]).returns(DependencyRequirement) }
+    sig { params(hash: Input).returns(DependencyRequirement) }
     def self.create(hash)
       requirement = new
       requirement.replace(hash.keys.to_h { |k| [k.to_sym, hash[k]] })
@@ -52,16 +58,21 @@ module Dependabot
     end
 
     # The version constraint string, e.g. ">= 1.0, < 2.0". Nil when the
-    # dependency is pinned by a lockfile rather than a manifest constraint.
-    sig { returns(T.nilable(String)) }
+    # dependency is pinned by a lockfile rather than a manifest constraint,
+    # or :unfixable when no valid updated requirement can be generated.
+    sig { returns(T.nilable(Requirement)) }
     def requirement
-      self[:requirement]
+      value = T.cast(self[:requirement], T.nilable(Object))
+      return if value.nil?
+      return value if value.is_a?(String) || value == :unfixable
+
+      raise TypeError, "requirement must be a string, :unfixable, or nil"
     end
 
     # The manifest file this requirement was declared in, e.g. "Gemfile".
     sig { returns(T.nilable(String)) }
     def file
-      self[:file]
+      optional_string(:file)
     end
 
     # The dependency groups this requirement belongs to, e.g. ["dev"] or
@@ -69,26 +80,79 @@ module Dependabot
     # Nilable because some requirement entries are constructed with
     # groups: nil, and the reader must reflect that to stay a drop-in for
     # the underlying hash access under sorbet-runtime.
-    sig { returns(T.nilable(T::Array[T.untyped])) }
+    sig { returns(T.nilable(T::Array[Group])) }
     def groups
-      self[:groups]
+      value = T.cast(self[:groups], T.nilable(Object))
+      return if value.nil?
+      raise TypeError, "groups must be an array of strings or symbols, or nil" unless value.is_a?(Array)
+
+      value.each do |raw_group|
+        group = T.cast(raw_group, Object)
+        next if group.is_a?(String) || group.is_a?(Symbol)
+
+        raise TypeError, "groups must be an array of strings or symbols, or nil"
+      end
+      value
     end
 
     # The source details for the dependency, e.g.
     # { type: "git", url: "https://github.com/..." }. Keys may be symbols
     # or strings depending on whether the requirement was built by a file
     # parser or deserialised from a job definition.
-    sig { returns(T.nilable(T::Hash[T.any(Symbol, String), T.untyped])) }
+    sig { returns(T.nilable(Source)) }
     def source
-      self[:source]
+      value = T.cast(self[:source], T.nilable(Object))
+      return if value.nil?
+      return value if value.is_a?(String)
+
+      object_hash(value, :source)
     end
 
     # Optional ecosystem-specific metadata about the requirement, e.g.
     # { property_name: "rails.version" }.
-    sig { returns(T.nilable(T::Hash[T.any(Symbol, String), T.untyped])) }
+    sig { returns(T.nilable(ObjectHash)) }
     def metadata
-      self[:metadata]
+      optional_object_hash(:metadata)
+    end
+
+    private
+
+    sig { params(key: Symbol).returns(T.nilable(String)) }
+    def optional_string(key)
+      value = T.cast(self[key], T.nilable(Object))
+      return if value.nil?
+      return value if value.is_a?(String)
+
+      raise TypeError, "#{key} must be a string or nil"
+    end
+
+    sig { params(key: Symbol).returns(T.nilable(ObjectHash)) }
+    def optional_object_hash(key)
+      value = T.cast(self[key], T.nilable(Object))
+      return if value.nil?
+
+      object_hash(value, key)
+    end
+
+    sig { params(value: Object, key: Symbol).returns(ObjectHash) }
+    def object_hash(value, key)
+      message = object_hash_message(key)
+      raise TypeError, "#{key} must be #{message}" unless value.is_a?(Hash)
+
+      value.each_key do |raw_nested_key|
+        nested_key = T.cast(raw_nested_key, Object)
+        next if nested_key.is_a?(String) || nested_key.is_a?(Symbol)
+
+        raise TypeError, "#{key} must be #{message}"
+      end
+      value
+    end
+
+    sig { params(key: Symbol).returns(String) }
+    def object_hash_message(key)
+      return "a string or hash with string or symbol keys, or nil" if key == :source
+
+      "a hash with string or symbol keys, or nil"
     end
-    # rubocop:enable Sorbet/ForbidTUntyped
   end
 end

data/lib/dependabot/error_details.rb

@@ -0,0 +1,51 @@
+# typed: strong
+# frozen_string_literal: true
+
+require "sorbet-runtime"
+
+module Dependabot
+  class ErrorDetails < T::ImmutableStruct
+    extend T::Sig
+
+    DetailHash = T.type_alias { T::Hash[T.any(String, Symbol), T.anything] }
+    Detail = T.type_alias { T.any(String, DetailHash) }
+
+    const :error_type, String
+    const :error_detail, T.nilable(Detail)
+
+    sig { params(hash: T::Hash[Symbol, T.anything]).returns(ErrorDetails) }
+    def self.from_hash(hash)
+      raw_type = T.cast(hash[:"error-type"], Object)
+      raise TypeError, "error-type must be a string" unless raw_type.is_a?(String)
+
+      new(
+        error_type: raw_type,
+        error_detail: parse_detail(T.cast(hash[:"error-detail"], T.nilable(Object)))
+      )
+    end
+
+    sig { returns(T::Hash[Symbol, Object]) }
+    def to_h
+      result = T.let({ "error-type": error_type }, T::Hash[Symbol, Object])
+      result[:"error-detail"] = error_detail if error_detail
+      result
+    end
+
+    sig { params(value: T.nilable(Object)).returns(T.nilable(Detail)) }
+    def self.parse_detail(value)
+      return if value.nil?
+      return value if value.is_a?(String)
+      raise TypeError, "error-detail must be a string or hash" unless value.is_a?(Hash)
+
+      result = T.let({}, DetailHash)
+      value.each do |raw_key, raw_value|
+        key = T.cast(raw_key, Object)
+        raise TypeError, "error-detail keys must be strings or symbols" unless key.is_a?(String) || key.is_a?(Symbol)
+
+        result[key] = T.cast(raw_value, Object)
+      end
+      result
+    end
+    private_class_method :parse_detail
+  end
+end