noresponse 8.1.3 → 8.2.1

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

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

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AssessmentRevision
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AssessmentRevision
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def status
+  end
+
+  def status=(str_)
+  end
+
+  def flow
+  end
+
+  def flow=(str_)
+  end
+
+  def depth
+  end
+
+  def depth=(str_)
+  end
+
+  def detail
+  end
+
+  def detail=(str_)
+  end
+
+  def schema_version
+  end
+
+  def schema_version=(str_)
+  end
+end

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

@@ -0,0 +1,68 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # A bounded page of latest assessment revisions, newest creation first. Each revision identifies the exact result found; no current account risk is attached.
+      class AssessmentSearchPage
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :items,
+          Crystalline::Array.new(Models::Shared::AssessmentRevision),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("items"), required: true}}
+        )
+        # Version of the body shape.
+        field(
+          :schema_version,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("schema_version"), 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")}}
+        )
+        # The calling workspace's configured retention period in days. Default 365 (12 months), which is also the maximum: a workspace may only shorten it, to at least 1 day. Each record expires from its own created_at; see assessment expires_at.
+        field(
+          :retention_days,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("retention_days")}}
+        )
+
+        sig {
+          params(
+            items: T::Array[Models::Shared::AssessmentRevision],
+            schema_version: ::String,
+            next_cursor: T.nilable(::String),
+            retention_days: T.nilable(::Integer)
+          )
+            .void
+        }
+        def initialize(items:, schema_version: "1", next_cursor: nil, retention_days: 365)
+          @items = items
+          unless schema_version == "1"
+            raise ArgumentError, "Invalid value for schema_version"
+          end
+
+          @schema_version = "1"
+          @next_cursor = next_cursor
+          @retention_days = retention_days
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @items == other.items
+          return false unless @schema_version == other.schema_version
+          return false unless @next_cursor == other.next_cursor
+          return false unless @retention_days == other.retention_days
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,146 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Search retained assessments created in [from,to), over at most 366 days. Filters use each assessment decision, rather than the current account decision. Results can change between pages. Keep the assessment version to retrieve the exact decision later. This read does not require an idempotency key.
+      class AssessmentSearchRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :from, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("from"), required: true}}
+
+        field :to, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("to"), 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,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("account_id")}}
+        )
+        # 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,
+          Crystalline::Nilable.new(Models::Shared::Flow),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("flow"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Flow, 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,
+          Crystalline::Nilable.new(Models::Shared::Status),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("status"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Status, true)
+            }
+          }
+        )
+        # The recommended action: allow, step_up or review. Your application applies it.
+        field(
+          :recommendation,
+          Crystalline::Nilable.new(Models::Shared::Recommendation),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("recommendation"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Recommendation, true)
+            }
+          }
+        )
+        # Opaque, expiring cursor bound to this environment, operation and every filter. Keep the filters unchanged.
+        field(
+          :cursor,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("cursor")}}
+        )
+        # standard returns the consolidated risk response; detailed adds merged provider-neutral facts when the key has detailed scope. There is no raw mode.
+        field(
+          :response_mode,
+          Crystalline::Nilable.new(Models::Shared::ResponseMode),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("response_mode"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::ResponseMode, true)
+            }
+          }
+        )
+        # The decision of the assessment's latest stored revision: block when its stored risk.block is true, otherwise its recommendation. This is not the account's current decision or held-admission state. Combined with recommendation using AND.
+        field(
+          :decision,
+          Crystalline::Nilable.new(Models::Shared::Decision),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("decision"),
+              'decoder': ::NoResponse::Utils.enum_from_string(Models::Shared::Decision, true)
+            }
+          }
+        )
+
+        field(
+          :limit,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("limit")}}
+        )
+
+        sig {
+          params(
+            from: ::String,
+            to: ::String,
+            account_id: T.nilable(::String),
+            flow: T.nilable(Models::Shared::Flow),
+            status: T.nilable(Models::Shared::Status),
+            recommendation: T.nilable(Models::Shared::Recommendation),
+            cursor: T.nilable(::String),
+            response_mode: T.nilable(Models::Shared::ResponseMode),
+            decision: T.nilable(Models::Shared::Decision),
+            limit: T.nilable(::Integer)
+          )
+            .void
+        }
+        def initialize(
+          from:,
+          to:,
+          account_id: nil,
+          flow: nil,
+          status: nil,
+          recommendation: nil,
+          cursor: nil,
+          response_mode: nil,
+          decision: nil,
+          limit: 20
+        )
+          @from = from
+          @to = to
+          @account_id = account_id
+          @flow = flow
+          @status = status
+          @recommendation = recommendation
+          @cursor = cursor
+          @response_mode = response_mode
+          @decision = decision
+          @limit = limit
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @from == other.from
+          return false unless @to == other.to
+          return false unless @account_id == other.account_id
+          return false unless @flow == other.flow
+          return false unless @status == other.status
+          return false unless @recommendation == other.recommendation
+          return false unless @cursor == other.cursor
+          return false unless @response_mode == other.response_mode
+          return false unless @decision == other.decision
+          return false unless @limit == other.limit
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AssessmentSearchRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AssessmentSearchRequest
+  def from
+  end
+
+  def from=(str_)
+  end
+
+  def to
+  end
+
+  def to=(str_)
+  end
+
+  def account_id
+  end
+
+  def account_id=(str_)
+  end
+
+  def flow
+  end
+
+  def flow=(str_)
+  end
+
+  def status
+  end
+
+  def status=(str_)
+  end
+
+  def recommendation
+  end
+
+  def recommendation=(str_)
+  end
+
+  def cursor
+  end
+
+  def cursor=(str_)
+  end
+
+  def response_mode
+  end
+
+  def response_mode=(str_)
+  end
+
+  def decision
+  end
+
+  def decision=(str_)
+  end
+
+  def limit
+  end
+
+  def limit=(str_)
+  end
+end

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

@@ -16,6 +16,9 @@ module NoResponse
           RISK_VERSION_AHEAD = new("risk_version_ahead")
           KEY_LIMIT_REACHED = new("key_limit_reached")
           SELF_REVOCATION = new("self_revocation")
+          OUTCOME_CONFLICT = new("outcome_conflict")
+          CREDENTIAL_CONFLICT = new("credential_conflict")
+          BINDING_CONFLICT = new("binding_conflict")
           LIST_ENTRY_EXISTS = new("list_entry_exists")
           LIST_LIMIT_REACHED = new("list_limit_reached")
           LIST_ENTRY_TOO_BROAD = new("list_entry_too_broad")

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

@@ -0,0 +1,78 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # An association between an account and an issued key. The response excludes the key and its hash. Retirement removes this association from risk calculations; revoke the actual key through your own service.
+      class CredentialAssociation
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        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}}
+        )
+
+        field(
+          :created_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("created_at"), required: true}}
+        )
+
+        field(
+          :actor,
+          Models::Shared::CredentialAssociationActor,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("actor"), required: true}}
+        )
+
+        field(
+          :retired_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("retired_at")}}
+        )
+
+        field(
+          :retired_by,
+          Crystalline::Nilable.new(Models::Shared::CredentialAssociationRetiredBy),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("retired_by")}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            account_id: ::String,
+            created_at: ::String,
+            actor: Models::Shared::CredentialAssociationActor,
+            retired_at: T.nilable(::String),
+            retired_by: T.nilable(Models::Shared::CredentialAssociationRetiredBy)
+          )
+            .void
+        }
+        def initialize(id:, account_id:, created_at:, actor:, retired_at: nil, retired_by: nil)
+          @id = id
+          @account_id = account_id
+          @created_at = created_at
+          @actor = actor
+          @retired_at = retired_at
+          @retired_by = retired_by
+        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 @created_at == other.created_at
+          return false unless @actor == other.actor
+          return false unless @retired_at == other.retired_at
+          return false unless @retired_by == other.retired_by
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::CredentialAssociation
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::CredentialAssociation
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def account_id
+  end
+
+  def account_id=(str_)
+  end
+
+  def created_at
+  end
+
+  def created_at=(str_)
+  end
+
+  def actor
+  end
+
+  def actor=(str_)
+  end
+
+  def retired_at
+  end
+
+  def retired_at=(str_)
+  end
+
+  def retired_by
+  end
+
+  def retired_by=(str_)
+  end
+end

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

@@ -0,0 +1,40 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class CredentialAssociationActor
+        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/credentialassociationactor.rbi

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