lithic 0.1.0.pre.alpha.54 → 0.1.0.pre.alpha.56

data/rbi/lithic/models/auth_rules/velocity_limit_params.rbi

@@ -22,20 +22,15 @@ module Lithic
         end
         attr_writer :filters
 
-        # DEPRECATED: This has been deprecated in favor of the Trailing Window Objects
-        #
-        # The size of the trailing window to calculate Spend Velocity over in seconds. The
-        # minimum value is 10 seconds, and the maximum value is 2678400 seconds (31 days).
+        # Velocity over the current day since 00:00 / 12 AM in Eastern Time
         sig do
           returns(
             T.any(
-              Integer,
-              Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindow::OrSymbol,
-              Lithic::AuthRules::VelocityLimitParamsPeriodWindow::TrailingWindowObject,
-              Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindowDay,
-              Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindowWeek,
-              Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindowMonth,
-              Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindowYear
+              Lithic::AuthRules::VelocityLimitPeriod::TrailingWindowObject,
+              Lithic::AuthRules::VelocityLimitPeriod::FixedWindowDay,
+              Lithic::AuthRules::VelocityLimitPeriod::FixedWindowWeek,
+              Lithic::AuthRules::VelocityLimitPeriod::FixedWindowMonth,
+              Lithic::AuthRules::VelocityLimitPeriod::FixedWindowYear
             )
           )
         end
@@ -64,13 +59,11 @@ module Lithic
             filters: Lithic::AuthRules::VelocityLimitParams::Filters::OrHash,
             period:
               T.any(
-                Integer,
-                Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindow::OrSymbol,
-                Lithic::AuthRules::VelocityLimitParamsPeriodWindow::TrailingWindowObject::OrHash,
-                Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindowDay::OrHash,
-                Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindowWeek::OrHash,
-                Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindowMonth::OrHash,
-                Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindowYear::OrHash
+                Lithic::AuthRules::VelocityLimitPeriod::TrailingWindowObject::OrHash,
+                Lithic::AuthRules::VelocityLimitPeriod::FixedWindowDay::OrHash,
+                Lithic::AuthRules::VelocityLimitPeriod::FixedWindowWeek::OrHash,
+                Lithic::AuthRules::VelocityLimitPeriod::FixedWindowMonth::OrHash,
+                Lithic::AuthRules::VelocityLimitPeriod::FixedWindowYear::OrHash
               ),
             scope: Lithic::AuthRules::VelocityLimitParams::Scope::OrSymbol,
             limit_amount: T.nilable(Integer),
@@ -79,10 +72,7 @@ module Lithic
         end
         def self.new(
           filters:,
-          # DEPRECATED: This has been deprecated in favor of the Trailing Window Objects
-          #
-          # The size of the trailing window to calculate Spend Velocity over in seconds. The
-          # minimum value is 10 seconds, and the maximum value is 2678400 seconds (31 days).
+          # Velocity over the current day since 00:00 / 12 AM in Eastern Time
           period:,
           # The scope the velocity is calculated for
           scope:,
@@ -105,13 +95,11 @@ module Lithic
               filters: Lithic::AuthRules::VelocityLimitParams::Filters,
               period:
                 T.any(
-                  Integer,
-                  Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindow::OrSymbol,
-                  Lithic::AuthRules::VelocityLimitParamsPeriodWindow::TrailingWindowObject,
-                  Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindowDay,
-                  Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindowWeek,
-                  Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindowMonth,
-                  Lithic::AuthRules::VelocityLimitParamsPeriodWindow::FixedWindowYear
+                  Lithic::AuthRules::VelocityLimitPeriod::TrailingWindowObject,
+                  Lithic::AuthRules::VelocityLimitPeriod::FixedWindowDay,
+                  Lithic::AuthRules::VelocityLimitPeriod::FixedWindowWeek,
+                  Lithic::AuthRules::VelocityLimitPeriod::FixedWindowMonth,
+                  Lithic::AuthRules::VelocityLimitPeriod::FixedWindowYear
                 ),
               scope: Lithic::AuthRules::VelocityLimitParams::Scope::OrSymbol,
               limit_amount: T.nilable(Integer),

data/rbi/lithic/models/auth_rules/velocity_limit_period.rbi

@@ -0,0 +1,223 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module AuthRules
+      # Velocity over the current day since 00:00 / 12 AM in Eastern Time
+      module VelocityLimitPeriod
+        extend Lithic::Internal::Type::Union
+
+        Variants =
+          T.type_alias do
+            T.any(
+              Lithic::AuthRules::VelocityLimitPeriod::TrailingWindowObject,
+              Lithic::AuthRules::VelocityLimitPeriod::FixedWindowDay,
+              Lithic::AuthRules::VelocityLimitPeriod::FixedWindowWeek,
+              Lithic::AuthRules::VelocityLimitPeriod::FixedWindowMonth,
+              Lithic::AuthRules::VelocityLimitPeriod::FixedWindowYear
+            )
+          end
+
+        class TrailingWindowObject < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::AuthRules::VelocityLimitPeriod::TrailingWindowObject,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          # The size of the trailing window to calculate Spend Velocity over in seconds. The
+          # minimum value is 10 seconds, and the maximum value is 2678400 seconds (31 days).
+          sig { returns(Integer) }
+          attr_accessor :duration
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          sig do
+            params(duration: Integer, type: Symbol).returns(T.attached_class)
+          end
+          def self.new(
+            # The size of the trailing window to calculate Spend Velocity over in seconds. The
+            # minimum value is 10 seconds, and the maximum value is 2678400 seconds (31 days).
+            duration:,
+            type: :CUSTOM
+          )
+          end
+
+          sig { override.returns({ duration: Integer, type: Symbol }) }
+          def to_hash
+          end
+        end
+
+        class FixedWindowDay < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::AuthRules::VelocityLimitPeriod::FixedWindowDay,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # Velocity over the current day since 00:00 / 12 AM in Eastern Time
+          sig { params(type: Symbol).returns(T.attached_class) }
+          def self.new(type: :DAY)
+          end
+
+          sig { override.returns({ type: Symbol }) }
+          def to_hash
+          end
+        end
+
+        class FixedWindowWeek < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::AuthRules::VelocityLimitPeriod::FixedWindowWeek,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The day of the week to start the week from. Following ISO-8601, 1 is Monday and
+          # 7 is Sunday. Defaults to Monday if not specified.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :day_of_week
+
+          sig { params(day_of_week: Integer).void }
+          attr_writer :day_of_week
+
+          # Velocity over the current week since 00:00 / 12 AM in Eastern Time on specified
+          # `day_of_week`
+          sig do
+            params(day_of_week: Integer, type: Symbol).returns(T.attached_class)
+          end
+          def self.new(
+            # The day of the week to start the week from. Following ISO-8601, 1 is Monday and
+            # 7 is Sunday. Defaults to Monday if not specified.
+            day_of_week: nil,
+            type: :WEEK
+          )
+          end
+
+          sig { override.returns({ type: Symbol, day_of_week: Integer }) }
+          def to_hash
+          end
+        end
+
+        class FixedWindowMonth < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::AuthRules::VelocityLimitPeriod::FixedWindowMonth,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The day of the month to start from. Accepts values from 1 to 31, and will reset
+          # at the end of the month if the day exceeds the number of days in the month.
+          # Defaults to the 1st of the month if not specified.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :day_of_month
+
+          sig { params(day_of_month: Integer).void }
+          attr_writer :day_of_month
+
+          # Velocity over the current month since 00:00 / 12 AM in Eastern Time on specified
+          # `day_of_month`.
+          sig do
+            params(day_of_month: Integer, type: Symbol).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # The day of the month to start from. Accepts values from 1 to 31, and will reset
+            # at the end of the month if the day exceeds the number of days in the month.
+            # Defaults to the 1st of the month if not specified.
+            day_of_month: nil,
+            type: :MONTH
+          )
+          end
+
+          sig { override.returns({ type: Symbol, day_of_month: Integer }) }
+          def to_hash
+          end
+        end
+
+        class FixedWindowYear < Lithic::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                Lithic::AuthRules::VelocityLimitPeriod::FixedWindowYear,
+                Lithic::Internal::AnyHash
+              )
+            end
+
+          sig { returns(Symbol) }
+          attr_accessor :type
+
+          # The day of the month to start from. Defaults to the 1st of the month if not
+          # specified.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :day_of_month
+
+          sig { params(day_of_month: Integer).void }
+          attr_writer :day_of_month
+
+          # The month to start from. 1 is January and 12 is December. Defaults to January if
+          # not specified.
+          sig { returns(T.nilable(Integer)) }
+          attr_reader :month
+
+          sig { params(month: Integer).void }
+          attr_writer :month
+
+          # Velocity over the current year since 00:00 / 12 AM in Eastern Time on specified
+          # `month` and `day_of_month`. This validates the month and day of the year to
+          # start from is a real date. In the event that February 29th is selected, in
+          # non-leap years, the window will start from February 28th.
+          sig do
+            params(day_of_month: Integer, month: Integer, type: Symbol).returns(
+              T.attached_class
+            )
+          end
+          def self.new(
+            # The day of the month to start from. Defaults to the 1st of the month if not
+            # specified.
+            day_of_month: nil,
+            # The month to start from. 1 is January and 12 is December. Defaults to January if
+            # not specified.
+            month: nil,
+            type: :YEAR
+          )
+          end
+
+          sig do
+            override.returns(
+              { type: Symbol, day_of_month: Integer, month: Integer }
+            )
+          end
+          def to_hash
+          end
+        end
+
+        sig do
+          override.returns(
+            T::Array[Lithic::AuthRules::VelocityLimitPeriod::Variants]
+          )
+        end
+        def self.variants
+        end
+      end
+    end
+  end
+end

data/rbi/lithic/models/book_transfer_response.rbi

@@ -255,7 +255,9 @@ module Lithic
 
         sig do
           returns(
-            Lithic::BookTransferResponse::Event::DetailedResults::TaggedSymbol
+            T::Array[
+              Lithic::BookTransferResponse::Event::DetailedResult::TaggedSymbol
+            ]
           )
         end
         attr_accessor :detailed_results
@@ -286,7 +288,9 @@ module Lithic
             amount: Integer,
             created: Time,
             detailed_results:
-              Lithic::BookTransferResponse::Event::DetailedResults::OrSymbol,
+              T::Array[
+                Lithic::BookTransferResponse::Event::DetailedResult::OrSymbol
+              ],
             memo: String,
             result: Lithic::BookTransferResponse::Event::Result::OrSymbol,
             subtype: String,
@@ -321,7 +325,9 @@ module Lithic
               amount: Integer,
               created: Time,
               detailed_results:
-                Lithic::BookTransferResponse::Event::DetailedResults::TaggedSymbol,
+                T::Array[
+                  Lithic::BookTransferResponse::Event::DetailedResult::TaggedSymbol
+                ],
               memo: String,
               result: Lithic::BookTransferResponse::Event::Result::TaggedSymbol,
               subtype: String,
@@ -332,33 +338,30 @@ module Lithic
         def to_hash
         end
 
-        module DetailedResults
+        module DetailedResult
           extend Lithic::Internal::Type::Enum
 
           TaggedSymbol =
             T.type_alias do
-              T.all(
-                Symbol,
-                Lithic::BookTransferResponse::Event::DetailedResults
-              )
+              T.all(Symbol, Lithic::BookTransferResponse::Event::DetailedResult)
             end
           OrSymbol = T.type_alias { T.any(Symbol, String) }
 
           APPROVED =
             T.let(
               :APPROVED,
-              Lithic::BookTransferResponse::Event::DetailedResults::TaggedSymbol
+              Lithic::BookTransferResponse::Event::DetailedResult::TaggedSymbol
             )
           FUNDS_INSUFFICIENT =
             T.let(
               :FUNDS_INSUFFICIENT,
-              Lithic::BookTransferResponse::Event::DetailedResults::TaggedSymbol
+              Lithic::BookTransferResponse::Event::DetailedResult::TaggedSymbol
             )
 
           sig do
             override.returns(
               T::Array[
-                Lithic::BookTransferResponse::Event::DetailedResults::TaggedSymbol
+                Lithic::BookTransferResponse::Event::DetailedResult::TaggedSymbol
               ]
             )
           end
@@ -634,6 +637,8 @@ module Lithic
           T.let(:REVERSED, Lithic::BookTransferResponse::Status::TaggedSymbol)
         CANCELED =
           T.let(:CANCELED, Lithic::BookTransferResponse::Status::TaggedSymbol)
+        RETURNED =
+          T.let(:RETURNED, Lithic::BookTransferResponse::Status::TaggedSymbol)
 
         sig do
           override.returns(

data/rbi/lithic/models/category_details.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class CategoryDetails < Lithic::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(Lithic::CategoryDetails, Lithic::Internal::AnyHash)
+        end
+
+      sig { returns(String) }
+      attr_accessor :balance_transfers
+
+      sig { returns(String) }
+      attr_accessor :cash_advances
+
+      sig { returns(String) }
+      attr_accessor :purchases
+
+      sig do
+        params(
+          balance_transfers: String,
+          cash_advances: String,
+          purchases: String
+        ).returns(T.attached_class)
+      end
+      def self.new(balance_transfers:, cash_advances:, purchases:)
+      end
+
+      sig do
+        override.returns(
+          {
+            balance_transfers: String,
+            cash_advances: String,
+            purchases: String
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end