noresponse 8.4.1 → 9.0.0

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

@@ -0,0 +1,101 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class PolicyEvaluationRequest
+        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(
+          :candidates,
+          Crystalline::Array.new(Models::Shared::Thresholds),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("candidates"), required: true}}
+        )
+
+        field(
+          :costs,
+          Models::Shared::PolicyEvaluationRequestCosts,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("costs"), required: true}}
+        )
+
+        field(
+          :limits,
+          Models::Shared::PolicyEvaluationRequestLimits,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("limits"), required: true}}
+        )
+
+        field(
+          :label_collection,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("label_collection"), required: true}}
+        )
+
+        field(
+          :split_seed,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("split_seed"), required: true}}
+        )
+
+        sig {
+          params(
+            expected_policy_version: ::Integer,
+            from: ::String,
+            to: ::String,
+            candidates: T::Array[Models::Shared::Thresholds],
+            costs: Models::Shared::PolicyEvaluationRequestCosts,
+            limits: Models::Shared::PolicyEvaluationRequestLimits,
+            label_collection: ::String,
+            split_seed: ::String
+          )
+            .void
+        }
+        def initialize(
+          expected_policy_version:,
+          from:,
+          to:,
+          candidates:,
+          costs:,
+          limits:,
+          label_collection:,
+          split_seed:
+        )
+          @expected_policy_version = expected_policy_version
+          @from = from
+          @to = to
+          @candidates = candidates
+          @costs = costs
+          @limits = limits
+          @label_collection = label_collection
+          @split_seed = split_seed
+        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 @candidates == other.candidates
+          return false unless @costs == other.costs
+          return false unless @limits == other.limits
+          return false unless @label_collection == other.label_collection
+          return false unless @split_seed == other.split_seed
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::PolicyEvaluationRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::PolicyEvaluationRequest
+  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 candidates
+  end
+
+  def candidates=(str_)
+  end
+
+  def costs
+  end
+
+  def costs=(str_)
+  end
+
+  def limits
+  end
+
+  def limits=(str_)
+  end
+
+  def label_collection
+  end
+
+  def label_collection=(str_)
+  end
+
+  def split_seed
+  end
+
+  def split_seed=(str_)
+  end
+end

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

@@ -0,0 +1,40 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class PolicyEvaluationRequestCosts
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :legitimate,
+          Models::Shared::Cost,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("legitimate"), required: true}}
+        )
+
+        field(
+          :abuse,
+          Models::Shared::Cost,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("abuse"), required: true}}
+        )
+
+        sig { params(legitimate: Models::Shared::Cost, abuse: Models::Shared::Cost).void }
+        def initialize(legitimate:, abuse:)
+          @legitimate = legitimate
+          @abuse = abuse
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @legitimate == other.legitimate
+          return false unless @abuse == other.abuse
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,59 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class PolicyEvaluationRequestLimits
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :review_rate,
+          ::Float,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("review_rate"), required: true}}
+        )
+
+        field(
+          :server_error_rate,
+          ::Float,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("server_error_rate"), required: true}}
+        )
+
+        field(
+          :unavailable_result_rate,
+          ::Float,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("unavailable_result_rate"), required: true}}
+        )
+
+        field(
+          :p95_ms,
+          ::Float,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("p95_ms"), required: true}}
+        )
+
+        sig {
+          params(review_rate: ::Float, server_error_rate: ::Float, unavailable_result_rate: ::Float, p95_ms: ::Float)
+            .void
+        }
+        def initialize(review_rate:, server_error_rate:, unavailable_result_rate:, p95_ms:)
+          @review_rate = review_rate
+          @server_error_rate = server_error_rate
+          @unavailable_result_rate = unavailable_result_rate
+          @p95_ms = p95_ms
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @review_rate == other.review_rate
+          return false unless @server_error_rate == other.server_error_rate
+          return false unless @unavailable_result_rate == other.unavailable_result_rate
+          return false unless @p95_ms == other.p95_ms
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::PolicyEvaluationRequestLimits
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::PolicyEvaluationRequestLimits
+  def review_rate
+  end
+
+  def review_rate=(str_)
+  end
+
+  def server_error_rate
+  end
+
+  def server_error_rate=(str_)
+  end
+
+  def unavailable_result_rate
+  end
+
+  def unavailable_result_rate=(str_)
+  end
+
+  def p95_ms
+  end
+
+  def p95_ms=(str_)
+  end
+end

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

@@ -0,0 +1,40 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # The evaluation report and its provenance. A no_change report cannot authorise publication.
+      class PolicyEvaluationResult
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :evaluation,
+          Models::Shared::PolicyEvaluation,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("evaluation"), required: true}}
+        )
+
+        field(
+          :report,
+          Models::Shared::Report,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("report"), required: true}}
+        )
+
+        sig { params(evaluation: Models::Shared::PolicyEvaluation, report: Models::Shared::Report).void }
+        def initialize(evaluation:, report:)
+          @evaluation = evaluation
+          @report = report
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @evaluation == other.evaluation
+          return false unless @report == other.report
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,22 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class PolicyEvaluationStatus
+        include ::Crystalline::Enum
+        enums do
+          QUEUED = new("queued")
+          RUNNING = new("running")
+          COMPLETED = new("completed")
+          FAILED = new("failed")
+          CANCELLED = new("cancelled")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,64 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Immutable settings snapshots, newest first. history_complete is false when earlier versions predate capture. A restored version is published with a fresh version number. History is removed with the tenant.
+      class PolicyHistory
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :items,
+          Crystalline::Array.new(Models::Shared::PolicyHistoryItem),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("items"), required: true}}
+        )
+
+        field(
+          :has_more,
+          Crystalline::Boolean.new,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("has_more"), required: true}}
+        )
+
+        field(
+          :history_complete,
+          Crystalline::Boolean.new,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("history_complete"), required: true}}
+        )
+
+        field(
+          :next_before_version,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("next_before_version")}}
+        )
+
+        sig {
+          params(
+            items: T::Array[Models::Shared::PolicyHistoryItem],
+            has_more: T::Boolean,
+            history_complete: T::Boolean,
+            next_before_version: T.nilable(::Integer)
+          )
+            .void
+        }
+        def initialize(items:, has_more:, history_complete:, next_before_version: nil)
+          @items = items
+          @has_more = has_more
+          @history_complete = history_complete
+          @next_before_version = next_before_version
+        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 @has_more == other.has_more
+          return false unless @history_complete == other.history_complete
+          return false unless @next_before_version == other.next_before_version
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::PolicyHistory
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::PolicyHistory
+  def items
+  end
+
+  def items=(str_)
+  end
+
+  def has_more
+  end
+
+  def has_more=(str_)
+  end
+
+  def history_complete
+  end
+
+  def history_complete=(str_)
+  end
+
+  def next_before_version
+  end
+
+  def next_before_version=(str_)
+  end
+end

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

@@ -0,0 +1,74 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class PolicyHistoryItem
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # One environment's settings: how long its assessments are kept, and for each flow the risk thresholds that decide it and the depth a request that names none is served at, and the sources it refuses. Live and test each have their own. A flow without thresholds of its own uses account_creation's (inherits_account_creation). Every change is recorded in the audit log as settings.updated, with who made it.
+        field(
+          :settings,
+          Models::Shared::Settings,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("settings"), required: true}}
+        )
+        # Capture time, not a backfilled activation time. Absent only for the current configuration before its first capture.
+        field(
+          :recorded_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("recorded_at")}}
+        )
+
+        field(
+          :change_reason,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("change_reason")}}
+        )
+
+        field(
+          :restored_from,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("restored_from")}}
+        )
+        # Immutable publication provenance remains in policy history after evaluation evidence expires. SHA-256 values identify the frozen manifest, evaluator semantic input, cohort, and canonical result separately.
+        field(
+          :evaluation,
+          Crystalline::Nilable.new(Models::Shared::Publication),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("evaluation")}}
+        )
+
+        sig {
+          params(
+            settings: Models::Shared::Settings,
+            recorded_at: T.nilable(::String),
+            change_reason: T.nilable(::String),
+            restored_from: T.nilable(::Integer),
+            evaluation: T.nilable(Models::Shared::Publication)
+          )
+            .void
+        }
+        def initialize(settings:, recorded_at: nil, change_reason: nil, restored_from: nil, evaluation: nil)
+          @settings = settings
+          @recorded_at = recorded_at
+          @change_reason = change_reason
+          @restored_from = restored_from
+          @evaluation = evaluation
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @settings == other.settings
+          return false unless @recorded_at == other.recorded_at
+          return false unless @change_reason == other.change_reason
+          return false unless @restored_from == other.restored_from
+          return false unless @evaluation == other.evaluation
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::PolicyHistoryItem
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::PolicyHistoryItem
+  def settings
+  end
+
+  def settings=(str_)
+  end
+
+  def recorded_at
+  end
+
+  def recorded_at=(str_)
+  end
+
+  def change_reason
+  end
+
+  def change_reason=(str_)
+  end
+
+  def restored_from
+  end
+
+  def restored_from=(str_)
+  end
+
+  def evaluation
+  end
+
+  def evaluation=(str_)
+  end
+end