lithic 0.1.0.pre.alpha.1

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

@@ -0,0 +1,325 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class Transactions
+      sig { returns(Lithic::Resources::Transactions::EnhancedCommercialData) }
+      attr_reader :enhanced_commercial_data
+
+      sig { returns(Lithic::Resources::Transactions::Events) }
+      attr_reader :events
+
+      # Get a specific card transaction. All amounts are in the smallest unit of their
+      #   respective currency (e.g., cents for USD).
+      sig do
+        params(
+          transaction_token: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::Transaction)
+      end
+      def retrieve(
+        # Globally unique identifier for the transaction.
+        transaction_token,
+        request_options: {}
+      )
+      end
+
+      # List card transactions. All amounts are in the smallest unit of their respective
+      #   currency (e.g., cents for USD) and inclusive of any acquirer fees.
+      sig do
+        params(
+          account_token: String,
+          begin_: Time,
+          card_token: String,
+          end_: Time,
+          ending_before: String,
+          page_size: Integer,
+          result: Lithic::Models::TransactionListParams::Result::OrSymbol,
+          starting_after: String,
+          status: Lithic::Models::TransactionListParams::Status::OrSymbol,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::CursorPage[Lithic::Models::Transaction])
+      end
+      def list(
+        # Filters for transactions associated with a specific account.
+        account_token: nil,
+        # Date string in RFC 3339 format. Only entries created after the specified time
+        #   will be included. UTC time zone.
+        begin_: nil,
+        # Filters for transactions associated with a specific card.
+        card_token: nil,
+        # Date string in RFC 3339 format. Only entries created before the specified time
+        #   will be included. UTC time zone.
+        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,
+        # Filters for transactions using transaction result field. Can filter by
+        #   `APPROVED`, and `DECLINED`.
+        result: 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,
+        # Filters for transactions using transaction status field.
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      # Expire authorization
+      sig do
+        params(
+          transaction_token: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .void
+      end
+      def expire_authorization(
+        # The token of the transaction to expire.
+        transaction_token,
+        request_options: {}
+      )
+      end
+
+      # Simulates an authorization request from the card network as if it came from a
+      #   merchant acquirer. If you are configured for ASA, simulating authorizations
+      #   requires your ASA client to be set up properly, i.e. be able to respond to the
+      #   ASA request with a valid JSON. For users that are not configured for ASA, a
+      #   daily transaction limit of $5000 USD is applied by default. You can update this
+      #   limit via the
+      #   [update account](https://docs.lithic.com/reference/patchaccountbytoken)
+      #   endpoint.
+      sig do
+        params(
+          amount: Integer,
+          descriptor: String,
+          pan: String,
+          mcc: String,
+          merchant_acceptor_id: String,
+          merchant_amount: Integer,
+          merchant_currency: String,
+          partial_approval_capable: T::Boolean,
+          pin: String,
+          status: Lithic::Models::TransactionSimulateAuthorizationParams::Status::OrSymbol,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::TransactionSimulateAuthorizationResponse)
+      end
+      def simulate_authorization(
+        # Amount (in cents) to authorize. For credit authorizations and financial credit
+        #   authorizations, any value entered will be converted into a negative amount in
+        #   the simulated transaction. For example, entering 100 in this field will result
+        #   in a -100 amount in the transaction. For balance inquiries, this field must be
+        #   set to 0.
+        amount:,
+        # Merchant descriptor.
+        descriptor:,
+        # Sixteen digit card number.
+        pan:,
+        # Merchant category code for the transaction to be simulated. A four-digit number
+        #   listed in ISO 18245. Supported merchant category codes can be found
+        #   [here](https://docs.lithic.com/docs/transactions#merchant-category-codes-mccs).
+        mcc: nil,
+        # Unique identifier to identify the payment card acceptor.
+        merchant_acceptor_id: nil,
+        # Amount of the transaction to be simulated in currency specified in
+        #   merchant_currency, including any acquirer fees.
+        merchant_amount: nil,
+        # 3-character alphabetic ISO 4217 currency code. Note: Simulator only accepts USD,
+        #   GBP, EUR and defaults to GBP if another ISO 4217 code is provided
+        merchant_currency: nil,
+        # Set to true if the terminal is capable of partial approval otherwise false.
+        #   Partial approval is when part of a transaction is approved and another payment
+        #   must be used for the remainder.
+        partial_approval_capable: nil,
+        # Simulate entering a PIN. If omitted, PIN check will not be performed.
+        pin: nil,
+        # Type of event to simulate.
+        #
+        #   - `AUTHORIZATION` is a dual message purchase authorization, meaning a subsequent
+        #     clearing step is required to settle the transaction.
+        #   - `BALANCE_INQUIRY` is a $0 authorization requesting the balance held on the
+        #     card, and is most often observed when a cardholder requests to view a card's
+        #     balance at an ATM.
+        #   - `CREDIT_AUTHORIZATION` is a dual message request from a merchant to authorize
+        #     a refund, meaning a subsequent clearing step is required to settle the
+        #     transaction.
+        #   - `FINANCIAL_AUTHORIZATION` is a single message request from a merchant to debit
+        #     funds immediately (such as an ATM withdrawal), and no subsequent clearing is
+        #     required to settle the transaction.
+        #   - `FINANCIAL_CREDIT_AUTHORIZATION` is a single message request from a merchant
+        #     to credit funds immediately, and no subsequent clearing is required to settle
+        #     the transaction.
+        status: nil,
+        request_options: {}
+      )
+      end
+
+      # Simulates an authorization advice from the card network as if it came from a
+      #   merchant acquirer. An authorization advice changes the pending amount of the
+      #   transaction.
+      sig do
+        params(
+          token: String,
+          amount: Integer,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::TransactionSimulateAuthorizationAdviceResponse)
+      end
+      def simulate_authorization_advice(
+        # The transaction token returned from the /v1/simulate/authorize. response.
+        token:,
+        # Amount (in cents) to authorize. This amount will override the transaction's
+        #   amount that was originally set by /v1/simulate/authorize.
+        amount:,
+        request_options: {}
+      )
+      end
+
+      # Clears an existing authorization, either debit or credit. After this event, the
+      #   transaction transitions from `PENDING` to `SETTLED` status.
+      #
+      #   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.
+      sig do
+        params(
+          token: String,
+          amount: Integer,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::TransactionSimulateClearingResponse)
+      end
+      def simulate_clearing(
+        # The transaction token returned from the /v1/simulate/authorize response.
+        token:,
+        # Amount (in cents) to clear. Typically this will match the amount in the original
+        #   authorization, but can be higher or lower. The sign of this amount will
+        #   automatically match the sign of the original authorization's amount. For
+        #   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.
+        amount: nil,
+        request_options: {}
+      )
+      end
+
+      # Simulates a credit authorization advice from the card network. This message
+      #   indicates that the network approved a credit authorization on your behalf.
+      sig do
+        params(
+          amount: Integer,
+          descriptor: String,
+          pan: String,
+          mcc: String,
+          merchant_acceptor_id: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::TransactionSimulateCreditAuthorizationResponse)
+      end
+      def simulate_credit_authorization(
+        # Amount (in cents). Any value entered will be converted into a negative amount in
+        #   the simulated transaction. For example, entering 100 in this field will appear
+        #   as a -100 amount in the transaction.
+        amount:,
+        # Merchant descriptor.
+        descriptor:,
+        # Sixteen digit card number.
+        pan:,
+        # Merchant category code for the transaction to be simulated. A four-digit number
+        #   listed in ISO 18245. Supported merchant category codes can be found
+        #   [here](https://docs.lithic.com/docs/transactions#merchant-category-codes-mccs).
+        mcc: nil,
+        # Unique identifier to identify the payment card acceptor.
+        merchant_acceptor_id: nil,
+        request_options: {}
+      )
+      end
+
+      # Returns, or refunds, an amount back to a card. Returns simulated via this
+      #   endpoint clear immediately, without prior authorization, and result in a
+      #   `SETTLED` transaction status.
+      sig do
+        params(
+          amount: Integer,
+          descriptor: String,
+          pan: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::TransactionSimulateReturnResponse)
+      end
+      def simulate_return(
+        # Amount (in cents) to authorize.
+        amount:,
+        # Merchant descriptor.
+        descriptor:,
+        # Sixteen digit card number.
+        pan:,
+        request_options: {}
+      )
+      end
+
+      # Reverses a return, i.e. a credit transaction with a `SETTLED` status. Returns
+      #   can be financial credit authorizations, or credit authorizations that have
+      #   cleared.
+      sig do
+        params(
+          token: String,
+          request_options: T.nilable(
+            T.any(
+              Lithic::RequestOptions,
+              Lithic::Util::AnyHash
+            )
+          )
+        )
+          .returns(Lithic::Models::TransactionSimulateReturnReversalResponse)
+      end
+      def simulate_return_reversal(
+        # The transaction token returned from the /v1/simulate/authorize response.
+        token:,
+        request_options: {}
+      )
+      end
+
+      # Voids a pending authorization. If `amount` is not set, the full amount will be
+      #   voided. Can be used on partially voided transactions but not partially cleared
+      #   transactions. _Simulating an authorization expiry on credit authorizations or
+      #   credit authorization advice is not currently supported but will be added soon._
+      sig do
+        params(
+          token: String,
+          amount: Integer,
+          type: Lithic::Models::TransactionSimulateVoidParams::Type::OrSymbol,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::TransactionSimulateVoidResponse)
+      end
+      def simulate_void(
+        # The transaction token returned from the /v1/simulate/authorize response.
+        token:,
+        # Amount (in cents) to void. Typically this will match the amount in the original
+        #   authorization, but can be less.
+        amount: nil,
+        # Type of event to simulate. Defaults to `AUTHORIZATION_REVERSAL`.
+        #
+        #   - `AUTHORIZATION_EXPIRY` indicates authorization has expired and been reversed
+        #     by Lithic.
+        #   - `AUTHORIZATION_REVERSAL` indicates authorization was reversed by the merchant.
+        type: 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/transfers.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module Lithic
+  module Resources
+    class Transfers
+      # Transfer funds between two financial accounts or between a financial account and
+      #   card
+      sig do
+        params(
+          amount: Integer,
+          from: String,
+          to: String,
+          token: String,
+          memo: String,
+          request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Util::AnyHash))
+        )
+          .returns(Lithic::Models::Transfer)
+      end
+      def create(
+        # Amount to be transferred in the currency’s smallest unit (e.g., cents for USD).
+        #   This should always be a positive value.
+        amount:,
+        # Globally unique identifier for the financial account or card that will send the
+        #   funds. Accepted type dependent on the program's use case.
+        from:,
+        # Globally unique identifier for the financial account or card that will receive
+        #   the funds. Accepted type dependent on the program's use case.
+        to:,
+        # Customer-provided token that will serve as an idempotency token. This token will
+        #   become the transaction token.
+        token: nil,
+        # Optional descriptor for the transfer.
+        memo: 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/single_page.rbi

@@ -0,0 +1,19 @@
+# typed: strong
+
+module Lithic
+  class SinglePage
+    include Lithic::BasePage
+
+    Elem = type_member
+
+    sig { returns(T.nilable(T::Array[Elem])) }
+    attr_accessor :data
+
+    sig { returns(T::Boolean) }
+    attr_accessor :has_more
+
+    sig { returns(String) }
+    def inspect
+    end
+  end
+end

data/rbi/lib/lithic/util.rbi

@@ -0,0 +1,280 @@
+# typed: strong
+
+module Lithic
+  # @api private
+  module Util
+    # Due to the current WIP status of Shapes support in Sorbet, types referencing
+    #   this alias might be refined in the future.
+    AnyHash = T.type_alias { T::Hash[Symbol, T.anything] }
+
+    # @api private
+    sig { returns(Float) }
+    def self.monotonic_secs
+    end
+
+    class << self
+      # @api private
+      sig { returns(String) }
+      def arch
+      end
+
+      # @api private
+      sig { returns(String) }
+      def os
+      end
+    end
+
+    class << self
+      # @api private
+      sig { params(input: T.anything).returns(T::Boolean) }
+      def primitive?(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(T::Boolean, T.anything)) }
+      def coerce_boolean(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.nilable(T::Boolean)) }
+      def coerce_boolean!(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(Integer, T.anything)) }
+      def coerce_integer(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(Float, T.anything)) }
+      def coerce_float(input)
+      end
+
+      # @api private
+      sig { params(input: T.anything).returns(T.any(T::Hash[T.anything, T.anything], T.anything)) }
+      def coerce_hash(input)
+      end
+    end
+
+    # Use this to indicate that a value should be explicitly removed from a data
+    #   structure when using `Lithic::Util.deep_merge`.
+    #
+    #   e.g. merging `{a: 1}` and `{a: OMIT}` should produce `{}`, where merging
+    #   `{a: 1}` and `{}` would produce `{a: 1}`.
+    OMIT = T.let(T.anything, T.anything)
+
+    class << self
+      # @api private
+      sig { params(lhs: T.anything, rhs: T.anything, concat: T::Boolean).returns(T.anything) }
+      private def deep_merge_lr(lhs, rhs, concat: false)
+      end
+
+      # @api private
+      #
+      # Recursively merge one hash with another. If the values at a given key are not
+      #   both hashes, just take the new value.
+      sig do
+        params(values: T::Array[T.anything], sentinel: T.nilable(T.anything), concat: T::Boolean)
+          .returns(T.anything)
+      end
+      def deep_merge(
+        *values,
+        # the value to return if no values are provided.
+        sentinel: nil,
+        # whether to merge sequences by concatenation.
+        concat: false
+      )
+      end
+
+      # @api private
+      sig do
+        params(
+          data: T.any(Lithic::Util::AnyHash, T::Array[T.anything], T.anything),
+          pick: T.nilable(T.any(Symbol, Integer, T::Array[T.any(Symbol, Integer)])),
+          sentinel: T.nilable(T.anything),
+          blk: T.nilable(T.proc.returns(T.anything))
+        )
+          .returns(T.nilable(T.anything))
+      end
+      def dig(data, pick, sentinel = nil, &blk)
+      end
+    end
+
+    class << self
+      # @api private
+      sig { params(uri: URI::Generic).returns(String) }
+      def uri_origin(uri)
+      end
+
+      # @api private
+      sig { params(path: T.any(String, T::Array[String])).returns(String) }
+      def interpolate_path(path)
+      end
+    end
+
+    class << self
+      # @api private
+      sig { params(query: T.nilable(String)).returns(T::Hash[String, T::Array[String]]) }
+      def decode_query(query)
+      end
+
+      # @api private
+      sig do
+        params(query: T.nilable(T::Hash[String, T.nilable(T.any(T::Array[String], String))]))
+          .returns(T.nilable(String))
+      end
+      def encode_query(query)
+      end
+    end
+
+    ParsedUriShape =
+      T.type_alias do
+        {
+          scheme: T.nilable(String),
+          host: T.nilable(String),
+          port: T.nilable(Integer),
+          path: T.nilable(String),
+          query: T::Hash[String, T::Array[String]]
+        }
+      end
+
+    class << self
+      # @api private
+      sig { params(url: T.any(URI::Generic, String)).returns(Lithic::Util::ParsedUriShape) }
+      def parse_uri(url)
+      end
+
+      # @api private
+      sig { params(parsed: Lithic::Util::ParsedUriShape).returns(URI::Generic) }
+      def unparse_uri(parsed)
+      end
+
+      # @api private
+      sig do
+        params(lhs: Lithic::Util::ParsedUriShape, rhs: Lithic::Util::ParsedUriShape).returns(URI::Generic)
+      end
+      def join_parsed_uri(lhs, rhs)
+      end
+    end
+
+    class << self
+      # @api private
+      sig do
+        params(
+          headers: T::Hash[String,
+                           T.nilable(T.any(String, Integer, T::Array[T.nilable(T.any(String, Integer))]))]
+        )
+          .returns(T::Hash[String, String])
+      end
+      def normalized_headers(*headers)
+      end
+    end
+
+    # @api private
+    #
+    # An adapter that satisfies the IO interface required by `::IO.copy_stream`
+    class ReadIOAdapter
+      # @api private
+      sig { params(max_len: T.nilable(Integer)).returns(String) }
+      private def read_enum(max_len)
+      end
+
+      # @api private
+      sig { params(max_len: T.nilable(Integer), out_string: T.nilable(String)).returns(T.nilable(String)) }
+      def read(max_len = nil, out_string = nil)
+      end
+
+      # @api private
+      sig do
+        params(
+          stream: T.any(String, IO, StringIO, T::Enumerable[String]),
+          blk: T.proc.params(arg0: String).void
+        )
+          .returns(T.attached_class)
+      end
+      def self.new(stream, &blk)
+      end
+    end
+
+    class << self
+      sig { params(blk: T.proc.params(y: Enumerator::Yielder).void).returns(T::Enumerable[String]) }
+      def string_io(&blk)
+      end
+    end
+
+    class << self
+      # @api private
+      sig do
+        params(y: Enumerator::Yielder, boundary: String, key: T.any(Symbol, String), val: T.anything).void
+      end
+      private def encode_multipart_formdata(y, boundary:, key:, val:)
+      end
+
+      # @api private
+      sig { params(body: T.anything).returns([String, T::Enumerable[String]]) }
+      private def encode_multipart_streaming(body)
+      end
+
+      # @api private
+      sig { params(headers: T::Hash[String, String], body: T.anything).returns(T.anything) }
+      def encode_content(headers, body)
+      end
+
+      # @api private
+      sig do
+        params(
+          headers: T.any(T::Hash[String, String], Net::HTTPHeader),
+          stream: T::Enumerable[String],
+          suppress_error: T::Boolean
+        )
+          .returns(T.anything)
+      end
+      def decode_content(headers, stream:, suppress_error: false)
+      end
+    end
+
+    class << self
+      # @api private
+      #
+      # https://doc.rust-lang.org/std/iter/trait.FusedIterator.html
+      sig do
+        params(enum: T::Enumerable[T.anything], external: T::Boolean, close: T.proc.void)
+          .returns(T::Enumerable[T.anything])
+      end
+      def fused_enum(enum, external: false, &close)
+      end
+
+      # @api private
+      sig { params(enum: T.nilable(T::Enumerable[T.anything])).void }
+      def close_fused!(enum)
+      end
+
+      # @api private
+      sig do
+        params(enum: T.nilable(T::Enumerable[T.anything]), blk: T.proc.params(arg0: Enumerator::Yielder).void)
+          .returns(T::Enumerable[T.anything])
+      end
+      def chain_fused(enum, &blk)
+      end
+    end
+
+    ServerSentEvent =
+      T.type_alias do
+        {event: T.nilable(String), data: T.nilable(String), id: T.nilable(String), retry: T.nilable(Integer)}
+      end
+
+    class << self
+      # @api private
+      sig { params(enum: T::Enumerable[String]).returns(T::Enumerable[String]) }
+      def decode_lines(enum)
+      end
+
+      # @api private
+      #
+      # https://html.spec.whatwg.org/multipage/server-sent-events.html#parsing-an-event-stream
+      sig { params(lines: T::Enumerable[String]).returns(Lithic::Util::ServerSentEvent) }
+      def decode_sse(lines)
+      end
+    end
+  end
+end

data/rbi/lib/lithic/version.rbi

@@ -0,0 +1,5 @@
+# typed: strong
+
+module Lithic
+  VERSION = "0.1.0-alpha.1"
+end