lithic 0.1.0.pre.alpha.1

data/rbi/lib/lithic/resources/responder_endpoints.rbi

@@ -0,0 +1,59 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class ResponderEndpoints
+      # Enroll a responder endpoint
+      sig do
+        params(
+          type: Lithic::Models::ResponderEndpointCreateParams::Type::OrSymbol,
+          url: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::ResponderEndpointCreateResponse)
+      end
+      def create(
+        # The type of the endpoint.
+        type: nil,
+        # The URL for the responder endpoint (must be http(s)).
+        url: nil,
+        request_options: {}
+      )
+      end
+
+      # Disenroll a responder endpoint
+      sig do
+        params(
+          type: Lithic::Models::ResponderEndpointDeleteParams::Type::OrSymbol,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .void
+      end
+      def delete(
+        # The type of the endpoint.
+        type:,
+        request_options: {}
+      )
+      end
+
+      # Check the status of a responder endpoint
+      sig do
+        params(
+          type: Lithic::Models::ResponderEndpointCheckStatusParams::Type::OrSymbol,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::ResponderEndpointStatus)
+      end
+      def check_status(
+        # The type of the endpoint.
+        type:,
+        request_options: {}
+      )
+      end
+
+      sig { params(client: Lithic::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/three_ds/authentication.rbi

@@ -0,0 +1,76 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class ThreeDS
+      class Authentication
+        # Get 3DS Authentication by token
+        sig do
+          params(
+            three_ds_authentication_token: String,
+            request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+          )
+            .returns(Lithic::Models::ThreeDS::AuthenticationRetrieveResponse)
+        end
+        def retrieve(
+          # 3DS Authentication Token
+          three_ds_authentication_token,
+          request_options: {}
+        )
+        end
+
+        # Simulates a 3DS authentication request from the payment network as if it came
+        #   from an ACS. If you're configured for 3DS Customer Decisioning, simulating
+        #   authentications requires your customer decisioning endpoint to be set up
+        #   properly (respond with a valid JSON).
+        sig do
+          params(
+            merchant: T.any(Lithic::Models::ThreeDS::AuthenticationSimulateParams::Merchant, Lithic::Util::AnyHash),
+            pan: String,
+            transaction: T.any(Lithic::Models::ThreeDS::AuthenticationSimulateParams::Transaction, Lithic::Util::AnyHash),
+            card_expiry_check: Lithic::Models::ThreeDS::AuthenticationSimulateParams::CardExpiryCheck::OrSymbol,
+            request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+          )
+            .returns(Lithic::Models::ThreeDS::AuthenticationSimulateResponse)
+        end
+        def simulate(
+          merchant:,
+          # Sixteen digit card number.
+          pan:,
+          transaction:,
+          # When set will use the following values as part of the Simulated Authentication.
+          #   When not set defaults to MATCH
+          card_expiry_check: nil,
+          request_options: {}
+        )
+        end
+
+        # Endpoint for simulating entering OTP into 3DS Challenge UI. A call to
+        #   /v1/three_ds_authentication/simulate that resulted in triggered SMS-OTP
+        #   challenge must precede. Only a single attempt is supported; upon entering OTP,
+        #   the challenge is either approved or declined.
+        sig do
+          params(
+            token: String,
+            otp: String,
+            request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+          )
+            .void
+        end
+        def simulate_otp_entry(
+          # A unique token returned as part of a /v1/three_ds_authentication/simulate call
+          #   that resulted in PENDING_CHALLENGE authentication result.
+          token:,
+          # The OTP entered by the cardholder
+          otp:,
+          request_options: {}
+        )
+        end
+
+        sig { params(client: Lithic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/three_ds/decisioning.rbi

@@ -0,0 +1,55 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class ThreeDS
+      class Decisioning
+        # Card program's response to a 3DS Challenge Request (CReq)
+        sig do
+          params(
+            token: String,
+            challenge_response: Lithic::Models::ThreeDS::ChallengeResult::OrSymbol,
+            request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+          )
+            .void
+        end
+        def challenge_response(
+          # Globally unique identifier for the 3DS authentication. This token is sent as
+          #   part of the initial 3DS Decisioning Request and as part of the 3DS Challenge
+          #   Event in the [ThreeDSAuthentication](#/components/schemas/ThreeDSAuthentication)
+          #   object
+          token:,
+          # Whether the Cardholder has Approved or Declined the issued Challenge
+          challenge_response:,
+          request_options: {}
+        )
+        end
+
+        # Retrieve the 3DS Decisioning HMAC secret key. If one does not exist for your
+        #   program yet, calling this endpoint will create one for you. The headers (which
+        #   you can use to verify 3DS Decisioning requests) will begin appearing shortly
+        #   after calling this endpoint for the first time. See
+        #   [this page](https://docs.lithic.com/docs/3ds-decisioning#3ds-decisioning-hmac-secrets)
+        #   for more detail about verifying 3DS Decisioning requests.
+        sig do
+          params(request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)))
+            .returns(Lithic::Models::ThreeDS::DecisioningRetrieveSecretResponse)
+        end
+        def retrieve_secret(request_options: {})
+        end
+
+        # Generate a new 3DS Decisioning HMAC secret key. The old secret key will be
+        #   deactivated 24 hours after a successful request to this endpoint. Make a
+        #   [`GET /three_ds_decisioning/secret`](https://docs.lithic.com/reference/getthreedsdecisioningsecret)
+        #   request to retrieve the new secret key.
+        sig { params(request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))).void }
+        def rotate_secret(request_options: {})
+        end
+
+        sig { params(client: Lithic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/three_ds.rbi

@@ -0,0 +1,17 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class ThreeDS
+      sig { returns(Lithic::Resources::ThreeDS::Authentication) }
+      attr_reader :authentication
+
+      sig { returns(Lithic::Resources::ThreeDS::Decisioning) }
+      attr_reader :decisioning
+
+      sig { params(client: Lithic::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/tokenization_decisioning.rbi

@@ -0,0 +1,34 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class TokenizationDecisioning
+      # Retrieve the Tokenization Decisioning secret key. If one does not exist your
+      #   program yet, calling this endpoint will create one for you. The headers of the
+      #   Tokenization Decisioning request will contain a hmac signature which you can use
+      #   to verify requests originate from Lithic. See
+      #   [this page](https://docs.lithic.com/docs/events-api#verifying-webhooks) for more
+      #   detail about verifying Tokenization Decisioning requests.
+      sig do
+        params(request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)))
+          .returns(Lithic::Models::TokenizationSecret)
+      end
+      def retrieve_secret(request_options: {})
+      end
+
+      # Generate a new Tokenization Decisioning secret key. The old Tokenization
+      #   Decisioning secret key will be deactivated 24 hours after a successful request
+      #   to this endpoint.
+      sig do
+        params(request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash)))
+          .returns(Lithic::Models::TokenizationDecisioningRotateSecretResponse)
+      end
+      def rotate_secret(request_options: {})
+      end
+
+      sig { params(client: Lithic::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/tokenizations.rbi

@@ -0,0 +1,250 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class Tokenizations
+      # Get tokenization
+      sig do
+        params(
+          tokenization_token: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::TokenizationRetrieveResponse)
+      end
+      def retrieve(
+        # Tokenization token
+        tokenization_token,
+        request_options: {}
+      )
+      end
+
+      # List card tokenizations
+      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.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::CursorPage[Lithic::Models::Tokenization])
+      end
+      def list(
+        # Filters for tokenizations associated with a specific account.
+        account_token: nil,
+        # Filter for tokenizations created after this date.
+        begin_: nil,
+        # Filters for tokenizations associated with a specific card.
+        card_token: nil,
+        # Filter for tokenizations created before this date.
+        end_: nil,
+        # 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.
+        ending_before: nil,
+        # Page size (for pagination).
+        page_size: nil,
+        # 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.
+        starting_after: nil,
+        # Filter for tokenizations by tokenization channel. If this is not specified, only
+        #   DIGITAL_WALLET tokenizations will be returned.
+        tokenization_channel: nil,
+        request_options: {}
+      )
+      end
+
+      # This endpoint is used to ask the card network to activate a tokenization. A
+      #   successful response indicates that the request was successfully delivered to the
+      #   card network. When the card network activates the tokenization, the state will
+      #   be updated and a tokenization.updated event will be sent. The endpoint may only
+      #   be used on digital wallet tokenizations with status `INACTIVE`,
+      #   `PENDING_ACTIVATION`, or `PENDING_2FA`. This will put the tokenization in an
+      #   active state, and transactions will be allowed. Reach out at
+      #   [lithic.com/contact](https://lithic.com/contact) for more information.
+      sig do
+        params(
+          tokenization_token: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .void
+      end
+      def activate(
+        # Tokenization token
+        tokenization_token,
+        request_options: {}
+      )
+      end
+
+      # This endpoint is used to ask the card network to deactivate a tokenization. A
+      #   successful response indicates that the request was successfully delivered to the
+      #   card network. When the card network deactivates the tokenization, the state will
+      #   be updated and a tokenization.updated event will be sent. Authorizations
+      #   attempted with a deactivated tokenization will be blocked and will not be
+      #   forwarded to Lithic from the network. Deactivating the token is a permanent
+      #   operation. If the target is a digital wallet tokenization, it will be removed
+      #   from its device. Reach out at [lithic.com/contact](https://lithic.com/contact)
+      #   for more information.
+      sig do
+        params(
+          tokenization_token: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .void
+      end
+      def deactivate(
+        # Tokenization token
+        tokenization_token,
+        request_options: {}
+      )
+      end
+
+      # This endpoint is used to ask the card network to pause a tokenization. A
+      #   successful response indicates that the request was successfully delivered to the
+      #   card network. When the card network pauses the tokenization, the state will be
+      #   updated and a tokenization.updated event will be sent. The endpoint may only be
+      #   used on tokenizations with status `ACTIVE`. A paused token will prevent
+      #   merchants from sending authorizations, and is a temporary status that can be
+      #   changed. Reach out at [lithic.com/contact](https://lithic.com/contact) for more
+      #   information.
+      sig do
+        params(
+          tokenization_token: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .void
+      end
+      def pause(
+        # Tokenization token
+        tokenization_token,
+        request_options: {}
+      )
+      end
+
+      # This endpoint is used to ask the card network to send another activation code to
+      #   a cardholder that has already tried tokenizing a card. A successful response
+      #   indicates that the request was successfully delivered to the card network. The
+      #   endpoint may only be used on Mastercard digital wallet tokenizations with status
+      #   `INACTIVE`, `PENDING_ACTIVATION`, or `PENDING_2FA`. The network will send a new
+      #   activation code to the one of the contact methods provided in the initial
+      #   tokenization flow. If a user fails to enter the code correctly 3 times, the
+      #   contact method will not be eligible for resending the activation code, and the
+      #   cardholder must restart the provision process. Reach out at
+      #   [lithic.com/contact](https://lithic.com/contact) for more information.
+      sig do
+        params(
+          tokenization_token: String,
+          activation_method_type: Lithic::Models::TokenizationResendActivationCodeParams::ActivationMethodType::OrSymbol,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .void
+      end
+      def resend_activation_code(
+        # Tokenization token
+        tokenization_token,
+        # 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"
+        activation_method_type: nil,
+        request_options: {}
+      )
+      end
+
+      # This endpoint is used to simulate a card's tokenization in the Digital Wallet
+      #   and merchant tokenization ecosystem.
+      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.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::TokenizationSimulateResponse)
+      end
+      def simulate(
+        # The three digit cvv for the card.
+        cvv:,
+        # The expiration date of the card in 'MM/YY' format.
+        expiration_date:,
+        # The sixteen digit card number.
+        pan:,
+        # The source of the tokenization request.
+        tokenization_source:,
+        # The account score (1-5) that represents how the Digital Wallet's view on how
+        #   reputable an end user's account is.
+        account_score: nil,
+        # The device score (1-5) that represents how the Digital Wallet's view on how
+        #   reputable an end user's device is.
+        device_score: nil,
+        # Optional field to specify the token requestor name for a merchant token
+        #   simulation. Ignored when tokenization_source is not MERCHANT.
+        entity: nil,
+        # The decision that the Digital Wallet's recommend
+        wallet_recommended_decision: nil,
+        request_options: {}
+      )
+      end
+
+      # This endpoint is used to ask the card network to unpause a tokenization. A
+      #   successful response indicates that the request was successfully delivered to the
+      #   card network. When the card network unpauses the tokenization, the state will be
+      #   updated and a tokenization.updated event will be sent. The endpoint may only be
+      #   used on tokenizations with status `PAUSED`. This will put the tokenization in an
+      #   active state, and transactions may resume. Reach out at
+      #   [lithic.com/contact](https://lithic.com/contact) for more information.
+      sig do
+        params(
+          tokenization_token: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .void
+      end
+      def unpause(
+        # Tokenization token
+        tokenization_token,
+        request_options: {}
+      )
+      end
+
+      # This endpoint is used update the digital card art for a digital wallet
+      #   tokenization. A successful response indicates that the card network has updated
+      #   the tokenization's art, and the tokenization's `digital_cart_art_token` field
+      #   was updated. The endpoint may not be used on tokenizations with status
+      #   `DEACTIVATED`. Note that this updates the art for one specific tokenization, not
+      #   all tokenizations for a card. New tokenizations for a card will be created with
+      #   the art referenced in the card object's `digital_card_art_token` field. Reach
+      #   out at [lithic.com/contact](https://lithic.com/contact) for more information.
+      sig do
+        params(
+          tokenization_token: String,
+          digital_card_art_token: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::TokenizationUpdateDigitalCardArtResponse)
+      end
+      def update_digital_card_art(
+        # Tokenization token
+        tokenization_token,
+        # 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).
+        digital_card_art_token: nil,
+        request_options: {}
+      )
+      end
+
+      sig { params(client: Lithic::Client).returns(T.attached_class) }
+      def self.new(client:)
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/transactions/enhanced_commercial_data.rbi

@@ -0,0 +1,29 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class Transactions
+      class EnhancedCommercialData
+        # Get all L2/L3 enhanced commercial data associated with a transaction. Not
+        #   available in sandbox.
+        sig do
+          params(
+            transaction_token: String,
+            request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+          )
+            .returns(Lithic::Models::Transactions::EnhancedCommercialDataRetrieveResponse)
+        end
+        def retrieve(
+          # The token of the transaction that the enhanced data is associated with.
+          transaction_token,
+          request_options: {}
+        )
+        end
+
+        sig { params(client: Lithic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/transactions/events/enhanced_commercial_data.rbi

@@ -0,0 +1,31 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class Transactions
+      class Events
+        class EnhancedCommercialData
+          # Get L2/L3 enhanced commercial data associated with a transaction event. Not
+          #   available in sandbox.
+          sig do
+            params(
+              event_token: String,
+              request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+            )
+              .returns(Lithic::Models::Transactions::Events::EnhancedData)
+          end
+          def retrieve(
+            # The token of the transaction event that the enhanced data is associated with.
+            event_token,
+            request_options: {}
+          )
+          end
+
+          sig { params(client: Lithic::Client).returns(T.attached_class) }
+          def self.new(client:)
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/lib/lithic/resources/transactions/events.rbi

@@ -0,0 +1,16 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class Transactions
+      class Events
+        sig { returns(Lithic::Resources::Transactions::Events::EnhancedCommercialData) }
+        attr_reader :enhanced_commercial_data
+
+        sig { params(client: Lithic::Client).returns(T.attached_class) }
+        def self.new(client:)
+        end
+      end
+    end
+  end
+end