noresponse 2.0.17

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

@@ -0,0 +1,70 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # POST /v1/assessments/query body. account_id travels in the body rather than the URL path so a provider value that turns out to hold personal data is not written to access logs, proxies or browser history. Read-only: no Idempotency-Key. An account with no unexpired assessments answers 200 with empty items.
+      class AssessmentQuery
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Your own opaque identifier for the account being checked, scoped to your tenant. Use an id you mint, with no direct identifier (email, phone, name or national id) in it. '|' is accepted so an Auth0 user id such as 'auth0|64abc' passes unchanged; '@', '+', '$' and whitespace are refused, as is a JWT; a hex digest such as a SHA-256 is allowed. It travels only in request bodies. An assessment requested by a provider hook at pre_registration, which has no account yet, carries the server-issued account_id pre: followed by its assessment_id.
+        field(
+          :account_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("account_id"), required: true}}
+        )
+        # next_cursor from the previous page, unchanged. Opaque, MAC'd and bound to the tenant and account_id.
+        field(
+          :cursor,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("cursor")}}
+        )
+        # 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.enum_from_string(Models::Shared::ResponseMode, true)
+            }
+          }
+        )
+
+        field(
+          :limit,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("limit")}}
+        )
+
+        sig {
+          params(
+            account_id: ::String,
+            cursor: T.nilable(::String),
+            response_mode: T.nilable(Models::Shared::ResponseMode),
+            limit: T.nilable(::Integer)
+          )
+            .void
+        }
+        def initialize(account_id:, cursor: nil, response_mode: nil, limit: 20)
+          @account_id = account_id
+          @cursor = cursor
+          @response_mode = response_mode
+          @limit = limit
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @account_id == other.account_id
+          return false unless @cursor == other.cursor
+          return false unless @response_mode == other.response_mode
+          return false unless @limit == other.limit
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AssessmentQuery
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AssessmentQuery
+  def account_id
+  end
+
+  def account_id=(str_)
+  end
+
+  def cursor
+  end
+
+  def cursor=(str_)
+  end
+
+  def response_mode
+  end
+
+  def response_mode=(str_)
+  end
+
+  def limit
+  end
+
+  def limit=(str_)
+  end
+end

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

@@ -0,0 +1,125 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # POST /v1/assessments body. At least one of email, username or phone is required; name and ip only refine an assessment. No field carries a password, hash, token or breach value, and unknown members are refused. The email local part is kept as received and only the domain is lower-cased; the username is compared case-insensitively; the phone is strict E.164 and is assessed asynchronously. The whole body is capped at 32768 bytes. client_context holds bounded hints from the signup client; auth_context holds normalised claims from a session your backend has verified. Raw tokens are refused.
+      class AssessmentRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Your own opaque identifier for the account being checked, scoped to your tenant. Use an id you mint, with no direct identifier (email, phone, name or national id) in it. '|' is accepted so an Auth0 user id such as 'auth0|64abc' passes unchanged; '@', '+', '$' and whitespace are refused, as is a JWT; a hex digest such as a SHA-256 is allowed. It travels only in request bodies. An assessment requested by a provider hook at pre_registration, which has no account yet, carries the server-issued account_id pre: followed by its assessment_id.
+        field(
+          :account_id,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("account_id"), required: true}}
+        )
+        # At least one of email, username or phone. name and ip refine the match and travel beside a lookup identifier; a body with only name or ip is refused with 400.
+        field(
+          :identifiers,
+          Models::Shared::AssessmentRequestIdentifiers,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("identifiers"), required: true}}
+        )
+
+        field(
+          :policy_context,
+          Crystalline::Nilable.new(Models::Shared::AssessmentRequestPolicyContext),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("policy_context")}}
+        )
+        # An optional provider correlation id, echoed back. It is not an idempotency key. Refuses an exact-shape JWT or a bare 40, 64 or 128 character hex digest; a UUID is accepted.
+        field(
+          :request_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("request_id")}}
+        )
+        # Optional tighter budget, 50 to 500 ms, measured from the moment the request reaches NoResponse. Absent means the 500 ms ceiling; a value above it is refused with 400 rather than clamped.
+        field(
+          :deadline_ms,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("deadline_ms")}}
+        )
+        # 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.enum_from_string(Models::Shared::ResponseMode, true)
+            }
+          }
+        )
+        # Optional context observed by your signup client. The server parses these hints into coarse features, leaves raw user_agent and opaque ids out of every answer, and weighs a mismatch with the other evidence.
+        field(
+          :client_context,
+          Crystalline::Nilable.new(Models::Shared::AssessmentRequestClientContext),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("client_context")}}
+        )
+        # Normalised claims from a session your backend has already verified with WorkOS, Clerk, Auth0 or any OIDC provider. Pass the output of the SDK's auth adapters, not a raw token.
+        field(
+          :auth_context,
+          Crystalline::Nilable.new(Models::Shared::AuthContext),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("auth_context")}}
+        )
+        # Optional. When the signup gate issues an API key to the new account, send SHA-256 of that key, so later usage of the key, or a leaked copy, ties back to this assessment. Each SDK has a helper that computes it. Send only the hash: customer keys are high-entropy, so the hash reveals nothing about them. The assessment stores it, and no response, webhook or log carries it.
+        field(
+          :issued_credential,
+          Crystalline::Nilable.new(Models::Shared::AssessmentRequestIssuedCredential),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("issued_credential")}}
+        )
+
+        sig {
+          params(
+            account_id: ::String,
+            identifiers: Models::Shared::AssessmentRequestIdentifiers,
+            policy_context: T.nilable(Models::Shared::AssessmentRequestPolicyContext),
+            request_id: T.nilable(::String),
+            deadline_ms: T.nilable(::Integer),
+            response_mode: T.nilable(Models::Shared::ResponseMode),
+            client_context: T.nilable(Models::Shared::AssessmentRequestClientContext),
+            auth_context: T.nilable(Models::Shared::AuthContext),
+            issued_credential: T.nilable(Models::Shared::AssessmentRequestIssuedCredential)
+          )
+            .void
+        }
+        def initialize(
+          account_id:,
+          identifiers:,
+          policy_context: nil,
+          request_id: nil,
+          deadline_ms: nil,
+          response_mode: nil,
+          client_context: nil,
+          auth_context: nil,
+          issued_credential: nil
+        )
+          @account_id = account_id
+          @identifiers = identifiers
+          @policy_context = policy_context
+          @request_id = request_id
+          @deadline_ms = deadline_ms
+          @response_mode = response_mode
+          @client_context = client_context
+          @auth_context = auth_context
+          @issued_credential = issued_credential
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @account_id == other.account_id
+          return false unless @identifiers == other.identifiers
+          return false unless @policy_context == other.policy_context
+          return false unless @request_id == other.request_id
+          return false unless @deadline_ms == other.deadline_ms
+          return false unless @response_mode == other.response_mode
+          return false unless @client_context == other.client_context
+          return false unless @auth_context == other.auth_context
+          return false unless @issued_credential == other.issued_credential
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AssessmentRequest
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AssessmentRequest
+  def account_id
+  end
+
+  def account_id=(str_)
+  end
+
+  def identifiers
+  end
+
+  def identifiers=(str_)
+  end
+
+  def policy_context
+  end
+
+  def policy_context=(str_)
+  end
+
+  def request_id
+  end
+
+  def request_id=(str_)
+  end
+
+  def deadline_ms
+  end
+
+  def deadline_ms=(str_)
+  end
+
+  def response_mode
+  end
+
+  def response_mode=(str_)
+  end
+
+  def client_context
+  end
+
+  def client_context=(str_)
+  end
+
+  def auth_context
+  end
+
+  def auth_context=(str_)
+  end
+
+  def issued_credential
+  end
+
+  def issued_credential=(str_)
+  end
+end

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

@@ -0,0 +1,125 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Optional context observed by your signup client. The server parses these hints into coarse features, leaves raw user_agent and opaque ids out of every answer, and weighs a mismatch with the other evidence.
+      class AssessmentRequestClientContext
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # IANA time-zone name such as Europe/London or America/Los_Angeles. Fixed numeric offsets are not accepted.
+        field(
+          :timezone,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("timezone")}}
+        )
+        # BCP 47 locale, for example en-AU. Treat as a presentation hint, not a nationality signal.
+        field(
+          :locale,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("locale")}}
+        )
+        # Client platform. Closed vocabulary keeps integrations stable.
+        field(
+          :platform,
+          Crystalline::Nilable.new(Models::Shared::Platform),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("platform"),
+              'decoder': ::NoResponse::Utils.enum_from_string(Models::Shared::Platform, true)
+            }
+          }
+        )
+        # Customer application version, without build metadata that contains secrets.
+        field(
+          :app_version,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("app_version")}}
+        )
+        # The raw User-Agent header of the signup request, at most 512 characters. It is parsed into coarse features and left out of every answer.
+        field(
+          :user_agent,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("user_agent")}}
+        )
+        # Tenant-scoped opaque identifier your application mints and rotates when the account or device changes. Send an id of your own, not a hardware fingerprint.
+        field(
+          :device_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("device_id")}}
+        )
+        # Opaque signup session identifier. It is used for tenant-scoped velocity and replay checks only.
+        field(
+          :session_id,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("session_id")}}
+        )
+        # Elapsed time from form start to submit. Values below three seconds are a weak automation hint, weighed with the other evidence.
+        field(
+          :form_duration_ms,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("form_duration_ms")}}
+        )
+        # RFC 3339 timestamp observed by the client. Server ingress time remains authoritative; a large clock skew is only a low-confidence feature.
+        field(
+          :client_observed_at,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("client_observed_at")}}
+        )
+
+        sig {
+          params(
+            timezone: T.nilable(::String),
+            locale: T.nilable(::String),
+            platform: T.nilable(Models::Shared::Platform),
+            app_version: T.nilable(::String),
+            user_agent: T.nilable(::String),
+            device_id: T.nilable(::String),
+            session_id: T.nilable(::String),
+            form_duration_ms: T.nilable(::Integer),
+            client_observed_at: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(
+          timezone: nil,
+          locale: nil,
+          platform: nil,
+          app_version: nil,
+          user_agent: nil,
+          device_id: nil,
+          session_id: nil,
+          form_duration_ms: nil,
+          client_observed_at: nil
+        )
+          @timezone = timezone
+          @locale = locale
+          @platform = platform
+          @app_version = app_version
+          @user_agent = user_agent
+          @device_id = device_id
+          @session_id = session_id
+          @form_duration_ms = form_duration_ms
+          @client_observed_at = client_observed_at
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @timezone == other.timezone
+          return false unless @locale == other.locale
+          return false unless @platform == other.platform
+          return false unless @app_version == other.app_version
+          return false unless @user_agent == other.user_agent
+          return false unless @device_id == other.device_id
+          return false unless @session_id == other.session_id
+          return false unless @form_duration_ms == other.form_duration_ms
+          return false unless @client_observed_at == other.client_observed_at
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AssessmentRequestClientContext
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AssessmentRequestClientContext
+  def timezone
+  end
+
+  def timezone=(str_)
+  end
+
+  def locale
+  end
+
+  def locale=(str_)
+  end
+
+  def platform
+  end
+
+  def platform=(str_)
+  end
+
+  def app_version
+  end
+
+  def app_version=(str_)
+  end
+
+  def user_agent
+  end
+
+  def user_agent=(str_)
+  end
+
+  def device_id
+  end
+
+  def device_id=(str_)
+  end
+
+  def session_id
+  end
+
+  def session_id=(str_)
+  end
+
+  def form_duration_ms
+  end
+
+  def form_duration_ms=(str_)
+  end
+
+  def client_observed_at
+  end
+
+  def client_observed_at=(str_)
+  end
+end

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

@@ -0,0 +1,74 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # At least one of email, username or phone. name and ip refine the match and travel beside a lookup identifier; a body with only name or ip is refused with 400.
+      class AssessmentRequestIdentifiers
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # One address: a 1 to 64 character local part without whitespace, angle brackets, control or invisible characters, '@', and a domain with a letter TLD. Send an internationalised domain in punycode. Nothing is trimmed. The local part keeps its case and the domain is lower-cased; no alias rewriting ('+tag', dots or provider heuristics) is applied.
+        field(
+          :email,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("email")}}
+        )
+        # The handle the account is signing up with: 1 to 64 characters, no whitespace, control or invisible characters, and not a credential hash or token. Echoed as received; compared case-insensitively.
+        field(
+          :username,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("username")}}
+        )
+        # Strict E.164: '+', then 8 to 15 digits, the first not 0, with no separators. Phone evidence is gathered asynchronously, so a phone-only request answers 202 pending and the phone is listed in incomplete_sources on the synchronous answer.
+        field(
+          :phone,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("phone")}}
+        )
+        # The full name as the user typed it, 1 to 128 characters with no control or invisible characters. It is used only to match names in the evidence.
+        field(
+          :name,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("name")}}
+        )
+        # The signup's client IP address: an IPv4 dotted quad without leading zeros, or an IPv6 address in its RFC 5952 text form (lower case, no leading zeros, the longest zero run compressed). Send an IPv4 client as a dotted quad, not IPv4-mapped. No zone, port or prefix. The server refuses a non-canonical IPv6 spelling, and every private, loopback, link-local, multicast, documentation or otherwise reserved address (the IANA special-purpose registries), with 400: only a public address says anything about a signup.
+        field(
+          :ip,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("ip")}}
+        )
+
+        sig {
+          params(
+            email: T.nilable(::String),
+            username: T.nilable(::String),
+            phone: T.nilable(::String),
+            name: T.nilable(::String),
+            ip: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(email: nil, username: nil, phone: nil, name: nil, ip: nil)
+          @email = email
+          @username = username
+          @phone = phone
+          @name = name
+          @ip = ip
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @email == other.email
+          return false unless @username == other.username
+          return false unless @phone == other.phone
+          return false unless @name == other.name
+          return false unless @ip == other.ip
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AssessmentRequestIdentifiers
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AssessmentRequestIdentifiers
+  def email
+  end
+
+  def email=(str_)
+  end
+
+  def username
+  end
+
+  def username=(str_)
+  end
+
+  def phone
+  end
+
+  def phone=(str_)
+  end
+
+  def name
+  end
+
+  def name=(str_)
+  end
+
+  def ip
+  end
+
+  def ip=(str_)
+  end
+end

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

@@ -0,0 +1,33 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Optional. When the signup gate issues an API key to the new account, send SHA-256 of that key, so later usage of the key, or a leaked copy, ties back to this assessment. Each SDK has a helper that computes it. Send only the hash: customer keys are high-entropy, so the hash reveals nothing about them. The assessment stores it, and no response, webhook or log carries it.
+      class AssessmentRequestIssuedCredential
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # SHA-256 of the issued key's UTF-8 bytes, as 64 lower-case hex characters.
+        field(
+          :sha256,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("sha256"), required: true}}
+        )
+
+        sig { params(sha256: ::String).void }
+        def initialize(sha256:)
+          @sha256 = sha256
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @sha256 == other.sha256
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,46 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class AssessmentRequestPolicyContext
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # The provider flow the assessment gates. Absent means signup.
+        field(
+          :flow,
+          Crystalline::Nilable.new(Models::Shared::Flow),
+          {
+            'format_json': {
+              'letter_case': ::NoResponse::Utils.field_name("flow"),
+              'decoder': ::NoResponse::Utils.enum_from_string(Models::Shared::Flow, true)
+            }
+          }
+        )
+        # ISO 3166-1 alpha-2 region of the signup, as the provider determines it.
+        field(
+          :region,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("region")}}
+        )
+
+        sig { params(flow: T.nilable(Models::Shared::Flow), region: T.nilable(::String)).void }
+        def initialize(flow: nil, region: nil)
+          @flow = flow
+          @region = region
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @flow == other.flow
+          return false unless @region == other.region
+          true
+        end
+      end
+    end
+  end
+end