lithic 0.1.0.pre.alpha.55 → 0.1.0

data/rbi/lithic/models/internal_transaction.rbi

@@ -0,0 +1,277 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class InternalTransactionAPI < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::InternalTransactionAPI, Lithic::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :token
+
+      sig { returns(Lithic::InternalTransactionAPI::Category::OrSymbol) }
+      attr_accessor :category
+
+      sig { returns(Time) }
+      attr_accessor :created
+
+      sig { returns(String) }
+      attr_accessor :currency
+
+      sig { returns(String) }
+      attr_accessor :descriptor
+
+      sig { returns(T::Array[Lithic::InternalTransactionAPI::Event]) }
+      attr_accessor :events
+
+      sig { returns(Integer) }
+      attr_accessor :pending_amount
+
+      sig { returns(Lithic::InternalTransactionAPI::Result::OrSymbol) }
+      attr_accessor :result
+
+      sig { returns(Integer) }
+      attr_accessor :settled_amount
+
+      sig { returns(Lithic::InternalTransactionAPI::Status::OrSymbol) }
+      attr_accessor :status
+
+      sig { returns(Time) }
+      attr_accessor :updated
+
+      sig do
+        params(
+          token: String,
+          category: Lithic::InternalTransactionAPI::Category::OrSymbol,
+          created: Time,
+          currency: String,
+          descriptor: String,
+          events: T::Array[Lithic::InternalTransactionAPI::Event::OrHash],
+          pending_amount: Integer,
+          result: Lithic::InternalTransactionAPI::Result::OrSymbol,
+          settled_amount: Integer,
+          status: Lithic::InternalTransactionAPI::Status::OrSymbol,
+          updated: Time
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        token:,
+        category:,
+        created:,
+        currency:,
+        descriptor:,
+        events:,
+        pending_amount:,
+        result:,
+        settled_amount:,
+        status:,
+        updated:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            token: String,
+            category: Lithic::InternalTransactionAPI::Category::OrSymbol,
+            created: Time,
+            currency: String,
+            descriptor: String,
+            events: T::Array[Lithic::InternalTransactionAPI::Event],
+            pending_amount: Integer,
+            result: Lithic::InternalTransactionAPI::Result::OrSymbol,
+            settled_amount: Integer,
+            status: Lithic::InternalTransactionAPI::Status::OrSymbol,
+            updated: Time
+          }
+        )
+      end
+      def to_hash
+      end
+
+      module Category
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::InternalTransactionAPI::Category)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        INTERNAL =
+          T.let(
+            :INTERNAL,
+            Lithic::InternalTransactionAPI::Category::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[Lithic::InternalTransactionAPI::Category::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      class Event < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              Lithic::InternalTransactionAPI::Event,
+              Lithic::Internal::AnyHash
+            )
+          end
+
+        sig { returns(String) }
+        attr_accessor :token
+
+        sig { returns(Integer) }
+        attr_accessor :amount
+
+        sig { returns(Time) }
+        attr_accessor :created
+
+        sig { returns(Lithic::InternalTransactionAPI::Event::Result::OrSymbol) }
+        attr_accessor :result
+
+        sig { returns(Lithic::InternalTransactionAPI::Event::Type::OrSymbol) }
+        attr_accessor :type
+
+        sig do
+          params(
+            token: String,
+            amount: Integer,
+            created: Time,
+            result: Lithic::InternalTransactionAPI::Event::Result::OrSymbol,
+            type: Lithic::InternalTransactionAPI::Event::Type::OrSymbol
+          ).returns(T.attached_class)
+        end
+        def self.new(token:, amount:, created:, result:, type:)
+        end
+
+        sig do
+          override.returns(
+            {
+              token: String,
+              amount: Integer,
+              created: Time,
+              result: Lithic::InternalTransactionAPI::Event::Result::OrSymbol,
+              type: Lithic::InternalTransactionAPI::Event::Type::OrSymbol
+            }
+          )
+        end
+        def to_hash
+        end
+
+        module Result
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Lithic::InternalTransactionAPI::Event::Result)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          APPROVED =
+            T.let(
+              :APPROVED,
+              Lithic::InternalTransactionAPI::Event::Result::TaggedSymbol
+            )
+          DECLINED =
+            T.let(
+              :DECLINED,
+              Lithic::InternalTransactionAPI::Event::Result::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::InternalTransactionAPI::Event::Result::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+
+        module Type
+          extend Lithic::Internal::Type::Enum
+
+          TaggedSymbol =
+            T.type_alias do
+              T.all(Symbol, Lithic::InternalTransactionAPI::Event::Type)
+            end
+          OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+          INTERNAL_ADJUSTMENT =
+            T.let(
+              :INTERNAL_ADJUSTMENT,
+              Lithic::InternalTransactionAPI::Event::Type::TaggedSymbol
+            )
+
+          sig do
+            override.returns(
+              T::Array[
+                Lithic::InternalTransactionAPI::Event::Type::TaggedSymbol
+              ]
+            )
+          end
+          def self.values
+          end
+        end
+      end
+
+      module Result
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::InternalTransactionAPI::Result) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        APPROVED =
+          T.let(:APPROVED, Lithic::InternalTransactionAPI::Result::TaggedSymbol)
+        DECLINED =
+          T.let(:DECLINED, Lithic::InternalTransactionAPI::Result::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Lithic::InternalTransactionAPI::Result::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      module Status
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::InternalTransactionAPI::Status) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        PENDING =
+          T.let(:PENDING, Lithic::InternalTransactionAPI::Status::TaggedSymbol)
+        SETTLED =
+          T.let(:SETTLED, Lithic::InternalTransactionAPI::Status::TaggedSymbol)
+        DECLINED =
+          T.let(:DECLINED, Lithic::InternalTransactionAPI::Status::TaggedSymbol)
+        REVERSED =
+          T.let(:REVERSED, Lithic::InternalTransactionAPI::Status::TaggedSymbol)
+        CANCELED =
+          T.let(:CANCELED, Lithic::InternalTransactionAPI::Status::TaggedSymbol)
+        RETURNED =
+          T.let(:RETURNED, Lithic::InternalTransactionAPI::Status::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Lithic::InternalTransactionAPI::Status::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/management_operation_create_params.rbi

@@ -322,6 +322,36 @@ module Lithic
             :DISBURSE_REVERSAL,
             Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
           )
+        ANNUAL =
+          T.let(
+            :ANNUAL,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
+        ANNUAL_REVERSAL =
+          T.let(
+            :ANNUAL_REVERSAL,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
+        QUARTERLY =
+          T.let(
+            :QUARTERLY,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
+        QUARTERLY_REVERSAL =
+          T.let(
+            :QUARTERLY_REVERSAL,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
+        MONTHLY =
+          T.let(
+            :MONTHLY,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
+        MONTHLY_REVERSAL =
+          T.let(
+            :MONTHLY_REVERSAL,
+            Lithic::ManagementOperationCreateParams::EventType::TaggedSymbol
+          )
 
         sig do
           override.returns(

data/rbi/lithic/models/management_operation_list_params.rbi

@@ -239,6 +239,11 @@ module Lithic
             :CANCELED,
             Lithic::ManagementOperationListParams::Status::TaggedSymbol
           )
+        RETURNED =
+          T.let(
+            :RETURNED,
+            Lithic::ManagementOperationListParams::Status::TaggedSymbol
+          )
 
         sig do
           override.returns(

data/rbi/lithic/models/management_operation_transaction.rbi

@@ -162,10 +162,7 @@ module Lithic
       attr_writer :transaction_series
 
       sig { returns(T.nilable(String)) }
-      attr_reader :user_defined_id
-
-      sig { params(user_defined_id: String).void }
-      attr_writer :user_defined_id
+      attr_accessor :user_defined_id
 
       sig do
         params(
@@ -189,7 +186,7 @@ module Lithic
             T.nilable(
               Lithic::ManagementOperationTransaction::TransactionSeries::OrHash
             ),
-          user_defined_id: String
+          user_defined_id: T.nilable(String)
         ).returns(T.attached_class)
       end
       def self.new(
@@ -244,7 +241,7 @@ module Lithic
               T.nilable(
                 Lithic::ManagementOperationTransaction::TransactionSeries
               ),
-            user_defined_id: String
+            user_defined_id: T.nilable(String)
           }
         )
       end
@@ -286,6 +283,11 @@ module Lithic
             :CANCELED,
             Lithic::ManagementOperationTransaction::Status::TaggedSymbol
           )
+        RETURNED =
+          T.let(
+            :RETURNED,
+            Lithic::ManagementOperationTransaction::Status::TaggedSymbol
+          )
 
         sig do
           override.returns(
@@ -423,10 +425,7 @@ module Lithic
         attr_accessor :type
 
         sig { returns(T.nilable(String)) }
-        attr_reader :subtype
-
-        sig { params(subtype: String).void }
-        attr_writer :subtype
+        attr_accessor :subtype
 
         sig do
           params(
@@ -442,7 +441,7 @@ module Lithic
             result:
               Lithic::ManagementOperationTransaction::Event::Result::OrSymbol,
             type: Lithic::ManagementOperationTransaction::Event::Type::OrSymbol,
-            subtype: String
+            subtype: T.nilable(String)
           ).returns(T.attached_class)
         end
         def self.new(
@@ -474,7 +473,7 @@ module Lithic
                 Lithic::ManagementOperationTransaction::Event::Result::TaggedSymbol,
               type:
                 Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol,
-              subtype: String
+              subtype: T.nilable(String)
             }
           )
         end
@@ -653,6 +652,36 @@ module Lithic
               :DISBURSE_REVERSAL,
               Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
             )
+          ANNUAL =
+            T.let(
+              :ANNUAL,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
+          ANNUAL_REVERSAL =
+            T.let(
+              :ANNUAL_REVERSAL,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
+          QUARTERLY =
+            T.let(
+              :QUARTERLY,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
+          QUARTERLY_REVERSAL =
+            T.let(
+              :QUARTERLY_REVERSAL,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
+          MONTHLY =
+            T.let(
+              :MONTHLY,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
+          MONTHLY_REVERSAL =
+            T.let(
+              :MONTHLY_REVERSAL,
+              Lithic::ManagementOperationTransaction::Event::Type::TaggedSymbol
+            )
 
           sig do
             override.returns(

data/rbi/lithic/models/merchant.rbi

@@ -0,0 +1,89 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class Merchant < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Lithic::Merchant, Lithic::Internal::AnyHash) }
+
+      # Unique alphanumeric identifier for the payment card acceptor (merchant).
+      sig { returns(String) }
+      attr_accessor :acceptor_id
+
+      # Unique numeric identifier of the acquiring institution.
+      sig { returns(String) }
+      attr_accessor :acquiring_institution_id
+
+      # City of card acceptor. Note that in many cases, particularly in card-not-present
+      # transactions, merchants may send through a phone number or URL in this field.
+      sig { returns(String) }
+      attr_accessor :city
+
+      # Country or entity of card acceptor. Possible values are: (1) all ISO 3166-1
+      # alpha-3 country codes, (2) QZZ for Kosovo, and (3) ANT for Netherlands Antilles.
+      sig { returns(String) }
+      attr_accessor :country
+
+      # Short description of card acceptor.
+      sig { returns(String) }
+      attr_accessor :descriptor
+
+      # Merchant category code (MCC). A four-digit number listed in ISO 18245. An MCC is
+      # used to classify a business by the types of goods or services it provides.
+      sig { returns(String) }
+      attr_accessor :mcc
+
+      # Geographic state of card acceptor.
+      sig { returns(String) }
+      attr_accessor :state
+
+      sig do
+        params(
+          acceptor_id: String,
+          acquiring_institution_id: String,
+          city: String,
+          country: String,
+          descriptor: String,
+          mcc: String,
+          state: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Unique alphanumeric identifier for the payment card acceptor (merchant).
+        acceptor_id:,
+        # Unique numeric identifier of the acquiring institution.
+        acquiring_institution_id:,
+        # City of card acceptor. Note that in many cases, particularly in card-not-present
+        # transactions, merchants may send through a phone number or URL in this field.
+        city:,
+        # Country or entity of card acceptor. Possible values are: (1) all ISO 3166-1
+        # alpha-3 country codes, (2) QZZ for Kosovo, and (3) ANT for Netherlands Antilles.
+        country:,
+        # Short description of card acceptor.
+        descriptor:,
+        # Merchant category code (MCC). A four-digit number listed in ISO 18245. An MCC is
+        # used to classify a business by the types of goods or services it provides.
+        mcc:,
+        # Geographic state of card acceptor.
+        state:
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            acceptor_id: String,
+            acquiring_institution_id: String,
+            city: String,
+            country: String,
+            descriptor: String,
+            mcc: String,
+            state: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end