noresponse 9.4.0 → 9.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2a7a4007667832081cb401d07ff168481e8b0cdc4d9a04f5f0073e0b90091055
-  data.tar.gz: 395f33f137064474997f8ac4e317f8cc28eeb7985ba59cf4f9a131d6f5bb69d2
+  metadata.gz: 0bae69f44a1abc84cf6831495b5511656fd70a09f3ead4a2e0ffa65b411260bd
+  data.tar.gz: f4b1115778e67d6e4b437d4513b5155ca5cefa0cbe48553c3a482641202eefa2
 SHA512:
-  metadata.gz: ff44abdfd0eb5e23ec94da15450a264b51ce6cb11a1bd0be5e66fa295fd43594a1d0e3daf2e270cd2bb55970f90bba44a4996d25acdef6b15fde303327412c90
-  data.tar.gz: 450e4088b4029c7f3d33a2be2c3d6e9e184bd540673f4d1d3f740ac59834b0ac77fa4c01a0dbec407b20518456c72bfcc07a1a1da8e3e1dd58c7caee25f00a5f
+  metadata.gz: a66befcc80ec8e4927fafbcfa1771db60425c212ed1d6a88755060ded08f2181c26d6190f9f72681e117103f9154825512da96c77e432bb648eae08b70bc6177
+  data.tar.gz: 52161b5f9290967fd536c4ae6049e0ebc343b145515daa55afa747be39c95e4bd611d9a06635bd81420bb657be9bae6e42f308b8e40aaf34103aab9f7868192b

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.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.1"
       @gen_version = "internal"
-      @user_agent = "noresponse-sdk/ruby 9.4.0 internal 1 noresponse"
+      @user_agent = "noresponse-sdk/ruby 9.4.1 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.1
 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