lithic 0.1.0 → 0.2.0

data/rbi/lithic/models/auth_rules_backtest_report_created_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class AuthRulesBacktestReportCreatedWebhookEvent < Lithic::Models::AuthRules::V2::BacktestResults
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::AuthRulesBacktestReportCreatedWebhookEvent,
+            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: :"auth_rules.backtest_report.created"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/balance_updated_webhook_event.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class BalanceUpdatedWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::BalanceUpdatedWebhookEvent, Lithic::Internal::AnyHash)
+        end
+
+      sig { returns(T::Array[Lithic::FinancialAccountBalance]) }
+      attr_accessor :data
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig do
+        params(
+          data: T::Array[Lithic::FinancialAccountBalance::OrHash],
+          event_type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        data:,
+        # The type of event that occurred.
+        event_type: :"balance.updated"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            data: T::Array[Lithic::FinancialAccountBalance],
+            event_type: Symbol
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/book_transfer_transaction_created_webhook_event.rbi

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

data/rbi/lithic/models/book_transfer_transaction_updated_webhook_event.rbi

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

data/rbi/lithic/models/card_converted_webhook_event.rbi

@@ -0,0 +1,35 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class CardConvertedWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::CardConvertedWebhookEvent, Lithic::Internal::AnyHash)
+        end
+
+      # The token of the card that was created.
+      sig { returns(String) }
+      attr_accessor :card_token
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      sig do
+        params(card_token: String, event_type: Symbol).returns(T.attached_class)
+      end
+      def self.new(
+        # The token of the card that was created.
+        card_token:,
+        # The type of event that occurred.
+        event_type: :"card.converted"
+      )
+      end
+
+      sig { override.returns({ card_token: String, event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/card_created_webhook_event.rbi

@@ -0,0 +1,53 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class CardCreatedWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::CardCreatedWebhookEvent, Lithic::Internal::AnyHash)
+        end
+
+      # The token of the card that was created.
+      sig { returns(String) }
+      attr_accessor :card_token
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      # The token of the card that was replaced, if the new card is a replacement card.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :replacement_for
+
+      sig do
+        params(
+          card_token: String,
+          replacement_for: T.nilable(String),
+          event_type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The token of the card that was created.
+        card_token:,
+        # The token of the card that was replaced, if the new card is a replacement card.
+        replacement_for: nil,
+        # The type of event that occurred.
+        event_type: :"card.created"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            card_token: String,
+            event_type: Symbol,
+            replacement_for: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/card_reissued_webhook_event.rbi

@@ -0,0 +1,38 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class CardReissuedWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::CardReissuedWebhookEvent, Lithic::Internal::AnyHash)
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      # The token of the card that was reissued.
+      sig { returns(T.nilable(String)) }
+      attr_reader :card_token
+
+      sig { params(card_token: String).void }
+      attr_writer :card_token
+
+      sig do
+        params(card_token: String, event_type: Symbol).returns(T.attached_class)
+      end
+      def self.new(
+        # The token of the card that was reissued.
+        card_token: nil,
+        # The type of event that occurred.
+        event_type: :"card.reissued"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol, card_token: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/card_renewed_webhook_event.rbi

@@ -0,0 +1,92 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class CardRenewedWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::CardRenewedWebhookEvent, Lithic::Internal::AnyHash)
+        end
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      # The token of the card that was renewed.
+      sig { returns(T.nilable(String)) }
+      attr_reader :card_token
+
+      sig { params(card_token: String).void }
+      attr_writer :card_token
+
+      # The new expiration month of the card.
+      sig { returns(T.nilable(String)) }
+      attr_reader :exp_month
+
+      sig { params(exp_month: String).void }
+      attr_writer :exp_month
+
+      # The new expiration year of the card.
+      sig { returns(T.nilable(String)) }
+      attr_reader :exp_year
+
+      sig { params(exp_year: String).void }
+      attr_writer :exp_year
+
+      # The previous expiration month of the card.
+      sig { returns(T.nilable(String)) }
+      attr_reader :previous_exp_month
+
+      sig { params(previous_exp_month: String).void }
+      attr_writer :previous_exp_month
+
+      # The previous expiration year of the card.
+      sig { returns(T.nilable(String)) }
+      attr_reader :previous_exp_year
+
+      sig { params(previous_exp_year: String).void }
+      attr_writer :previous_exp_year
+
+      sig do
+        params(
+          card_token: String,
+          exp_month: String,
+          exp_year: String,
+          previous_exp_month: String,
+          previous_exp_year: String,
+          event_type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The token of the card that was renewed.
+        card_token: nil,
+        # The new expiration month of the card.
+        exp_month: nil,
+        # The new expiration year of the card.
+        exp_year: nil,
+        # The previous expiration month of the card.
+        previous_exp_month: nil,
+        # The previous expiration year of the card.
+        previous_exp_year: nil,
+        # The type of event that occurred.
+        event_type: :"card.renewed"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            event_type: Symbol,
+            card_token: String,
+            exp_month: String,
+            exp_year: String,
+            previous_exp_month: String,
+            previous_exp_year: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/card_shipped_webhook_event.rbi

@@ -0,0 +1,150 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class CardShippedWebhookEvent < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::CardShippedWebhookEvent, Lithic::Internal::AnyHash)
+        end
+
+      # The token of the bulk order associated with this card shipment, if applicable.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :bulk_order_token
+
+      # The token of the card that was shipped.
+      sig { returns(String) }
+      attr_accessor :card_token
+
+      # The type of event that occurred.
+      sig { returns(Symbol) }
+      attr_accessor :event_type
+
+      # The specific shipping method used to ship the card.
+      sig do
+        returns(Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol)
+      end
+      attr_accessor :shipping_method
+
+      # The tracking number of the shipment.
+      sig { returns(T.nilable(String)) }
+      attr_accessor :tracking_number
+
+      sig do
+        params(
+          bulk_order_token: T.nilable(String),
+          card_token: String,
+          shipping_method:
+            Lithic::CardShippedWebhookEvent::ShippingMethod::OrSymbol,
+          tracking_number: T.nilable(String),
+          event_type: Symbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The token of the bulk order associated with this card shipment, if applicable.
+        bulk_order_token:,
+        # The token of the card that was shipped.
+        card_token:,
+        # The specific shipping method used to ship the card.
+        shipping_method:,
+        # The tracking number of the shipment.
+        tracking_number:,
+        # The type of event that occurred.
+        event_type: :"card.shipped"
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            bulk_order_token: T.nilable(String),
+            card_token: String,
+            event_type: Symbol,
+            shipping_method:
+              Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol,
+            tracking_number: T.nilable(String)
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # The specific shipping method used to ship the card.
+      module ShippingMethod
+        extend Lithic::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, Lithic::CardShippedWebhookEvent::ShippingMethod)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        EX_US_EXPEDITED_WITH_TRACKING =
+          T.let(
+            :"Ex-US expedited with tracking",
+            Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol
+          )
+        EX_US_STANDARD_WITH_TRACKING =
+          T.let(
+            :"Ex-US standard with tracking",
+            Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol
+          )
+        EX_US_STANDARD_WITHOUT_TRACKING =
+          T.let(
+            :"Ex-US standard without tracking",
+            Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol
+          )
+        FED_EX_2_DAYS =
+          T.let(
+            :"FedEx 2 days",
+            Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol
+          )
+        FED_EX_EXPRESS =
+          T.let(
+            :"FedEx express",
+            Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol
+          )
+        FED_EX_OVERNIGHT =
+          T.let(
+            :"FedEx overnight",
+            Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol
+          )
+        USPS_PRIORITY =
+          T.let(
+            :"USPS priority",
+            Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol
+          )
+        USPS_WITH_TRACKING =
+          T.let(
+            :"USPS with tracking",
+            Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol
+          )
+        USPS_WITHOUT_TRACKING_ENVELOPE =
+          T.let(
+            :"USPS without tracking envelope",
+            Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol
+          )
+        USPS_WITHOUT_TRACKING_ENVELOPE_NON_MACHINE =
+          T.let(
+            :"USPS without tracking envelope non-machine",
+            Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol
+          )
+        USPS_WITHOUT_TRACKING_FLAT =
+          T.let(
+            :"USPS without tracking flat",
+            Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol
+          )
+
+        sig do
+          override.returns(
+            T::Array[
+              Lithic::CardShippedWebhookEvent::ShippingMethod::TaggedSymbol
+            ]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/card_transaction_enhanced_data_created_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class CardTransactionEnhancedDataCreatedWebhookEvent < Lithic::Models::Transactions::Events::EnhancedData
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::CardTransactionEnhancedDataCreatedWebhookEvent,
+            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: :"card_transaction.enhanced_data.created"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/card_transaction_enhanced_data_updated_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class CardTransactionEnhancedDataUpdatedWebhookEvent < Lithic::Models::Transactions::Events::EnhancedData
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::CardTransactionEnhancedDataUpdatedWebhookEvent,
+            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: :"card_transaction.enhanced_data.updated"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/card_transaction_updated_webhook_event.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class CardTransactionUpdatedWebhookEvent < Lithic::Models::Transaction
+      OrHash =
+        T.type_alias do
+          T.any(
+            Lithic::CardTransactionUpdatedWebhookEvent,
+            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: :"card_transaction.updated"
+      )
+      end
+
+      sig { override.returns({ event_type: Symbol }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lithic/models/digital_wallet_token_metadata.rbi

@@ -40,7 +40,7 @@ module Lithic
       sig do
         returns(
           T.nilable(
-            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::OrSymbol
+            Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
           )
         )
       end
@@ -90,7 +90,7 @@ module Lithic
             payment_app_instance_id: T.nilable(String),
             token_requestor_id: String,
             token_requestor_name:
-              Lithic::DigitalWalletTokenMetadata::TokenRequestorName::OrSymbol
+              Lithic::DigitalWalletTokenMetadata::TokenRequestorName::TaggedSymbol
           }
         )
       end