lithic 0.1.0 → 0.2.0

data/rbi/lithic/models/digital_wallet_tokenization_updated_webhook_event.rbi

@@ -0,0 +1,73 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DigitalWalletTokenizationUpdatedWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::DigitalWalletTokenizationUpdatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # Account token
+      sig { returns(String) }
+      attr_accessor :account_token
+
+      # Card token
+      sig { returns(String) }
+      attr_accessor :card_token
+
+      # Created date
+      sig { returns(Time) }
+      attr_accessor :created
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { returns(Lithic::Tokenization) }
+      attr_reader :tokenization
+
+      sig { params(tokenization: Lithic::Tokenization::OrHash).void }
+      attr_writer :tokenization
+
+      sig do
+        params(
+          account_token: String,
+          card_token: String,
+          created: Time,
+          tokenization: Lithic::Tokenization::OrHash,
+          event_type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Account token
+        account_token:,
+        # Card token
+        card_token:,
+        # Created date
+        created:,
+        tokenization:,
+        # The type of event that occurred.
+        event_type: :"digital_wallet.tokenization_updated"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            account_token: String,
+            card_token: String,
+            created: Time,
+            event_type: Symbol,
+            tokenization: Lithic::Tokenization
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/dispute_evidence_upload_failed_webhook_event.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DisputeEvidenceUploadFailedWebhookEvent < Lithic::Models::DisputeEvidence
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::DisputeEvidenceUploadFailedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      # Dispute evidence.
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"dispute_evidence.upload_failed"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/dispute_transaction_created_webhook_event.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DisputeTransactionCreatedWebhookEvent < Lithic::Models::DisputeV2
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::DisputeTransactionCreatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      # The Dispute object tracks the progression of a dispute throughout its lifecycle.
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"dispute_transaction.created"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/dispute_transaction_updated_webhook_event.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DisputeTransactionUpdatedWebhookEvent < Lithic::Models::DisputeV2
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::DisputeTransactionUpdatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      # The Dispute object tracks the progression of a dispute throughout its lifecycle.
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"dispute_transaction.updated"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/dispute_updated_webhook_event.rbi

@@ -0,0 +1,28 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class DisputeUpdatedWebhookEvent < Lithic::Models::Dispute
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::DisputeUpdatedWebhookEvent, Lithic::Internal::AnyHash)
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      # Dispute.
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"dispute.updated"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/external_bank_account_created_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ExternalBankAccountCreatedWebhookEvent < Lithic::Models::ExternalBankAccount
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::ExternalBankAccountCreatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"external_bank_account.created"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/external_bank_account_updated_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ExternalBankAccountUpdatedWebhookEvent < Lithic::Models::ExternalBankAccount
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::ExternalBankAccountUpdatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"external_bank_account.updated"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/external_payment_created_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ExternalPaymentCreatedWebhookEvent < Lithic::Models::ExternalPayment
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::ExternalPaymentCreatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"external_payment.created"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/external_payment_updated_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ExternalPaymentUpdatedWebhookEvent < Lithic::Models::ExternalPayment
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::ExternalPaymentUpdatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"external_payment.updated"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/financial_account_created_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class FinancialAccountCreatedWebhookEvent < Lithic::Models::FinancialAccount
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::FinancialAccountCreatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"financial_account.created"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/financial_account_updated_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class FinancialAccountUpdatedWebhookEvent < Lithic::Models::FinancialAccount
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::FinancialAccountUpdatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"financial_account.updated"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/funding_event_created_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class FundingEventCreatedWebhookEvent < Lithic::Models::FundingEvent
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::FundingEventCreatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"funding_event.created"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/internal_transaction.rbi

@@ -11,7 +11,7 @@ module Lithic
       sig { returns(String) }
       attr_accessor :token
 
-      sig { returns(Lithic::InternalTransactionAPI::Category::OrSymbol) }
+      sig { returns(Lithic::InternalTransactionAPI::Category::TaggedSymbol) }
       attr_accessor :category
 
       sig { returns(Time) }
@@ -29,13 +29,13 @@ module Lithic
       sig { returns(Integer) }
       attr_accessor :pending_amount
 
-      sig { returns(Lithic::InternalTransactionAPI::Result::OrSymbol) }
+      sig { returns(Lithic::InternalTransactionAPI::Result::TaggedSymbol) }
       attr_accessor :result
 
       sig { returns(Integer) }
       attr_accessor :settled_amount
 
-      sig { returns(Lithic::InternalTransactionAPI::Status::OrSymbol) }
+      sig { returns(Lithic::InternalTransactionAPI::Status::TaggedSymbol) }
       attr_accessor :status
 
       sig { returns(Time) }
@@ -75,15 +75,15 @@ module Lithic
         override.returns(
           {
             token: String,
-            category: Lithic::InternalTransactionAPI::Category::OrSymbol,
+            category: Lithic::InternalTransactionAPI::Category::TaggedSymbol,
             created: Time,
             currency: String,
             descriptor: String,
             events: T::Array[Lithic::InternalTransactionAPI::Event],
             pending_amount: Integer,
-            result: Lithic::InternalTransactionAPI::Result::OrSymbol,
+            result: Lithic::InternalTransactionAPI::Result::TaggedSymbol,
             settled_amount: Integer,
-            status: Lithic::InternalTransactionAPI::Status::OrSymbol,
+            status: Lithic::InternalTransactionAPI::Status::TaggedSymbol,
             updated: Time
           }
         )
@@ -133,10 +133,14 @@ module Lithic
         sig { returns(Time) }
         attr_accessor :created
 
-        sig { returns(Lithic::InternalTransactionAPI::Event::Result::OrSymbol) }
+        sig do
+          returns(Lithic::InternalTransactionAPI::Event::Result::TaggedSymbol)
+        end
         attr_accessor :result
 
-        sig { returns(Lithic::InternalTransactionAPI::Event::Type::OrSymbol) }
+        sig do
+          returns(Lithic::InternalTransactionAPI::Event::Type::TaggedSymbol)
+        end
         attr_accessor :type
 
         sig do
@@ -157,8 +161,9 @@ module Lithic
               token: String,
               amount: Integer,
               created: Time,
-              result: Lithic::InternalTransactionAPI::Event::Result::OrSymbol,
-              type: Lithic::InternalTransactionAPI::Event::Type::OrSymbol
+              result:
+                Lithic::InternalTransactionAPI::Event::Result::TaggedSymbol,
+              type: Lithic::InternalTransactionAPI::Event::Type::TaggedSymbol
             }
           )
         end

data/rbi/lithic/models/internal_transaction_created_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class InternalTransactionCreatedWebhookEvent < Lithic::Models::InternalTransactionAPI
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::InternalTransactionCreatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"internal_transaction.created"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/internal_transaction_updated_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class InternalTransactionUpdatedWebhookEvent < Lithic::Models::InternalTransactionAPI
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::InternalTransactionUpdatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"internal_transaction.updated"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/loan_tape_created_webhook_event.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class LoanTapeCreatedWebhookEvent < Lithic::Models::FinancialAccounts::LoanTape
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::LoanTapeCreatedWebhookEvent, Lithic::Internal::AnyHash)
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"loan_tape.created"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/loan_tape_updated_webhook_event.rbi

@@ -0,0 +1,27 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class LoanTapeUpdatedWebhookEvent < Lithic::Models::FinancialAccounts::LoanTape
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::LoanTapeUpdatedWebhookEvent, Lithic::Internal::AnyHash)
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"loan_tape.updated"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/management_operation_created_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ManagementOperationCreatedWebhookEvent < Lithic::Models::ManagementOperationTransaction
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::ManagementOperationCreatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"management_operation.created"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/management_operation_updated_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class ManagementOperationUpdatedWebhookEvent < Lithic::Models::ManagementOperationTransaction
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::ManagementOperationUpdatedWebhookEvent,
+            Lithic::Internal::AnyHash
+          )
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig { params(event_type: Symbol).returns(T.attached_class) }
+      def self.new(
+        # The type of event that occurred.
+        event_type: :"management_operation.updated"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end