lithic 0.1.0.pre.alpha.56 → 0.1.0

data/rbi/lithic/models/{funding_event_list_response.rbi → funding_event.rbi}

@@ -2,14 +2,9 @@
 
 module Lithic
   module Models
-    class FundingEventListResponse < Lithic::Internal::Type::BaseModel
+    class FundingEvent < Lithic::Internal::Type::BaseModel
       OrHash =
-        T.type_alias do
-          T.any(
-            Lithic::Models::FundingEventListResponse,
-            Lithic::Internal::AnyHash
-          )
-        end
+        T.type_alias { T.any(Lithic::FundingEvent, Lithic::Internal::AnyHash) }
 
       # Unique token ID
       sig { returns(String) }
@@ -17,9 +12,7 @@ module Lithic
 
       # Collection resource type
       sig do
-        returns(
-          Lithic::Models::FundingEventListResponse::CollectionResourceType::TaggedSymbol
-        )
+        returns(Lithic::FundingEvent::CollectionResourceType::TaggedSymbol)
       end
       attr_accessor :collection_resource_type
 
@@ -37,13 +30,7 @@ module Lithic
       attr_accessor :high_watermark
 
       # Network settlement summary breakdown by network settlement date
-      sig do
-        returns(
-          T::Array[
-            Lithic::Models::FundingEventListResponse::NetworkSettlementSummary
-          ]
-        )
-      end
+      sig { returns(T::Array[Lithic::FundingEvent::NetworkSettlementSummary]) }
       attr_accessor :network_settlement_summary
 
       # Time of the previous high watermark
@@ -58,14 +45,12 @@ module Lithic
         params(
           token: String,
           collection_resource_type:
-            Lithic::Models::FundingEventListResponse::CollectionResourceType::OrSymbol,
+            Lithic::FundingEvent::CollectionResourceType::OrSymbol,
           collection_tokens: T::Array[String],
           created: Time,
           high_watermark: Time,
           network_settlement_summary:
-            T::Array[
-              Lithic::Models::FundingEventListResponse::NetworkSettlementSummary::OrHash
-            ],
+            T::Array[Lithic::FundingEvent::NetworkSettlementSummary::OrHash],
           previous_high_watermark: Time,
           updated: Time
         ).returns(T.attached_class)
@@ -96,14 +81,12 @@ module Lithic
           {
             token: String,
             collection_resource_type:
-              Lithic::Models::FundingEventListResponse::CollectionResourceType::TaggedSymbol,
+              Lithic::FundingEvent::CollectionResourceType::TaggedSymbol,
             collection_tokens: T::Array[String],
             created: Time,
             high_watermark: Time,
             network_settlement_summary:
-              T::Array[
-                Lithic::Models::FundingEventListResponse::NetworkSettlementSummary
-              ],
+              T::Array[Lithic::FundingEvent::NetworkSettlementSummary],
             previous_high_watermark: Time,
             updated: Time
           }
@@ -118,29 +101,24 @@ module Lithic
 
         TaggedSymbol =
           T.type_alias do
-            T.all(
-              Symbol,
-              Lithic::Models::FundingEventListResponse::CollectionResourceType
-            )
+            T.all(Symbol, Lithic::FundingEvent::CollectionResourceType)
           end
         OrSymbol = T.type_alias { T.any(Symbol, String) }
 
         BOOK_TRANSFER =
           T.let(
             :BOOK_TRANSFER,
-            Lithic::Models::FundingEventListResponse::CollectionResourceType::TaggedSymbol
+            Lithic::FundingEvent::CollectionResourceType::TaggedSymbol
           )
         PAYMENT =
           T.let(
             :PAYMENT,
-            Lithic::Models::FundingEventListResponse::CollectionResourceType::TaggedSymbol
+            Lithic::FundingEvent::CollectionResourceType::TaggedSymbol
           )
 
         sig do
           override.returns(
-            T::Array[
-              Lithic::Models::FundingEventListResponse::CollectionResourceType::TaggedSymbol
-            ]
+            T::Array[Lithic::FundingEvent::CollectionResourceType::TaggedSymbol]
           )
         end
         def self.values
@@ -151,7 +129,7 @@ module Lithic
         OrHash =
           T.type_alias do
             T.any(
-              Lithic::Models::FundingEventListResponse::NetworkSettlementSummary,
+              Lithic::FundingEvent::NetworkSettlementSummary,
               Lithic::Internal::AnyHash
             )
           end

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_transaction.rbi

@@ -652,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/network_total.rbi

@@ -0,0 +1,226 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class NetworkTotal < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias { T.any(Lithic::NetworkTotal, Lithic::Internal::AnyHash) }
+
+      # Globally unique identifier.
+      sig { returns(String) }
+      attr_accessor :token
+
+      sig { returns(Lithic::NetworkTotal::Amounts) }
+      attr_reader :amounts
+
+      sig { params(amounts: Lithic::NetworkTotal::Amounts::OrHash).void }
+      attr_writer :amounts
+
+      # RFC 3339 timestamp for when the record was created. UTC time zone.
+      sig { returns(Time) }
+      attr_accessor :created
+
+      # 3-character alphabetic ISO 4217 code.
+      sig { returns(String) }
+      attr_accessor :currency
+
+      # The institution that activity occurred on. For Mastercard: ICA (Interbank Card
+      # Association). For Maestro: institution ID. For Visa: lowest level SRE
+      # (Settlement Reporting Entity).
+      sig { returns(String) }
+      attr_accessor :institution_id
+
+      # Indicates that all settlement records related to this Network Total are
+      # available in the details endpoint.
+      sig { returns(T::Boolean) }
+      attr_accessor :is_complete
+
+      # Card network where the transaction took place. AMEX, VISA, MASTERCARD, MAESTRO,
+      # or INTERLINK.
+      sig { returns(Lithic::NetworkTotal::Network::TaggedSymbol) }
+      attr_accessor :network
+
+      # Date that the network total record applies to. YYYY-MM-DD format.
+      sig { returns(Date) }
+      attr_accessor :report_date
+
+      # The institution responsible for settlement. For Mastercard: same as
+      # `institution_id`. For Maestro: billing ICA. For Visa: Funds Transfer SRE
+      # (FTSRE).
+      sig { returns(String) }
+      attr_accessor :settlement_institution_id
+
+      # Settlement service.
+      sig { returns(String) }
+      attr_accessor :settlement_service
+
+      # RFC 3339 timestamp for when the record was last updated. UTC time zone.
+      sig { returns(Time) }
+      attr_accessor :updated
+
+      # The clearing cycle that the network total record applies to. Mastercard only.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :cycle
+
+      sig { params(cycle: Integer).void }
+      attr_writer :cycle
+
+      sig do
+        params(
+          token: String,
+          amounts: Lithic::NetworkTotal::Amounts::OrHash,
+          created: Time,
+          currency: String,
+          institution_id: String,
+          is_complete: T::Boolean,
+          network: Lithic::NetworkTotal::Network::OrSymbol,
+          report_date: Date,
+          settlement_institution_id: String,
+          settlement_service: String,
+          updated: Time,
+          cycle: Integer
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Globally unique identifier.
+        token:,
+        amounts:,
+        # RFC 3339 timestamp for when the record was created. UTC time zone.
+        created:,
+        # 3-character alphabetic ISO 4217 code.
+        currency:,
+        # The institution that activity occurred on. For Mastercard: ICA (Interbank Card
+        # Association). For Maestro: institution ID. For Visa: lowest level SRE
+        # (Settlement Reporting Entity).
+        institution_id:,
+        # Indicates that all settlement records related to this Network Total are
+        # available in the details endpoint.
+        is_complete:,
+        # Card network where the transaction took place. AMEX, VISA, MASTERCARD, MAESTRO,
+        # or INTERLINK.
+        network:,
+        # Date that the network total record applies to. YYYY-MM-DD format.
+        report_date:,
+        # The institution responsible for settlement. For Mastercard: same as
+        # `institution_id`. For Maestro: billing ICA. For Visa: Funds Transfer SRE
+        # (FTSRE).
+        settlement_institution_id:,
+        # Settlement service.
+        settlement_service:,
+        # RFC 3339 timestamp for when the record was last updated. UTC time zone.
+        updated:,
+        # The clearing cycle that the network total record applies to. Mastercard only.
+        cycle: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            token: String,
+            amounts: Lithic::NetworkTotal::Amounts,
+            created: Time,
+            currency: String,
+            institution_id: String,
+            is_complete: T::Boolean,
+            network: Lithic::NetworkTotal::Network::TaggedSymbol,
+            report_date: Date,
+            settlement_institution_id: String,
+            settlement_service: String,
+            updated: Time,
+            cycle: Integer
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class Amounts < Lithic::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(Lithic::NetworkTotal::Amounts, Lithic::Internal::AnyHash)
+          end
+
+        # Total settlement amount excluding interchange, in currency's smallest unit.
+        sig { returns(Integer) }
+        attr_accessor :gross_settlement
+
+        # Interchange amount, in currency's smallest unit.
+        sig { returns(Integer) }
+        attr_accessor :interchange_fees
+
+        # `gross_settlement` net of `interchange_fees` and `visa_charges` (if applicable),
+        # in currency's smallest unit.
+        sig { returns(Integer) }
+        attr_accessor :net_settlement
+
+        # Charges specific to Visa/Interlink, in currency's smallest unit.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :visa_charges
+
+        sig { params(visa_charges: Integer).void }
+        attr_writer :visa_charges
+
+        sig do
+          params(
+            gross_settlement: Integer,
+            interchange_fees: Integer,
+            net_settlement: Integer,
+            visa_charges: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # Total settlement amount excluding interchange, in currency's smallest unit.
+          gross_settlement:,
+          # Interchange amount, in currency's smallest unit.
+          interchange_fees:,
+          # `gross_settlement` net of `interchange_fees` and `visa_charges` (if applicable),
+          # in currency's smallest unit.
+          net_settlement:,
+          # Charges specific to Visa/Interlink, in currency's smallest unit.
+          visa_charges: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              gross_settlement: Integer,
+              interchange_fees: Integer,
+              net_settlement: Integer,
+              visa_charges: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      # Card network where the transaction took place. AMEX, VISA, MASTERCARD, MAESTRO,
+      # or INTERLINK.
+      module Network
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::NetworkTotal::Network) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        AMEX = T.let(:AMEX, Lithic::NetworkTotal::Network::TaggedSymbol)
+        VISA = T.let(:VISA, Lithic::NetworkTotal::Network::TaggedSymbol)
+        MASTERCARD =
+          T.let(:MASTERCARD, Lithic::NetworkTotal::Network::TaggedSymbol)
+        MAESTRO = T.let(:MAESTRO, Lithic::NetworkTotal::Network::TaggedSymbol)
+        INTERLINK =
+          T.let(:INTERLINK, Lithic::NetworkTotal::Network::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[Lithic::NetworkTotal::Network::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end