noresponse 9.4.0 → 9.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a7a4007667832081cb401d07ff168481e8b0cdc4d9a04f5f0073e0b90091055
-  data.tar.gz: 395f33f137064474997f8ac4e317f8cc28eeb7985ba59cf4f9a131d6f5bb69d2
+  metadata.gz: 4841d5bf61440a9ed5297a66f4e7d7fb820bed09831a82e47f82e64667b392ed
+  data.tar.gz: 5066f04bd959fbc943c8db239e9f514d961a66a62c2482df743c37b1b00b5024
 SHA512:
-  metadata.gz: ff44abdfd0eb5e23ec94da15450a264b51ce6cb11a1bd0be5e66fa295fd43594a1d0e3daf2e270cd2bb55970f90bba44a4996d25acdef6b15fde303327412c90
-  data.tar.gz: 450e4088b4029c7f3d33a2be2c3d6e9e184bd540673f4d1d3f740ac59834b0ac77fa4c01a0dbec407b20518456c72bfcc07a1a1da8e3e1dd58c7caee25f00a5f
+  metadata.gz: a8c8a8067ffce9661db26303506a401a66c4ac29aa3762e22fd1cb2b2c19b9668e584efc4213616369b211c19cc36a3c42a211a6e00c171115234db3c0692b82
+  data.tar.gz: e18056623cc7625e67347c7fe43b15751fa16d4e978f5acfa9a3e2718672b045771b28fada6c5cbf16dcc66eee7446de480927f17f75a049ccf19f99b2acd52a

data/lib/no_response/accounts.rb

@@ -4266,5 +4266,298 @@ module NoResponse
 
       end
     end
+
+    sig {
+      params(
+        request: Models::Shared::AccountDirectorySearchRequest,
+        retries: T.nilable(Utils::RetryConfig),
+        timeout_ms: T.nilable(Integer),
+        http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])
+      )
+        .returns(Models::Operations::SearchAccountsResponse)
+    }
+    def search(request:, retries: nil, timeout_ms: nil, http_headers: nil)
+      # search - Search distinct accounts by email or account ID
+      # Search distinct accounts observed in retained assessments in this environment. Match an exact account_id or canonical email; an email matches any retained assessment belonging to the account. The response contains one row per account with its newest retained assessment, current decision when available, per-account assessment count, and total distinct-account count. Send next_cursor with unchanged filters to continue. Totals are exact below 10000 and capped at 10000. Results are live across pages. Requires history access and identifier access for email. Read-only and safe to retry.
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = "#{base_url}/v1/accounts/search"
+      headers = {}
+      headers = T.cast(headers, T::Hash[String, String])
+      req_content_type, data, form = Utils.serialize_request_body(request, false, false, :request, :json)
+      headers["content-type"] = req_content_type
+      raise StandardError, "request body is required" if data.nil? && form.nil?
+
+      if form && !form.empty?
+        body = Utils.encode_form(form)
+      elsif Utils.match_content_type(req_content_type, "application/x-www-form-urlencoded")
+        body = URI.encode_www_form(T.cast(data, T::Hash[Symbol, Object]))
+      else
+        body = data
+      end
+
+      headers["Accept"] = "application/json"
+      headers["user-agent"] = @sdk_configuration.user_agent
+      retries ||= @sdk_configuration.retry_config
+      retries ||= Utils::RetryConfig.new(
+        backoff: Utils::BackoffStrategy.new(
+          exponent: 2.0,
+          initial_interval: 500,
+          max_elapsed_time: 30_000,
+          max_interval: 8000
+        ),
+        retry_connection_errors: true,
+        strategy: "backoff"
+      )
+      retry_options = retries.to_faraday_retry_options(initial_time: Time.now)
+      retry_options[:retry_statuses] = [408, 429, 500, 501, 502, 503, 504, 505]
+
+      security = @sdk_configuration.security_source&.call
+
+      timeout = (timeout_ms.to_f / 1000) unless timeout_ms.nil?
+      timeout ||= @sdk_configuration.timeout
+
+      connection = @sdk_configuration.client.dup
+      connection.use(Utils::RetryMiddleware, retry_options)
+
+      hook_ctx = SDKHooks::HookContext.new(
+        config: @sdk_configuration,
+        base_url: base_url,
+        oauth2_scopes: nil,
+        operation_id: "searchAccounts",
+        security_source: @sdk_configuration.security_source
+      )
+
+      error = T.let(nil, T.nilable(StandardError))
+      http_response = T.let(nil, T.nilable(Faraday::Response))
+
+      begin
+        http_response = T.must(connection).post(url) do |req|
+          req.body = body
+          req.headers.merge!(headers)
+          req.options.timeout = timeout unless timeout.nil?
+          Utils.configure_request_security(req, security)
+          http_headers&.each do |key, value|
+            req.headers[key.to_s] = value
+          end
+
+          @sdk_configuration.hooks.before_request(
+            hook_ctx: SDKHooks::BeforeRequestHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            request: req
+          )
+        end
+
+      rescue StandardError => e
+        error = e
+      ensure
+        if http_response.nil? || Utils.error_status?(http_response.status)
+          http_response = @sdk_configuration.hooks.after_error(
+            error: error,
+            hook_ctx: SDKHooks::AfterErrorHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        else
+          http_response = @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+        end
+
+        if http_response.nil?
+          raise error if !error.nil?
+          raise "no response"
+        end
+      end
+
+      content_type = http_response.headers.fetch("Content-Type", "application/octet-stream")
+      if Utils.match_status_code(http_response.status, ["200"])
+        if Utils.match_content_type(content_type, "application/json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Shared::AccountDirectoryPage)
+          result = obj
+          response = Models::Operations::SearchAccountsResponse.new(
+            result: result,
+            headers: http_response.headers
+          )
+
+          return response
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["400"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::BadRequestError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["401"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::AuthenticationError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["403"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::PermissionDeniedError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["404"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::NotFoundError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["409"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::ConflictError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["429"])
+        if Utils.match_content_type(content_type, "application/problem+json")
+          @sdk_configuration.hooks.after_success(
+            hook_ctx: SDKHooks::AfterSuccessHookContext.new(
+              hook_ctx: hook_ctx
+            ),
+            response: http_response
+          )
+          response_data = http_response.env.response_body
+          obj = Crystalline.unmarshal_json(JSON.parse(response_data), Models::Errors::RateLimitError)
+          raise obj
+        else
+          raise(
+            ::NoResponse::Models::Errors::APIStatusError.new(
+              status_code: http_response.status,
+              body: http_response.env.response_body,
+              raw_response: http_response
+            ),
+            "Unknown content type received"
+          )
+        end
+      elsif Utils.match_status_code(http_response.status, ["4XX"])
+        raise(
+          ::NoResponse::Models::Errors::APIStatusError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "API error occurred"
+        )
+      elsif Utils.match_status_code(http_response.status, ["5XX"])
+        raise(
+          ::NoResponse::Models::Errors::APIStatusError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "API error occurred"
+        )
+      else
+        raise(
+          ::NoResponse::Models::Errors::APIStatusError.new(
+            status_code: http_response.status,
+            body: http_response.env.response_body,
+            raw_response: http_response
+          ),
+          "Unknown status code received"
+        )
+
+      end
+    end
   end
 end

data/lib/no_response/models/operations/searchaccounts_response.rb

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class SearchAccountsResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :headers, Crystalline::Hash.new(Symbol, Crystalline::Array.new(::String))
+
+        field :result, Models::Shared::AccountDirectoryPage, {}
+
+        sig { params(headers: T::Hash[Symbol, T::Array[::String]], result: Models::Shared::AccountDirectoryPage).void }
+        def initialize(headers:, result:)
+          @headers = headers
+          @result = result
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @headers == other.headers
+          return false unless @result == other.result
+          true
+        end
+      end
+    end
+  end
+end

data/lib/no_response/models/operations/searchaccounts_response.rbi

@@ -0,0 +1,20 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Operations::SearchAccountsResponse
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Operations::SearchAccountsResponse
+  def headers
+  end
+
+  def headers=(str_)
+  end
+
+  def result
+  end
+
+  def result=(str_)
+  end
+end

data/lib/no_response/models/operations.rb

@@ -182,6 +182,7 @@ module NoResponse
       autoload :RotateIntegrationSecretResponse, "no_response/models/operations/rotateintegrationsecret_response.rb"
       autoload :RotateWebhookSigningKeyRequest, "no_response/models/operations/rotatewebhooksigningkey_request.rb"
       autoload :RotateWebhookSigningKeyResponse, "no_response/models/operations/rotatewebhooksigningkey_response.rb"
+      autoload :SearchAccountsResponse, "no_response/models/operations/searchaccounts_response.rb"
       autoload :SearchAssessmentsResponse, "no_response/models/operations/searchassessments_response.rb"
       autoload :SendWebhookTestEventRequest, "no_response/models/operations/sendwebhooktestevent_request.rb"
       autoload :SendWebhookTestEventResponse, "no_response/models/operations/sendwebhooktestevent_response.rb"

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

@@ -0,0 +1,77 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Accounts observed in retained assessments, newest seen first, with each account once per page and across pages. Counts and keyset pagination are computed over distinct accounts in one database snapshot per page. Live data can change between pages.
+      class AccountDirectoryPage
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :items,
+          Crystalline::Array.new(Models::Shared::AccountDirectoryPageItem),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("items"), required: true}}
+        )
+        # Distinct accounts matching the filters, exact below 10000 and capped at 10000.
+        field(
+          :total,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("total"), required: true}}
+        )
+        # True when at least 10000 accounts match.
+        field(
+          :total_capped,
+          Crystalline::Boolean.new,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("total_capped"), required: true}}
+        )
+        # Version of the body shape.
+        field(
+          :schema_version,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("schema_version"), required: true}}
+        )
+        # Opaque, expiring cursor bound to this environment, operation and every filter. Keep the filters unchanged.
+        field(
+          :next_cursor,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("next_cursor")}}
+        )
+
+        sig {
+          params(
+            items: T::Array[Models::Shared::AccountDirectoryPageItem],
+            total: ::Integer,
+            total_capped: T::Boolean,
+            schema_version: ::String,
+            next_cursor: T.nilable(::String)
+          )
+            .void
+        }
+        def initialize(items:, total:, total_capped:, schema_version: "1", next_cursor: nil)
+          @items = items
+          @total = total
+          @total_capped = total_capped
+          unless schema_version == "1"
+            raise ArgumentError, "Invalid value for schema_version"
+          end
+
+          @schema_version = "1"
+          @next_cursor = next_cursor
+        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 @total == other.total
+          return false unless @total_capped == other.total_capped
+          return false unless @schema_version == other.schema_version
+          return false unless @next_cursor == other.next_cursor
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AccountDirectoryPage
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AccountDirectoryPage
+  def items
+  end
+
+  def items=(str_)
+  end
+
+  def total
+  end
+
+  def total=(str_)
+  end
+
+  def total_capped
+  end
+
+  def total_capped=(str_)
+  end
+
+  def schema_version
+  end
+
+  def schema_version=(str_)
+  end
+
+  def next_cursor
+  end
+
+  def next_cursor=(str_)
+  end
+end

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

@@ -0,0 +1,65 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+
+      class AccountDirectoryPageItem
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Your own opaque identifier for the account being checked, scoped to your workspace. 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 by the pattern, as is an exact-shape JWT; a hex digest such as a SHA-256 is allowed, because hashing an internal id is a common pseudonymous scheme. A value such as '07700900123' or 'jane.doe.gmail.com' cannot be told apart from an opaque id. It travels in bodies, and in a URL only as the path segment of GET /v1/accounts/{account_id} and its /assessments. 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}}
+        )
+        # Retrieve a retained assessment version with its original decision, policy, flow and depth. This response excludes the current account decision. Current retention and response-mode permissions still apply.
+        field(
+          :latest,
+          Models::Shared::AssessmentRevision,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("latest"), required: true}}
+        )
+        # Count of admitted retained assessments belonging to this account, not just the returned page.
+        field(
+          :assessments,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("assessments"), required: true}}
+        )
+        # Body of the 200 answer to GET /v1/accounts/{account_id}: the one current risk of one of the calling workspace's accounts. It is the risk of the account's latest assessment that has a decision (status complete or partial), by created_at and then assessment_id, scored exactly as GET /v1/assessments/{assessment_id} scores that assessment, plus the account's own reason shared_api_key when a key issued to the account was used from many IP addresses or countries (POST /v1/key_usage/batches). Its assessments are the account's history (GET /v1/accounts/{account_id}/assessments).
+        field(
+          :current,
+          Crystalline::Nilable.new(Models::Shared::Account),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("current")}}
+        )
+
+        sig {
+          params(
+            account_id: ::String,
+            latest: Models::Shared::AssessmentRevision,
+            assessments: ::Integer,
+            current: T.nilable(Models::Shared::Account)
+          )
+            .void
+        }
+        def initialize(account_id:, latest:, assessments:, current: nil)
+          @account_id = account_id
+          @latest = latest
+          @assessments = assessments
+          @current = current
+        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 @latest == other.latest
+          return false unless @assessments == other.assessments
+          return false unless @current == other.current
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::AccountDirectoryPageItem
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::AccountDirectoryPageItem
+  def account_id
+  end
+
+  def account_id=(str_)
+  end
+
+  def latest
+  end
+
+  def latest=(str_)
+  end
+
+  def assessments
+  end
+
+  def assessments=(str_)
+  end
+
+  def current
+  end
+
+  def current=(str_)
+  end
+end

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

@@ -0,0 +1,65 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # Bounded distinct-account search for a single authenticated workspace/environment. Email matches any retained admitted assessment of an account, using assessment search's canonical mailbox rules. No assessment history download is required.
+      class AccountDirectorySearchRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Your own opaque identifier for the account being checked, scoped to your workspace. 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 by the pattern, as is an exact-shape JWT; a hex digest such as a SHA-256 is allowed, because hashing an internal id is a common pseudonymous scheme. A value such as '07700900123' or 'jane.doe.gmail.com' cannot be told apart from an opaque id. It travels in bodies, and in a URL only as the path segment of GET /v1/accounts/{account_id} and its /assessments. 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,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("account_id")}}
+        )
+        # Assessments of every account that one of its retained admitted assessments sent this mailbox as identifiers.email, matched as lists match an email entry: case-insensitive, a +tag removed and, at gmail.com and googlemail.com, the dots of the local part ignored. Only assessments stored since email list matching began carry the mailbox. An address that is not a valid mailbox is refused with 400.
+        field(
+          :email,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("email")}}
+        )
+        # Opaque, expiring cursor bound to this environment, operation and every filter. Keep the filters unchanged.
+        field(
+          :cursor,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("cursor")}}
+        )
+
+        field(
+          :limit,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("limit")}}
+        )
+
+        sig {
+          params(
+            account_id: T.nilable(::String),
+            email: T.nilable(::String),
+            cursor: T.nilable(::String),
+            limit: T.nilable(::Integer)
+          )
+            .void
+        }
+        def initialize(account_id: nil, email: nil, cursor: nil, limit: 25)
+          @account_id = account_id
+          @email = email
+          @cursor = cursor
+          @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 @email == other.email
+          return false unless @cursor == other.cursor
+          return false unless @limit == other.limit
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -11,7 +11,7 @@ module NoResponse
 
         # This assessment's id, equal to detail.assessment_id.
         field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
-        # complete: final; nothing is still running. A lane that failed or missed its 10 s deadline stays listed in incomplete_sources, and confidence is lower. partial: a recommendation exists and at least one lane is still running or did not settle (see incomplete_sources). pending: nothing usable before the deadline; no recommendation yet, poll or wait for the webhook.
+        # Processing state, separate from evidence coverage. complete: final; nothing is still running, but unsupported, failed or unanswered lanes remain in incomplete_sources. partial: a recommendation exists and evidence is incomplete; assessment_url identifies continuing work when present. pending: no recommendation yet; poll or wait for the webhook. Finished processing does not mean all sources answered.
         field(
           :status,
           Models::Shared::Status,

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

@@ -48,7 +48,7 @@ module NoResponse
             }
           }
         )
-        # complete: final; nothing is still running. A lane that failed or missed its 10 s deadline stays listed in incomplete_sources, and confidence is lower. partial: a recommendation exists and at least one lane is still running or did not settle (see incomplete_sources). pending: nothing usable before the deadline; no recommendation yet, poll or wait for the webhook.
+        # Processing state, separate from evidence coverage. complete: final; nothing is still running, but unsupported, failed or unanswered lanes remain in incomplete_sources. partial: a recommendation exists and evidence is incomplete; assessment_url identifies continuing work when present. pending: no recommendation yet; poll or wait for the webhook. Finished processing does not mean all sources answered.
         field(
           :status,
           Crystalline::Nilable.new(Models::Shared::Status),

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

@@ -21,7 +21,7 @@ module NoResponse
           ::String,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("account_id"), required: true}}
         )
-        # complete: final; nothing is still running. A lane that failed or missed its 10 s deadline stays listed in incomplete_sources, and confidence is lower. partial: a recommendation exists and at least one lane is still running or did not settle (see incomplete_sources). pending: nothing usable before the deadline; no recommendation yet, poll or wait for the webhook.
+        # Processing state, separate from evidence coverage. complete: final; nothing is still running, but unsupported, failed or unanswered lanes remain in incomplete_sources. partial: a recommendation exists and evidence is incomplete; assessment_url identifies continuing work when present. pending: no recommendation yet; poll or wait for the webhook. Finished processing does not mean all sources answered.
         field(
           :status,
           Models::Shared::Status,
@@ -33,7 +33,7 @@ module NoResponse
             }
           }
         )
-        # Ordinal confidence in the recommendation under the current policy: low, medium, high or unavailable.
+        # Evidence coverage: how much of the planned source evidence gave a definite answer. This is not confidence that an identity is genuine, agreement between identifiers, a risk score or a probability. unavailable means no usable evidence answered; a terminal uncovered assessment can have this value and recommend review.
         field(
           :confidence,
           Models::Shared::Confidence,

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

@@ -11,7 +11,7 @@ module NoResponse
 
         # This assessment's id, equal to detail.assessment_id.
         field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
-        # complete: final; nothing is still running. A lane that failed or missed its 10 s deadline stays listed in incomplete_sources, and confidence is lower. partial: a recommendation exists and at least one lane is still running or did not settle (see incomplete_sources). pending: nothing usable before the deadline; no recommendation yet, poll or wait for the webhook.
+        # Processing state, separate from evidence coverage. complete: final; nothing is still running, but unsupported, failed or unanswered lanes remain in incomplete_sources. partial: a recommendation exists and evidence is incomplete; assessment_url identifies continuing work when present. pending: no recommendation yet; poll or wait for the webhook. Finished processing does not mean all sources answered.
         field(
           :status,
           Models::Shared::Status,

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

@@ -11,7 +11,7 @@ module NoResponse
 
         # This assessment's id, equal to detail.assessment_id.
         field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
-        # complete: final; nothing is still running. A lane that failed or missed its 10 s deadline stays listed in incomplete_sources, and confidence is lower. partial: a recommendation exists and at least one lane is still running or did not settle (see incomplete_sources). pending: nothing usable before the deadline; no recommendation yet, poll or wait for the webhook.
+        # Processing state, separate from evidence coverage. complete: final; nothing is still running, but unsupported, failed or unanswered lanes remain in incomplete_sources. partial: a recommendation exists and evidence is incomplete; assessment_url identifies continuing work when present. pending: no recommendation yet; poll or wait for the webhook. Finished processing does not mean all sources answered.
         field(
           :status,
           Models::Shared::Status,

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

@@ -35,7 +35,7 @@ module NoResponse
             }
           }
         )
-        # complete: final; nothing is still running. A lane that failed or missed its 10 s deadline stays listed in incomplete_sources, and confidence is lower. partial: a recommendation exists and at least one lane is still running or did not settle (see incomplete_sources). pending: nothing usable before the deadline; no recommendation yet, poll or wait for the webhook.
+        # Processing state, separate from evidence coverage. complete: final; nothing is still running, but unsupported, failed or unanswered lanes remain in incomplete_sources. partial: a recommendation exists and evidence is incomplete; assessment_url identifies continuing work when present. pending: no recommendation yet; poll or wait for the webhook. Finished processing does not mean all sources answered.
         field(
           :status,
           Crystalline::Nilable.new(Models::Shared::Status),

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

@@ -4,7 +4,7 @@
 module NoResponse
   module Models
     module Shared
-      # Confidence - Ordinal confidence in the recommendation under the current policy: low, medium, high or unavailable.
+      # Confidence - Evidence coverage: how much of the planned source evidence gave a definite answer. This is not confidence that an identity is genuine, agreement between identifiers, a risk score or a probability. unavailable means no usable evidence answered; a terminal uncovered assessment can have this value and recommend review.
       class Confidence
         include ::Crystalline::Enum
         enums do

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

@@ -33,7 +33,7 @@ module NoResponse
             }
           }
         )
-        # complete: final; nothing is still running. A lane that failed or missed its 10 s deadline stays listed in incomplete_sources, and confidence is lower. partial: a recommendation exists and at least one lane is still running or did not settle (see incomplete_sources). pending: nothing usable before the deadline; no recommendation yet, poll or wait for the webhook.
+        # Processing state, separate from evidence coverage. complete: final; nothing is still running, but unsupported, failed or unanswered lanes remain in incomplete_sources. partial: a recommendation exists and evidence is incomplete; assessment_url identifies continuing work when present. pending: no recommendation yet; poll or wait for the webhook. Finished processing does not mean all sources answered.
         field(
           :status,
           Models::Shared::Status,

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

@@ -12,6 +12,7 @@ module NoResponse
           VOIP_NUMBER = new("voip_number")
           DISPOSABLE_EMAIL = new("disposable_email")
           NEW_EMAIL = new("new_email")
+          NO_EMAIL_MATCHES = new("no_email_matches")
           SPAM_REPORTS = new("spam_reports")
           FRAUD_FLAG = new("fraud_flag")
           IDENTITY_MISMATCH = new("identity_mismatch")

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

@@ -62,7 +62,7 @@ module NoResponse
           Crystalline::Array.new(Models::Shared::RiskReason),
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("reasons"), required: true}}
         )
-        # Sources counted by state, not named.
+        # Counts of planned source-identifier pairs by evidence outcome, deduplicated across signals and incomplete entries. These counts do not measure identity agreement or prove that processing is still running. A lane that was not searched is not an answered source.
         field(
           :coverage,
           Models::Shared::RiskCoverage,

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

@@ -4,24 +4,24 @@
 module NoResponse
   module Models
     module Shared
-      # Sources counted by state, not named.
+      # Counts of planned source-identifier pairs by evidence outcome, deduplicated across signals and incomplete entries. These counts do not measure identity agreement or prove that processing is still running. A lane that was not searched is not an answered source.
       class RiskCoverage
         extend T::Sig
         include Crystalline::MetadataFields
 
-        # Sources that gave a definite answer.
+        # Source-identifier pairs that gave a definite found or not_found answer.
         field(
           :answered,
           ::Integer,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("answered"), required: true}}
         )
-        # Sources that could not answer.
+        # Source-identifier pairs that could not answer, including unsupported coverage markers and source failures. Read detailed signals to distinguish Not covered from Failed.
         field(
           :failed,
           ::Integer,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("failed"), required: true}}
         )
-        # Sources still being asked.
+        # Source-identifier pairs with deferred or timed_out evidence. A terminal timeout can remain here after processing finishes; use assessment status and continuation metadata to determine whether work is still running.
         field(
           :pending,
           ::Integer,

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

@@ -4,7 +4,7 @@
 module NoResponse
   module Models
     module Shared
-      # Status - complete: final; nothing is still running. A lane that failed or missed its 10 s deadline stays listed in incomplete_sources, and confidence is lower. partial: a recommendation exists and at least one lane is still running or did not settle (see incomplete_sources). pending: nothing usable before the deadline; no recommendation yet, poll or wait for the webhook.
+      # Status - Processing state, separate from evidence coverage. complete: final; nothing is still running, but unsupported, failed or unanswered lanes remain in incomplete_sources. partial: a recommendation exists and evidence is incomplete; assessment_url identifies continuing work when present. pending: no recommendation yet; poll or wait for the webhook. Finished processing does not mean all sources answered.
       class Status
         include ::Crystalline::Enum
         enums do

data/lib/no_response/models/shared.rb

@@ -15,6 +15,9 @@ module NoResponse
       autoload :AccountDeleted, "no_response/models/shared/accountdeleted.rb"
       autoload :AccountDeletedEvent, "no_response/models/shared/accountdeletedevent.rb"
       autoload :AccountDeletion, "no_response/models/shared/accountdeletion.rb"
+      autoload :AccountDirectoryPage, "no_response/models/shared/accountdirectorypage.rb"
+      autoload :AccountDirectoryPageItem, "no_response/models/shared/accountdirectorypageitem.rb"
+      autoload :AccountDirectorySearchRequest, "no_response/models/shared/accountdirectorysearchrequest.rb"
       autoload :AccountEnforcementList, "no_response/models/shared/accountenforcementlist.rb"
       autoload :AccountExport, "no_response/models/shared/accountexport.rb"
       autoload :AccountList, "no_response/models/shared/accountlist.rb"

data/lib/no_response/sdkconfiguration.rb

@@ -95,9 +95,9 @@ module NoResponse
 
       @language = "ruby"
       @openapi_doc_version = "1"
-      @sdk_version = "9.4.0"
+      @sdk_version = "9.4.2"
       @gen_version = "internal"
-      @user_agent = "noresponse-sdk/ruby 9.4.0 internal 1 noresponse"
+      @user_agent = "noresponse-sdk/ruby 9.4.2 internal 1 noresponse"
     end
 
     sig { returns([String, T::Hash[Symbol, String]]) }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: noresponse
 version: !ruby/object:Gem::Version
-  version: 9.4.0
+  version: 9.4.2
 platform: ruby
 authors:
 - NoResponse
@@ -628,6 +628,8 @@ files:
 - lib/no_response/models/operations/rotatewebhooksigningkey_request.rbi
 - lib/no_response/models/operations/rotatewebhooksigningkey_response.rb
 - lib/no_response/models/operations/rotatewebhooksigningkey_response.rbi
+- lib/no_response/models/operations/searchaccounts_response.rb
+- lib/no_response/models/operations/searchaccounts_response.rbi
 - lib/no_response/models/operations/searchassessments_response.rb
 - lib/no_response/models/operations/searchassessments_response.rbi
 - lib/no_response/models/operations/sendwebhooktestevent_request.rb
@@ -681,6 +683,12 @@ files:
 - lib/no_response/models/shared/accountdeletedevent.rbi
 - lib/no_response/models/shared/accountdeletion.rb
 - lib/no_response/models/shared/accountdeletion.rbi
+- lib/no_response/models/shared/accountdirectorypage.rb
+- lib/no_response/models/shared/accountdirectorypage.rbi
+- lib/no_response/models/shared/accountdirectorypageitem.rb
+- lib/no_response/models/shared/accountdirectorypageitem.rbi
+- lib/no_response/models/shared/accountdirectorysearchrequest.rb
+- lib/no_response/models/shared/accountdirectorysearchrequest.rbi
 - lib/no_response/models/shared/accountenforcementlist.rb
 - lib/no_response/models/shared/accountenforcementlist.rbi
 - lib/no_response/models/shared/accountexport.rb