noresponse 2.0.18 → 2.0.19

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

@@ -0,0 +1,100 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # One of the tenant's registered webhook endpoints. Signing secrets are not part of it: a secret is shown once, when it is issued (POST /v1/webhooks and POST /v1/webhooks/{endpoint_id}/rotate).
+      class WebhookEndpoint
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Opaque id of the endpoint registration.
+        field(
+          :endpoint_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("endpoint_id"), required: true}}
+        )
+        # The destination URL, as registered.
+        field :url, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("url"), required: true}}
+        # unverified until the endpoint echoes an endpoint.verification challenge (send one with POST /v1/webhooks/{endpoint_id}/test); verified receives assessment.updated events; disabled after 72 hours of continuous delivery failure, and verified again by the same challenge.
+        field(
+          :state,
+          Models::Shared::WebhookEndpointState,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("state"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::WebhookEndpointState, 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(
+          :created_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("created_at"), required: true}}
+        )
+        # The keys a receiver may see in NR-Webhook-Key-Id, oldest first. The last one signs every new delivery; an older one keeps verifying until its expires_at.
+        field(
+          :signing_keys,
+          Crystalline::Array.new(Models::Shared::SigningKey),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("signing_keys"), required: true}}
+        )
+        # When the endpoint last echoed a challenge. Absent until it first does.
+        field(
+          :verified_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("verified_at")}}
+        )
+
+        sig {
+          params(
+            endpoint_id: ::String,
+            url: ::String,
+            state: Models::Shared::WebhookEndpointState,
+            response_mode: Models::Shared::ResponseMode,
+            created_at: ::String,
+            signing_keys: T::Array[Models::Shared::SigningKey],
+            verified_at: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(endpoint_id:, url:, state:, response_mode:, created_at:, signing_keys:, verified_at: nil)
+          @endpoint_id = endpoint_id
+          @url = url
+          @state = state
+          @response_mode = response_mode
+          @created_at = created_at
+          @signing_keys = signing_keys
+          @verified_at = verified_at
+        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 @url == other.url
+          return false unless @state == other.state
+          return false unless @response_mode == other.response_mode
+          return false unless @created_at == other.created_at
+          return false unless @signing_keys == other.signing_keys
+          return false unless @verified_at == other.verified_at
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::WebhookEndpoint
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::WebhookEndpoint
+  def endpoint_id
+  end
+
+  def endpoint_id=(str_)
+  end
+
+  def url
+  end
+
+  def url=(str_)
+  end
+
+  def state
+  end
+
+  def state=(str_)
+  end
+
+  def response_mode
+  end
+
+  def response_mode=(str_)
+  end
+
+  def created_at
+  end
+
+  def created_at=(str_)
+  end
+
+  def signing_keys
+  end
+
+  def signing_keys=(str_)
+  end
+
+  def verified_at
+  end
+
+  def verified_at=(str_)
+  end
+end

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

@@ -0,0 +1,41 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # The 201 answer of POST /v1/webhooks: the new endpoint, unverified, and its first signing secret, shown once. Store the secret where the receiver reads it, then send endpoint.verification with POST /v1/webhooks/{endpoint_id}/test.
+      class WebhookEndpointCreated
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # One of the tenant's registered webhook endpoints. Signing secrets are not part of it: a secret is shown once, when it is issued (POST /v1/webhooks and POST /v1/webhooks/{endpoint_id}/rotate).
+        field(
+          :endpoint,
+          Models::Shared::WebhookEndpoint,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("endpoint"), required: true}}
+        )
+        # A newly issued signing key with its secret, shown only in this answer. A receiver verifies NR-Webhook-Signature with the secret's UTF-8 bytes as the HMAC-SHA256 key.
+        field(
+          :signing_secret,
+          Models::Shared::SigningSecret,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("signing_secret"), required: true}}
+        )
+
+        sig { params(endpoint: Models::Shared::WebhookEndpoint, signing_secret: Models::Shared::SigningSecret).void }
+        def initialize(endpoint:, signing_secret:)
+          @endpoint = endpoint
+          @signing_secret = signing_secret
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @endpoint == other.endpoint
+          return false unless @signing_secret == other.signing_secret
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # GET /v1/webhooks answer: every endpoint of the calling tenant, in every state, ordered by endpoint_id. A tenant holds at most 5, so there is no page.
+      class WebhookEndpointList
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :items,
+          Crystalline::Array.new(Models::Shared::WebhookEndpoint),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("items"), required: true}}
+        )
+
+        sig { params(items: T::Array[Models::Shared::WebhookEndpoint]).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/webhookendpointlist.rbi

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

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

@@ -0,0 +1,42 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # POST /v1/webhooks body. The tenant is the API key that signs the request, so it is not a body member. The URL must be https on port 443 or 8443 with a DNS name, not an IP literal, and every address the name resolves to must be public.
+      class WebhookEndpointRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Where deliveries are sent: an https URL on port 443 or 8443, with a DNS host and no userinfo or fragment, at most 2048 characters.
+        field :url, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("url"), required: true}}
+        # 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,
+          Crystalline::Nilable.new(Models::Shared::ResponseMode),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("response_mode"),
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::ResponseMode, true)
+            }
+          }
+        )
+
+        sig { params(url: ::String, response_mode: T.nilable(Models::Shared::ResponseMode)).void }
+        def initialize(url:, response_mode: nil)
+          @url = url
+          @response_mode = response_mode
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @url == other.url
+          return false unless @response_mode == other.response_mode
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # WebhookEndpointState - unverified until the endpoint echoes an endpoint.verification challenge (send one with POST /v1/webhooks/{endpoint_id}/test); verified receives assessment.updated events; disabled after 72 hours of continuous delivery failure, and verified again by the same challenge.
+      class WebhookEndpointState
+        include ::Crystalline::Enum
+        enums do
+          UNVERIFIED = new("unverified")
+          VERIFIED = new("verified")
+          DISABLED = new("disabled")
+        end
+
+        open!
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,65 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # The 201 answer of POST /v1/webhooks/{endpoint_id}/rotate: the new signing secret, shown once, which signs every delivery from now on, and when the key it replaced stops verifying. Until then a receiver accepts both.
+      class WebhookKeyRotation
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Opaque id of the endpoint registration.
+        field(
+          :endpoint_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("endpoint_id"), required: true}}
+        )
+        # A newly issued signing key with its secret, shown only in this answer. A receiver verifies NR-Webhook-Signature with the secret's UTF-8 bytes as the HMAC-SHA256 key.
+        field(
+          :signing_secret,
+          Models::Shared::SigningSecret,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("signing_secret"), required: true}}
+        )
+        # The key that signed until this rotation.
+        field(
+          :previous_key_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("previous_key_id"), required: true}}
+        )
+        # When the previous key stops verifying: 7 days after the rotation.
+        field(
+          :previous_key_expires_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("previous_key_expires_at"), required: true}}
+        )
+
+        sig {
+          params(
+            endpoint_id: ::String,
+            signing_secret: Models::Shared::SigningSecret,
+            previous_key_id: ::String,
+            previous_key_expires_at: ::String
+          )
+            .void
+        }
+        def initialize(endpoint_id:, signing_secret:, previous_key_id:, previous_key_expires_at:)
+          @endpoint_id = endpoint_id
+          @signing_secret = signing_secret
+          @previous_key_id = previous_key_id
+          @previous_key_expires_at = previous_key_expires_at
+        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 @signing_secret == other.signing_secret
+          return false unless @previous_key_id == other.previous_key_id
+          return false unless @previous_key_expires_at == other.previous_key_expires_at
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::WebhookKeyRotation
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::WebhookKeyRotation
+  def endpoint_id
+  end
+
+  def endpoint_id=(str_)
+  end
+
+  def signing_secret
+  end
+
+  def signing_secret=(str_)
+  end
+
+  def previous_key_id
+  end
+
+  def previous_key_id=(str_)
+  end
+
+  def previous_key_expires_at
+  end
+
+  def previous_key_expires_at=(str_)
+  end
+end

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

@@ -0,0 +1,23 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # POST /v1/webhooks/{endpoint_id}/rotate body: an empty object. The old key keeps verifying for 7 days.
+      class WebhookKeyRotationRequest
+        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/webhookkeyrotationrequest.rbi

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

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

@@ -0,0 +1,86 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # The 202 answer of POST /v1/webhooks/{endpoint_id}/test: the event that was sent or queued.
+      class WebhookTest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The event id the receiver sees as NR-Webhook-Id and as the body's id.
+        field(
+          :delivery_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("delivery_id"), required: true}}
+        )
+        # Opaque id of the endpoint registration.
+        field(
+          :endpoint_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("endpoint_id"), required: true}}
+        )
+        # endpoint.verification sends a fresh challenge now, in this call, and the endpoint is verified if it echoes it. assessment.updated queues an event whose data is a fixed example assessment, with test true, delivered and retried like any other; the endpoint must be verified.
+        field(
+          :event,
+          Models::Shared::WebhookTestRequestEvent,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("event"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::WebhookTestRequestEvent, false)
+            }
+          }
+        )
+        # unverified until the endpoint echoes an endpoint.verification challenge (send one with POST /v1/webhooks/{endpoint_id}/test); verified receives assessment.updated events; disabled after 72 hours of continuous delivery failure, and verified again by the same challenge.
+        field(
+          :state,
+          Models::Shared::WebhookEndpointState,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("state"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::WebhookEndpointState, false)
+            }
+          }
+        )
+        # endpoint.verification only: true when the endpoint echoed the challenge within 5 seconds. A false answer leaves the endpoint's state as it was.
+        field(
+          :verified,
+          Crystalline::Nilable.new(Crystalline::Boolean.new),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("verified")}}
+        )
+
+        sig {
+          params(
+            delivery_id: ::String,
+            endpoint_id: ::String,
+            event: Models::Shared::WebhookTestRequestEvent,
+            state: Models::Shared::WebhookEndpointState,
+            verified: T.nilable(T::Boolean)
+          )
+            .void
+        }
+        def initialize(delivery_id:, endpoint_id:, event:, state:, verified: nil)
+          @delivery_id = delivery_id
+          @endpoint_id = endpoint_id
+          @event = event
+          @state = state
+          @verified = verified
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @delivery_id == other.delivery_id
+          return false unless @endpoint_id == other.endpoint_id
+          return false unless @event == other.event
+          return false unless @state == other.state
+          return false unless @verified == other.verified
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::WebhookTest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::WebhookTest
+  def delivery_id
+  end
+
+  def delivery_id=(str_)
+  end
+
+  def endpoint_id
+  end
+
+  def endpoint_id=(str_)
+  end
+
+  def event
+  end
+
+  def event=(str_)
+  end
+
+  def state
+  end
+
+  def state=(str_)
+  end
+
+  def verified
+  end
+
+  def verified=(str_)
+  end
+end

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

@@ -0,0 +1,39 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # POST /v1/webhooks/{endpoint_id}/test body: which event to send.
+      class WebhookTestRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # endpoint.verification sends a fresh challenge now, in this call, and the endpoint is verified if it echoes it. assessment.updated queues an event whose data is a fixed example assessment, with test true, delivered and retried like any other; the endpoint must be verified.
+        field(
+          :event,
+          Models::Shared::WebhookTestRequestEvent,
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("event"),
+              required: true,
+              'decoder': ::NoResponse::Utils.open_enum_from_string(Models::Shared::WebhookTestRequestEvent, false)
+            }
+          }
+        )
+
+        sig { params(event: Models::Shared::WebhookTestRequestEvent).void }
+        def initialize(event:)
+          @event = event
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @event == other.event
+          true
+        end
+      end
+    end
+  end
+end

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

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