noresponse 3.0.1 → 3.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9ced920c7288c6434e1fbd06de24541b1ac3bec7dccb43bcef7aa7ccad375377
-  data.tar.gz: 67f9fc2cce7b114edd72d84031d91312c04414114fd61ce3f7db0c3e63c6714e
+  metadata.gz: 6272c4f6b966191e3e8d1879bb44b6eea0ff2787788deddda4c756eb41505f57
+  data.tar.gz: a0e14b7bffcc0e479bd3eff446a429f0a0219fa476a1b0d12eb20d94b489db04
 SHA512:
-  metadata.gz: a7c8af727605dcef753fb10d0d3c46bf0a5fc8c90bb411d0117aceb023fb5807af788984dd5d77a09dc984a0979ee797ea75cdf6c301edc8d4aa4f74e3c83fdd
-  data.tar.gz: 02faf461ec16e415a4c799557fff8ae5e9bdcd5f62a192dfa5682c0a37bdbe10c00176d71b7de6f360616442f00b055ce429be012dc70a24acf75b18bdc3fc96
+  metadata.gz: a5560fb17f62d0bb9818153ca09b167961a889e4632063104dc4b39187d129f9f70c61d3b2b8616bd2ee5f8fe3b53d7fab97b290dffa26b89bd4e192aacd100a
+  data.tar.gz: bc91446c598e079f66b8ac40e687bded47e02b320afd56c064c089e08b1713ceaeba1a861644a37ad124c11a9508395cf7161a5a153ef7fee5571b9ee035a7ef

data/lib/no_response/keyusage.rb

@@ -0,0 +1,336 @@
+# typed: true
+# frozen_string_literal: true
+
+require "faraday"
+require "faraday/multipart"
+require "faraday/retry"
+require "sorbet-runtime"
+
+require_relative "sdk_hooks/hooks"
+require_relative "utils/retries"
+
+module NoResponse
+  extend T::Sig
+
+  class KeyUsage
+    extend T::Sig
+
+    sig { params(sdk_config: SDKConfiguration).void }
+    def initialize(sdk_config)
+      @sdk_configuration = sdk_config
+    end
+
+    sig { params(base_url: String, url_variables: T.nilable(T::Hash[Symbol, T.any(String, T::Enum)])).returns(String) }
+    def get_url(base_url:, url_variables: nil)
+      sd_base_url, sd_options = @sdk_configuration.get_server_details
+
+      if base_url.nil?
+        base_url = sd_base_url
+      end
+
+      if url_variables.nil?
+        url_variables = sd_options
+      end
+
+      return Utils.template_url(base_url, url_variables)
+    end
+
+    sig {
+      params(
+        body: Models::Shared::KeyUsageBatchRequest,
+        idempotency_key: T.nilable(::String),
+        retries: T.nilable(Utils::RetryConfig),
+        timeout_ms: T.nilable(Integer),
+        http_headers: T.nilable(T::Hash[T.any(String, Symbol), String])
+      )
+        .returns(Models::Operations::RecordKeyUsageResponse)
+    }
+    def record(body:, idempotency_key: nil, retries: nil, timeout_ms: nil, http_headers: nil)
+      # record - Report requests made with API keys your signup gate issued.
+      # Records requests made with API keys your signup gate issued to your accounts, one event per request: the key's SHA-256 (the issued_credential.sha256 the account's assessment carried), the client IP, the time and optionally the user agent, model and token counts. Most callers use the SDK's usage buffer, which batches events and sends them in the background. Sampling is allowed: sample_rate weights an event's request and token counts. Requires the assess scope. Idempotency-Key is optional in the SDK and handled as on POST /v1/assessments: a retry with the same key and body answers the same record with Idempotent-Replayed: true and counts nothing again; a different body answers 409. A batch holds 1 to 500 events and at most 256 KiB. No raw event is kept: usage is aggregated per key, and IPs, user agents and models are kept only as keyed digests, with the IP's country, for 24 hours. When one key is used from 20 or more IP addresses, or 3 or more countries, within 24 hours, every account whose assessment carried that key gets the shared_api_key reason for 30 days.
+      request = Models::Operations::RecordKeyUsageRequest.new(
+        body: body,
+        idempotency_key: idempotency_key
+      )
+      url, params = @sdk_configuration.get_server_details
+      base_url = Utils.template_url(url, params)
+      url = "#{base_url}/v1/key_usage/batches"
+      headers = Utils.get_headers(request)
+      headers = T.cast(headers, T::Hash[String, String])
+      req_content_type, data, form = Utils.serialize_request_body(request, false, false, :body, :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: "recordKeyUsage",
+        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, ["202"])
+        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::KeyUsageBatch)
+          result = obj
+          response = Models::Operations::RecordKeyUsageResponse.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/recordkeyusage_request.rb

@@ -0,0 +1,36 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class RecordKeyUsageRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :body, Models::Shared::KeyUsageBatchRequest, {'request': {'media_type': "application/json"}}
+        # Opaque client key, 16 to 128 characters of [A-Za-z0-9._:-] (a UUID or ULID fits). Scoped to the tenant principal and bound to the canonical body for 24 hours. Optional: the SDK generates a UUID when you omit it and sends the same key on every retry of the call.
+        field(
+          :idempotency_key,
+          Crystalline::Nilable.new(::String),
+          {'header': {'field_name': "Idempotency-Key", 'style': "simple", 'explode': false}}
+        )
+
+        sig { params(body: Models::Shared::KeyUsageBatchRequest, idempotency_key: T.nilable(::String)).void }
+        def initialize(body:, idempotency_key: nil)
+          @body = body
+          @idempotency_key = idempotency_key
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @body == other.body
+          return false unless @idempotency_key == other.idempotency_key
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Operations
+
+      class RecordKeyUsageResponse
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field :headers, Crystalline::Hash.new(Symbol, Crystalline::Array.new(::String))
+
+        field :result, Models::Shared::KeyUsageBatch, {}
+
+        sig { params(headers: T::Hash[Symbol, T::Array[::String]], result: Models::Shared::KeyUsageBatch).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/recordkeyusage_response.rbi

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

data/lib/no_response/models/operations.rb

@@ -29,6 +29,8 @@ module NoResponse
       autoload :QueryAccountAssessmentsResponse, "no_response/models/operations/queryaccountassessments_response.rb"
       autoload :RecordAssessmentOutcomeRequest, "no_response/models/operations/recordassessmentoutcome_request.rb"
       autoload :RecordAssessmentOutcomeResponse, "no_response/models/operations/recordassessmentoutcome_response.rb"
+      autoload :RecordKeyUsageRequest, "no_response/models/operations/recordkeyusage_request.rb"
+      autoload :RecordKeyUsageResponse, "no_response/models/operations/recordkeyusage_response.rb"
       autoload :ReplayWebhookDeliveryRequest, "no_response/models/operations/replaywebhookdelivery_request.rb"
       autoload :ReplayWebhookDeliveryResponse, "no_response/models/operations/replaywebhookdelivery_response.rb"
       autoload :RotateApiKeyResponse, "no_response/models/operations/rotateapikey_response.rb"

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

@@ -4,7 +4,7 @@
 module NoResponse
   module Models
     module Shared
-      # Body of the 200 answer to GET /v1/accounts/{account_id}: the one current risk of one of the calling tenant'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. Its assessments are the account's history (GET /v1/accounts/{account_id}/assessments).
+      # Body of the 200 answer to GET /v1/accounts/{account_id}: the one current risk of one of the calling tenant'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).
       class Account
         extend T::Sig
         include Crystalline::MetadataFields

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

@@ -59,7 +59,7 @@ module NoResponse
           ::String,
           {'format_json': {'letter_case': ::NoResponse::Utils.field_name("schema_version"), required: true}}
         )
-        # Body of the 200 answer to GET /v1/accounts/{account_id}: the one current risk of one of the calling tenant'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. Its assessments are the account's history (GET /v1/accounts/{account_id}/assessments).
+        # Body of the 200 answer to GET /v1/accounts/{account_id}: the one current risk of one of the calling tenant'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(
           :account,
           Crystalline::Nilable.new(Models::Shared::Account),

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

@@ -0,0 +1,53 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # The 202 answer of POST /v1/key_usage/batches. A replay with the same Idempotency-Key and body answers the same record and counts nothing again.
+      class KeyUsageBatch
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # Opaque, server-assigned id of the batch: 'kub_' and a 26-character Crockford base32 ULID.
+        field :id, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("id"), required: true}}
+        # When NoResponse first recorded the batch.
+        field(
+          :received_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("received_at"), required: true}}
+        )
+        # Events counted.
+        field(
+          :accepted,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("accepted"), required: true}}
+        )
+        # Events that added nothing: a private, reserved or unreadable ip, or an occurred_at more than 24 hours old or more than 5 minutes ahead.
+        field(
+          :ignored,
+          ::Integer,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("ignored"), required: true}}
+        )
+
+        sig { params(id: ::String, received_at: ::String, accepted: ::Integer, ignored: ::Integer).void }
+        def initialize(id:, received_at:, accepted:, ignored:)
+          @id = id
+          @received_at = received_at
+          @accepted = accepted
+          @ignored = ignored
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @id == other.id
+          return false unless @received_at == other.received_at
+          return false unless @accepted == other.accepted
+          return false unless @ignored == other.ignored
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::KeyUsageBatch
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::KeyUsageBatch
+  def id
+  end
+
+  def id=(str_)
+  end
+
+  def received_at
+  end
+
+  def received_at=(str_)
+  end
+
+  def accepted
+  end
+
+  def accepted=(str_)
+  end
+
+  def ignored
+  end
+
+  def ignored=(str_)
+  end
+end

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

@@ -0,0 +1,32 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # POST /v1/key_usage/batches body: facts about requests made with API keys your signup gate issued to your accounts, one event per request. Each event names the key by the SHA-256 that the assessment's issued_credential.sha256 carried, not the key itself. The SDKs buffer events and send them in the background. A batch holds 1 to 500 events and at most 256 KiB. Idempotency-Key is required and binds the body as on POST /v1/assessments, so a retried batch is counted once.
+      class KeyUsageBatchRequest
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        field(
+          :events,
+          Crystalline::Array.new(Models::Shared::KeyUsageEvent),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("events"), required: true}}
+        )
+
+        sig { params(events: T::Array[Models::Shared::KeyUsageEvent]).void }
+        def initialize(events:)
+          @events = events
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @events == other.events
+          true
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,106 @@
+# typed: true
+# frozen_string_literal: true
+
+module NoResponse
+  module Models
+    module Shared
+      # One request made with an issued key. An event whose ip is not a public address, or whose occurred_at is more than 24 hours old or more than 5 minutes ahead, is counted in ignored and adds nothing.
+      class KeyUsageEvent
+        extend T::Sig
+        include Crystalline::MetadataFields
+
+        # SHA-256 of the issued key's UTF-8 bytes, as 64 lower-case hex characters: the value sent as issued_credential.sha256 when the account was assessed. Each SDK's issued-credential helper computes it.
+        field(
+          :key_sha256,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("key_sha256"), required: true}}
+        )
+        # The client IP address the request came from, IPv4 or IPv6, as your server saw it. Stored only as a keyed digest and its country.
+        field :ip, ::String, {'format_json': {'letter_case': ::NoResponse::Utils.field_name("ip"), required: true}}
+        # When the request was made.
+        field(
+          :occurred_at,
+          ::String,
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("occurred_at"), required: true}}
+        )
+        # The request's User-Agent header, at most 512 characters. Stored only as a keyed digest.
+        field(
+          :user_agent,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("user_agent")}}
+        )
+        # The model or product the request used, such as gpt-4o-mini. Stored only as a keyed digest.
+        field(
+          :model,
+          Crystalline::Nilable.new(::String),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("model")}}
+        )
+        # Input tokens the request consumed.
+        field(
+          :input_tokens,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("input_tokens")}}
+        )
+        # Output tokens the request produced.
+        field(
+          :output_tokens,
+          Crystalline::Nilable.new(::Integer),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("output_tokens")}}
+        )
+        # The share of requests your sampler records, when it records only some: 0.1 means this event stands for 10 requests. Request and token totals are weighted by its inverse. Distinct IP and country counts see only the events sent.
+        field(
+          :sample_rate,
+          Crystalline::Nilable.new(::Float),
+          {'format_json': {'letter_case': ::NoResponse::Utils.field_name("sample_rate")}}
+        )
+
+        sig {
+          params(
+            key_sha256: ::String,
+            ip: ::String,
+            occurred_at: ::String,
+            user_agent: T.nilable(::String),
+            model: T.nilable(::String),
+            input_tokens: T.nilable(::Integer),
+            output_tokens: T.nilable(::Integer),
+            sample_rate: T.nilable(::Float)
+          )
+            .void
+        }
+        def initialize(
+          key_sha256:,
+          ip:,
+          occurred_at:,
+          user_agent: nil,
+          model: nil,
+          input_tokens: nil,
+          output_tokens: nil,
+          sample_rate: 1.0
+        )
+          @key_sha256 = key_sha256
+          @ip = ip
+          @occurred_at = occurred_at
+          @user_agent = user_agent
+          @model = model
+          @input_tokens = input_tokens
+          @output_tokens = output_tokens
+          @sample_rate = sample_rate
+        end
+
+        sig { params(other: T.untyped).returns(T::Boolean) }
+        def ==(other)
+          return false unless other.is_a?(self.class)
+          return false unless @key_sha256 == other.key_sha256
+          return false unless @ip == other.ip
+          return false unless @occurred_at == other.occurred_at
+          return false unless @user_agent == other.user_agent
+          return false unless @model == other.model
+          return false unless @input_tokens == other.input_tokens
+          return false unless @output_tokens == other.output_tokens
+          return false unless @sample_rate == other.sample_rate
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+# typed: true
+# frozen_string_literal: true
+
+class NoResponse::Models::Shared::KeyUsageEvent
+  extend ::Crystalline::MetadataFields::ClassMethods
+end
+
+class NoResponse::Models::Shared::KeyUsageEvent
+  def key_sha256
+  end
+
+  def key_sha256=(str_)
+  end
+
+  def ip
+  end
+
+  def ip=(str_)
+  end
+
+  def occurred_at
+  end
+
+  def occurred_at=(str_)
+  end
+
+  def user_agent
+  end
+
+  def user_agent=(str_)
+  end
+
+  def model
+  end
+
+  def model=(str_)
+  end
+
+  def input_tokens
+  end
+
+  def input_tokens=(str_)
+  end
+
+  def output_tokens
+  end
+
+  def output_tokens=(str_)
+  end
+
+  def sample_rate
+  end
+
+  def sample_rate=(str_)
+  end
+end

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

@@ -44,6 +44,7 @@ module NoResponse
           CONTEXT_LINE_COUNTRY_MISMATCH = new("context_line_country_mismatch")
           PRIOR_ABUSE_LINK = new("prior_abuse_link")
           TEST_SCENARIO = new("test_scenario")
+          SHARED_API_KEY = new("shared_api_key")
         end
 
         open!

data/lib/no_response/models/shared.rb

@@ -61,6 +61,9 @@ module NoResponse
       autoload :IpSummaryType, "no_response/models/shared/ipsummarytype.rb"
       autoload :KeyRotation, "no_response/models/shared/keyrotation.rb"
       autoload :KeyRotationRequest, "no_response/models/shared/keyrotationrequest.rb"
+      autoload :KeyUsageBatch, "no_response/models/shared/keyusagebatch.rb"
+      autoload :KeyUsageBatchRequest, "no_response/models/shared/keyusagebatchrequest.rb"
+      autoload :KeyUsageEvent, "no_response/models/shared/keyusageevent.rb"
       autoload :Lane, "no_response/models/shared/lane.rb"
       autoload :LineType, "no_response/models/shared/linetype.rb"
       autoload :NotFoundErrorCode, "no_response/models/shared/notfounderrorcode.rb"

data/lib/no_response/noresponseclient.rb

@@ -15,7 +15,7 @@ module NoResponse
   class NoResponseClient
     extend T::Sig
 
-    attr_accessor :assessments, :accounts, :keys, :integrations, :webhook_endpoints
+    attr_accessor :assessments, :accounts, :key_usage, :keys, :integrations, :webhook_endpoints
 
     # Instantiates the SDK, configuring it with the provided parameters.
     #
@@ -89,6 +89,7 @@ module NoResponse
     def init_sdks
       @assessments = Assessments.new(@sdk_configuration)
       @accounts = Accounts.new(@sdk_configuration)
+      @key_usage = KeyUsage.new(@sdk_configuration)
       @keys = Keys.new(@sdk_configuration)
       @integrations = Integrations.new(@sdk_configuration)
       @webhook_endpoints = WebhookEndpoints.new(@sdk_configuration)

data/lib/no_response/sdkconfiguration.rb

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

data/lib/noresponse.rb

@@ -5,6 +5,7 @@ module NoResponse
   autoload :NoResponseClient, "no_response/noresponseclient"
   autoload :Assessments, "no_response/assessments"
   autoload :Accounts, "no_response/accounts"
+  autoload :KeyUsage, "no_response/keyusage"
   autoload :Keys, "no_response/keys"
   autoload :Integrations, "no_response/integrations"
   autoload :WebhookEndpoints, "no_response/webhookendpoints"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: noresponse
 version: !ruby/object:Gem::Version
-  version: 3.0.1
+  version: 3.0.3
 platform: ruby
 authors:
 - NoResponse
@@ -258,6 +258,7 @@ files:
 - lib/no_response/integrations.rb
 - lib/no_response/issued_credential.rb
 - lib/no_response/keys.rb
+- lib/no_response/keyusage.rb
 - lib/no_response/late_results.rb
 - lib/no_response/models/callbacks.rb
 - lib/no_response/models/errors.rb
@@ -326,6 +327,10 @@ files:
 - lib/no_response/models/operations/recordassessmentoutcome_request.rbi
 - lib/no_response/models/operations/recordassessmentoutcome_response.rb
 - lib/no_response/models/operations/recordassessmentoutcome_response.rbi
+- lib/no_response/models/operations/recordkeyusage_request.rb
+- lib/no_response/models/operations/recordkeyusage_request.rbi
+- lib/no_response/models/operations/recordkeyusage_response.rb
+- lib/no_response/models/operations/recordkeyusage_response.rbi
 - lib/no_response/models/operations/replaywebhookdelivery_request.rb
 - lib/no_response/models/operations/replaywebhookdelivery_request.rbi
 - lib/no_response/models/operations/replaywebhookdelivery_response.rb
@@ -467,6 +472,12 @@ files:
 - lib/no_response/models/shared/keyrotation.rbi
 - lib/no_response/models/shared/keyrotationrequest.rb
 - lib/no_response/models/shared/keyrotationrequest.rbi
+- lib/no_response/models/shared/keyusagebatch.rb
+- lib/no_response/models/shared/keyusagebatch.rbi
+- lib/no_response/models/shared/keyusagebatchrequest.rb
+- lib/no_response/models/shared/keyusagebatchrequest.rbi
+- lib/no_response/models/shared/keyusageevent.rb
+- lib/no_response/models/shared/keyusageevent.rbi
 - lib/no_response/models/shared/lane.rb
 - lib/no_response/models/shared/lane.rbi
 - lib/no_response/models/shared/linetype.rb