noresponse 8.4.1 → 9.1.0

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

@@ -0,0 +1,115 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Exact threshold transitions among eligible retained first answers, newest first within the limit. Partial older revisions without a frozen hold snapshot are reported as unsupported. Preview leaves account state, outcomes and source evidence unchanged.
+      class PolicyPreview
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :policy_version,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("policy_version"), required: true}}
+        )
+
+        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}}
+
+        field(
+          :retention_from,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("retention_from"), required: true}}
+        )
+
+        field(
+          :coverage,
+          Models::Shared::PolicyPreviewCoverage,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("coverage"), required: true}}
+        )
+
+        field(
+          :changed,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("changed"), required: true}}
+        )
+
+        field(
+          :unchanged,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("unchanged"), required: true}}
+        )
+
+        field(
+          :transitions,
+          Crystalline::Array.new(Models::Shared::PolicyPreviewTransition),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("transitions"), required: true}}
+        )
+
+        field(
+          :scope,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("scope"), required: true}}
+        )
+
+        sig {
+          params(
+            policy_version: ::Integer,
+            from: ::String,
+            to: ::String,
+            retention_from: ::String,
+            coverage: Models::Shared::PolicyPreviewCoverage,
+            changed: ::Integer,
+            unchanged: ::Integer,
+            transitions: T::Array[Models::Shared::PolicyPreviewTransition],
+            scope: ::String
+          )
+            .void
+        }
+        def initialize(
+          policy_version:,
+          from:,
+          to:,
+          retention_from:,
+          coverage:,
+          changed:,
+          unchanged:,
+          transitions:,
+          scope: "retained_first_answer_thresholds"
+        )
+          @policy_version = policy_version
+          @from = from
+          @to = to
+          @retention_from = retention_from
+          @coverage = coverage
+          @changed = changed
+          @unchanged = unchanged
+          @transitions = transitions
+          unless scope == "retained_first_answer_thresholds"
+            raise ArgumentError, "Invalid value for scope"
+          end
+
+          @scope = "retained_first_answer_thresholds"
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @policy_version == other.policy_version
+          return false unless @from == other.from
+          return false unless @to == other.to
+          return false unless @retention_from == other.retention_from
+          return false unless @coverage == other.coverage
+          return false unless @changed == other.changed
+          return false unless @unchanged == other.unchanged
+          return false unless @transitions == other.transitions
+          return false unless @scope == other.scope
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::PolicyPreview
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::PolicyPreview
+  def policy_version
+  end
+
+  def policy_version=(str_)
+  end
+
+  def from
+  end
+
+  def from=(str_)
+  end
+
+  def to
+  end
+
+  def to=(str_)
+  end
+
+  def retention_from
+  end
+
+  def retention_from=(str_)
+  end
+
+  def coverage
+  end
+
+  def coverage=(str_)
+  end
+
+  def changed
+  end
+
+  def changed=(str_)
+  end
+
+  def unchanged
+  end
+
+  def unchanged=(str_)
+  end
+
+  def transitions
+  end
+
+  def transitions=(str_)
+  end
+
+  def scope
+  end
+
+  def scope=(str_)
+  end
+end

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

@@ -0,0 +1,108 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class PolicyPreviewCoverage
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :scanned,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("scanned"), required: true}}
+        )
+
+        field(
+          :eligible,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("eligible"), required: true}}
+        )
+
+        field(
+          :missing_score,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("missing_score"), required: true}}
+        )
+
+        field(
+          :unsupported,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("unsupported"), required: true}}
+        )
+
+        field(
+          :truncated,
+          Crystalline::Boolean.new,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("truncated"), required: true}}
+        )
+
+        field(
+          :complete_retained_window,
+          Crystalline::Boolean.new,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("complete_retained_window"), required: true}}
+        )
+        # Deleted, expired and uncaptured records cannot be reconstructed. Counts describe retained evidence and provide no causal estimate of fraud prevented.
+        field(
+          :historical_population_known,
+          Crystalline::Boolean.new,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("historical_population_known"),
+              required: true
+            }
+          }
+        )
+
+        sig {
+          params(
+            scanned: ::Integer,
+            eligible: ::Integer,
+            missing_score: ::Integer,
+            unsupported: ::Integer,
+            truncated: T::Boolean,
+            complete_retained_window: T::Boolean,
+            historical_population_known: T::Boolean
+          )
+            .void
+        }
+        def initialize(
+          scanned:,
+          eligible:,
+          missing_score:,
+          unsupported:,
+          truncated:,
+          complete_retained_window:,
+          historical_population_known: false
+        )
+          @scanned = scanned
+          @eligible = eligible
+          @missing_score = missing_score
+          @unsupported = unsupported
+          @truncated = truncated
+          @complete_retained_window = complete_retained_window
+          unless historical_population_known == false
+            raise ArgumentError, "Invalid value for historical_population_known"
+          end
+
+          @historical_population_known = false
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @scanned == other.scanned
+          return false unless @eligible == other.eligible
+          return false unless @missing_score == other.missing_score
+          return false unless @unsupported == other.unsupported
+          return false unless @truncated == other.truncated
+          return false unless @complete_retained_window == other.complete_retained_window
+          return false unless @historical_population_known == other.historical_population_known
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::PolicyPreviewCoverage
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::PolicyPreviewCoverage
+  def scanned
+  end
+
+  def scanned=(str_)
+  end
+
+  def eligible
+  end
+
+  def eligible=(str_)
+  end
+
+  def missing_score
+  end
+
+  def missing_score=(str_)
+  end
+
+  def unsupported
+  end
+
+  def unsupported=(str_)
+  end
+
+  def truncated
+  end
+
+  def truncated=(str_)
+  end
+
+  def complete_retained_window
+  end
+
+  def complete_retained_window=(str_)
+  end
+
+  def historical_population_known
+  end
+
+  def historical_population_known=(str_)
+  end
+end

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

@@ -0,0 +1,65 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Side-effect-free threshold preview for at most 31 days. Retained first answers are evaluated at their exact frozen scores using the production threshold and hold rules. Changes to admission, source selection, depth or retention are not simulated.
+      class PolicyPreviewRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :expected_policy_version,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("expected_policy_version"), required: true}}
+        )
+
+        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}}
+
+        field(
+          :flows,
+          Models::Shared::PolicyPreviewRequestFlows,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("flows"), required: true}}
+        )
+
+        field(
+          :limit,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("limit")}}
+        )
+
+        sig {
+          params(
+            expected_policy_version: ::Integer,
+            from: ::String,
+            to: ::String,
+            flows: Models::Shared::PolicyPreviewRequestFlows,
+            limit: T.nilable(::Integer)
+          )
+            .void
+        }
+        def initialize(expected_policy_version:, from:, to:, flows:, limit: 1000)
+          @expected_policy_version = expected_policy_version
+          @from = from
+          @to = to
+          @flows = flows
+          @limit = limit
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @expected_policy_version == other.expected_policy_version
+          return false unless @from == other.from
+          return false unless @to == other.to
+          return false unless @flows == other.flows
+          return false unless @limit == other.limit
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::PolicyPreviewRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::PolicyPreviewRequest
+  def expected_policy_version
+  end
+
+  def expected_policy_version=(str_)
+  end
+
+  def from
+  end
+
+  def from=(str_)
+  end
+
+  def to
+  end
+
+  def to=(str_)
+  end
+
+  def flows
+  end
+
+  def flows=(str_)
+  end
+
+  def limit
+  end
+
+  def limit=(str_)
+  end
+end

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

@@ -0,0 +1,55 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class PolicyPreviewRequestFlows
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :account_creation,
+          Crystalline::Nilable.new(Models::Shared::PolicyPreviewRequestFlowsAccountCreation),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("account_creation")}}
+        )
+
+        field(
+          :login,
+          Crystalline::Nilable.new(Models::Shared::PolicyPreviewRequestFlowsLogin),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("login")}}
+        )
+
+        field(
+          :purchase,
+          Crystalline::Nilable.new(Models::Shared::PolicyPreviewRequestFlowsPurchase),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("purchase")}}
+        )
+
+        sig {
+          params(
+            account_creation: T.nilable(Models::Shared::PolicyPreviewRequestFlowsAccountCreation),
+            login: T.nilable(Models::Shared::PolicyPreviewRequestFlowsLogin),
+            purchase: T.nilable(Models::Shared::PolicyPreviewRequestFlowsPurchase)
+          )
+            .void
+        }
+        def initialize(account_creation: nil, login: nil, purchase: nil)
+          @account_creation = account_creation
+          @login = login
+          @purchase = purchase
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @account_creation == other.account_creation
+          return false unless @login == other.login
+          return false unless @purchase == other.purchase
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::PolicyPreviewRequestFlows
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::PolicyPreviewRequestFlows
+  def account_creation
+  end
+
+  def account_creation=(str_)
+  end
+
+  def login
+  end
+
+  def login=(str_)
+  end
+
+  def purchase
+  end
+
+  def purchase=(str_)
+  end
+end

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

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

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

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::PolicyPreviewRequestFlowsAccountCreation
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::PolicyPreviewRequestFlowsAccountCreation
+  def step_up
+  end
+
+  def step_up=(str_)
+  end
+
+  def review
+  end
+
+  def review=(str_)
+  end
+
+  def block
+  end
+
+  def block=(str_)
+  end
+end

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

@@ -0,0 +1,64 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class PolicyPreviewRequestFlowsLogin
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :step_up,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("step_up")}}
+        )
+
+        field(
+          :review,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("review")}}
+        )
+        # Send true; false is refused.
+        field(
+          :inherits_account_creation,
+          Crystalline::Nilable.new(Crystalline::Boolean.new),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("inherits_account_creation")}}
+        )
+
+        field(
+          :block,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("block")}}
+        )
+
+        sig {
+          params(
+            step_up: T.nilable(::Integer),
+            review: T.nilable(::Integer),
+            inherits_account_creation: T.nilable(T::Boolean),
+            block: T.nilable(::Integer)
+          )
+            .void
+        }
+        def initialize(step_up: nil, review: nil, inherits_account_creation: nil, block: nil)
+          @step_up = step_up
+          @review = review
+          @inherits_account_creation = inherits_account_creation
+          @block = block
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @step_up == other.step_up
+          return false unless @review == other.review
+          return false unless @inherits_account_creation == other.inherits_account_creation
+          return false unless @block == other.block
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::PolicyPreviewRequestFlowsLogin
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::PolicyPreviewRequestFlowsLogin
+  def step_up
+  end
+
+  def step_up=(str_)
+  end
+
+  def review
+  end
+
+  def review=(str_)
+  end
+
+  def inherits_account_creation
+  end
+
+  def inherits_account_creation=(str_)
+  end
+
+  def block
+  end
+
+  def block=(str_)
+  end
+end