lithic 0.1.0.pre.alpha.1

data/rbi/lib/lithic/models/tokenization_activate_params.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationActivateParams < 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/tokenization_deactivate_params.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationDeactivateParams < 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/tokenization_decisioning_retrieve_secret_params.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationDecisioningRetrieveSecretParams < 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/tokenization_decisioning_rotate_secret_params.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationDecisioningRotateSecretParams < 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/tokenization_decisioning_rotate_secret_response.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationDecisioningRotateSecretResponse < Lithic::BaseModel
+      # The new Tokenization Decisioning HMAC 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

data/rbi/lib/lithic/models/tokenization_list_params.rbi

@@ -0,0 +1,135 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationListParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      # Filters for tokenizations associated with a specific account.
+      sig { returns(T.nilable(String)) }
+      attr_reader :account_token
+
+      sig { params(account_token: String).void }
+      attr_writer :account_token
+
+      # Filter for tokenizations created after this date.
+      sig { returns(T.nilable(Date)) }
+      attr_reader :begin_
+
+      sig { params(begin_: Date).void }
+      attr_writer :begin_
+
+      # Filters for tokenizations associated with a specific card.
+      sig { returns(T.nilable(String)) }
+      attr_reader :card_token
+
+      sig { params(card_token: String).void }
+      attr_writer :card_token
+
+      # Filter for tokenizations created before this date.
+      sig { returns(T.nilable(Date)) }
+      attr_reader :end_
+
+      sig { params(end_: Date).void }
+      attr_writer :end_
+
+      # A cursor representing an item's token before which a page of results should end.
+      #   Used to retrieve the previous page of results before this item.
+      sig { returns(T.nilable(String)) }
+      attr_reader :ending_before
+
+      sig { params(ending_before: String).void }
+      attr_writer :ending_before
+
+      # Page size (for pagination).
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :page_size
+
+      sig { params(page_size: Integer).void }
+      attr_writer :page_size
+
+      # A cursor representing an item's token after which a page of results should
+      #   begin. Used to retrieve the next page of results after this item.
+      sig { returns(T.nilable(String)) }
+      attr_reader :starting_after
+
+      sig { params(starting_after: String).void }
+      attr_writer :starting_after
+
+      # Filter for tokenizations by tokenization channel. If this is not specified, only
+      #   DIGITAL_WALLET tokenizations will be returned.
+      sig { returns(T.nilable(Lithic::Models::TokenizationListParams::TokenizationChannel::OrSymbol)) }
+      attr_reader :tokenization_channel
+
+      sig { params(tokenization_channel: Lithic::Models::TokenizationListParams::TokenizationChannel::OrSymbol).void }
+      attr_writer :tokenization_channel
+
+      sig do
+        params(
+          account_token: String,
+          begin_: Date,
+          card_token: String,
+          end_: Date,
+          ending_before: String,
+          page_size: Integer,
+          starting_after: String,
+          tokenization_channel: Lithic::Models::TokenizationListParams::TokenizationChannel::OrSymbol,
+          request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        account_token: nil,
+        begin_: nil,
+        card_token: nil,
+        end_: nil,
+        ending_before: nil,
+        page_size: nil,
+        starting_after: nil,
+        tokenization_channel: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              account_token: String,
+              begin_: Date,
+              card_token: String,
+              end_: Date,
+              ending_before: String,
+              page_size: Integer,
+              starting_after: String,
+              tokenization_channel: Lithic::Models::TokenizationListParams::TokenizationChannel::OrSymbol,
+              request_options: Lithic::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # Filter for tokenizations by tokenization channel. If this is not specified, only
+      #   DIGITAL_WALLET tokenizations will be returned.
+      module TokenizationChannel
+        extend Lithic::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::Models::TokenizationListParams::TokenizationChannel) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::TokenizationListParams::TokenizationChannel::TaggedSymbol) }
+
+        DIGITAL_WALLET =
+          T.let(:DIGITAL_WALLET, Lithic::Models::TokenizationListParams::TokenizationChannel::TaggedSymbol)
+        MERCHANT = T.let(:MERCHANT, Lithic::Models::TokenizationListParams::TokenizationChannel::TaggedSymbol)
+        ALL = T.let(:ALL, Lithic::Models::TokenizationListParams::TokenizationChannel::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::TokenizationListParams::TokenizationChannel::TaggedSymbol]) }
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/tokenization_pause_params.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationPauseParams < 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/tokenization_resend_activation_code_params.rbi

@@ -0,0 +1,78 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationResendActivationCodeParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      # The communication method that the user has selected to use to receive the
+      #   authentication code. Supported Values: Sms = "TEXT_TO_CARDHOLDER_NUMBER". Email
+      #   = "EMAIL_TO_CARDHOLDER_ADDRESS"
+      sig { returns(T.nilable(Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol)) }
+      attr_reader :activation_method_type
+
+      sig do
+        params(
+          activation_method_type: Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol
+        )
+          .void
+      end
+      attr_writer :activation_method_type
+
+      sig do
+        params(
+          activation_method_type: Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol,
+          request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(activation_method_type: nil, request_options: {})
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              activation_method_type: Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol,
+              request_options: Lithic::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # The communication method that the user has selected to use to receive the
+      #   authentication code. Supported Values: Sms = "TEXT_TO_CARDHOLDER_NUMBER". Email
+      #   = "EMAIL_TO_CARDHOLDER_ADDRESS"
+      module ActivationMethodType
+        extend Lithic::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::TaggedSymbol) }
+
+        EMAIL_TO_CARDHOLDER_ADDRESS =
+          T.let(
+            :EMAIL_TO_CARDHOLDER_ADDRESS,
+            Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::TaggedSymbol
+          )
+        TEXT_TO_CARDHOLDER_NUMBER =
+          T.let(
+            :TEXT_TO_CARDHOLDER_NUMBER,
+            Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::TaggedSymbol
+          )
+
+        sig do
+          override
+            .returns(
+              T::Array[Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::TaggedSymbol]
+            )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/tokenization_retrieve_params.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationRetrieveParams < 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/tokenization_retrieve_response.rbi

@@ -0,0 +1,21 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationRetrieveResponse < Lithic::BaseModel
+      sig { returns(T.nilable(Lithic::Models::Tokenization)) }
+      attr_reader :data
+
+      sig { params(data: T.any(Lithic::Models::Tokenization, Lithic::Util::AnyHash)).void }
+      attr_writer :data
+
+      sig { params(data: T.any(Lithic::Models::Tokenization, Lithic::Util::AnyHash)).returns(T.attached_class) }
+      def self.new(data: nil)
+      end
+
+      sig { override.returns({data: Lithic::Models::Tokenization}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/tokenization_secret.rbi

@@ -0,0 +1,22 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationSecret < Lithic::BaseModel
+      # The Tokenization Decisioning HMAC 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

data/rbi/lib/lithic/models/tokenization_simulate_params.rbi

@@ -0,0 +1,156 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationSimulateParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      # The three digit cvv for the card.
+      sig { returns(String) }
+      attr_accessor :cvv
+
+      # The expiration date of the card in 'MM/YY' format.
+      sig { returns(String) }
+      attr_accessor :expiration_date
+
+      # The sixteen digit card number.
+      sig { returns(String) }
+      attr_accessor :pan
+
+      # The source of the tokenization request.
+      sig { returns(Lithic::Models::TokenizationSimulateParams::TokenizationSource::OrSymbol) }
+      attr_accessor :tokenization_source
+
+      # The account score (1-5) that represents how the Digital Wallet's view on how
+      #   reputable an end user's account is.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :account_score
+
+      sig { params(account_score: Integer).void }
+      attr_writer :account_score
+
+      # The device score (1-5) that represents how the Digital Wallet's view on how
+      #   reputable an end user's device is.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :device_score
+
+      sig { params(device_score: Integer).void }
+      attr_writer :device_score
+
+      # Optional field to specify the token requestor name for a merchant token
+      #   simulation. Ignored when tokenization_source is not MERCHANT.
+      sig { returns(T.nilable(String)) }
+      attr_reader :entity
+
+      sig { params(entity: String).void }
+      attr_writer :entity
+
+      # The decision that the Digital Wallet's recommend
+      sig { returns(T.nilable(Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol)) }
+      attr_reader :wallet_recommended_decision
+
+      sig do
+        params(
+          wallet_recommended_decision: Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol
+        )
+          .void
+      end
+      attr_writer :wallet_recommended_decision
+
+      sig do
+        params(
+          cvv: String,
+          expiration_date: String,
+          pan: String,
+          tokenization_source: Lithic::Models::TokenizationSimulateParams::TokenizationSource::OrSymbol,
+          account_score: Integer,
+          device_score: Integer,
+          entity: String,
+          wallet_recommended_decision: Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol,
+          request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(
+        cvv:,
+        expiration_date:,
+        pan:,
+        tokenization_source:,
+        account_score: nil,
+        device_score: nil,
+        entity: nil,
+        wallet_recommended_decision: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override
+          .returns(
+            {
+              cvv: String,
+              expiration_date: String,
+              pan: String,
+              tokenization_source: Lithic::Models::TokenizationSimulateParams::TokenizationSource::OrSymbol,
+              account_score: Integer,
+              device_score: Integer,
+              entity: String,
+              wallet_recommended_decision: Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::OrSymbol,
+              request_options: Lithic::RequestOptions
+            }
+          )
+      end
+      def to_hash
+      end
+
+      # The source of the tokenization request.
+      module TokenizationSource
+        extend Lithic::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::Models::TokenizationSimulateParams::TokenizationSource) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::TokenizationSimulateParams::TokenizationSource::TaggedSymbol) }
+
+        APPLE_PAY =
+          T.let(:APPLE_PAY, Lithic::Models::TokenizationSimulateParams::TokenizationSource::TaggedSymbol)
+        GOOGLE = T.let(:GOOGLE, Lithic::Models::TokenizationSimulateParams::TokenizationSource::TaggedSymbol)
+        SAMSUNG_PAY =
+          T.let(:SAMSUNG_PAY, Lithic::Models::TokenizationSimulateParams::TokenizationSource::TaggedSymbol)
+        MERCHANT = T.let(:MERCHANT, Lithic::Models::TokenizationSimulateParams::TokenizationSource::TaggedSymbol)
+
+        sig { override.returns(T::Array[Lithic::Models::TokenizationSimulateParams::TokenizationSource::TaggedSymbol]) }
+        def self.values
+        end
+      end
+
+      # The decision that the Digital Wallet's recommend
+      module WalletRecommendedDecision
+        extend Lithic::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision) }
+        OrSymbol =
+          T.type_alias { T.any(Symbol, Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::TaggedSymbol) }
+
+        APPROVED =
+          T.let(:APPROVED, Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::TaggedSymbol)
+        DECLINED =
+          T.let(:DECLINED, Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::TaggedSymbol)
+        REQUIRE_ADDITIONAL_AUTHENTICATION =
+          T.let(
+            :REQUIRE_ADDITIONAL_AUTHENTICATION,
+            Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::TaggedSymbol
+          )
+
+        sig do
+          override
+            .returns(T::Array[Lithic::Models::TokenizationSimulateParams::WalletRecommendedDecision::TaggedSymbol])
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/tokenization_simulate_response.rbi

@@ -0,0 +1,24 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationSimulateResponse < Lithic::BaseModel
+      sig { returns(T.nilable(T::Array[Lithic::Models::Tokenization])) }
+      attr_reader :data
+
+      sig { params(data: T::Array[T.any(Lithic::Models::Tokenization, Lithic::Util::AnyHash)]).void }
+      attr_writer :data
+
+      sig do
+        params(data: T::Array[T.any(Lithic::Models::Tokenization, Lithic::Util::AnyHash)])
+          .returns(T.attached_class)
+      end
+      def self.new(data: nil)
+      end
+
+      sig { override.returns({data: T::Array[Lithic::Models::Tokenization]}) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/lib/lithic/models/tokenization_unpause_params.rbi

@@ -0,0 +1,25 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationUnpauseParams < 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/tokenization_update_digital_card_art_params.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Lithic
+  module Models
+    class TokenizationUpdateDigitalCardArtParams < Lithic::BaseModel
+      extend Lithic::RequestParameters::Converter
+      include Lithic::RequestParameters
+
+      # Specifies the digital card art to be displayed in the user’s digital wallet for
+      #   a tokenization. This artwork must be approved by the network and configured by
+      #   Lithic to use. See
+      #   [Flexible Card Art Guide](https://docs.lithic.com/docs/about-digital-wallets#flexible-card-art).
+      sig { returns(T.nilable(String)) }
+      attr_reader :digital_card_art_token
+
+      sig { params(digital_card_art_token: String).void }
+      attr_writer :digital_card_art_token
+
+      sig do
+        params(
+          digital_card_art_token: String,
+          request_options: T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(digital_card_art_token: nil, request_options: {})
+      end
+
+      sig { override.returns({digital_card_art_token: String, request_options: Lithic::RequestOptions}) }
+      def to_hash
+      end
+    end
+  end
+end