noresponse 8.4.1 → 9.0.0

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

@@ -0,0 +1,24 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Role - A built-in capability set. Specialist roles are independent; effective access is returned by GET /v1/workspaces/{workspace_id}/capabilities.
+      class Role
+        include ::Crystalline::Enum
+        enums do
+          OWNER = new("owner")
+          ADMIN = new("admin")
+          DEVELOPER = new("developer")
+          VIEWER = new("viewer")
+          INVESTIGATOR = new("investigator")
+          AUDITOR = new("auditor")
+          BILLING = new("billing")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -33,7 +33,7 @@ module NoResponse
           ::Integer,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("retention_days"), required: true}}
         )
-        # How many times this environment's policy has changed; 0 while the defaults apply. A served risk.policy_version ends in +t<policy_version> once it is above 0.
+        # The monotonic settings configuration epoch, including retention changes. Zero while defaults apply. Historical assessments keep their frozen policy version; the active version reaches new assessments within a minute.
         field(
           :policy_version,
           ::Integer,

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

@@ -4,7 +4,7 @@
 module NoResponse
   module Models
     module Shared
-      # PATCH /v1/workspaces/{workspace_id}/settings/{environment} body. Changes only what it names, in one transaction; a policy change is one new policy_version. Needs the admin or owner role, or an API key with the management scope for its own environment.
+      # Changes only named settings, atomically. Every successful write advances policy_version and retains an immutable settings snapshot. expected_policy_version optionally guards against stale edits; restore always requires it.
       class SettingsRequest
         extend T::Sig
         include Crystalline::MetadataFields
@@ -26,19 +26,41 @@ module NoResponse
           Crystalline::Nilable.new(Models::Shared::SettingsRequestFlows),
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("flows")}}
         )
+        # Compare-and-set guard. A stale version returns 409 policy_version_conflict before any change; every settings write including retention advances the version.
+        field(
+          :expected_policy_version,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("expected_policy_version")}}
+        )
+
+        field(
+          :change_reason,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("change_reason")}}
+        )
 
         sig {
           params(
             retention_days: T.nilable(::Integer),
             refused_sources: T.nilable(T::Array[Models::Shared::SourceId]),
-            flows: T.nilable(Models::Shared::SettingsRequestFlows)
+            flows: T.nilable(Models::Shared::SettingsRequestFlows),
+            expected_policy_version: T.nilable(::Integer),
+            change_reason: T.nilable(::String)
           )
             .void
         }
-        def initialize(retention_days: nil, refused_sources: nil, flows: nil)
+        def initialize(
+          retention_days: nil,
+          refused_sources: nil,
+          flows: nil,
+          expected_policy_version: nil,
+          change_reason: nil
+        )
           @retention_days = retention_days
           @refused_sources = refused_sources
           @flows = flows
+          @expected_policy_version = expected_policy_version
+          @change_reason = change_reason
         end
 
         sig { params(other: T.untyped).returns(T::Boolean) }
@@ -47,6 +69,8 @@ module NoResponse
           return false unless @retention_days == other.retention_days
           return false unless @refused_sources == other.refused_sources
           return false unless @flows == other.flows
+          return false unless @expected_policy_version == other.expected_policy_version
+          return false unless @change_reason == other.change_reason
           true
         end
       end

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

@@ -23,4 +23,16 @@ class NoResponse::Models::Shared::SettingsRequest
 
   def flows=(str_)
   end
+
+  def expected_policy_version
+  end
+
+  def expected_policy_version=(str_)
+  end
+
+  def change_reason
+  end
+
+  def change_reason=(str_)
+  end
 end

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

@@ -0,0 +1,19 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class Source
+        include ::Crystalline::Enum
+        enums do
+          REQUESTS = new("requests")
+          WEBHOOK_ATTEMPTS = new("webhook_attempts")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

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

@@ -0,0 +1,26 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::Thresholds
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::Thresholds
+  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/usage.rb

@@ -0,0 +1,51 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Body of the 200 answer to GET /v1/workspaces/{workspace_id}/usage: what the workspace's environments were metered for on each UTC day from from through to. Each billable unit is counted once, where it becomes final: an assessment when it is admitted (by flow and depth), a webhook delivery once per event per endpoint (retries and replays add nothing), and a key-usage event once when the ingest accepts it. A count does not change when the assessment, account or workspace is later deleted. A day, environment or metric with nothing counted has no item. No prices, limits or billing.
+      class Usage
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The workspace id, which is also its live environment's workspace id; the test environment's is the same id with :test appended. A workspace created through the API is tnt_ and a 26-character ULID.
+        field(
+          :workspace_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("workspace_id"), required: true}}
+        )
+        # The first UTC day covered.
+        field :from, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("from"), required: true}}
+        # The last UTC day covered, included.
+        field :to, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("to"), required: true}}
+        # Ordered by environment (live first), then day, metric, flow and depth.
+        field(
+          :items,
+          Crystalline::Array.new(Models::Shared::UsageCount),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("items"), required: true}}
+        )
+
+        sig {
+          params(workspace_id: ::String, from: ::String, to: ::String, items: T::Array[Models::Shared::UsageCount]).void
+        }
+        def initialize(workspace_id:, from:, to:, items:)
+          @workspace_id = workspace_id
+          @from = from
+          @to = to
+          @items = items
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @workspace_id == other.workspace_id
+          return false unless @from == other.from
+          return false unless @to == other.to
+          return false unless @items == other.items
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::Usage
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::Usage
+  def workspace_id
+  end
+
+  def workspace_id=(str_)
+  end
+
+  def from
+  end
+
+  def from=(str_)
+  end
+
+  def to
+  end
+
+  def to=(str_)
+  end
+
+  def items
+  end
+
+  def items=(str_)
+  end
+end

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

@@ -0,0 +1,100 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class UsageCount
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        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 :day, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("day"), required: true}}
+        # assessments: assessments admitted. webhook_deliveries: events sent to endpoints, one per event per endpoint. key_usage_events: key-usage events accepted.
+        field(
+          :metric,
+          Models::Shared::Metric,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("metric"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::Metric, false)
+            }
+          }
+        )
+
+        field(
+          :count,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("count"), required: true}}
+        )
+        # assessments only.
+        field(
+          :flow,
+          Crystalline::Nilable.new(Models::Shared::UsageCountFlow),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("flow"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::UsageCountFlow, true)
+            }
+          }
+        )
+        # assessments only.
+        field(
+          :depth,
+          Crystalline::Nilable.new(Models::Shared::UsageCountDepth),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("depth"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::UsageCountDepth, true)
+            }
+          }
+        )
+
+        sig {
+          params(
+            environment: Models::Shared::AuditSettingsEnvironment,
+            day: ::String,
+            metric: Models::Shared::Metric,
+            count: ::Integer,
+            flow: T.nilable(Models::Shared::UsageCountFlow),
+            depth: T.nilable(Models::Shared::UsageCountDepth)
+          )
+            .void
+        }
+        def initialize(environment:, day:, metric:, count:, flow: nil, depth: nil)
+          @environment = environment
+          @day = day
+          @metric = metric
+          @count = count
+          @flow = flow
+          @depth = depth
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @environment == other.environment
+          return false unless @day == other.day
+          return false unless @metric == other.metric
+          return false unless @count == other.count
+          return false unless @flow == other.flow
+          return false unless @depth == other.depth
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::UsageCount
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::UsageCount
+  def environment
+  end
+
+  def environment=(str_)
+  end
+
+  def day
+  end
+
+  def day=(str_)
+  end
+
+  def metric
+  end
+
+  def metric=(str_)
+  end
+
+  def count
+  end
+
+  def count=(str_)
+  end
+
+  def flow
+  end
+
+  def flow=(str_)
+  end
+
+  def depth
+  end
+
+  def depth=(str_)
+  end
+end

data/lib/no_response/models/shared/{defaultdepth.rb → usagecountdepth.rb}

@@ -4,8 +4,8 @@
 module NoResponse
   module Models
     module Shared
-      # DefaultDepth - The depth a request for this flow that names none is served at. Defaults: full for account_creation and purchase, quick for login.
-      class DefaultDepth
+      # UsageCountDepth - assessments only.
+      class UsageCountDepth
         include ::Crystalline::Enum
         enums do
           QUICK = new("quick")

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

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

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

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # UsageCountFlow - assessments only.
+      class UsageCountFlow
+        include ::Crystalline::Enum
+        enums do
+          ACCOUNT_CREATION = new("account_creation")
+          LOGIN = new("login")
+          PURCHASE = new("purchase")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,65 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class UserActor
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The user's id at the identity provider the console signs people in with: 1 to 256 printable ASCII characters with no space, compared exactly.
+        field(
+          :external_user_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("external_user_id"), required: true}}
+        )
+        # The public id of the console credential the user acted through.
+        field(
+          :console_credential_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("console_credential_id"), required: true}}
+        )
+
+        field :type, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("type"), required: true}}
+        # Stable workspace principal id, retained across identity-provider subject migration. Absent for older events.
+        field(
+          :principal_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("principal_id")}}
+        )
+
+        sig {
+          params(
+            external_user_id: ::String,
+            console_credential_id: ::String,
+            type: ::String,
+            principal_id: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(external_user_id:, console_credential_id:, type: "user", principal_id: nil)
+          @external_user_id = external_user_id
+          @console_credential_id = console_credential_id
+          unless type == "user"
+            raise ArgumentError, "Invalid value for type"
+          end
+
+          @type = "user"
+          @principal_id = principal_id
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @external_user_id == other.external_user_id
+          return false unless @console_credential_id == other.console_credential_id
+          return false unless @type == other.type
+          return false unless @principal_id == other.principal_id
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::UserActor
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::UserActor
+  def external_user_id
+  end
+
+  def external_user_id=(str_)
+  end
+
+  def console_credential_id
+  end
+
+  def console_credential_id=(str_)
+  end
+
+  def type
+  end
+
+  def type=(str_)
+  end
+
+  def principal_id
+  end
+
+  def principal_id=(str_)
+  end
+end

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

@@ -0,0 +1,70 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Count every retained matching attempt in [from,to). Capture is best effort; missing attempts cannot be inferred. UTC buckets may be partial at the edges. The window is at most 30 days.
+      class WebhookAggregateRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        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(
+          :bucket,
+          Crystalline::Nilable.new(Models::Shared::RequestAggregateRequestBucket),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("bucket"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::RequestAggregateRequestBucket, true)
+            }
+          }
+        )
+
+        field(
+          :status,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("status")}}
+        )
+        # Opaque id of the endpoint registration.
+        field(
+          :endpoint_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("endpoint_id")}}
+        )
+
+        sig {
+          params(
+            from: ::String,
+            to: ::String,
+            bucket: T.nilable(Models::Shared::RequestAggregateRequestBucket),
+            status: T.nilable(::Integer),
+            endpoint_id: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(from:, to:, bucket: nil, status: nil, endpoint_id: nil)
+          @from = from
+          @to = to
+          @bucket = bucket
+          @status = status
+          @endpoint_id = endpoint_id
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @from == other.from
+          return false unless @to == other.to
+          return false unless @bucket == other.bucket
+          return false unless @status == other.status
+          return false unless @endpoint_id == other.endpoint_id
+          true
+        end
+      end
+    end
+  end
+end