noresponse 2.1.0 → 2.1.2

data/lib/no_response/models/operations/getaccount_request.rb

@@ -0,0 +1,29 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class GetAccountRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The account_id the tenant sends with its assessments, as one path segment (percent-encode '|' and ':' if the client requires it). A value that does not match the account_id shape answers 400 invalid_request.
+        field :account_id, ::String, {'path_param': {'field_name': "account_id", 'style': "simple", 'explode': false}}
+
+        sig { params(account_id: ::String).void }
+        def initialize(account_id:)
+          @account_id = account_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
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/operations/getaccount_request.rbi

@@ -0,0 +1,14 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Operations::GetAccountRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Operations::GetAccountRequest
+  def account_id
+  end
+
+  def account_id=(str_)
+  end
+end

data/lib/no_response/models/operations/getaccount_response.rb

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class GetAccountResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :headers, Crystalline::Hash.new(Symbol, Crystalline::Array.new(::String))
+
+        field :result, Models::Shared::Account, {}
+
+        sig { params(headers: T::Hash[Symbol, T::Array[::String]], result: Models::Shared::Account).void }
+        def initialize(headers:, result:)
+          @headers = headers
+          @result = result
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @headers == other.headers
+          return false unless @result == other.result
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/operations/getaccount_response.rbi

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Operations::GetAccountResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Operations::GetAccountResponse
+  def headers
+  end
+
+  def headers=(str_)
+  end
+
+  def result
+  end
+
+  def result=(str_)
+  end
+end

data/lib/no_response/models/operations/listaccountassessments_request.rb

@@ -0,0 +1,61 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class ListAccountAssessmentsRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The account_id the tenant sends with its assessments, as one path segment (percent-encode '|' and ':' if the client requires it). A value that does not match the account_id shape answers 400 invalid_request.
+        field :account_id, ::String, {'path_param': {'field_name': "account_id", 'style': "simple", 'explode': false}}
+        # next_cursor from the previous page, unchanged.
+        field(
+          :cursor,
+          Crystalline::Nilable.new(::String),
+          {'query_param': {'field_name': "cursor", 'style': "form", 'explode': true}}
+        )
+        # Optional standard or separately authorised detailed customer view; raw is rejected.
+        field(
+          :response_mode,
+          Crystalline::Nilable.new(Models::Shared::ResponseMode),
+          {'query_param': {'field_name': "response_mode", 'style': "form", 'explode': true}}
+        )
+        # Items per page.
+        field(
+          :limit,
+          Crystalline::Nilable.new(::Integer),
+          {'query_param': {'field_name': "limit", 'style': "form", 'explode': true}}
+        )
+
+        sig {
+          params(
+            account_id: ::String,
+            cursor: T.nilable(::String),
+            response_mode: T.nilable(Models::Shared::ResponseMode),
+            limit: T.nilable(::Integer)
+          )
+            .void
+        }
+        def initialize(account_id:, cursor: nil, response_mode: nil, limit: 20)
+          @account_id = account_id
+          @cursor = cursor
+          @response_mode = response_mode
+          @limit = limit
+        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 @cursor == other.cursor
+          return false unless @response_mode == other.response_mode
+          return false unless @limit == other.limit
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/operations/listaccountassessments_request.rbi

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Operations::ListAccountAssessmentsRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Operations::ListAccountAssessmentsRequest
+  def account_id
+  end
+
+  def account_id=(str_)
+  end
+
+  def cursor
+  end
+
+  def cursor=(str_)
+  end
+
+  def response_mode
+  end
+
+  def response_mode=(str_)
+  end
+
+  def limit
+  end
+
+  def limit=(str_)
+  end
+end

data/lib/no_response/models/operations/listaccountassessments_response.rb

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class ListAccountAssessmentsResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+        sig { returns(T.proc.returns(T.nilable(ListAccountAssessmentsResponse))) }
+        attr_accessor :next_page
+
+        field :headers, Crystalline::Hash.new(Symbol, Crystalline::Array.new(::String))
+
+        field :result, Models::Shared::AssessmentList, {}
+
+        sig { params(headers: T::Hash[Symbol, T::Array[::String]], result: Models::Shared::AssessmentList).void }
+        def initialize(headers:, result:)
+          @headers = headers
+          @result = result
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @headers == other.headers
+          return false unless @result == other.result
+          true
+        end
+
+        def each
+          page = self
+          loop do
+            yield page
+            next_page = page.next_page.call if page.next_page
+            break if next_page.nil?
+            page = T.must(next_page)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/operations/listaccountassessments_response.rbi

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Operations::ListAccountAssessmentsResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Operations::ListAccountAssessmentsResponse
+  def headers
+  end
+
+  def headers=(str_)
+  end
+
+  def result
+  end
+
+  def result=(str_)
+  end
+end

data/lib/no_response/models/operations.rb

@@ -12,8 +12,12 @@ module NoResponse
       autoload :DeleteIntegrationResponse, "no_response/models/operations/deleteintegration_response.rb"
       autoload :DeleteWebhookEndpointRequest, "no_response/models/operations/deletewebhookendpoint_request.rb"
       autoload :DeleteWebhookEndpointResponse, "no_response/models/operations/deletewebhookendpoint_response.rb"
+      autoload :GetAccountRequest, "no_response/models/operations/getaccount_request.rb"
+      autoload :GetAccountResponse, "no_response/models/operations/getaccount_response.rb"
       autoload :GetAssessmentRequest, "no_response/models/operations/getassessment_request.rb"
       autoload :GetAssessmentResponse, "no_response/models/operations/getassessment_response.rb"
+      autoload :ListAccountAssessmentsRequest, "no_response/models/operations/listaccountassessments_request.rb"
+      autoload :ListAccountAssessmentsResponse, "no_response/models/operations/listaccountassessments_response.rb"
       autoload :ListIntegrationsResponse, "no_response/models/operations/listintegrations_response.rb"
       autoload :ListWebhookEndpointsResponse, "no_response/models/operations/listwebhookendpoints_response.rb"
       autoload :QueryAccountAssessmentsResponse, "no_response/models/operations/queryaccountassessments_response.rb"

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

@@ -0,0 +1,83 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Body of the 200 answer to GET /v1/accounts/{account_id}: the one current risk of one of the calling tenant's accounts. It is the risk of the account's latest assessment that has a decision (status complete or partial), by created_at and then assessment_id, scored exactly as GET /v1/assessments/{assessment_id} scores that assessment. Its assessments are the account's history (GET /v1/accounts/{account_id}/assessments).
+      class Account
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The account_id the tenant sends with its assessments.
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+
+        field(
+          :risk,
+          Models::Shared::AccountRisk,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("risk"), required: true}}
+        )
+        # The decision for each flow. Every flow uses the tenant's signup thresholds today, so all three equal risk.decision.
+        field(
+          :decisions_by_flow,
+          Models::Shared::AccountDecisionsByFlow,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("decisions_by_flow"), required: true}}
+        )
+        # The assessment the current risk comes from.
+        field(
+          :assessment_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("assessment_id"), required: true}}
+        )
+        # updated_at of that assessment's latest revision.
+        field(
+          :updated_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("updated_at"), 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,
+            risk: Models::Shared::AccountRisk,
+            decisions_by_flow: Models::Shared::AccountDecisionsByFlow,
+            assessment_id: ::String,
+            updated_at: ::String,
+            schema_version: ::String
+          )
+            .void
+        }
+        def initialize(id:, risk:, decisions_by_flow:, assessment_id:, updated_at:, schema_version: "1")
+          @id = id
+          @risk = risk
+          @decisions_by_flow = decisions_by_flow
+          @assessment_id = assessment_id
+          @updated_at = updated_at
+          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 @risk == other.risk
+          return false unless @decisions_by_flow == other.decisions_by_flow
+          return false unless @assessment_id == other.assessment_id
+          return false unless @updated_at == other.updated_at
+          return false unless @schema_version == other.schema_version
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::Account
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::Account
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def risk
+  end
+
+  def risk=(str_)
+  end
+
+  def decisions_by_flow
+  end
+
+  def decisions_by_flow=(str_)
+  end
+
+  def assessment_id
+  end
+
+  def assessment_id=(str_)
+  end
+
+  def updated_at
+  end
+
+  def updated_at=(str_)
+  end
+
+  def schema_version
+  end
+
+  def schema_version=(str_)
+  end
+end

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

@@ -0,0 +1,21 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # AccountDecision - block when the score reached your block threshold (risk.block of the assessment), otherwise the assessment's recommendation. Your application applies it.
+      class AccountDecision
+        include ::Crystalline::Enum
+        enums do
+          ALLOW = new("allow")
+          STEP_UP = new("step_up")
+          REVIEW = new("review")
+          BLOCK = new("block")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,74 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # The decision for each flow. Every flow uses the tenant's signup thresholds today, so all three equal risk.decision.
+      class AccountDecisionsByFlow
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # block when the score reached your block threshold (risk.block of the assessment), otherwise the assessment's recommendation. Your application applies it.
+        field(
+          :signup,
+          Models::Shared::AccountDecision,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("signup"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::AccountDecision, false)
+            }
+          }
+        )
+        # block when the score reached your block threshold (risk.block of the assessment), otherwise the assessment's recommendation. Your application applies it.
+        field(
+          :login,
+          Models::Shared::AccountDecision,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("login"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::AccountDecision, false)
+            }
+          }
+        )
+        # block when the score reached your block threshold (risk.block of the assessment), otherwise the assessment's recommendation. Your application applies it.
+        field(
+          :purchase,
+          Models::Shared::AccountDecision,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("purchase"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::AccountDecision, false)
+            }
+          }
+        )
+
+        sig {
+          params(
+            signup: Models::Shared::AccountDecision,
+            login: Models::Shared::AccountDecision,
+            purchase: Models::Shared::AccountDecision
+          )
+            .void
+        }
+        def initialize(signup:, login:, purchase:)
+          @signup = signup
+          @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 @signup == other.signup
+          return false unless @login == other.login
+          return false unless @purchase == other.purchase
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,62 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class AccountRisk
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # 0 (safe) to 100 (risky), as risk.score of the assessment.
+        field(
+          :score,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("score"), required: true}}
+        )
+        # block when the score reached your block threshold (risk.block of the assessment), otherwise the assessment's recommendation. Your application applies it.
+        field(
+          :decision,
+          Models::Shared::AccountDecision,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("decision"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::AccountDecision, false)
+            }
+          }
+        )
+        # Every reason that fired, highest weight first. The weights sum to score before clamping.
+        field(
+          :reasons,
+          Crystalline::Array.new(Models::Shared::AccountRiskReason),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("reasons"), required: true}}
+        )
+
+        sig {
+          params(
+            score: ::Integer,
+            decision: Models::Shared::AccountDecision,
+            reasons: T::Array[Models::Shared::AccountRiskReason]
+          )
+            .void
+        }
+        def initialize(score:, decision:, reasons:)
+          @score = score
+          @decision = decision
+          @reasons = reasons
+        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 @decision == other.decision
+          return false unless @reasons == other.reasons
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AccountRisk
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AccountRisk
+  def score
+  end
+
+  def score=(str_)
+  end
+
+  def decision
+  end
+
+  def decision=(str_)
+  end
+
+  def reasons
+  end
+
+  def reasons=(str_)
+  end
+end