noresponse 8.4.0 → 9.0.0

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

@@ -0,0 +1,50 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AuditStream
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AuditStream
+  def endpoint_id
+  end
+
+  def endpoint_id=(str_)
+  end
+
+  def environment
+  end
+
+  def environment=(str_)
+  end
+
+  def actions
+  end
+
+  def actions=(str_)
+  end
+
+  def created_at
+  end
+
+  def created_at=(str_)
+  end
+
+  def endpoint_state
+  end
+
+  def endpoint_state=(str_)
+  end
+
+  def last_attempt_at
+  end
+
+  def last_attempt_at=(str_)
+  end
+
+  def last_delivered_at
+  end
+
+  def last_delivered_at=(str_)
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Read audit stream subscriptions.
+      class AuditStreamList
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :items,
+          Crystalline::Array.new(Models::Shared::AuditStream),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("items"), required: true}}
+        )
+
+        sig { params(items: T::Array[Models::Shared::AuditStream]).void }
+        def initialize(items:)
+          @items = items
+        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
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,33 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class AuditStreamReplayRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Opaque, workspace-scoped webhook event id. A redelivery of the same event carries the same event_id, so consumers deduplicate on it.
+        field(
+          :event_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("event_id"), required: true}}
+        )
+
+        sig { params(event_id: ::String).void }
+        def initialize(event_id:)
+          @event_id = event_id
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @event_id == other.event_id
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,40 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class AuditStreamRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :endpoint_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("endpoint_id"), required: true}}
+        )
+
+        field(
+          :actions,
+          Crystalline::Nilable.new(Crystalline::Array.new(::String)),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("actions")}}
+        )
+
+        sig { params(endpoint_id: ::String, actions: T.nilable(T::Array[::String])).void }
+        def initialize(endpoint_id:, actions: nil)
+          @endpoint_id = endpoint_id
+          @actions = actions
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @endpoint_id == other.endpoint_id
+          return false unless @actions == other.actions
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -4,7 +4,7 @@
 module NoResponse
   module Models
     module Shared
-      # Band - low 0-29, medium 30-59, high 60-84, critical 85-100.
+
       class Band
         include ::Crystalline::Enum
         enums do

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

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class Conclusion
+        include ::Crystalline::Enum
+        enums do
+          BENIGN = new("benign")
+          ABUSE = new("abuse")
+          INCONCLUSIVE = new("inconclusive")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -22,6 +22,16 @@ module NoResponse
           LIST_ENTRY_EXISTS = new("list_entry_exists")
           LIST_LIMIT_REACHED = new("list_limit_reached")
           LIST_ENTRY_TOO_BROAD = new("list_entry_too_broad")
+          POLICY_VERSION_CONFLICT = new("policy_version_conflict")
+          REVIEW_VERSION_CONFLICT = new("review_version_conflict")
+          REVIEW_EXISTS = new("review_exists")
+          REVIEW_LIMIT_REACHED = new("review_limit_reached")
+          EXPORT_CONFLICT = new("export_conflict")
+          EVALUATION_CONFLICT = new("evaluation_conflict")
+          EVALUATION_NO_PROPOSAL = new("evaluation_no_proposal")
+          EVALUATION_LIMIT_REACHED = new("evaluation_limit_reached")
+          ALREADY_MEMBER = new("already_member")
+          MEMBER_LIMIT_REACHED = new("member_limit_reached")
         end
 
         open!

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

@@ -0,0 +1,48 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class Cost
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :allow, ::Float, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("allow"), required: true}}
+
+        field(
+          :step_up,
+          ::Float,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("step_up"), required: true}}
+        )
+
+        field(
+          :review,
+          ::Float,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("review"), required: true}}
+        )
+
+        field :block, ::Float, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("block"), required: true}}
+
+        sig { params(allow: ::Float, step_up: ::Float, review: ::Float, block: ::Float).void }
+        def initialize(allow:, step_up:, review:, block:)
+          @allow = allow
+          @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 @allow == other.allow
+          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/cost.rbi

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::Cost
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::Cost
+  def allow
+  end
+
+  def allow=(str_)
+  end
+
+  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/coverage.rb

@@ -0,0 +1,40 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Counts only; a zero denominator means no eligible retained records and does not imply a zero rate.
+      class Coverage
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :numerator,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("numerator"), required: true}}
+        )
+
+        field(
+          :denominator,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("denominator"), required: true}}
+        )
+
+        sig { params(numerator: ::Integer, denominator: ::Integer).void }
+        def initialize(numerator:, denominator:)
+          @numerator = numerator
+          @denominator = denominator
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @numerator == other.numerator
+          return false unless @denominator == other.denominator
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,209 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Request an asynchronous customer export.
+      class CustomerExport
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+
+        field(
+          :kind,
+          Models::Shared::CustomerExportRequestKind,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("kind"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::CustomerExportRequestKind, false)
+            }
+          }
+        )
+
+        field(
+          :environment,
+          Models::Shared::Environment,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("environment"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Environment, false)
+            }
+          }
+        )
+        # 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,
+          Models::Shared::ResponseMode,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("response_mode"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::ResponseMode, false)
+            }
+          }
+        )
+
+        field(
+          :status,
+          Models::Shared::CustomerExportStatus,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("status"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::CustomerExportStatus, false)
+            }
+          }
+        )
+
+        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(
+          :records,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("records"), required: true}}
+        )
+
+        field(
+          :bytes,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("bytes"), required: true}}
+        )
+
+        field(
+          :chunks,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("chunks"), required: true}}
+        )
+
+        field(
+          :attempts,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("attempts"), required: true}}
+        )
+
+        field(
+          :generation,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("generation"), required: true}}
+        )
+
+        field(
+          :request_sha256,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("request_sha256"), required: true}}
+        )
+
+        field(
+          :snapshot_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("snapshot_at")}}
+        )
+
+        field(
+          :finished_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("finished_at")}}
+        )
+
+        field(
+          :error_code,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("error_code")}}
+        )
+
+        sig {
+          params(
+            id: ::String,
+            kind: Models::Shared::CustomerExportRequestKind,
+            environment: Models::Shared::Environment,
+            response_mode: Models::Shared::ResponseMode,
+            status: Models::Shared::CustomerExportStatus,
+            created_at: ::String,
+            expires_at: ::String,
+            records: ::Integer,
+            bytes: ::Integer,
+            chunks: ::Integer,
+            attempts: ::Integer,
+            generation: ::Integer,
+            request_sha256: ::String,
+            snapshot_at: T.nilable(::String),
+            finished_at: T.nilable(::String),
+            error_code: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(
+          id:,
+          kind:,
+          environment:,
+          response_mode:,
+          status:,
+          created_at:,
+          expires_at:,
+          records:,
+          bytes:,
+          chunks:,
+          attempts:,
+          generation:,
+          request_sha256:,
+          snapshot_at: nil,
+          finished_at: nil,
+          error_code: nil
+        )
+          @id = id
+          @kind = kind
+          @environment = environment
+          @response_mode = response_mode
+          @status = status
+          @created_at = created_at
+          @expires_at = expires_at
+          @records = records
+          @bytes = bytes
+          @chunks = chunks
+          @attempts = attempts
+          @generation = generation
+          @request_sha256 = request_sha256
+          @snapshot_at = snapshot_at
+          @finished_at = finished_at
+          @error_code = error_code
+        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 @kind == other.kind
+          return false unless @environment == other.environment
+          return false unless @response_mode == other.response_mode
+          return false unless @status == other.status
+          return false unless @created_at == other.created_at
+          return false unless @expires_at == other.expires_at
+          return false unless @records == other.records
+          return false unless @bytes == other.bytes
+          return false unless @chunks == other.chunks
+          return false unless @attempts == other.attempts
+          return false unless @generation == other.generation
+          return false unless @request_sha256 == other.request_sha256
+          return false unless @snapshot_at == other.snapshot_at
+          return false unless @finished_at == other.finished_at
+          return false unless @error_code == other.error_code
+          true
+        end
+      end
+    end
+  end
+end