lithic 0.1.0.pre.alpha.1

data/rbi/lib/lithic/models/auth_rules/v2_update_params.rbi

@@ -0,0 +1,113 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module AuthRules
+      class V2UpdateParams < Lithic::BaseModel
+        extend Lithic::RequestParameters::Converter
+        include Lithic::RequestParameters
+
+        # Account tokens to which the Auth Rule applies.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :account_tokens
+
+        sig { params(account_tokens: T::Array[String]).void }
+        attr_writer :account_tokens
+
+        # Auth Rule Name
+        sig { returns(T.nilable(String)) }
+        attr_accessor :name
+
+        # The desired state of the Auth Rule.
+        #
+        #   Note that only deactivating an Auth Rule through this endpoint is supported at
+        #   this time. If you need to (re-)activate an Auth Rule the /promote endpoint
+        #   should be used to promote a draft to the currently active version.
+        sig { returns(T.nilable(Lithic::Models::AuthRules::V2UpdateParams::State::OrSymbol)) }
+        attr_reader :state
+
+        sig { params(state: Lithic::Models::AuthRules::V2UpdateParams::State::OrSymbol).void }
+        attr_writer :state
+
+        # Card tokens to which the Auth Rule applies.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :card_tokens
+
+        sig { params(card_tokens: T::Array[String]).void }
+        attr_writer :card_tokens
+
+        # Card tokens to which the Auth Rule does not apply.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :excluded_card_tokens
+
+        sig { params(excluded_card_tokens: T::Array[String]).void }
+        attr_writer :excluded_card_tokens
+
+        # Whether the Auth Rule applies to all authorizations on the card program.
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :program_level
+
+        sig { params(program_level: T::Boolean).void }
+        attr_writer :program_level
+
+        sig do
+          params(
+            account_tokens: T::Array[String],
+            name: T.nilable(String),
+            state: Lithic::Models::AuthRules::V2UpdateParams::State::OrSymbol,
+            card_tokens: T::Array[String],
+            excluded_card_tokens: T::Array[String],
+            program_level: T::Boolean,
+            request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          account_tokens: nil,
+          name: nil,
+          state: nil,
+          card_tokens: nil,
+          excluded_card_tokens: nil,
+          program_level: nil,
+          request_options: {}
+        )
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                account_tokens: T::Array[String],
+                name: T.nilable(String),
+                state: Lithic::Models::AuthRules::V2UpdateParams::State::OrSymbol,
+                card_tokens: T::Array[String],
+                excluded_card_tokens: T::Array[String],
+                program_level: T::Boolean,
+                request_options: Lithic::RequestOptions
+              }
+            )
+        end
+        def to_hash
+        end
+
+        # The desired state of the Auth Rule.
+        #
+        #   Note that only deactivating an Auth Rule through this endpoint is supported at
+        #   this time. If you need to (re-)activate an Auth Rule the /promote endpoint
+        #   should be used to promote a draft to the currently active version.
+        module State
+          extend Lithic::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AuthRules::V2UpdateParams::State) }
+          OrSymbol = T.type_alias { T.any(Symbol, Lithic::Models::AuthRules::V2UpdateParams::State::TaggedSymbol) }
+
+          INACTIVE = T.let(:INACTIVE, Lithic::Models::AuthRules::V2UpdateParams::State::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::AuthRules::V2UpdateParams::State::TaggedSymbol]) }
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/auth_rules/v2_update_response.rbi

@@ -0,0 +1,270 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module AuthRules
+      class V2UpdateResponse < Lithic::BaseModel
+        # Auth Rule Token
+        sig { returns(String) }
+        attr_accessor :token
+
+        # Account tokens to which the Auth Rule applies.
+        sig { returns(T::Array[String]) }
+        attr_accessor :account_tokens
+
+        # Card tokens to which the Auth Rule applies.
+        sig { returns(T::Array[String]) }
+        attr_accessor :card_tokens
+
+        sig { returns(T.nilable(Lithic::Models::AuthRules::V2UpdateResponse::CurrentVersion)) }
+        attr_reader :current_version
+
+        sig do
+          params(
+            current_version: T.nilable(T.any(Lithic::Models::AuthRules::V2UpdateResponse::CurrentVersion, Lithic::Util::AnyHash))
+          )
+            .void
+        end
+        attr_writer :current_version
+
+        sig { returns(T.nilable(Lithic::Models::AuthRules::V2UpdateResponse::DraftVersion)) }
+        attr_reader :draft_version
+
+        sig do
+          params(
+            draft_version: T.nilable(T.any(Lithic::Models::AuthRules::V2UpdateResponse::DraftVersion, Lithic::Util::AnyHash))
+          )
+            .void
+        end
+        attr_writer :draft_version
+
+        # Auth Rule Name
+        sig { returns(T.nilable(String)) }
+        attr_accessor :name
+
+        # Whether the Auth Rule applies to all authorizations on the card program.
+        sig { returns(T::Boolean) }
+        attr_accessor :program_level
+
+        # The state of the Auth Rule
+        sig { returns(Lithic::Models::AuthRules::V2UpdateResponse::State::TaggedSymbol) }
+        attr_accessor :state
+
+        # The type of Auth Rule
+        sig { returns(Lithic::Models::AuthRules::V2UpdateResponse::Type::TaggedSymbol) }
+        attr_accessor :type
+
+        # Card tokens to which the Auth Rule does not apply.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :excluded_card_tokens
+
+        sig { params(excluded_card_tokens: T::Array[String]).void }
+        attr_writer :excluded_card_tokens
+
+        sig do
+          params(
+            token: String,
+            account_tokens: T::Array[String],
+            card_tokens: T::Array[String],
+            current_version: T.nilable(T.any(Lithic::Models::AuthRules::V2UpdateResponse::CurrentVersion, Lithic::Util::AnyHash)),
+            draft_version: T.nilable(T.any(Lithic::Models::AuthRules::V2UpdateResponse::DraftVersion, Lithic::Util::AnyHash)),
+            name: T.nilable(String),
+            program_level: T::Boolean,
+            state: Lithic::Models::AuthRules::V2UpdateResponse::State::OrSymbol,
+            type: Lithic::Models::AuthRules::V2UpdateResponse::Type::OrSymbol,
+            excluded_card_tokens: T::Array[String]
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(
+          token:,
+          account_tokens:,
+          card_tokens:,
+          current_version:,
+          draft_version:,
+          name:,
+          program_level:,
+          state:,
+          type:,
+          excluded_card_tokens: nil
+        )
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                token: String,
+                account_tokens: T::Array[String],
+                card_tokens: T::Array[String],
+                current_version: T.nilable(Lithic::Models::AuthRules::V2UpdateResponse::CurrentVersion),
+                draft_version: T.nilable(Lithic::Models::AuthRules::V2UpdateResponse::DraftVersion),
+                name: T.nilable(String),
+                program_level: T::Boolean,
+                state: Lithic::Models::AuthRules::V2UpdateResponse::State::TaggedSymbol,
+                type: Lithic::Models::AuthRules::V2UpdateResponse::Type::TaggedSymbol,
+                excluded_card_tokens: T::Array[String]
+              }
+            )
+        end
+        def to_hash
+        end
+
+        class CurrentVersion < Lithic::BaseModel
+          # Parameters for the Auth Rule
+          sig do
+            returns(
+              T.any(
+                Lithic::Models::AuthRules::ConditionalBlockParameters,
+                Lithic::Models::AuthRules::VelocityLimitParams
+              )
+            )
+          end
+          attr_accessor :parameters
+
+          # The version of the rule, this is incremented whenever the rule's parameters
+          #   change.
+          sig { returns(Integer) }
+          attr_accessor :version
+
+          sig do
+            params(
+              parameters: T.any(
+                Lithic::Models::AuthRules::ConditionalBlockParameters,
+                Lithic::Util::AnyHash,
+                Lithic::Models::AuthRules::VelocityLimitParams
+              ),
+              version: Integer
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(parameters:, version:)
+          end
+
+          sig do
+            override
+              .returns(
+                {
+                  parameters: T.any(
+                    Lithic::Models::AuthRules::ConditionalBlockParameters,
+                    Lithic::Models::AuthRules::VelocityLimitParams
+                  ),
+                  version: Integer
+                }
+              )
+          end
+          def to_hash
+          end
+
+          # Parameters for the Auth Rule
+          module Parameters
+            extend Lithic::Union
+
+            sig do
+              override
+                .returns(
+                  [Lithic::Models::AuthRules::ConditionalBlockParameters, Lithic::Models::AuthRules::VelocityLimitParams]
+                )
+            end
+            def self.variants
+            end
+          end
+        end
+
+        class DraftVersion < Lithic::BaseModel
+          # Parameters for the Auth Rule
+          sig do
+            returns(
+              T.any(
+                Lithic::Models::AuthRules::ConditionalBlockParameters,
+                Lithic::Models::AuthRules::VelocityLimitParams
+              )
+            )
+          end
+          attr_accessor :parameters
+
+          # The version of the rule, this is incremented whenever the rule's parameters
+          #   change.
+          sig { returns(Integer) }
+          attr_accessor :version
+
+          sig do
+            params(
+              parameters: T.any(
+                Lithic::Models::AuthRules::ConditionalBlockParameters,
+                Lithic::Util::AnyHash,
+                Lithic::Models::AuthRules::VelocityLimitParams
+              ),
+              version: Integer
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(parameters:, version:)
+          end
+
+          sig do
+            override
+              .returns(
+                {
+                  parameters: T.any(
+                    Lithic::Models::AuthRules::ConditionalBlockParameters,
+                    Lithic::Models::AuthRules::VelocityLimitParams
+                  ),
+                  version: Integer
+                }
+              )
+          end
+          def to_hash
+          end
+
+          # Parameters for the Auth Rule
+          module Parameters
+            extend Lithic::Union
+
+            sig do
+              override
+                .returns(
+                  [Lithic::Models::AuthRules::ConditionalBlockParameters, Lithic::Models::AuthRules::VelocityLimitParams]
+                )
+            end
+            def self.variants
+            end
+          end
+        end
+
+        # The state of the Auth Rule
+        module State
+          extend Lithic::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AuthRules::V2UpdateResponse::State) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, Lithic::Models::AuthRules::V2UpdateResponse::State::TaggedSymbol) }
+
+          ACTIVE = T.let(:ACTIVE, Lithic::Models::AuthRules::V2UpdateResponse::State::TaggedSymbol)
+          INACTIVE = T.let(:INACTIVE, Lithic::Models::AuthRules::V2UpdateResponse::State::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::AuthRules::V2UpdateResponse::State::TaggedSymbol]) }
+          def self.values
+          end
+        end
+
+        # The type of Auth Rule
+        module Type
+          extend Lithic::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AuthRules::V2UpdateResponse::Type) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, Lithic::Models::AuthRules::V2UpdateResponse::Type::TaggedSymbol) }
+
+          CONDITIONAL_BLOCK =
+            T.let(:CONDITIONAL_BLOCK, Lithic::Models::AuthRules::V2UpdateResponse::Type::TaggedSymbol)
+          VELOCITY_LIMIT = T.let(:VELOCITY_LIMIT, Lithic::Models::AuthRules::V2UpdateResponse::Type::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::AuthRules::V2UpdateResponse::Type::TaggedSymbol]) }
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,140 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module AuthRules
+      class VelocityLimitParams < Lithic::BaseModel
+        sig { returns(Lithic::Models::AuthRules::VelocityLimitParams::Filters) }
+        attr_reader :filters
+
+        sig { params(filters: T.any(Lithic::Models::AuthRules::VelocityLimitParams::Filters, Lithic::Util::AnyHash)).void }
+        attr_writer :filters
+
+        # 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(T.any(Integer, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::OrSymbol)) }
+        attr_accessor :period
+
+        sig { returns(Lithic::Models::AuthRules::VelocityLimitParams::Scope::OrSymbol) }
+        attr_accessor :scope
+
+        # The maximum amount of spend velocity allowed in the period in minor units (the
+        #   smallest unit of a currency, e.g. cents for USD). Transactions exceeding this
+        #   limit will be declined.
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :limit_amount
+
+        # The number of spend velocity impacting transactions may not exceed this limit in
+        #   the period. Transactions exceeding this limit will be declined. A spend velocity
+        #   impacting transaction is a transaction that has been authorized, and optionally
+        #   settled, or a force post (a transaction that settled without prior
+        #   authorization).
+        sig { returns(T.nilable(Integer)) }
+        attr_accessor :limit_count
+
+        sig do
+          params(
+            filters: T.any(Lithic::Models::AuthRules::VelocityLimitParams::Filters, Lithic::Util::AnyHash),
+            period: T.any(Integer, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::OrSymbol),
+            scope: Lithic::Models::AuthRules::VelocityLimitParams::Scope::OrSymbol,
+            limit_amount: T.nilable(Integer),
+            limit_count: T.nilable(Integer)
+          )
+            .returns(T.attached_class)
+        end
+        def self.new(filters:, period:, scope:, limit_amount: nil, limit_count: nil)
+        end
+
+        sig do
+          override
+            .returns(
+              {
+                filters: Lithic::Models::AuthRules::VelocityLimitParams::Filters,
+                period: T.any(Integer, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::OrSymbol),
+                scope: Lithic::Models::AuthRules::VelocityLimitParams::Scope::OrSymbol,
+                limit_amount: T.nilable(Integer),
+                limit_count: T.nilable(Integer)
+              }
+            )
+        end
+        def to_hash
+        end
+
+        class Filters < Lithic::BaseModel
+          # ISO-3166-1 alpha-3 Country Codes to exclude from the velocity calculation.
+          #   Transactions matching any of the provided will be excluded from the calculated
+          #   velocity.
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_accessor :exclude_countries
+
+          # Merchant Category Codes to exclude from the velocity calculation. Transactions
+          #   matching this MCC will be excluded from the calculated velocity.
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_accessor :exclude_mccs
+
+          # ISO-3166-1 alpha-3 Country Codes to include in the velocity calculation.
+          #   Transactions not matching any of the provided will not be included in the
+          #   calculated velocity.
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_accessor :include_countries
+
+          # Merchant Category Codes to include in the velocity calculation. Transactions not
+          #   matching this MCC will not be included in the calculated velocity.
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_accessor :include_mccs
+
+          sig do
+            params(
+              exclude_countries: T.nilable(T::Array[String]),
+              exclude_mccs: T.nilable(T::Array[String]),
+              include_countries: T.nilable(T::Array[String]),
+              include_mccs: T.nilable(T::Array[String])
+            )
+              .returns(T.attached_class)
+          end
+          def self.new(exclude_countries: nil, exclude_mccs: nil, include_countries: nil, include_mccs: nil)
+          end
+
+          sig do
+            override
+              .returns(
+                {
+                  exclude_countries: T.nilable(T::Array[String]),
+                  exclude_mccs: T.nilable(T::Array[String]),
+                  include_countries: T.nilable(T::Array[String]),
+                  include_mccs: T.nilable(T::Array[String])
+                }
+              )
+          end
+          def to_hash
+          end
+        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).
+        module Period
+          extend Lithic::Union
+
+          sig { override.returns([Integer, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::OrSymbol]) }
+          def self.variants
+          end
+        end
+
+        module Scope
+          extend Lithic::Enum
+
+          TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AuthRules::VelocityLimitParams::Scope) }
+          OrSymbol =
+            T.type_alias { T.any(Symbol, Lithic::Models::AuthRules::VelocityLimitParams::Scope::TaggedSymbol) }
+
+          CARD = T.let(:CARD, Lithic::Models::AuthRules::VelocityLimitParams::Scope::TaggedSymbol)
+          ACCOUNT = T.let(:ACCOUNT, Lithic::Models::AuthRules::VelocityLimitParams::Scope::TaggedSymbol)
+
+          sig { override.returns(T::Array[Lithic::Models::AuthRules::VelocityLimitParams::Scope::TaggedSymbol]) }
+          def self.values
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/auth_rules/velocity_limit_params_period_window.rbi

@@ -0,0 +1,30 @@
+# typed: strong
+
+module Lithic
+  module Models
+    module AuthRules
+      # The window of time to calculate Spend Velocity over.
+      #
+      #   - `DAY`: Velocity over the current day since midnight Eastern Time.
+      #   - `WEEK`: Velocity over the current week since 00:00 / 12 AM on Monday in
+      #     Eastern Time.
+      #   - `MONTH`: Velocity over the current month since 00:00 / 12 AM on the first of
+      #     the month in Eastern Time.
+      module VelocityLimitParamsPeriodWindow
+        extend Lithic::Enum
+
+        TaggedSymbol = T.type_alias { T.all(Symbol, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol) }
+
+        DAY = T.let(:DAY, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol)
+        WEEK = T.let(:WEEK, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol)
+        MONTH = T.let(:MONTH, Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::AuthRules::VelocityLimitParamsPeriodWindow::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/auth_stream_enrollment_retrieve_secret_params.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class AuthStreamEnrollmentRetrieveSecretParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      sig do
+        params(
+          request_options: T.any(
+            Lithic::RequestOptions,
+            Lithic::Util::AnyHash
+          )
+        ).returns(T.attached_class)
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({request_options: Lithic::RequestOptions}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/auth_stream_enrollment_rotate_secret_params.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class AuthStreamEnrollmentRotateSecretParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      sig do
+        params(
+          request_options: T.any(
+            Lithic::RequestOptions,
+            Lithic::Util::AnyHash
+          )
+        ).returns(T.attached_class)
+      end
+      def self.new(request_options: {})
+      end
+
+      sig { override.returns({request_options: Lithic::RequestOptions}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/auth_stream_secret.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class AuthStreamSecret < Lithic::BaseModel
+      # The shared HMAC ASA secret
+      sig { returns(T.nilable(String)) }
+      attr_reader :secret
+
+      sig { params(secret: String).void }
+      attr_writer :secret
+
+      sig { params(secret: String).returns(T.attached_class) }
+      def self.new(secret: nil)
+      end
+
+      sig { override.returns({secret: String}) }
+      def to_hash
+      end
+    end
+  end
+end