safetykit 0.5.0

data/rbi/safety_kit/models/data_get_download_url_response.rbi

@@ -0,0 +1,136 @@
+# typed: strong
+
+module SafetyKit
+  module Models
+    class DataGetDownloadURLResponse < SafetyKit::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            SafetyKit::Models::DataGetDownloadURLResponse,
+            SafetyKit::Internal::AnyHash
+          )
+        end
+
+      # Number of processed objects in the request. Null until the request has
+      # succeeded.
+      sig { returns(T.nilable(Integer)) }
+      attr_accessor :data_count
+
+      # ISO timestamp when `data_url` expires. Null until the request has succeeded.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :data_expires_at
+
+      # Temporary S3 URL for the full request result. Null until the request has
+      # succeeded.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :data_url
+
+      sig { returns(String) }
+      attr_accessor :namespace
+
+      sig { returns(String) }
+      attr_accessor :request_id
+
+      # Current processing status of the request
+      sig do
+        returns(
+          SafetyKit::Models::DataGetDownloadURLResponse::Status::TaggedSymbol
+        )
+      end
+      attr_accessor :status
+
+      # Response containing request status and a temporary S3 URL for the full request
+      # result. The shape is stable across all request sizes; before processing
+      # completes, the download fields are null.
+      sig do
+        params(
+          data_count: T.nilable(Integer),
+          data_expires_at: T.nilable(String),
+          data_url: T.nilable(String),
+          namespace: String,
+          request_id: String,
+          status:
+            SafetyKit::Models::DataGetDownloadURLResponse::Status::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Number of processed objects in the request. Null until the request has
+        # succeeded.
+        data_count:,
+        # ISO timestamp when `data_url` expires. Null until the request has succeeded.
+        data_expires_at:,
+        # Temporary S3 URL for the full request result. Null until the request has
+        # succeeded.
+        data_url:,
+        namespace:,
+        request_id:,
+        # Current processing status of the request
+        status:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data_count: T.nilable(Integer),
+            data_expires_at: T.nilable(String),
+            data_url: T.nilable(String),
+            namespace: String,
+            request_id: String,
+            status:
+              SafetyKit::Models::DataGetDownloadURLResponse::Status::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Current processing status of the request
+      module Status
+        extend SafetyKit::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, SafetyKit::Models::DataGetDownloadURLResponse::Status)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        QUEUED =
+          T.let(
+            :queued,
+            SafetyKit::Models::DataGetDownloadURLResponse::Status::TaggedSymbol
+          )
+        UPLOADING =
+          T.let(
+            :uploading,
+            SafetyKit::Models::DataGetDownloadURLResponse::Status::TaggedSymbol
+          )
+        INGESTING =
+          T.let(
+            :ingesting,
+            SafetyKit::Models::DataGetDownloadURLResponse::Status::TaggedSymbol
+          )
+        SUCCEEDED =
+          T.let(
+            :succeeded,
+            SafetyKit::Models::DataGetDownloadURLResponse::Status::TaggedSymbol
+          )
+        FAILED =
+          T.let(
+            :failed,
+            SafetyKit::Models::DataGetDownloadURLResponse::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              SafetyKit::Models::DataGetDownloadURLResponse::Status::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/safety_kit/models/data_get_status_params.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module SafetyKit
+  module Models
+    class DataGetStatusParams < SafetyKit::Internal::Type::BaseModel
+      extend SafetyKit::Internal::Type::RequestParameters::Converter
+      include SafetyKit::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(SafetyKit::DataGetStatusParams, SafetyKit::Internal::AnyHash)
+        end
+
+      # The namespace the data was ingested into
+      sig { returns(String) }
+      attr_accessor :namespace
+
+      # The request ID returned when the ingest request was created
+      sig { returns(String) }
+      attr_accessor :request_id
+
+      sig do
+        params(
+          namespace: String,
+          request_id: String,
+          request_options: SafetyKit::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The namespace the data was ingested into
+        namespace:,
+        # The request ID returned when the ingest request was created
+        request_id:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            namespace: String,
+            request_id: String,
+            request_options: SafetyKit::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/safety_kit/models/data_get_status_response.rbi

@@ -0,0 +1,264 @@
+# typed: strong
+
+module SafetyKit
+  module Models
+    class DataGetStatusResponse < SafetyKit::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            SafetyKit::Models::DataGetStatusResponse,
+            SafetyKit::Internal::AnyHash
+          )
+        end
+
+      sig { returns(T::Array[SafetyKit::Models::DataGetStatusResponse::Data]) }
+      attr_accessor :data
+
+      sig { returns(String) }
+      attr_accessor :namespace
+
+      sig { returns(String) }
+      attr_accessor :request_id
+
+      # Current processing status of the request
+      sig do
+        returns(SafetyKit::Models::DataGetStatusResponse::Status::TaggedSymbol)
+      end
+      attr_accessor :status
+
+      # Response containing request status and processed output data. Before processing
+      # completes, `data` is an empty array. If the processed output exceeds the 5 MiB
+      # inline response limit, this endpoint returns an error instructing you to use the
+      # results download URL endpoint instead.
+      sig do
+        params(
+          data:
+            T::Array[SafetyKit::Models::DataGetStatusResponse::Data::OrHash],
+          namespace: String,
+          request_id: String,
+          status: SafetyKit::Models::DataGetStatusResponse::Status::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        data:,
+        namespace:,
+        request_id:,
+        # Current processing status of the request
+        status:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T::Array[SafetyKit::Models::DataGetStatusResponse::Data],
+            namespace: String,
+            request_id: String,
+            status:
+              SafetyKit::Models::DataGetStatusResponse::Status::TaggedSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Data < SafetyKit::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              SafetyKit::Models::DataGetStatusResponse::Data,
+              SafetyKit::Internal::AnyHash
+            )
+          end
+
+        # Object identifier from the ingested data
+        sig { returns(String) }
+        attr_accessor :id
+
+        sig do
+          returns(
+            T.nilable(SafetyKit::Models::DataGetStatusResponse::Data::Output)
+          )
+        end
+        attr_reader :output
+
+        sig do
+          params(
+            output:
+              T.nilable(
+                SafetyKit::Models::DataGetStatusResponse::Data::Output::OrHash
+              )
+          ).void
+        end
+        attr_writer :output
+
+        sig { returns(String) }
+        attr_accessor :url
+
+        sig { returns(T.nilable(T::Hash[Symbol, T.nilable(T.anything)])) }
+        attr_reader :metadata
+
+        sig { params(metadata: T::Hash[Symbol, T.nilable(T.anything)]).void }
+        attr_writer :metadata
+
+        # Per-object processing output for the request
+        sig do
+          params(
+            id: String,
+            output:
+              T.nilable(
+                SafetyKit::Models::DataGetStatusResponse::Data::Output::OrHash
+              ),
+            url: String,
+            metadata: T::Hash[Symbol, T.nilable(T.anything)]
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Object identifier from the ingested data
+          id:,
+          output:,
+          url:,
+          metadata: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              id: String,
+              output:
+                T.nilable(
+                  SafetyKit::Models::DataGetStatusResponse::Data::Output
+                ),
+              url: String,
+              metadata: T::Hash[Symbol, T.nilable(T.anything)]
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Output < SafetyKit::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                SafetyKit::Models::DataGetStatusResponse::Data::Output,
+                SafetyKit::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T::Array[T.nilable(T.anything)]) }
+          attr_accessor :actions
+
+          sig { returns(T::Hash[Symbol, T.nilable(T.anything)]) }
+          attr_accessor :fields
+
+          sig do
+            returns(
+              T::Array[
+                SafetyKit::Models::DataGetStatusResponse::Data::Output::Label
+              ]
+            )
+          end
+          attr_accessor :labels
+
+          sig do
+            params(
+              actions: T::Array[T.nilable(T.anything)],
+              fields: T::Hash[Symbol, T.nilable(T.anything)],
+              labels:
+                T::Array[
+                  SafetyKit::Models::DataGetStatusResponse::Data::Output::Label::OrHash
+                ]
+            ).returns(T.attached_class)
+          end
+          def self.new(actions:, fields:, labels:)
+          end
+
+          sig do
+            override.returns(
+              {
+                actions: T::Array[T.nilable(T.anything)],
+                fields: T::Hash[Symbol, T.nilable(T.anything)],
+                labels:
+                  T::Array[
+                    SafetyKit::Models::DataGetStatusResponse::Data::Output::Label
+                  ]
+              }
+            )
+          end
+          def to_hash
+          end
+
+          class Label < SafetyKit::Internal::Type::BaseModel
+            OrHash =
+              T.type_alias do
+                T.any(
+                  SafetyKit::Models::DataGetStatusResponse::Data::Output::Label,
+                  SafetyKit::Internal::AnyHash
+                )
+              end
+
+            sig { returns(String) }
+            attr_accessor :label
+
+            sig { params(label: String).returns(T.attached_class) }
+            def self.new(label:)
+            end
+
+            sig { override.returns({ label: String }) }
+            def to_hash
+            end
+          end
+        end
+      end
+
+      # Current processing status of the request
+      module Status
+        extend SafetyKit::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, SafetyKit::Models::DataGetStatusResponse::Status)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        QUEUED =
+          T.let(
+            :queued,
+            SafetyKit::Models::DataGetStatusResponse::Status::TaggedSymbol
+          )
+        UPLOADING =
+          T.let(
+            :uploading,
+            SafetyKit::Models::DataGetStatusResponse::Status::TaggedSymbol
+          )
+        INGESTING =
+          T.let(
+            :ingesting,
+            SafetyKit::Models::DataGetStatusResponse::Status::TaggedSymbol
+          )
+        SUCCEEDED =
+          T.let(
+            :succeeded,
+            SafetyKit::Models::DataGetStatusResponse::Status::TaggedSymbol
+          )
+        FAILED =
+          T.let(
+            :failed,
+            SafetyKit::Models::DataGetStatusResponse::Status::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              SafetyKit::Models::DataGetStatusResponse::Status::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/safety_kit/models/data_object.rbi

@@ -0,0 +1,33 @@
+# typed: strong
+
+module SafetyKit
+  module Models
+    class DataObject < SafetyKit::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(SafetyKit::DataObject, SafetyKit::Internal::AnyHash)
+        end
+
+      # Unique identifier for this data object. This should be a meaningful identifier
+      # in the customer's system, as it is the main way to search for specific items
+      # between systems.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # A data object to ingest. It must include an id field. All other fields are
+      # flexible and can be any JSON type.
+      sig { params(id: String).returns(T.attached_class) }
+      def self.new(
+        # Unique identifier for this data object. This should be a meaningful identifier
+        # in the customer's system, as it is the main way to search for specific items
+        # between systems.
+        id:
+      )
+      end
+
+      sig { override.returns({ id: String }) }
+      def to_hash
+      end
+    end
+  end
+end