safetykit 0.5.0

data/rbi/safety_kit/models/stream_add_params.rbi

@@ -0,0 +1,55 @@
+# typed: strong
+
+module SafetyKit
+  module Models
+    class StreamAddParams < SafetyKit::Internal::Type::BaseModel
+      extend SafetyKit::Internal::Type::RequestParameters::Converter
+      include SafetyKit::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(SafetyKit::StreamAddParams, SafetyKit::Internal::AnyHash)
+        end
+
+      # The namespace to ingest stream data into
+      sig { returns(String) }
+      attr_accessor :namespace
+
+      sig { returns(String) }
+      attr_accessor :id
+
+      sig { returns(String) }
+      attr_accessor :stream_url
+
+      sig do
+        params(
+          namespace: String,
+          id: String,
+          stream_url: String,
+          request_options: SafetyKit::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The namespace to ingest stream data into
+        namespace:,
+        id:,
+        stream_url:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            namespace: String,
+            id: String,
+            stream_url: String,
+            request_options: SafetyKit::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/safety_kit/models/stream_add_response.rbi

@@ -0,0 +1,68 @@
+# typed: strong
+
+module SafetyKit
+  module Models
+    class StreamAddResponse < SafetyKit::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            SafetyKit::Models::StreamAddResponse,
+            SafetyKit::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :request_id
+
+      sig do
+        returns(SafetyKit::Models::StreamAddResponse::Status::TaggedSymbol)
+      end
+      attr_accessor :status
+
+      # Stream ingestion request accepted for asynchronous processing.
+      sig do
+        params(
+          request_id: String,
+          status: SafetyKit::Models::StreamAddResponse::Status::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(request_id:, status:)
+      end
+
+      sig do
+        override.returns(
+          {
+            request_id: String,
+            status: SafetyKit::Models::StreamAddResponse::Status::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Status
+        extend SafetyKit::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, SafetyKit::Models::StreamAddResponse::Status)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACCEPTED =
+          T.let(
+            :accepted,
+            SafetyKit::Models::StreamAddResponse::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[SafetyKit::Models::StreamAddResponse::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/safety_kit/models/stream_add_transcript_params.rbi

@@ -0,0 +1,64 @@
+# typed: strong
+
+module SafetyKit
+  module Models
+    class StreamAddTranscriptParams < SafetyKit::Internal::Type::BaseModel
+      extend SafetyKit::Internal::Type::RequestParameters::Converter
+      include SafetyKit::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            SafetyKit::StreamAddTranscriptParams,
+            SafetyKit::Internal::AnyHash
+          )
+        end
+
+      # The namespace to ingest stream data into
+      sig { returns(String) }
+      attr_accessor :namespace
+
+      sig { returns(String) }
+      attr_accessor :stream_id
+
+      sig { returns(String) }
+      attr_accessor :text
+
+      sig { returns(Integer) }
+      attr_accessor :timestamp
+
+      sig do
+        params(
+          namespace: String,
+          stream_id: String,
+          text: String,
+          timestamp: Integer,
+          request_options: SafetyKit::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The namespace to ingest stream data into
+        namespace:,
+        stream_id:,
+        text:,
+        timestamp:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            namespace: String,
+            stream_id: String,
+            text: String,
+            timestamp: Integer,
+            request_options: SafetyKit::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/safety_kit/models/stream_add_transcript_response.rbi

@@ -0,0 +1,77 @@
+# typed: strong
+
+module SafetyKit
+  module Models
+    class StreamAddTranscriptResponse < SafetyKit::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            SafetyKit::Models::StreamAddTranscriptResponse,
+            SafetyKit::Internal::AnyHash
+          )
+        end
+
+      sig { returns(String) }
+      attr_accessor :request_id
+
+      sig do
+        returns(
+          SafetyKit::Models::StreamAddTranscriptResponse::Status::TaggedSymbol
+        )
+      end
+      attr_accessor :status
+
+      # Stream ingestion request accepted for asynchronous processing.
+      sig do
+        params(
+          request_id: String,
+          status:
+            SafetyKit::Models::StreamAddTranscriptResponse::Status::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(request_id:, status:)
+      end
+
+      sig do
+        override.returns(
+          {
+            request_id: String,
+            status:
+              SafetyKit::Models::StreamAddTranscriptResponse::Status::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Status
+        extend SafetyKit::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(
+              Symbol,
+              SafetyKit::Models::StreamAddTranscriptResponse::Status
+            )
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACCEPTED =
+          T.let(
+            :accepted,
+            SafetyKit::Models::StreamAddTranscriptResponse::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              SafetyKit::Models::StreamAddTranscriptResponse::Status::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/safety_kit/models.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module SafetyKit
+  AgentDecisionCreateAgentDecisionParams =
+    SafetyKit::Models::AgentDecisionCreateAgentDecisionParams
+
+  Beta = SafetyKit::Models::Beta
+
+  ClientSessionCreateSessionParams =
+    SafetyKit::Models::ClientSessionCreateSessionParams
+
+  DataAddParams = SafetyKit::Models::DataAddParams
+
+  DataCreateUploadURLParams = SafetyKit::Models::DataCreateUploadURLParams
+
+  DataGetDownloadURLParams = SafetyKit::Models::DataGetDownloadURLParams
+
+  DataGetStatusParams = SafetyKit::Models::DataGetStatusParams
+
+  DataObject = SafetyKit::Models::DataObject
+
+  DataUpdateSettingsParams = SafetyKit::Models::DataUpdateSettingsParams
+
+  StreamAddFrameParams = SafetyKit::Models::StreamAddFrameParams
+
+  StreamAddParams = SafetyKit::Models::StreamAddParams
+
+  StreamAddTranscriptParams = SafetyKit::Models::StreamAddTranscriptParams
+end

data/rbi/safety_kit/request_options.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module SafetyKit
+  # Specify HTTP behaviour to use for a specific request. These options supplement
+  # or override those provided at the client level.
+  #
+  # When making a request, you can pass an actual {RequestOptions} instance, or
+  # simply pass a Hash with symbol keys matching the attributes on this class.
+  class RequestOptions < SafetyKit::Internal::Type::BaseModel
+    OrHash =
+      T.type_alias do
+        T.any(SafetyKit::RequestOptions, SafetyKit::Internal::AnyHash)
+      end
+
+    # @api private
+    sig { params(opts: SafetyKit::RequestOptions::OrHash).void }
+    def self.validate!(opts)
+    end
+
+    # Idempotency key to send with request and all associated retries. Will only be
+    # sent for write requests.
+    sig { returns(T.nilable(String)) }
+    attr_accessor :idempotency_key
+
+    # Extra query params to send with the request. These are `.merge`’d into any
+    # `query` given at the client level.
+    sig do
+      returns(
+        T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))])
+      )
+    end
+    attr_accessor :extra_query
+
+    # Extra headers to send with the request. These are `.merged`’d into any
+    # `extra_headers` given at the client level.
+    sig { returns(T.nilable(T::Hash[String, T.nilable(String)])) }
+    attr_accessor :extra_headers
+
+    # Extra data to send with the request. These are deep merged into any data
+    # generated as part of the normal request.
+    sig { returns(T.nilable(T.anything)) }
+    attr_accessor :extra_body
+
+    # Maximum number of retries to attempt after a failed initial request.
+    sig { returns(T.nilable(Integer)) }
+    attr_accessor :max_retries
+
+    # Request timeout in seconds.
+    sig { returns(T.nilable(Float)) }
+    attr_accessor :timeout
+
+    # Returns a new instance of RequestOptions.
+    sig do
+      params(values: SafetyKit::Internal::AnyHash).returns(T.attached_class)
+    end
+    def self.new(values = {})
+    end
+  end
+end

data/rbi/safety_kit/resources/agent_decisions.rbi

@@ -0,0 +1,50 @@
+# typed: strong
+
+module SafetyKit
+  module Resources
+    # Send human reviewer final verdicts to SafetyKit. This feedback improves the
+    # accuracy of SafetyKit's automated decisions over time.
+    class AgentDecisions
+      # Record a human reviewer's final verdict for content that SafetyKit has
+      # previously reviewed. This ground truth feedback allows SafetyKit to improve the
+      # accuracy of automated decisions. Each call provides feedback on whether a given
+      # piece of content violates a specific policy category. If content is reviewed for
+      # multiple policies, send one call per policy.
+      sig do
+        params(
+          content_type: String,
+          decision: String,
+          policy_id: String,
+          reference_id: String,
+          action: String,
+          comment: T.nilable(String),
+          request_options: SafetyKit::RequestOptions::OrHash
+        ).returns(SafetyKit::Models::AgentDecisionCreateAgentDecisionResponse)
+      end
+      def create_agent_decision(
+        # The dataapi namespace of the content being reviewed
+        content_type:,
+        # The human reviewer's verdict on whether the content violates the specified
+        # policy ('match'/'no_match').
+        decision:,
+        # The SafetyKit policy category ID that was evaluated, as configured for your
+        # account
+        policy_id:,
+        # The external id for the content being reviewed
+        reference_id:,
+        # The correct enforcement action for this content (e.g. 'reduce_visibility',
+        # 'unpublish')
+        action: nil,
+        # Additional context or details from the human reviewer
+        comment: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: SafetyKit::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/safety_kit/resources/beta/events.rbi

@@ -0,0 +1,40 @@
+# typed: strong
+
+module SafetyKit
+  module Resources
+    class Beta
+      # Beta. Send backend events for account, content, and user interaction activity.
+      class Events
+        # Beta. Send a backend event after a meaningful product action happens in your
+        # system. Use events for durable server-side context such as account creation,
+        # account updates, user-to-user contact, and content uploads. Do not send browser
+        # pageviews, button clicks, or other client-only telemetry through this endpoint.
+        sig do
+          params(
+            body:
+              T.any(
+                SafetyKit::Beta::EventCreateParams::Body::UserContact::OrHash,
+                SafetyKit::Beta::EventCreateParams::Body::ContentUploaded::OrHash,
+                SafetyKit::Beta::EventCreateParams::Body::CreateAccount::OrHash,
+                SafetyKit::Beta::EventCreateParams::Body::UpdateAccount::OrHash
+              ),
+            request_options: SafetyKit::RequestOptions::OrHash
+          ).returns(SafetyKit::Models::Beta::EventCreateResponse)
+        end
+        def create(
+          # Backend event to send to SafetyKit. Send events from your server after an action
+          # has happened in your product. Do not send these events directly from a browser
+          # or mobile client.
+          body:,
+          request_options: {}
+        )
+        end
+
+        # @api private
+        sig { params(client: SafetyKit::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/safety_kit/resources/beta.rbi

@@ -0,0 +1,16 @@
+# typed: strong
+
+module SafetyKit
+  module Resources
+    class Beta
+      # Beta. Send backend events for account, content, and user interaction activity.
+      sig { returns(SafetyKit::Resources::Beta::Events) }
+      attr_reader :events
+
+      # @api private
+      sig { params(client: SafetyKit::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/safety_kit/resources/client_sessions.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module SafetyKit
+  module Resources
+    # Create browser-safe webapp SDK session tokens from authenticated server-side
+    # code.
+    class ClientSessions
+      # Create a browser-safe SafetyKit webapp SDK session token from server-side code
+      # before rendering pages that load the browser SDK. The request must be
+      # authenticated with a valid Bearer token.
+      sig do
+        params(
+          customer_session_hash: String,
+          customer_user_id: String,
+          request_options: SafetyKit::RequestOptions::OrHash
+        ).returns(SafetyKit::Models::ClientSessionCreateSessionResponse)
+      end
+      def create_session(
+        # Hashed customer browser session value associated with the browser SDK session.
+        customer_session_hash: nil,
+        # Customer user identifier associated with the browser SDK session.
+        customer_user_id: nil,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: SafetyKit::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/safety_kit/resources/data.rbi

@@ -0,0 +1,126 @@
+# typed: strong
+
+module SafetyKit
+  module Resources
+    # Ingest data for fraud detection and risk analysis.
+    class Data
+      # Add data to a namespace, returning immediately. Processing happens
+      # asynchronously in the background.
+      sig do
+        params(
+          namespace: String,
+          data:
+            T.any(
+              SafetyKit::DataObject::OrHash,
+              T::Array[SafetyKit::DataObject::OrHash]
+            ),
+          request_options: SafetyKit::RequestOptions::OrHash
+        ).returns(SafetyKit::Models::DataAddResponse)
+      end
+      def add(
+        # The namespace to ingest data into
+        namespace,
+        # A data object to ingest. It must include an id field. All other fields are
+        # flexible and can be any JSON type.
+        data:,
+        request_options: {}
+      )
+      end
+
+      # Request a pre-signed upload URL for large JSONL batches into a namespace. After
+      # receiving `upload_url`, upload your JSONL file using `PUT {upload_url}` with
+      # header `Content-Type: application/json`; put each JSON object on a new line.
+      sig do
+        params(
+          namespace: String,
+          schema:
+            T::Hash[
+              Symbol,
+              SafetyKit::DataCreateUploadURLParams::Schema::OrHash
+            ],
+          request_options: SafetyKit::RequestOptions::OrHash
+        ).returns(SafetyKit::Models::DataCreateUploadURLResponse)
+      end
+      def create_upload_url(
+        # The namespace to ingest data into
+        namespace,
+        # Schema mapping field names to their definitions. Use content_type to specify
+        # which fields contain URLs that should be processed (images, videos, or
+        # websites), datetime fields, or 'metadata' for fields that should be stored but
+        # not indexed. Use display_hint to provide UI rendering hints.
+        schema: nil,
+        request_options: {}
+      )
+      end
+
+      # Retrieve the status of a data ingestion request and, once complete, a temporary
+      # S3 URL for the full result file. This endpoint always uses the URL-based
+      # response shape regardless of request size.
+      sig do
+        params(
+          request_id: String,
+          namespace: String,
+          request_options: SafetyKit::RequestOptions::OrHash
+        ).returns(SafetyKit::Models::DataGetDownloadURLResponse)
+      end
+      def get_download_url(
+        # The request ID returned when the ingest request was created
+        request_id,
+        # The namespace the data was ingested into
+        namespace:,
+        request_options: {}
+      )
+      end
+
+      # Retrieve the status of a data ingestion request and, once complete, return
+      # processed objects inline. If the processed output exceeds the 5 MiB inline
+      # response limit, this endpoint returns an error instructing you to use the
+      # download endpoint instead.
+      sig do
+        params(
+          request_id: String,
+          namespace: String,
+          request_options: SafetyKit::RequestOptions::OrHash
+        ).returns(SafetyKit::Models::DataGetStatusResponse)
+      end
+      def get_status(
+        # The request ID returned when the ingest request was created
+        request_id,
+        # The namespace the data was ingested into
+        namespace:,
+        request_options: {}
+      )
+      end
+
+      # Create or replace settings for a namespace, primarily used to change the schema
+      # associated with the namespace.
+      sig do
+        params(
+          namespace: String,
+          schema:
+            T::Hash[
+              Symbol,
+              SafetyKit::DataUpdateSettingsParams::Schema::OrHash
+            ],
+          request_options: SafetyKit::RequestOptions::OrHash
+        ).returns(SafetyKit::Models::DataUpdateSettingsResponse)
+      end
+      def update_settings(
+        # The namespace to ingest data into
+        namespace,
+        # Schema mapping field names to their definitions. Use content_type to specify
+        # which fields contain URLs that should be processed (images, videos, or
+        # websites), datetime fields, or 'metadata' for fields that should be stored but
+        # not indexed. Use display_hint to provide UI rendering hints.
+        schema:,
+        request_options: {}
+      )
+      end
+
+      # @api private
+      sig { params(client: SafetyKit::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end