noresponse 2.0.17

data/lib/no_response/models/shared/probleminvalidparam.rb

@@ -0,0 +1,48 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class ProblemInvalidParam
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :field,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("field"), required: true}}
+        )
+
+        field(
+          :reason,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("reason"), required: true}}
+        )
+
+        field(
+          :example,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("example")}}
+        )
+
+        sig { params(field: ::String, reason: ::String, example: T.nilable(::String)).void }
+        def initialize(field:, reason:, example: nil)
+          @field = field
+          @reason = reason
+          @example = example
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @field == other.field
+          return false unless @reason == other.reason
+          return false unless @example == other.example
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/probleminvalidparam.rbi

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ProblemInvalidParam
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ProblemInvalidParam
+  def field
+  end
+
+  def field=(str_)
+  end
+
+  def reason
+  end
+
+  def reason=(str_)
+  end
+
+  def example
+  end
+
+  def example=(str_)
+  end
+end

data/lib/no_response/models/shared/ratelimiterrorcode.rb

@@ -0,0 +1,18 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # RateLimitErrorCode - Machine codes an HTTP 429 answer can carry.
+      class RateLimitErrorCode
+        include ::Crystalline::Enum
+        enums do
+          RATE_LIMITED = new("rate_limited")
+        end
+
+        open!
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/ratelimiterrorcode.rbi

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::RateLimitErrorCode
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::RateLimitErrorCode
+end

data/lib/no_response/models/shared/reasoncode.rb

@@ -0,0 +1,52 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # ReasonCode - A stable reason code. New codes may appear; ignore any you do not know.
+      class ReasonCode
+        include ::Crystalline::Enum
+        enums do
+          NO_DIGITAL_FOOTPRINT = new("no_digital_footprint")
+          VOIP_NUMBER = new("voip_number")
+          DISPOSABLE_EMAIL = new("disposable_email")
+          NEW_EMAIL = new("new_email")
+          SPAM_REPORTS = new("spam_reports")
+          FRAUD_FLAG = new("fraud_flag")
+          IDENTITY_MISMATCH = new("identity_mismatch")
+          COUNTRY_MISMATCH = new("country_mismatch")
+          PROXY_IP = new("proxy_ip")
+          SEEN_BEFORE = new("seen_before")
+          SHARED_IP = new("shared_ip")
+          MANY_RECENT_SIGNUPS = new("many_recent_signups")
+          ESTABLISHED_ACCOUNTS = new("established_accounts")
+          AGED_IDENTITY = new("aged_identity")
+          BREACH_NAME_MATCH = new("breach_name_match")
+          BREACH_COOCCURRENCE = new("breach_cooccurrence")
+          BREACH_NAME_MISMATCH = new("breach_name_mismatch")
+          BREACH_PHONE_MISMATCH = new("breach_phone_mismatch")
+          RECENT_PASSWORD_EXPOSURE = new("recent_password_exposure")
+          CREDENTIAL_LIST_EXPOSURE = new("credential_list_exposure")
+          ABUSE_ECOSYSTEM_MEMBER = new("abuse_ecosystem_member")
+          NO_BREACH_HISTORY = new("no_breach_history")
+          AUTOMATION_FAST_SUBMIT = new("automation_fast_submit")
+          CLIENT_CLOCK_SKEW = new("client_clock_skew")
+          BOT_OR_AUTOMATION = new("bot_or_automation")
+          AUTH_EMAIL_VERIFIED = new("auth_email_verified")
+          AUTH_PHONE_VERIFIED = new("auth_phone_verified")
+          AUTH_MFA_RECENT = new("auth_mfa_recent")
+          AUTH_NEW_SESSION = new("auth_new_session")
+          AUTH_NEW_ACCOUNT = new("auth_new_account")
+          AUTH_IMPERSONATED = new("auth_impersonated")
+          CONTEXT_TIMEZONE_MISMATCH = new("context_timezone_mismatch")
+          CONTEXT_LOCALE_MISMATCH = new("context_locale_mismatch")
+          CONTEXT_LINE_COUNTRY_MISMATCH = new("context_line_country_mismatch")
+          PRIOR_ABUSE_LINK = new("prior_abuse_link")
+        end
+
+        open!
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/reasoncode.rbi

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ReasonCode
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ReasonCode
+end

data/lib/no_response/models/shared/reasonidentifier.rb

@@ -0,0 +1,23 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # ReasonIdentifier - The submitted identifier or client context field a reason concerns; absent when it concerns the whole assessment. Client context is a claimed hint, not a device fingerprint.
+      class ReasonIdentifier
+        include ::Crystalline::Enum
+        enums do
+          EMAIL = new("email")
+          USERNAME = new("username")
+          PHONE = new("phone")
+          NAME = new("name")
+          IP = new("ip")
+          CONTEXT = new("context")
+        end
+
+        open!
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/reasonidentifier.rbi

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ReasonIdentifier
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ReasonIdentifier
+end

data/lib/no_response/models/shared/recommendation.rb

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Recommendation - The recommended action: allow, step_up or review. Your application applies it.
+      class Recommendation
+        include ::Crystalline::Enum
+        enums do
+          ALLOW = new("allow")
+          STEP_UP = new("step_up")
+          REVIEW = new("review")
+        end
+
+        open!
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/recommendation.rbi

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::Recommendation
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::Recommendation
+end

data/lib/no_response/models/shared/responsemode.rb

@@ -0,0 +1,16 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # ResponseMode - standard returns the consolidated risk response; detailed adds merged provider-neutral facts when the key has detailed scope. There is no raw mode.
+      class ResponseMode < T::Enum
+        enums do
+          STANDARD = new("standard")
+          DETAILED = new("detailed")
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/responsemode.rbi

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::ResponseMode
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::ResponseMode
+end

data/lib/no_response/models/shared/risk.rb

@@ -0,0 +1,171 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # The one risk decision for this event. score is 0 (safe) to 100 (risky): the sum of the weights of the reasons that fired, clamped to 0 to 100, from hand-set versioned weights. Every answer with a recommendation carries it, and the top-level recommendation equals risk.recommendation. It names no source or provider.
+      class Risk
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :score,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("score"), required: true}}
+        )
+        # low 0-29, medium 30-59, high 60-84, critical 85-100.
+        field(
+          :band,
+          Models::Shared::Band,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("band"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Band, false)
+            }
+          }
+        )
+        # The recommended action: allow, step_up or review. Your application applies it.
+        field(
+          :recommendation,
+          Models::Shared::Recommendation,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("recommendation"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Recommendation, false)
+            }
+          }
+        )
+        # How much of the planned evidence answered; it says nothing about risk.
+        field(
+          :confidence,
+          Models::Shared::RiskConfidence,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("confidence"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::RiskConfidence, false)
+            }
+          }
+        )
+        # Version of the hand-authored heuristic weights that produced the recommendation, for example 'risk-2026-10.7'. A tenant threshold override adds a +t<N> suffix, e.g. 'risk-2026-10.7+t3'.
+        field(
+          :policy_version,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("policy_version"), required: true}}
+        )
+        # Every reason that fired, highest weight first. The weights sum to score before clamping.
+        field(
+          :reasons,
+          Crystalline::Array.new(Models::Shared::RiskReason),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("reasons"), required: true}}
+        )
+        # Sources counted by state, not named.
+        field(
+          :coverage,
+          Models::Shared::RiskCoverage,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("coverage"), required: true}}
+        )
+        # true when the tenant's block threshold is set and score reached it. A provider hook can deny the signup on it; the provider decides and enforces. It does not change recommendation. It is false while blocking is off, the default, and a body from before the flag existed omits it: read absent as false.
+        field(
+          :block,
+          Crystalline::Nilable.new(Crystalline::Boolean.new),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("block")}}
+        )
+        # The block threshold this answer used: block is true exactly when score is at least this value. Absent while blocking is off. NoResponse sets it per tenant on request, at or above the review threshold.
+        field(
+          :block_threshold,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("block_threshold")}}
+        )
+        # Labels the v0 policy as hand-authored and not statistically validated.
+        field(
+          :policy_basis,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("policy_basis"), required: true}}
+        )
+        # A few typed facts per identifier. Every fact is optional: absent means the evidence did not answer and makes no claim, while false or 0 is a definite answer. Lanes that do not exist yet leave their members absent.
+        field(
+          :summary,
+          Crystalline::Nilable.new(Models::Shared::RiskSummary),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("summary")}}
+        )
+        # Detailed view only (response_mode=detailed, which needs the detailed scope); a standard answer leaves it out. Merged observations without provider, source, origin, raw breach record, value or score.
+        field(
+          :details,
+          Crystalline::Nilable.new(Models::Shared::RiskDetails),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("details")}}
+        )
+
+        sig {
+          params(
+            score: ::Integer,
+            band: Models::Shared::Band,
+            recommendation: Models::Shared::Recommendation,
+            confidence: Models::Shared::RiskConfidence,
+            policy_version: ::String,
+            reasons: T::Array[Models::Shared::RiskReason],
+            coverage: Models::Shared::RiskCoverage,
+            block: T.nilable(T::Boolean),
+            block_threshold: T.nilable(::Integer),
+            policy_basis: ::String,
+            summary: T.nilable(Models::Shared::RiskSummary),
+            details: T.nilable(Models::Shared::RiskDetails)
+          )
+            .void
+        }
+        def initialize(
+          score:,
+          band:,
+          recommendation:,
+          confidence:,
+          policy_version:,
+          reasons:,
+          coverage:,
+          block: nil,
+          block_threshold: nil,
+          policy_basis: "heuristic_unvalidated",
+          summary: nil,
+          details: nil
+        )
+          @score = score
+          @band = band
+          @recommendation = recommendation
+          @confidence = confidence
+          @policy_version = policy_version
+          @reasons = reasons
+          @coverage = coverage
+          @block = block
+          @block_threshold = block_threshold
+          unless policy_basis == "heuristic_unvalidated"
+            raise ArgumentError, "Invalid value for policy_basis"
+          end
+
+          @policy_basis = "heuristic_unvalidated"
+          @summary = summary
+          @details = details
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @score == other.score
+          return false unless @band == other.band
+          return false unless @recommendation == other.recommendation
+          return false unless @confidence == other.confidence
+          return false unless @policy_version == other.policy_version
+          return false unless @reasons == other.reasons
+          return false unless @coverage == other.coverage
+          return false unless @block == other.block
+          return false unless @block_threshold == other.block_threshold
+          return false unless @policy_basis == other.policy_basis
+          return false unless @summary == other.summary
+          return false unless @details == other.details
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/risk.rbi

@@ -0,0 +1,80 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::Risk
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::Risk
+  def score
+  end
+
+  def score=(str_)
+  end
+
+  def band
+  end
+
+  def band=(str_)
+  end
+
+  def recommendation
+  end
+
+  def recommendation=(str_)
+  end
+
+  def confidence
+  end
+
+  def confidence=(str_)
+  end
+
+  def policy_version
+  end
+
+  def policy_version=(str_)
+  end
+
+  def reasons
+  end
+
+  def reasons=(str_)
+  end
+
+  def coverage
+  end
+
+  def coverage=(str_)
+  end
+
+  def block
+  end
+
+  def block=(str_)
+  end
+
+  def block_threshold
+  end
+
+  def block_threshold=(str_)
+  end
+
+  def policy_basis
+  end
+
+  def policy_basis=(str_)
+  end
+
+  def summary
+  end
+
+  def summary=(str_)
+  end
+
+  def details
+  end
+
+  def details=(str_)
+  end
+end

data/lib/no_response/models/shared/riskconfidence.rb

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # RiskConfidence - How much of the planned evidence answered; it says nothing about risk.
+      class RiskConfidence
+        include ::Crystalline::Enum
+        enums do
+          LOW = new("low")
+          MEDIUM = new("medium")
+          HIGH = new("high")
+        end
+
+        open!
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/riskconfidence.rbi

@@ -0,0 +1,9 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::RiskConfidence
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::RiskConfidence
+end

data/lib/no_response/models/shared/riskcoverage.rb

@@ -0,0 +1,49 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Sources counted by state, not named.
+      class RiskCoverage
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Sources that gave a definite answer.
+        field(
+          :answered,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("answered"), required: true}}
+        )
+        # Sources that could not answer.
+        field(
+          :failed,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("failed"), required: true}}
+        )
+        # Sources still being asked.
+        field(
+          :pending,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("pending"), required: true}}
+        )
+
+        sig { params(answered: ::Integer, failed: ::Integer, pending: ::Integer).void }
+        def initialize(answered:, failed:, pending:)
+          @answered = answered
+          @failed = failed
+          @pending = pending
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @answered == other.answered
+          return false unless @failed == other.failed
+          return false unless @pending == other.pending
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/shared/riskcoverage.rbi

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::RiskCoverage
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::RiskCoverage
+  def answered
+  end
+
+  def answered=(str_)
+  end
+
+  def failed
+  end
+
+  def failed=(str_)
+  end
+
+  def pending
+  end
+
+  def pending=(str_)
+  end
+end

data/lib/no_response/models/shared/riskdetails.rb

@@ -0,0 +1,55 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Detailed view only (response_mode=detailed, which needs the detailed scope); a standard answer leaves it out. Merged observations without provider, source, origin, raw breach record, value or score.
+      class RiskDetails
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :phone_names,
+          Crystalline::Nilable.new(Crystalline::Array.new(Models::Shared::RiskDetailsPhoneName)),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("phone_names")}}
+        )
+        # The matching breach tables, newest first, at most 50.
+        field(
+          :breaches,
+          Crystalline::Nilable.new(Crystalline::Array.new(Models::Shared::Breach)),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("breaches")}}
+        )
+        # Names found next to the identifiers in breach records, merged, with the number of distinct tables each was seen in.
+        field(
+          :breach_names,
+          Crystalline::Nilable.new(Crystalline::Array.new(Models::Shared::RiskDetailsBreachName)),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("breach_names")}}
+        )
+
+        sig {
+          params(
+            phone_names: T.nilable(T::Array[Models::Shared::RiskDetailsPhoneName]),
+            breaches: T.nilable(T::Array[Models::Shared::Breach]),
+            breach_names: T.nilable(T::Array[Models::Shared::RiskDetailsBreachName])
+          )
+            .void
+        }
+        def initialize(phone_names: nil, breaches: nil, breach_names: nil)
+          @phone_names = phone_names
+          @breaches = breaches
+          @breach_names = breach_names
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @phone_names == other.phone_names
+          return false unless @breaches == other.breaches
+          return false unless @breach_names == other.breach_names
+          true
+        end
+      end
+    end
+  end
+end