noresponse 8.1.2 → 8.2.0

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

@@ -0,0 +1,92 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AccountExport
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AccountExport
+  def account_id
+  end
+
+  def account_id=(str_)
+  end
+
+  def exported_at
+  end
+
+  def exported_at=(str_)
+  end
+
+  def current_risk_version
+  end
+
+  def current_risk_version=(str_)
+  end
+
+  def assessments
+  end
+
+  def assessments=(str_)
+  end
+
+  def decisions
+  end
+
+  def decisions=(str_)
+  end
+
+  def outcomes
+  end
+
+  def outcomes=(str_)
+  end
+
+  def assessment_outcomes
+  end
+
+  def assessment_outcomes=(str_)
+  end
+
+  def credentials
+  end
+
+  def credentials=(str_)
+  end
+
+  def bindings
+  end
+
+  def bindings=(str_)
+  end
+
+  def enforcements
+  end
+
+  def enforcements=(str_)
+  end
+
+  def requests
+  end
+
+  def requests=(str_)
+  end
+
+  def exclusions
+  end
+
+  def exclusions=(str_)
+  end
+
+  def schema_version
+  end
+
+  def schema_version=(str_)
+  end
+
+  def complete
+  end
+
+  def complete=(str_)
+  end
+end

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

@@ -0,0 +1,152 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Immutable acceptance receipt. risk_version is the account version after this report committed, not the version when a retry reads it. effective_outcome_id names the effective head at that write. The effective expiration may shorten under retention changes. A legitimate report or correction removes only the account-feedback contribution, not unrelated risk.
+      class AccountOutcome
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Opaque, server-assigned id of one recorded outcome: 'out_' and a 26-character Crockford base32 ULID. Unique within the workspace.
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+        # Your own opaque identifier for the account being checked, scoped to your workspace. Use an id you mint, with no direct identifier (email, phone, name or national id) in it. '|' is accepted so an Auth0 user id such as 'auth0|64abc' passes unchanged; '@', '+', '$' and whitespace are refused by the pattern, as is an exact-shape JWT; a hex digest such as a SHA-256 is allowed, because hashing an internal id is a common pseudonymous scheme. A value such as '07700900123' or 'jane.doe.gmail.com' cannot be told apart from an opaque id. It travels in bodies, and in a URL only as the path segment of GET /v1/accounts/{account_id} and its /assessments. An assessment requested by a provider hook at pre_registration, which has no account yet, carries the server-issued account_id pre: followed by its assessment_id.
+        field(
+          :account_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("account_id"), required: true}}
+        )
+        # What the provider later learned about the assessed account. confirmed_abuse, account_takeover and chargeback report abuse; false_positive and legitimate withdraw an earlier abuse report of this workspace for the assessment; unknown is recorded only. Outcomes are append-only and the latest one recorded for an assessment wins.
+        field(
+          :outcome,
+          Models::Shared::Outcome,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("outcome"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Outcome, false)
+            }
+          }
+        )
+
+        field(
+          :observed_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("observed_at"), required: true}}
+        )
+
+        field(
+          :received_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("received_at"), required: true}}
+        )
+
+        field(
+          :expires_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("expires_at"), required: true}}
+        )
+
+        field(
+          :actor,
+          Models::Shared::AccountOutcomeActor,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("actor"), required: true}}
+        )
+
+        field(
+          :risk_version_before,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("risk_version_before"), required: true}}
+        )
+
+        field(
+          :risk_version,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("risk_version"), required: true}}
+        )
+        # Opaque, server-assigned id of one recorded outcome: 'out_' and a 26-character Crockford base32 ULID. Unique within the workspace.
+        field(
+          :supersedes,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("supersedes")}}
+        )
+        # Your own opaque reference for the outcome, such as a case or ticket id. Stored as given and not interpreted; keep direct identifiers out of it.
+        field(
+          :external_ref,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("external_ref")}}
+        )
+        # Opaque, server-assigned id of one recorded outcome: 'out_' and a 26-character Crockford base32 ULID. Unique within the workspace.
+        field(
+          :effective_outcome_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("effective_outcome_id")}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            account_id: ::String,
+            outcome: Models::Shared::Outcome,
+            observed_at: ::String,
+            received_at: ::String,
+            expires_at: ::String,
+            actor: Models::Shared::AccountOutcomeActor,
+            risk_version_before: ::Integer,
+            risk_version: ::Integer,
+            supersedes: T.nilable(::String),
+            external_ref: T.nilable(::String),
+            effective_outcome_id: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(
+          id:,
+          account_id:,
+          outcome:,
+          observed_at:,
+          received_at:,
+          expires_at:,
+          actor:,
+          risk_version_before:,
+          risk_version:,
+          supersedes: nil,
+          external_ref: nil,
+          effective_outcome_id: nil
+        )
+          @id = id
+          @account_id = account_id
+          @outcome = outcome
+          @observed_at = observed_at
+          @received_at = received_at
+          @expires_at = expires_at
+          @actor = actor
+          @risk_version_before = risk_version_before
+          @risk_version = risk_version
+          @supersedes = supersedes
+          @external_ref = external_ref
+          @effective_outcome_id = effective_outcome_id
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @id == other.id
+          return false unless @account_id == other.account_id
+          return false unless @outcome == other.outcome
+          return false unless @observed_at == other.observed_at
+          return false unless @received_at == other.received_at
+          return false unless @expires_at == other.expires_at
+          return false unless @actor == other.actor
+          return false unless @risk_version_before == other.risk_version_before
+          return false unless @risk_version == other.risk_version
+          return false unless @supersedes == other.supersedes
+          return false unless @external_ref == other.external_ref
+          return false unless @effective_outcome_id == other.effective_outcome_id
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AccountOutcome
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AccountOutcome
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def account_id
+  end
+
+  def account_id=(str_)
+  end
+
+  def outcome
+  end
+
+  def outcome=(str_)
+  end
+
+  def observed_at
+  end
+
+  def observed_at=(str_)
+  end
+
+  def received_at
+  end
+
+  def received_at=(str_)
+  end
+
+  def expires_at
+  end
+
+  def expires_at=(str_)
+  end
+
+  def actor
+  end
+
+  def actor=(str_)
+  end
+
+  def risk_version_before
+  end
+
+  def risk_version_before=(str_)
+  end
+
+  def risk_version
+  end
+
+  def risk_version=(str_)
+  end
+
+  def supersedes
+  end
+
+  def supersedes=(str_)
+  end
+
+  def external_ref
+  end
+
+  def external_ref=(str_)
+  end
+
+  def effective_outcome_id
+  end
+
+  def effective_outcome_id=(str_)
+  end
+end

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

@@ -0,0 +1,40 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class AccountOutcomeActor
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :key_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("key_id"), required: true}}
+        )
+
+        field :type, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("type"), required: true}}
+
+        sig { params(key_id: ::String, type: ::String).void }
+        def initialize(key_id:, type: "api_key")
+          @key_id = key_id
+          unless type == "api_key"
+            raise ArgumentError, "Invalid value for type"
+          end
+
+          @type = "api_key"
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @key_id == other.key_id
+          return false unless @type == other.type
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AccountOutcomeActor
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AccountOutcomeActor
+  def key_id
+  end
+
+  def key_id=(str_)
+  end
+
+  def type
+  end
+
+  def type=(str_)
+  end
+end

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

@@ -0,0 +1,65 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # List retained account reports, newest first. The page-level effective outcome id names the current report. Each receipt preserves the effective report and risk version from its original write. Page with the returned cursor.
+      class AccountOutcomePage
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Your own opaque identifier for the account being checked, scoped to your workspace. Use an id you mint, with no direct identifier (email, phone, name or national id) in it. '|' is accepted so an Auth0 user id such as 'auth0|64abc' passes unchanged; '@', '+', '$' and whitespace are refused by the pattern, as is an exact-shape JWT; a hex digest such as a SHA-256 is allowed, because hashing an internal id is a common pseudonymous scheme. A value such as '07700900123' or 'jane.doe.gmail.com' cannot be told apart from an opaque id. It travels in bodies, and in a URL only as the path segment of GET /v1/accounts/{account_id} and its /assessments. An assessment requested by a provider hook at pre_registration, which has no account yet, carries the server-issued account_id pre: followed by its assessment_id.
+        field(
+          :account_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("account_id"), required: true}}
+        )
+
+        field(
+          :items,
+          Crystalline::Array.new(Models::Shared::AccountOutcome),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("items"), required: true}}
+        )
+        # Opaque, expiring cursor bound to this environment, operation and every filter. Keep the filters unchanged.
+        field(
+          :next_cursor,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("next_cursor")}}
+        )
+        # Opaque, server-assigned id of one recorded outcome: 'out_' and a 26-character Crockford base32 ULID. Unique within the workspace.
+        field(
+          :effective_outcome_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("effective_outcome_id")}}
+        )
+
+        sig {
+          params(
+            account_id: ::String,
+            items: T::Array[Models::Shared::AccountOutcome],
+            next_cursor: T.nilable(::String),
+            effective_outcome_id: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(account_id:, items:, next_cursor: nil, effective_outcome_id: nil)
+          @account_id = account_id
+          @items = items
+          @next_cursor = next_cursor
+          @effective_outcome_id = effective_outcome_id
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @account_id == other.account_id
+          return false unless @items == other.items
+          return false unless @next_cursor == other.next_cursor
+          return false unless @effective_outcome_id == other.effective_outcome_id
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AccountOutcomePage
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AccountOutcomePage
+  def account_id
+  end
+
+  def account_id=(str_)
+  end
+
+  def items
+  end
+
+  def items=(str_)
+  end
+
+  def next_cursor
+  end
+
+  def next_cursor=(str_)
+  end
+
+  def effective_outcome_id
+  end
+
+  def effective_outcome_id=(str_)
+  end
+end

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

@@ -0,0 +1,71 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Record a factual report, not an enforcement action. A known outcome replaces the effective report. unknown alone records uncertainty without changing it; unknown with supersedes explicitly retracts it. supersedes must name the current effective report or the request answers 409 outcome_conflict. Reports remain append-only. Idempotency-Key is required. observed_at defaults to receipt time and cannot be over five minutes ahead.
+      class AccountOutcomeRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # What the provider later learned about the assessed account. confirmed_abuse, account_takeover and chargeback report abuse; false_positive and legitimate withdraw an earlier abuse report of this workspace for the assessment; unknown is recorded only. Outcomes are append-only and the latest one recorded for an assessment wins.
+        field(
+          :outcome,
+          Models::Shared::Outcome,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("outcome"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Outcome, false)
+            }
+          }
+        )
+
+        field(
+          :observed_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("observed_at")}}
+        )
+        # Your own opaque reference for the outcome, such as a case or ticket id. Stored as given and not interpreted; keep direct identifiers out of it.
+        field(
+          :external_ref,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("external_ref")}}
+        )
+        # Opaque, server-assigned id of one recorded outcome: 'out_' and a 26-character Crockford base32 ULID. Unique within the workspace.
+        field(
+          :supersedes,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("supersedes")}}
+        )
+
+        sig {
+          params(
+            outcome: Models::Shared::Outcome,
+            observed_at: T.nilable(::String),
+            external_ref: T.nilable(::String),
+            supersedes: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(outcome:, observed_at: nil, external_ref: nil, supersedes: nil)
+          @outcome = outcome
+          @observed_at = observed_at
+          @external_ref = external_ref
+          @supersedes = supersedes
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @outcome == other.outcome
+          return false unless @observed_at == other.observed_at
+          return false unless @external_ref == other.external_ref
+          return false unless @supersedes == other.supersedes
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AccountOutcomeRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AccountOutcomeRequest
+  def outcome
+  end
+
+  def outcome=(str_)
+  end
+
+  def observed_at
+  end
+
+  def observed_at=(str_)
+  end
+
+  def external_ref
+  end
+
+  def external_ref=(str_)
+  end
+
+  def supersedes
+  end
+
+  def supersedes=(str_)
+  end
+end

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

@@ -0,0 +1,101 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Retrieve a retained assessment version with its original decision, policy, flow and depth. This response excludes the current account decision. Current retention and response-mode permissions still apply.
+      class AssessmentRevision
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # This assessment's id, equal to detail.assessment_id.
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+        # complete: final; nothing is still running. A lane that failed or missed its 10 s deadline stays listed in incomplete_sources, and confidence is lower. partial: a recommendation exists and at least one lane is still running or did not settle (see incomplete_sources). pending: nothing usable before the deadline; no recommendation yet, poll or wait for the webhook.
+        field(
+          :status,
+          Models::Shared::Status,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("status"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Status, false)
+            }
+          }
+        )
+        # The event an assessment is made for: account_creation (a user creates an account), login (a user returns to an existing account) or purchase (a payment or a credit grant). The account's risk is reported with the decision for this flow.
+        field(
+          :flow,
+          Models::Shared::Flow,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("flow"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Flow, false)
+            }
+          }
+        )
+        # How long the synchronous answer waits for sources. quick waits only for the fast sources, those that answer within 500 ms of ingress (or deadline_ms when lower); full waits for the whole budget, up to 3000 ms. Sources still running at the cut continue asynchronously and update the assessment either way.
+        field(
+          :depth,
+          Models::Shared::Depth,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("depth"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Depth, false)
+            }
+          }
+        )
+        # One assessment's own facts: its score and recommendation, the signals behind them, the lanes still running and its timing. risk here is this assessment's own score; the account's current risk is the account member of the assessment. risk and recommendation are present for complete and partial; assessment_url is present for pending.
+        field(
+          :detail,
+          Models::Shared::AssessmentDetail,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("detail"), required: true}}
+        )
+        # Version of the body shape.
+        field(
+          :schema_version,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("schema_version"), required: true}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            status: Models::Shared::Status,
+            flow: Models::Shared::Flow,
+            depth: Models::Shared::Depth,
+            detail: Models::Shared::AssessmentDetail,
+            schema_version: ::String
+          )
+            .void
+        }
+        def initialize(id:, status:, flow:, depth:, detail:, schema_version: "1")
+          @id = id
+          @status = status
+          @flow = flow
+          @depth = depth
+          @detail = detail
+          unless schema_version == "1"
+            raise ArgumentError, "Invalid value for schema_version"
+          end
+
+          @schema_version = "1"
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @id == other.id
+          return false unless @status == other.status
+          return false unless @flow == other.flow
+          return false unless @depth == other.depth
+          return false unless @detail == other.detail
+          return false unless @schema_version == other.schema_version
+          true
+        end
+      end
+    end
+  end
+end