noresponse 8.4.1 → 9.1.0

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

@@ -0,0 +1,256 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class PolicyEvaluation
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+
+        field(
+          :environment,
+          Models::Shared::AuditSettingsEnvironment,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("environment"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::AuditSettingsEnvironment, false)
+            }
+          }
+        )
+
+        field(
+          :status,
+          Models::Shared::PolicyEvaluationStatus,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("status"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::PolicyEvaluationStatus, false)
+            }
+          }
+        )
+
+        field(
+          :policy_version,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("policy_version"), required: true}}
+        )
+
+        field(
+          :scoring_policy,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("scoring_policy"), required: true}}
+        )
+
+        field(
+          :created_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("created_at"), required: true}}
+        )
+
+        field(
+          :expires_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("expires_at"), required: true}}
+        )
+
+        field(
+          :accounts,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("accounts"), required: true}}
+        )
+
+        field(
+          :requests,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("requests"), required: true}}
+        )
+
+        field(
+          :evaluator_sha256,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("evaluator_sha256"), required: true}}
+        )
+
+        field(
+          :captured_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("captured_at")}}
+        )
+
+        field(
+          :finished_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("finished_at")}}
+        )
+
+        field(
+          :evaluator_version,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("evaluator_version"), required: true}}
+        )
+
+        field(
+          :build_version,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("build_version")}}
+        )
+
+        field(
+          :result_status,
+          Crystalline::Nilable.new(Models::Shared::ResultStatus),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("result_status"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::ResultStatus, true)
+            }
+          }
+        )
+
+        field(
+          :error_code,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("error_code")}}
+        )
+
+        field(
+          :published_policy_version,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("published_policy_version")}}
+        )
+
+        field(
+          :manifest_sha256,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("manifest_sha256")}}
+        )
+
+        field(
+          :input_sha256,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("input_sha256")}}
+        )
+
+        field(
+          :cohort_sha256,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("cohort_sha256")}}
+        )
+
+        field(
+          :result_sha256,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("result_sha256")}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            environment: Models::Shared::AuditSettingsEnvironment,
+            status: Models::Shared::PolicyEvaluationStatus,
+            policy_version: ::Integer,
+            scoring_policy: ::String,
+            created_at: ::String,
+            expires_at: ::String,
+            accounts: ::Integer,
+            requests: ::Integer,
+            evaluator_sha256: ::String,
+            captured_at: T.nilable(::String),
+            finished_at: T.nilable(::String),
+            evaluator_version: ::String,
+            build_version: T.nilable(::String),
+            result_status: T.nilable(Models::Shared::ResultStatus),
+            error_code: T.nilable(::String),
+            published_policy_version: T.nilable(::Integer),
+            manifest_sha256: T.nilable(::String),
+            input_sha256: T.nilable(::String),
+            cohort_sha256: T.nilable(::String),
+            result_sha256: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(
+          id:,
+          environment:,
+          status:,
+          policy_version:,
+          scoring_policy:,
+          created_at:,
+          expires_at:,
+          accounts:,
+          requests:,
+          evaluator_sha256:,
+          captured_at: nil,
+          finished_at: nil,
+          evaluator_version: "identity-threshold-evaluator-v2",
+          build_version: nil,
+          result_status: nil,
+          error_code: nil,
+          published_policy_version: nil,
+          manifest_sha256: nil,
+          input_sha256: nil,
+          cohort_sha256: nil,
+          result_sha256: nil
+        )
+          @id = id
+          @environment = environment
+          @status = status
+          @policy_version = policy_version
+          @scoring_policy = scoring_policy
+          @created_at = created_at
+          @expires_at = expires_at
+          @accounts = accounts
+          @requests = requests
+          @evaluator_sha256 = evaluator_sha256
+          @captured_at = captured_at
+          @finished_at = finished_at
+          unless evaluator_version == "identity-threshold-evaluator-v2"
+            raise ArgumentError, "Invalid value for evaluator_version"
+          end
+
+          @evaluator_version = "identity-threshold-evaluator-v2"
+          @build_version = build_version
+          @result_status = result_status
+          @error_code = error_code
+          @published_policy_version = published_policy_version
+          @manifest_sha256 = manifest_sha256
+          @input_sha256 = input_sha256
+          @cohort_sha256 = cohort_sha256
+          @result_sha256 = result_sha256
+        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 @environment == other.environment
+          return false unless @status == other.status
+          return false unless @policy_version == other.policy_version
+          return false unless @scoring_policy == other.scoring_policy
+          return false unless @created_at == other.created_at
+          return false unless @expires_at == other.expires_at
+          return false unless @accounts == other.accounts
+          return false unless @requests == other.requests
+          return false unless @evaluator_sha256 == other.evaluator_sha256
+          return false unless @captured_at == other.captured_at
+          return false unless @finished_at == other.finished_at
+          return false unless @evaluator_version == other.evaluator_version
+          return false unless @build_version == other.build_version
+          return false unless @result_status == other.result_status
+          return false unless @error_code == other.error_code
+          return false unless @published_policy_version == other.published_policy_version
+          return false unless @manifest_sha256 == other.manifest_sha256
+          return false unless @input_sha256 == other.input_sha256
+          return false unless @cohort_sha256 == other.cohort_sha256
+          return false unless @result_sha256 == other.result_sha256
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,134 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::PolicyEvaluation
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::PolicyEvaluation
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def environment
+  end
+
+  def environment=(str_)
+  end
+
+  def status
+  end
+
+  def status=(str_)
+  end
+
+  def policy_version
+  end
+
+  def policy_version=(str_)
+  end
+
+  def scoring_policy
+  end
+
+  def scoring_policy=(str_)
+  end
+
+  def created_at
+  end
+
+  def created_at=(str_)
+  end
+
+  def expires_at
+  end
+
+  def expires_at=(str_)
+  end
+
+  def accounts
+  end
+
+  def accounts=(str_)
+  end
+
+  def requests
+  end
+
+  def requests=(str_)
+  end
+
+  def evaluator_sha256
+  end
+
+  def evaluator_sha256=(str_)
+  end
+
+  def captured_at
+  end
+
+  def captured_at=(str_)
+  end
+
+  def finished_at
+  end
+
+  def finished_at=(str_)
+  end
+
+  def evaluator_version
+  end
+
+  def evaluator_version=(str_)
+  end
+
+  def build_version
+  end
+
+  def build_version=(str_)
+  end
+
+  def result_status
+  end
+
+  def result_status=(str_)
+  end
+
+  def error_code
+  end
+
+  def error_code=(str_)
+  end
+
+  def published_policy_version
+  end
+
+  def published_policy_version=(str_)
+  end
+
+  def manifest_sha256
+  end
+
+  def manifest_sha256=(str_)
+  end
+
+  def input_sha256
+  end
+
+  def input_sha256=(str_)
+  end
+
+  def cohort_sha256
+  end
+
+  def cohort_sha256=(str_)
+  end
+
+  def result_sha256
+  end
+
+  def result_sha256=(str_)
+  end
+end

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

@@ -0,0 +1,23 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class PolicyEvaluationCancelRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        def initialize
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,40 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Retained jobs, newest first. Follow next_before for another page.
+      class PolicyEvaluationList
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :items,
+          Crystalline::Array.new(Models::Shared::PolicyEvaluation),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("items"), required: true}}
+        )
+
+        field(
+          :next_before,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("next_before")}}
+        )
+
+        sig { params(items: T::Array[Models::Shared::PolicyEvaluation], next_before: T.nilable(::String)).void }
+        def initialize(items:, next_before: nil)
+          @items = items
+          @next_before = next_before
+        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 @next_before == other.next_before
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,89 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class PolicyEvaluationPublishRequest
+        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(
+          :manifest_sha256,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("manifest_sha256"), required: true}}
+        )
+
+        field(
+          :input_sha256,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("input_sha256"), required: true}}
+        )
+
+        field(
+          :result_sha256,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("result_sha256"), required: true}}
+        )
+
+        field(
+          :candidate,
+          Models::Shared::Thresholds,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("candidate"), required: true}}
+        )
+
+        field(
+          :change_reason,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("change_reason"), required: true}}
+        )
+
+        sig {
+          params(
+            expected_policy_version: ::Integer,
+            manifest_sha256: ::String,
+            input_sha256: ::String,
+            result_sha256: ::String,
+            candidate: Models::Shared::Thresholds,
+            change_reason: ::String
+          )
+            .void
+        }
+        def initialize(
+          expected_policy_version:,
+          manifest_sha256:,
+          input_sha256:,
+          result_sha256:,
+          candidate:,
+          change_reason:
+        )
+          @expected_policy_version = expected_policy_version
+          @manifest_sha256 = manifest_sha256
+          @input_sha256 = input_sha256
+          @result_sha256 = result_sha256
+          @candidate = candidate
+          @change_reason = change_reason
+        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 @manifest_sha256 == other.manifest_sha256
+          return false unless @input_sha256 == other.input_sha256
+          return false unless @result_sha256 == other.result_sha256
+          return false unless @candidate == other.candidate
+          return false unless @change_reason == other.change_reason
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::PolicyEvaluationPublishRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::PolicyEvaluationPublishRequest
+  def expected_policy_version
+  end
+
+  def expected_policy_version=(str_)
+  end
+
+  def manifest_sha256
+  end
+
+  def manifest_sha256=(str_)
+  end
+
+  def input_sha256
+  end
+
+  def input_sha256=(str_)
+  end
+
+  def result_sha256
+  end
+
+  def result_sha256=(str_)
+  end
+
+  def candidate
+  end
+
+  def candidate=(str_)
+  end
+
+  def change_reason
+  end
+
+  def change_reason=(str_)
+  end
+end