lithic 0.18.0 → 0.19.0

data/rbi/lithic/models/payment.rbi

@@ -240,6 +240,7 @@ module Lithic
 
         ACH = T.let(:ACH, Lithic::Payment::Category::TaggedSymbol)
         WIRE = T.let(:WIRE, Lithic::Payment::Category::TaggedSymbol)
+        STABLECOIN = T.let(:STABLECOIN, Lithic::Payment::Category::TaggedSymbol)
         BALANCE_OR_FUNDING =
           T.let(:BALANCE_OR_FUNDING, Lithic::Payment::Category::TaggedSymbol)
         FEE = T.let(:FEE, Lithic::Payment::Category::TaggedSymbol)
@@ -277,6 +278,8 @@ module Lithic
         HOLD = T.let(:HOLD, Lithic::Payment::Category::TaggedSymbol)
         PROGRAM_FUNDING =
           T.let(:PROGRAM_FUNDING, Lithic::Payment::Category::TaggedSymbol)
+        PROGRAM_TRANSFER =
+          T.let(:PROGRAM_TRANSFER, Lithic::Payment::Category::TaggedSymbol)
 
         sig do
           override.returns(T::Array[Lithic::Payment::Category::TaggedSymbol])
@@ -379,6 +382,13 @@ module Lithic
         #   Reserve and funds returned to sender.
         # - `WIRE_RETURN_OUTBOUND_REJECTED` - Outbound wire return rejected by the Federal
         #   Reserve.
+        #
+        # Stablecoin events:
+        #
+        # - `STABLECOIN_RECEIVED` - Stablecoin pay-in received on-chain and pending
+        #   release to available balance.
+        # - `STABLECOIN_REVIEWED` - Stablecoin pay-in has completed the review process.
+        # - `STABLECOIN_SETTLED` - Stablecoin pay-in funds released to available balance.
         sig { returns(Lithic::Payment::Event::Type::TaggedSymbol) }
         attr_accessor :type
 
@@ -486,6 +496,13 @@ module Lithic
           #   Reserve and funds returned to sender.
           # - `WIRE_RETURN_OUTBOUND_REJECTED` - Outbound wire return rejected by the Federal
           #   Reserve.
+          #
+          # Stablecoin events:
+          #
+          # - `STABLECOIN_RECEIVED` - Stablecoin pay-in received on-chain and pending
+          #   release to available balance.
+          # - `STABLECOIN_REVIEWED` - Stablecoin pay-in has completed the review process.
+          # - `STABLECOIN_SETTLED` - Stablecoin pay-in funds released to available balance.
           type:,
           # More detailed reasons for the event
           detailed_results: nil,
@@ -588,6 +605,13 @@ module Lithic
         #   Reserve and funds returned to sender.
         # - `WIRE_RETURN_OUTBOUND_REJECTED` - Outbound wire return rejected by the Federal
         #   Reserve.
+        #
+        # Stablecoin events:
+        #
+        # - `STABLECOIN_RECEIVED` - Stablecoin pay-in received on-chain and pending
+        #   release to available balance.
+        # - `STABLECOIN_REVIEWED` - Stablecoin pay-in has completed the review process.
+        # - `STABLECOIN_SETTLED` - Stablecoin pay-in funds released to available balance.
         module Type
           extend Lithic::Internal::Type::Enum
 
@@ -705,6 +729,21 @@ module Lithic
               :WIRE_RETURN_OUTBOUND_REJECTED,
               Lithic::Payment::Event::Type::TaggedSymbol
             )
+          STABLECOIN_RECEIVED =
+            T.let(
+              :STABLECOIN_RECEIVED,
+              Lithic::Payment::Event::Type::TaggedSymbol
+            )
+          STABLECOIN_REVIEWED =
+            T.let(
+              :STABLECOIN_REVIEWED,
+              Lithic::Payment::Event::Type::TaggedSymbol
+            )
+          STABLECOIN_SETTLED =
+            T.let(
+              :STABLECOIN_SETTLED,
+              Lithic::Payment::Event::Type::TaggedSymbol
+            )
 
           sig do
             override.returns(
@@ -840,6 +879,10 @@ module Lithic
           sig { returns(T.nilable(String)) }
           attr_accessor :receipt_routing_number
 
+          # Name of the recipient on ACH receipts. Reflects the originating bank's record
+          sig { returns(T.nilable(String)) }
+          attr_accessor :recipient_name
+
           # Number of retries attempted
           sig { returns(T.nilable(Integer)) }
           attr_accessor :retries
@@ -864,6 +907,7 @@ module Lithic
               company_id: T.nilable(String),
               override_company_name: T.nilable(String),
               receipt_routing_number: T.nilable(String),
+              recipient_name: T.nilable(String),
               retries: T.nilable(Integer),
               return_reason_code: T.nilable(String),
               trace_numbers: T::Array[String]
@@ -883,6 +927,8 @@ module Lithic
             override_company_name: nil,
             # Receipt routing number
             receipt_routing_number: nil,
+            # Name of the recipient on ACH receipts. Reflects the originating bank's record
+            recipient_name: nil,
             # Number of retries attempted
             retries: nil,
             # Return reason code if the transaction was returned
@@ -902,6 +948,7 @@ module Lithic
                 company_id: T.nilable(String),
                 override_company_name: T.nilable(String),
                 receipt_routing_number: T.nilable(String),
+                recipient_name: T.nilable(String),
                 retries: T.nilable(Integer),
                 return_reason_code: T.nilable(String),
                 trace_numbers: T::Array[String]

data/rbi/lithic/models/payment_list_params.rbi

@@ -202,6 +202,8 @@ module Lithic
           T.let(:PENDING, Lithic::PaymentListParams::Status::TaggedSymbol)
         RETURNED =
           T.let(:RETURNED, Lithic::PaymentListParams::Status::TaggedSymbol)
+        REVERSED =
+          T.let(:REVERSED, Lithic::PaymentListParams::Status::TaggedSymbol)
         SETTLED =
           T.let(:SETTLED, Lithic::PaymentListParams::Status::TaggedSymbol)
 

data/rbi/lithic/models/transaction_monitoring/case_transaction.rbi

@@ -3,71 +3,176 @@
 module Lithic
   module Models
     module TransactionMonitoring
-      class CaseTransaction < Lithic::Internal::Type::BaseModel
-        OrHash =
+      # A single transaction associated with a case. The `category` field identifies
+      # whether this is a card transaction or a payment transaction.
+      module CaseTransaction
+        extend Lithic::Internal::Type::Union
+
+        Variants =
           T.type_alias do
             T.any(
-              Lithic::TransactionMonitoring::CaseTransaction,
-              Lithic::Internal::AnyHash
+              Lithic::TransactionMonitoring::CaseTransaction::CardCaseTransaction,
+              Lithic::TransactionMonitoring::CaseTransaction::PaymentCaseTransaction
             )
           end
 
-        # Globally unique identifier for the transaction
-        sig { returns(String) }
-        attr_accessor :token
+        class CardCaseTransaction < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::TransactionMonitoring::CaseTransaction::CardCaseTransaction,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # Globally unique identifier for the card transaction
+          sig { returns(String) }
+          attr_accessor :token
 
-        # Token of the account the transaction belongs to
-        sig { returns(String) }
-        attr_accessor :account_token
+          # Token of the account the transaction belongs to
+          sig { returns(String) }
+          attr_accessor :account_token
 
-        # Date and time at which the transaction was added to the case
-        sig { returns(Time) }
-        attr_accessor :added_at
+          # Date and time at which the transaction was added to the case
+          sig { returns(Time) }
+          attr_accessor :added_at
 
-        # Token of the card the transaction was made on
-        sig { returns(String) }
-        attr_accessor :card_token
+          # Token of the card the transaction was made on
+          sig { returns(String) }
+          attr_accessor :card_token
 
-        # Date and time at which the transaction was created
-        sig { returns(Time) }
-        attr_accessor :transaction_created_at
+          sig { returns(Symbol) }
+          attr_accessor :category
 
-        # A single transaction associated with a case
-        sig do
-          params(
-            token: String,
-            account_token: String,
-            added_at: Time,
-            card_token: String,
-            transaction_created_at: Time
-          ).returns(T.attached_class)
+          # Date and time at which the transaction was created
+          sig { returns(Time) }
+          attr_accessor :transaction_created_at
+
+          # A card transaction associated with a case
+          sig do
+            params(
+              token: String,
+              account_token: String,
+              added_at: Time,
+              card_token: String,
+              transaction_created_at: Time,
+              category: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Globally unique identifier for the card transaction
+            token:,
+            # Token of the account the transaction belongs to
+            account_token:,
+            # Date and time at which the transaction was added to the case
+            added_at:,
+            # Token of the card the transaction was made on
+            card_token:,
+            # Date and time at which the transaction was created
+            transaction_created_at:,
+            category: :CARD
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                token: String,
+                account_token: String,
+                added_at: Time,
+                card_token: String,
+                category: Symbol,
+                transaction_created_at: Time
+              }
+            )
+          end
+          def to_hash
+          end
         end
-        def self.new(
-          # Globally unique identifier for the transaction
-          token:,
-          # Token of the account the transaction belongs to
-          account_token:,
+
+        class PaymentCaseTransaction < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::TransactionMonitoring::CaseTransaction::PaymentCaseTransaction,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # Globally unique identifier for the payment transaction
+          sig { returns(String) }
+          attr_accessor :token
+
           # Date and time at which the transaction was added to the case
-          added_at:,
-          # Token of the card the transaction was made on
-          card_token:,
+          sig { returns(Time) }
+          attr_accessor :added_at
+
+          sig { returns(Symbol) }
+          attr_accessor :category
+
+          # Token of the financial account the payment belongs to
+          sig { returns(String) }
+          attr_accessor :financial_account_token
+
           # Date and time at which the transaction was created
-          transaction_created_at:
-        )
+          sig { returns(Time) }
+          attr_accessor :transaction_created_at
+
+          # Token of the account the payment belongs to, if applicable
+          sig { returns(T.nilable(String)) }
+          attr_reader :account_token
+
+          sig { params(account_token: String).void }
+          attr_writer :account_token
+
+          # A payment (ACH) transaction associated with a case
+          sig do
+            params(
+              token: String,
+              added_at: Time,
+              financial_account_token: String,
+              transaction_created_at: Time,
+              account_token: String,
+              category: Symbol
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            # Globally unique identifier for the payment transaction
+            token:,
+            # Date and time at which the transaction was added to the case
+            added_at:,
+            # Token of the financial account the payment belongs to
+            financial_account_token:,
+            # Date and time at which the transaction was created
+            transaction_created_at:,
+            # Token of the account the payment belongs to, if applicable
+            account_token: nil,
+            category: :PAYMENT
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                token: String,
+                added_at: Time,
+                category: Symbol,
+                financial_account_token: String,
+                transaction_created_at: Time,
+                account_token: String
+              }
+            )
+          end
+          def to_hash
+          end
         end
 
         sig do
           override.returns(
-            {
-              token: String,
-              account_token: String,
-              added_at: Time,
-              card_token: String,
-              transaction_created_at: Time
-            }
+            T::Array[Lithic::TransactionMonitoring::CaseTransaction::Variants]
           )
         end
-        def to_hash
+        def self.variants
         end
       end
     end

data/rbi/lithic/models/transaction_monitoring/case_update_params.rbi

@@ -46,29 +46,12 @@ module Lithic
         end
         attr_writer :priority
 
-        # Outcome recorded when a case is resolved:
-        #
-        # - `CONFIRMED_FRAUD` - The reviewed activity was confirmed to be fraudulent
-        # - `SUSPICIOUS_ACTIVITY` - The activity is suspicious but not confirmed fraud
-        # - `FALSE_POSITIVE` - The activity was legitimate and the alert was a false
-        #   positive
-        # - `NO_ACTION_REQUIRED` - No further action is required
-        # - `ESCALATED_EXTERNAL` - The case was escalated to an external party
-        sig do
-          returns(
-            T.nilable(
-              Lithic::TransactionMonitoring::ResolutionOutcome::OrSymbol
-            )
-          )
-        end
+        # Resolution to record on the case. Must be one of the `allowed_resolutions`
+        # configured on the case's queue, otherwise the request is rejected with a `400`
+        sig { returns(T.nilable(String)) }
         attr_reader :resolution
 
-        sig do
-          params(
-            resolution:
-              Lithic::TransactionMonitoring::ResolutionOutcome::OrSymbol
-          ).void
-        end
+        sig { params(resolution: String).void }
         attr_writer :resolution
 
         # Notes describing the resolution
@@ -123,8 +106,7 @@ module Lithic
             actor_token: String,
             assignee: T.nilable(String),
             priority: Lithic::TransactionMonitoring::CasePriority::OrSymbol,
-            resolution:
-              Lithic::TransactionMonitoring::ResolutionOutcome::OrSymbol,
+            resolution: String,
             resolution_notes: String,
             sla_deadline: T.nilable(Time),
             status: Lithic::TransactionMonitoring::CaseStatus::OrSymbol,
@@ -143,14 +125,8 @@ module Lithic
           assignee: nil,
           # Priority level of a case, controlling queue ordering and SLA urgency
           priority: nil,
-          # Outcome recorded when a case is resolved:
-          #
-          # - `CONFIRMED_FRAUD` - The reviewed activity was confirmed to be fraudulent
-          # - `SUSPICIOUS_ACTIVITY` - The activity is suspicious but not confirmed fraud
-          # - `FALSE_POSITIVE` - The activity was legitimate and the alert was a false
-          #   positive
-          # - `NO_ACTION_REQUIRED` - No further action is required
-          # - `ESCALATED_EXTERNAL` - The case was escalated to an external party
+          # Resolution to record on the case. Must be one of the `allowed_resolutions`
+          # configured on the case's queue, otherwise the request is rejected with a `400`
           resolution: nil,
           # Notes describing the resolution
           resolution_notes: nil,
@@ -182,8 +158,7 @@ module Lithic
               actor_token: String,
               assignee: T.nilable(String),
               priority: Lithic::TransactionMonitoring::CasePriority::OrSymbol,
-              resolution:
-                Lithic::TransactionMonitoring::ResolutionOutcome::OrSymbol,
+              resolution: String,
               resolution_notes: String,
               sla_deadline: T.nilable(Time),
               status: Lithic::TransactionMonitoring::CaseStatus::OrSymbol,

data/rbi/lithic/models/transaction_monitoring/monitoring_case.rbi

@@ -53,21 +53,9 @@ module Lithic
         sig { returns(String) }
         attr_accessor :queue_token
 
-        # Outcome recorded when a case is resolved:
-        #
-        # - `CONFIRMED_FRAUD` - The reviewed activity was confirmed to be fraudulent
-        # - `SUSPICIOUS_ACTIVITY` - The activity is suspicious but not confirmed fraud
-        # - `FALSE_POSITIVE` - The activity was legitimate and the alert was a false
-        #   positive
-        # - `NO_ACTION_REQUIRED` - No further action is required
-        # - `ESCALATED_EXTERNAL` - The case was escalated to an external party
-        sig do
-          returns(
-            T.nilable(
-              Lithic::TransactionMonitoring::ResolutionOutcome::TaggedSymbol
-            )
-          )
-        end
+        # Outcome recorded when the case was resolved, from the `allowed_resolutions`
+        # configured on the case's queue
+        sig { returns(T.nilable(String)) }
         attr_accessor :resolution
 
         # Free-form notes describing the resolution
@@ -123,10 +111,7 @@ module Lithic
             pending_transactions: T::Boolean,
             priority: Lithic::TransactionMonitoring::CasePriority::OrSymbol,
             queue_token: String,
-            resolution:
-              T.nilable(
-                Lithic::TransactionMonitoring::ResolutionOutcome::OrSymbol
-              ),
+            resolution: T.nilable(String),
             resolution_notes: T.nilable(String),
             resolved: T.nilable(Time),
             rule_token: T.nilable(String),
@@ -154,14 +139,8 @@ module Lithic
           priority:,
           # Token of the queue the case belongs to
           queue_token:,
-          # Outcome recorded when a case is resolved:
-          #
-          # - `CONFIRMED_FRAUD` - The reviewed activity was confirmed to be fraudulent
-          # - `SUSPICIOUS_ACTIVITY` - The activity is suspicious but not confirmed fraud
-          # - `FALSE_POSITIVE` - The activity was legitimate and the alert was a false
-          #   positive
-          # - `NO_ACTION_REQUIRED` - No further action is required
-          # - `ESCALATED_EXTERNAL` - The case was escalated to an external party
+          # Outcome recorded when the case was resolved, from the `allowed_resolutions`
+          # configured on the case's queue
           resolution:,
           # Free-form notes describing the resolution
           resolution_notes:,
@@ -203,10 +182,7 @@ module Lithic
               priority:
                 Lithic::TransactionMonitoring::CasePriority::TaggedSymbol,
               queue_token: String,
-              resolution:
-                T.nilable(
-                  Lithic::TransactionMonitoring::ResolutionOutcome::TaggedSymbol
-                ),
+              resolution: T.nilable(String),
               resolution_notes: T.nilable(String),
               resolved: T.nilable(Time),
               rule_token: T.nilable(String),

data/rbi/lithic/models/transaction_monitoring/queue.rbi

@@ -16,6 +16,11 @@ module Lithic
         sig { returns(String) }
         attr_accessor :token
 
+        # Resolutions that can be recorded on cases in this queue. Always the effective
+        # list: the queue's own values when it defines them, otherwise the default list
+        sig { returns(T::Array[String]) }
+        attr_accessor :allowed_resolutions
+
         # Number of cases in the queue, broken down by status. A status is omitted when
         # the queue has no cases in that status
         sig { returns(Lithic::TransactionMonitoring::Queue::CaseCounts) }
@@ -49,6 +54,7 @@ module Lithic
         sig do
           params(
             token: String,
+            allowed_resolutions: T::Array[String],
             case_counts:
               Lithic::TransactionMonitoring::Queue::CaseCounts::OrHash,
             created: Time,
@@ -60,6 +66,9 @@ module Lithic
         def self.new(
           # Globally unique identifier for the queue
           token:,
+          # Resolutions that can be recorded on cases in this queue. Always the effective
+          # list: the queue's own values when it defines them, otherwise the default list
+          allowed_resolutions:,
           # Number of cases in the queue, broken down by status. A status is omitted when
           # the queue has no cases in that status
           case_counts:,
@@ -78,6 +87,7 @@ module Lithic
           override.returns(
             {
               token: String,
+              allowed_resolutions: T::Array[String],
               case_counts: Lithic::TransactionMonitoring::Queue::CaseCounts,
               created: Time,
               description: T.nilable(String),

data/rbi/lithic/models/transaction_monitoring/queue_create_params.rbi

@@ -19,6 +19,12 @@ module Lithic
         sig { returns(String) }
         attr_accessor :name
 
+        # Resolutions that can be recorded on cases in this queue. Omit or send `null` to
+        # use the default list. Values are free-form labels and must be non-empty and
+        # unique
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :allowed_resolutions
+
         # Optional description of the queue
         sig { returns(T.nilable(String)) }
         attr_accessor :description
@@ -26,6 +32,7 @@ module Lithic
         sig do
           params(
             name: String,
+            allowed_resolutions: T.nilable(T::Array[String]),
             description: T.nilable(String),
             request_options: Lithic::RequestOptions::OrHash
           ).returns(T.attached_class)
@@ -33,6 +40,10 @@ module Lithic
         def self.new(
           # Human-readable name of the queue
           name:,
+          # Resolutions that can be recorded on cases in this queue. Omit or send `null` to
+          # use the default list. Values are free-form labels and must be non-empty and
+          # unique
+          allowed_resolutions: nil,
           # Optional description of the queue
           description: nil,
           request_options: {}
@@ -43,6 +54,7 @@ module Lithic
           override.returns(
             {
               name: String,
+              allowed_resolutions: T.nilable(T::Array[String]),
               description: T.nilable(String),
               request_options: Lithic::RequestOptions
             }

data/rbi/lithic/models/transaction_monitoring/queue_update_params.rbi

@@ -18,6 +18,13 @@ module Lithic
         sig { returns(String) }
         attr_accessor :queue_token
 
+        # New list of resolutions that can be recorded on cases in this queue, or `null`
+        # to revert to the default list. Values are free-form labels and must be non-empty
+        # and unique. Changing the list only affects what is selectable going forward; the
+        # `resolution` already stored on a case is preserved as-is
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_accessor :allowed_resolutions
+
         # New description for the queue, or `null` to clear it
         sig { returns(T.nilable(String)) }
         attr_accessor :description
@@ -32,6 +39,7 @@ module Lithic
         sig do
           params(
             queue_token: String,
+            allowed_resolutions: T.nilable(T::Array[String]),
             description: T.nilable(String),
             name: String,
             request_options: Lithic::RequestOptions::OrHash
@@ -39,6 +47,11 @@ module Lithic
         end
         def self.new(
           queue_token:,
+          # New list of resolutions that can be recorded on cases in this queue, or `null`
+          # to revert to the default list. Values are free-form labels and must be non-empty
+          # and unique. Changing the list only affects what is selectable going forward; the
+          # `resolution` already stored on a case is preserved as-is
+          allowed_resolutions: nil,
           # New description for the queue, or `null` to clear it
           description: nil,
           # New name for the queue
@@ -51,6 +64,7 @@ module Lithic
           override.returns(
             {
               queue_token: String,
+              allowed_resolutions: T.nilable(T::Array[String]),
               description: T.nilable(String),
               name: String,
               request_options: Lithic::RequestOptions

data/rbi/lithic/models/transaction_simulate_clearing_params.rbi

@@ -24,9 +24,10 @@ module Lithic
       # example, entering 100 in this field will result in a -100 amount in the
       # transaction, if the original authorization is a credit authorization.
       #
-      # If `amount` is not set, the full amount of the transaction will be cleared.
-      # Transactions that have already cleared, either partially or fully, cannot be
-      # cleared again using this endpoint.
+      # If `amount` is not set, the full amount of the transaction will be cleared. This
+      # endpoint may be called multiple times against the same authorization to simulate
+      # a multiple-completion scenario, with each call creating a separate clearing
+      # event.
       sig { returns(T.nilable(Integer)) }
       attr_reader :amount
 
@@ -49,9 +50,10 @@ module Lithic
         # example, entering 100 in this field will result in a -100 amount in the
         # transaction, if the original authorization is a credit authorization.
         #
-        # If `amount` is not set, the full amount of the transaction will be cleared.
-        # Transactions that have already cleared, either partially or fully, cannot be
-        # cleared again using this endpoint.
+        # If `amount` is not set, the full amount of the transaction will be cleared. This
+        # endpoint may be called multiple times against the same authorization to simulate
+        # a multiple-completion scenario, with each call creating a separate clearing
+        # event.
         amount: nil,
         request_options: {}
       )

data/rbi/lithic/models.rbi

@@ -278,6 +278,11 @@ module Lithic
 
   Document = Lithic::Models::Document
 
+  EmbedSessionGeneratedWebhookEvent =
+    Lithic::Models::EmbedSessionGeneratedWebhookEvent
+
+  EmbedViewedWebhookEvent = Lithic::Models::EmbedViewedWebhookEvent
+
   Event = Lithic::Models::Event
 
   EventListAttemptsParams = Lithic::Models::EventListAttemptsParams

data/rbi/lithic/resources/card_authorizations.rbi

@@ -5,7 +5,7 @@ module Lithic
     class CardAuthorizations
       # Card program's response to Authorization Challenge. Programs that have
       # Authorization Challenges configured as Out of Band receive a
-      # [card_authorization.challenge](https://docs.lithic.com/reference/post_card-authorization-challenge)
+      # [card_authorization.challenge](https://docs.lithic.com/reference/cardauthorizationchallengewebhook)
       # webhook when an authorization attempt triggers a challenge. The card program
       # should respond using this endpoint after the cardholder completes the challenge.
       sig do

data/rbi/lithic/resources/cards.rbi

@@ -393,6 +393,9 @@ module Lithic
       )
       end
 
+      # **Deprecated.** Use the modern embedded card flow instead: create a session with
+      # `POST /v1/cards/{card_token}/embed` and render it via `GET /v1/embed`.
+      #
       # Handling full card PANs and CVV codes requires that you comply with the Payment
       # Card Industry Data Security Standards (PCI DSS). Some clients choose to reduce
       # their compliance obligations by leveraging our embedded card UI solution

data/rbi/lithic/resources/external_payments.rbi

@@ -71,7 +71,7 @@ module Lithic
         # will be included. UTC time zone.
         begin_: nil,
         business_account_token: nil,
-        # External Payment category to be returned.
+        # The external rail the funds moved on
         category: nil,
         # Date string in RFC 3339 format. Only entries created before the specified time
         # will be included. UTC time zone.