dataleon 0.1.0.pre.alpha.1

data/rbi/dataleon/models/individual_create_params.rbi

@@ -0,0 +1,323 @@
+# typed: strong
+
+module Dataleon
+  module Models
+    class IndividualCreateParams < Dataleon::Internal::Type::BaseModel
+      extend Dataleon::Internal::Type::RequestParameters::Converter
+      include Dataleon::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Dataleon::IndividualCreateParams, Dataleon::Internal::AnyHash)
+        end
+
+      # Unique identifier of the workspace where the individual is being registered.
+      sig { returns(String) }
+      attr_accessor :workspace_id
+
+      # Personal information about the individual.
+      sig { returns(T.nilable(Dataleon::IndividualCreateParams::Person)) }
+      attr_reader :person
+
+      sig do
+        params(person: Dataleon::IndividualCreateParams::Person::OrHash).void
+      end
+      attr_writer :person
+
+      # Optional identifier for tracking the source system or integration from your
+      # system.
+      sig { returns(T.nilable(String)) }
+      attr_reader :source_id
+
+      sig { params(source_id: String).void }
+      attr_writer :source_id
+
+      # Technical metadata related to the request or processing.
+      sig do
+        returns(T.nilable(Dataleon::IndividualCreateParams::TechnicalData))
+      end
+      attr_reader :technical_data
+
+      sig do
+        params(
+          technical_data:
+            Dataleon::IndividualCreateParams::TechnicalData::OrHash
+        ).void
+      end
+      attr_writer :technical_data
+
+      sig do
+        params(
+          workspace_id: String,
+          person: Dataleon::IndividualCreateParams::Person::OrHash,
+          source_id: String,
+          technical_data:
+            Dataleon::IndividualCreateParams::TechnicalData::OrHash,
+          request_options: Dataleon::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique identifier of the workspace where the individual is being registered.
+        workspace_id:,
+        # Personal information about the individual.
+        person: nil,
+        # Optional identifier for tracking the source system or integration from your
+        # system.
+        source_id: nil,
+        # Technical metadata related to the request or processing.
+        technical_data: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            workspace_id: String,
+            person: Dataleon::IndividualCreateParams::Person,
+            source_id: String,
+            technical_data: Dataleon::IndividualCreateParams::TechnicalData,
+            request_options: Dataleon::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Person < Dataleon::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dataleon::IndividualCreateParams::Person,
+              Dataleon::Internal::AnyHash
+            )
+          end
+
+        # Date of birth in DD/MM/YYYY format.
+        sig { returns(T.nilable(String)) }
+        attr_reader :birthday
+
+        sig { params(birthday: String).void }
+        attr_writer :birthday
+
+        # Email address of the individual.
+        sig { returns(T.nilable(String)) }
+        attr_reader :email
+
+        sig { params(email: String).void }
+        attr_writer :email
+
+        # First name of the individual.
+        sig { returns(T.nilable(String)) }
+        attr_reader :first_name
+
+        sig { params(first_name: String).void }
+        attr_writer :first_name
+
+        # Gender of the individual (M for male, F for female).
+        sig do
+          returns(
+            T.nilable(
+              Dataleon::IndividualCreateParams::Person::Gender::OrSymbol
+            )
+          )
+        end
+        attr_reader :gender
+
+        sig do
+          params(
+            gender: Dataleon::IndividualCreateParams::Person::Gender::OrSymbol
+          ).void
+        end
+        attr_writer :gender
+
+        # Last name (family name) of the individual.
+        sig { returns(T.nilable(String)) }
+        attr_reader :last_name
+
+        sig { params(last_name: String).void }
+        attr_writer :last_name
+
+        # Maiden name, if applicable.
+        sig { returns(T.nilable(String)) }
+        attr_reader :maiden_name
+
+        sig { params(maiden_name: String).void }
+        attr_writer :maiden_name
+
+        # Phone number of the individual.
+        sig { returns(T.nilable(String)) }
+        attr_reader :phone_number
+
+        sig { params(phone_number: String).void }
+        attr_writer :phone_number
+
+        # Personal information about the individual.
+        sig do
+          params(
+            birthday: String,
+            email: String,
+            first_name: String,
+            gender: Dataleon::IndividualCreateParams::Person::Gender::OrSymbol,
+            last_name: String,
+            maiden_name: String,
+            phone_number: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Date of birth in DD/MM/YYYY format.
+          birthday: nil,
+          # Email address of the individual.
+          email: nil,
+          # First name of the individual.
+          first_name: nil,
+          # Gender of the individual (M for male, F for female).
+          gender: nil,
+          # Last name (family name) of the individual.
+          last_name: nil,
+          # Maiden name, if applicable.
+          maiden_name: nil,
+          # Phone number of the individual.
+          phone_number: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              birthday: String,
+              email: String,
+              first_name: String,
+              gender:
+                Dataleon::IndividualCreateParams::Person::Gender::OrSymbol,
+              last_name: String,
+              maiden_name: String,
+              phone_number: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        # Gender of the individual (M for male, F for female).
+        module Gender
+          extend Dataleon::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Dataleon::IndividualCreateParams::Person::Gender)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          M =
+            T.let(
+              :M,
+              Dataleon::IndividualCreateParams::Person::Gender::TaggedSymbol
+            )
+          F =
+            T.let(
+              :F,
+              Dataleon::IndividualCreateParams::Person::Gender::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Dataleon::IndividualCreateParams::Person::Gender::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      class TechnicalData < Dataleon::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Dataleon::IndividualCreateParams::TechnicalData,
+              Dataleon::Internal::AnyHash
+            )
+          end
+
+        # Flag indicating whether there are active research AML (Anti-Money Laundering)
+        # suspicions for the individual when you apply for a new entry or get an existing
+        # one.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :active_aml_suspicions
+
+        sig { params(active_aml_suspicions: T::Boolean).void }
+        attr_writer :active_aml_suspicions
+
+        # URL to call back upon completion of processing.
+        sig { returns(T.nilable(String)) }
+        attr_reader :callback_url
+
+        sig { params(callback_url: String).void }
+        attr_writer :callback_url
+
+        # URL for receive notifications about the processing state or status.
+        sig { returns(T.nilable(String)) }
+        attr_reader :callback_url_notification
+
+        sig { params(callback_url_notification: String).void }
+        attr_writer :callback_url_notification
+
+        # Preferred language for communication (e.g., "eng", "fra").
+        sig { returns(T.nilable(String)) }
+        attr_reader :language
+
+        sig { params(language: String).void }
+        attr_writer :language
+
+        # Flag indicating whether to include raw data in the response.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :raw_data
+
+        sig { params(raw_data: T::Boolean).void }
+        attr_writer :raw_data
+
+        # Technical metadata related to the request or processing.
+        sig do
+          params(
+            active_aml_suspicions: T::Boolean,
+            callback_url: String,
+            callback_url_notification: String,
+            language: String,
+            raw_data: T::Boolean
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Flag indicating whether there are active research AML (Anti-Money Laundering)
+          # suspicions for the individual when you apply for a new entry or get an existing
+          # one.
+          active_aml_suspicions: nil,
+          # URL to call back upon completion of processing.
+          callback_url: nil,
+          # URL for receive notifications about the processing state or status.
+          callback_url_notification: nil,
+          # Preferred language for communication (e.g., "eng", "fra").
+          language: nil,
+          # Flag indicating whether to include raw data in the response.
+          raw_data: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              active_aml_suspicions: T::Boolean,
+              callback_url: String,
+              callback_url_notification: String,
+              language: String,
+              raw_data: T::Boolean
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/dataleon/models/individual_delete_params.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Dataleon
+  module Models
+    class IndividualDeleteParams < Dataleon::Internal::Type::BaseModel
+      extend Dataleon::Internal::Type::RequestParameters::Converter
+      include Dataleon::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Dataleon::IndividualDeleteParams, Dataleon::Internal::AnyHash)
+        end
+
+      sig do
+        params(request_options: Dataleon::RequestOptions::OrHash).returns(
+          T.attached_class
+        )
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({ request_options: Dataleon::RequestOptions }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/dataleon/models/individual_list_params.rbi

@@ -0,0 +1,193 @@
+# typed: strong
+
+module Dataleon
+  module Models
+    class IndividualListParams < Dataleon::Internal::Type::BaseModel
+      extend Dataleon::Internal::Type::RequestParameters::Converter
+      include Dataleon::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Dataleon::IndividualListParams, Dataleon::Internal::AnyHash)
+        end
+
+      # Filter individuals created before this date (format YYYY-MM-DD)
+      sig { returns(T.nilable(Date)) }
+      attr_reader :end_date
+
+      sig { params(end_date: Date).void }
+      attr_writer :end_date
+
+      # Number of results to return (between 1 and 100)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :limit
+
+      sig { params(limit: Integer).void }
+      attr_writer :limit
+
+      # Number of results to offset (must be ≥ 0)
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :offset
+
+      sig { params(offset: Integer).void }
+      attr_writer :offset
+
+      # Filter by source ID
+      sig { returns(T.nilable(String)) }
+      attr_reader :source_id
+
+      sig { params(source_id: String).void }
+      attr_writer :source_id
+
+      # Filter individuals created after this date (format YYYY-MM-DD)
+      sig { returns(T.nilable(Date)) }
+      attr_reader :start_date
+
+      sig { params(start_date: Date).void }
+      attr_writer :start_date
+
+      # Filter by individual status (must be one of the allowed values)
+      sig do
+        returns(T.nilable(Dataleon::IndividualListParams::State::OrSymbol))
+      end
+      attr_reader :state
+
+      sig do
+        params(state: Dataleon::IndividualListParams::State::OrSymbol).void
+      end
+      attr_writer :state
+
+      # Filter by individual status (must be one of the allowed values)
+      sig do
+        returns(T.nilable(Dataleon::IndividualListParams::Status::OrSymbol))
+      end
+      attr_reader :status
+
+      sig do
+        params(status: Dataleon::IndividualListParams::Status::OrSymbol).void
+      end
+      attr_writer :status
+
+      # Filter by workspace ID
+      sig { returns(T.nilable(String)) }
+      attr_reader :workspace_id
+
+      sig { params(workspace_id: String).void }
+      attr_writer :workspace_id
+
+      sig do
+        params(
+          end_date: Date,
+          limit: Integer,
+          offset: Integer,
+          source_id: String,
+          start_date: Date,
+          state: Dataleon::IndividualListParams::State::OrSymbol,
+          status: Dataleon::IndividualListParams::Status::OrSymbol,
+          workspace_id: String,
+          request_options: Dataleon::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Filter individuals created before this date (format YYYY-MM-DD)
+        end_date: nil,
+        # Number of results to return (between 1 and 100)
+        limit: nil,
+        # Number of results to offset (must be ≥ 0)
+        offset: nil,
+        # Filter by source ID
+        source_id: nil,
+        # Filter individuals created after this date (format YYYY-MM-DD)
+        start_date: nil,
+        # Filter by individual status (must be one of the allowed values)
+        state: nil,
+        # Filter by individual status (must be one of the allowed values)
+        status: nil,
+        # Filter by workspace ID
+        workspace_id: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            end_date: Date,
+            limit: Integer,
+            offset: Integer,
+            source_id: String,
+            start_date: Date,
+            state: Dataleon::IndividualListParams::State::OrSymbol,
+            status: Dataleon::IndividualListParams::Status::OrSymbol,
+            workspace_id: String,
+            request_options: Dataleon::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Filter by individual status (must be one of the allowed values)
+      module State
+        extend Dataleon::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Dataleon::IndividualListParams::State) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        VOID = T.let(:VOID, Dataleon::IndividualListParams::State::TaggedSymbol)
+        WAITING =
+          T.let(:WAITING, Dataleon::IndividualListParams::State::TaggedSymbol)
+        STARTED =
+          T.let(:STARTED, Dataleon::IndividualListParams::State::TaggedSymbol)
+        RUNNING =
+          T.let(:RUNNING, Dataleon::IndividualListParams::State::TaggedSymbol)
+        PROCESSED =
+          T.let(:PROCESSED, Dataleon::IndividualListParams::State::TaggedSymbol)
+        FAILED =
+          T.let(:FAILED, Dataleon::IndividualListParams::State::TaggedSymbol)
+        ABORTED =
+          T.let(:ABORTED, Dataleon::IndividualListParams::State::TaggedSymbol)
+        EXPIRED =
+          T.let(:EXPIRED, Dataleon::IndividualListParams::State::TaggedSymbol)
+        DELETED =
+          T.let(:DELETED, Dataleon::IndividualListParams::State::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Dataleon::IndividualListParams::State::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Filter by individual status (must be one of the allowed values)
+      module Status
+        extend Dataleon::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Dataleon::IndividualListParams::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        REJECTED =
+          T.let(:rejected, Dataleon::IndividualListParams::Status::TaggedSymbol)
+        NEED_REVIEW =
+          T.let(
+            :need_review,
+            Dataleon::IndividualListParams::Status::TaggedSymbol
+          )
+        APPROVED =
+          T.let(:approved, Dataleon::IndividualListParams::Status::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Dataleon::IndividualListParams::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/dataleon/models/individual_list_response.rbi

@@ -0,0 +1,11 @@
+# typed: strong
+
+module Dataleon
+  module Models
+    IndividualListResponse =
+      T.let(
+        Dataleon::Internal::Type::ArrayOf[Dataleon::Individual],
+        Dataleon::Internal::Type::Converter
+      )
+  end
+end

data/rbi/dataleon/models/individual_retrieve_params.rbi

@@ -0,0 +1,57 @@
+# typed: strong
+
+module Dataleon
+  module Models
+    class IndividualRetrieveParams < Dataleon::Internal::Type::BaseModel
+      extend Dataleon::Internal::Type::RequestParameters::Converter
+      include Dataleon::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(Dataleon::IndividualRetrieveParams, Dataleon::Internal::AnyHash)
+        end
+
+      # Include document information
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :document
+
+      sig { params(document: T::Boolean).void }
+      attr_writer :document
+
+      # Scope filter (id or scope)
+      sig { returns(T.nilable(String)) }
+      attr_reader :scope
+
+      sig { params(scope: String).void }
+      attr_writer :scope
+
+      sig do
+        params(
+          document: T::Boolean,
+          scope: String,
+          request_options: Dataleon::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Include document information
+        document: nil,
+        # Scope filter (id or scope)
+        scope: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            document: T::Boolean,
+            scope: String,
+            request_options: Dataleon::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end