lithic 0.1.0.pre.alpha.6 → 0.1.0.pre.alpha.7

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

@@ -5,7 +5,7 @@ module Lithic
     class Transactions
       class EnhancedCommercialData
         # Get all L2/L3 enhanced commercial data associated with a transaction. Not
-        #   available in sandbox.
+        # available in sandbox.
         #
         # @overload retrieve(transaction_token, request_options: {})
         #

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

@@ -6,7 +6,7 @@ module Lithic
       class Events
         class EnhancedCommercialData
           # Get L2/L3 enhanced commercial data associated with a transaction event. Not
-          #   available in sandbox.
+          # available in sandbox.
           #
           # @overload retrieve(event_token, request_options: {})
           #

data/lib/lithic/resources/transactions.rb

@@ -10,7 +10,7 @@ module Lithic
       attr_reader :events
 
       # Get a specific card transaction. All amounts are in the smallest unit of their
-      #   respective currency (e.g., cents for USD).
+      # respective currency (e.g., cents for USD).
       #
       # @overload retrieve(transaction_token, request_options: {})
       #
@@ -30,7 +30,7 @@ module Lithic
       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.
+      # currency (e.g., cents for USD) and inclusive of any acquirer fees.
       #
       # @overload list(account_token: nil, begin_: nil, card_token: nil, end_: nil, ending_before: nil, page_size: nil, result: nil, starting_after: nil, status: nil, request_options: {})
       #
@@ -53,7 +53,7 @@ module Lithic
         @client.request(
           method: :get,
           path: "v1/transactions",
-          query: parsed.transform_keys(begin_: :begin, end_: :end),
+          query: parsed.transform_keys(begin_: "begin", end_: "end"),
           page: Lithic::Internal::CursorPage,
           model: Lithic::Models::Transaction,
           options: options
@@ -80,13 +80,13 @@ module Lithic
       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.
+      # 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.
       #
       # @overload simulate_authorization(amount:, descriptor:, pan:, mcc: nil, merchant_acceptor_id: nil, merchant_amount: nil, merchant_currency: nil, partial_approval_capable: nil, pin: nil, status: nil, request_options: {})
       #
@@ -117,8 +117,8 @@ module Lithic
       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.
+      # merchant acquirer. An authorization advice changes the pending amount of the
+      # transaction.
       #
       # @overload simulate_authorization_advice(token:, amount:, request_options: {})
       #
@@ -141,11 +141,11 @@ module Lithic
       end
 
       # Clears an existing authorization, either debit or credit. After this event, the
-      #   transaction transitions from `PENDING` to `SETTLED` status.
+      # 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.
+      # 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.
       #
       # @overload simulate_clearing(token:, amount: nil, request_options: {})
       #
@@ -168,7 +168,7 @@ module Lithic
       end
 
       # Simulates a credit authorization advice from the card network. This message
-      #   indicates that the network approved a credit authorization on your behalf.
+      # indicates that the network approved a credit authorization on your behalf.
       #
       # @overload simulate_credit_authorization(amount:, descriptor:, pan:, mcc: nil, merchant_acceptor_id: nil, request_options: {})
       #
@@ -194,8 +194,8 @@ module Lithic
       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.
+      # endpoint clear immediately, without prior authorization, and result in a
+      # `SETTLED` transaction status.
       #
       # @overload simulate_return(amount:, descriptor:, pan:, request_options: {})
       #
@@ -219,8 +219,8 @@ module Lithic
       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.
+      # can be financial credit authorizations, or credit authorizations that have
+      # cleared.
       #
       # @overload simulate_return_reversal(token:, request_options: {})
       #
@@ -242,9 +242,9 @@ module Lithic
       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._
+      # 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._
       #
       # @overload simulate_void(token:, amount: nil, type: nil, request_options: {})
       #

data/lib/lithic/resources/transfers.rb

@@ -4,7 +4,7 @@ module Lithic
   module Resources
     class Transfers
       # Transfer funds between two financial accounts or between a financial account and
-      #   card
+      # card
       #
       # @overload create(amount:, from:, to:, token: nil, memo: nil, request_options: {})
       #

data/lib/lithic/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Lithic
-  VERSION = "0.1.0.pre.alpha.6"
+  VERSION = "0.1.0.pre.alpha.7"
 end

data/rbi/lib/lithic/client.rbi

@@ -99,13 +99,11 @@ module Lithic
       params(request_options: T.nilable(T.any(Lithic::RequestOptions, Lithic::Internal::AnyHash)))
         .returns(Lithic::Models::APIStatus)
     end
-    def api_status(request_options: {})
-    end
+    def api_status(request_options: {}); end
 
     # @api private
     sig { override.returns(T::Hash[String, String]) }
-    private def auth_headers
-    end
+    private def auth_headers; end
 
     # Creates and returns a new client for interacting with the API.
     sig do
@@ -125,10 +123,10 @@ module Lithic
       api_key: ENV["LITHIC_API_KEY"],
       # Specifies the environment to use for the API.
       #
-      #   Each environment maps to a different base URL:
+      # Each environment maps to a different base URL:
       #
-      #   - `production` corresponds to `https://api.lithic.com`
-      #   - `sandbox` corresponds to `https://sandbox.lithic.com`
+      # - `production` corresponds to `https://api.lithic.com`
+      # - `sandbox` corresponds to `https://sandbox.lithic.com`
       environment: nil,
       # Override the default base URL for the API, e.g., `"https://api.example.com/v2/"`
       base_url: nil,
@@ -137,7 +135,6 @@ module Lithic
       timeout: DEFAULT_TIMEOUT_IN_SECONDS,
       initial_retry_delay: DEFAULT_INITIAL_RETRY_DELAY,
       max_retry_delay: DEFAULT_MAX_RETRY_DELAY
-    )
-    end
+    ); end
   end
 end

data/rbi/lib/lithic/errors.rbi

@@ -32,8 +32,7 @@ module Lithic
         )
           .returns(T.attached_class)
       end
-      def self.new(url:, status: nil, body: nil, request: nil, response: nil, message: nil)
-      end
+      def self.new(url:, status: nil, body: nil, request: nil, response: nil, message: nil); end
     end
 
     class APIConnectionError < Lithic::Errors::APIError
@@ -89,8 +88,7 @@ module Lithic
         )
           .returns(T.attached_class)
       end
-      def self.for(url:, status:, body:, request:, response:, message: nil)
-      end
+      def self.for(url:, status:, body:, request:, response:, message: nil); end
 
       sig { returns(Integer) }
       attr_accessor :status
@@ -107,8 +105,7 @@ module Lithic
         )
           .returns(T.attached_class)
       end
-      def self.new(url:, status:, body:, request:, response:, message: nil)
-      end
+      def self.new(url:, status:, body:, request:, response:, message: nil); end
     end
 
     class BadRequestError < Lithic::Errors::APIStatusError

data/rbi/lib/lithic/internal/cursor_page.rbi

@@ -14,8 +14,7 @@ module Lithic
       attr_accessor :has_more
 
       sig { returns(String) }
-      def inspect
-      end
+      def inspect; end
     end
   end
 end

data/rbi/lib/lithic/internal/single_page.rbi

@@ -14,8 +14,7 @@ module Lithic
       attr_accessor :has_more
 
       sig { returns(String) }
-      def inspect
-      end
+      def inspect; end
     end
   end
 end

data/rbi/lib/lithic/internal/transport/base_client.rbi

@@ -52,8 +52,7 @@ module Lithic
         class << self
           # @api private
           sig { params(req: Lithic::Internal::Transport::BaseClient::RequestComponentsShape).void }
-          def validate!(req)
-          end
+          def validate!(req); end
 
           # @api private
           sig do
@@ -65,8 +64,7 @@ module Lithic
               )
             ).returns(T::Boolean)
           end
-          def should_retry?(status, headers:)
-          end
+          def should_retry?(status, headers:); end
 
           # @api private
           sig do
@@ -77,8 +75,7 @@ module Lithic
             )
               .returns(Lithic::Internal::Transport::BaseClient::RequestInputShape)
           end
-          def follow_redirect(request, status:, response_headers:)
-          end
+          def follow_redirect(request, status:, response_headers:); end
 
           # @api private
           sig do
@@ -88,8 +85,7 @@ module Lithic
             )
               .void
           end
-          def reap_connection!(status, stream:)
-          end
+          def reap_connection!(status, stream:); end
         end
 
         # @api private
@@ -118,18 +114,14 @@ module Lithic
           max_retry_delay: 0.0,
           headers: {},
           idempotency_header: nil
-        )
-        end
-
+        ); end
         # @api private
         sig { overridable.returns(T::Hash[String, String]) }
-        private def auth_headers
-        end
+        private def auth_headers; end
 
         # @api private
         sig { returns(String) }
-        private def generate_idempotency_key
-        end
+        private def generate_idempotency_key; end
 
         # @api private
         sig do
@@ -140,13 +132,11 @@ module Lithic
             )
             .returns(Lithic::Internal::Transport::BaseClient::RequestInputShape)
         end
-        private def build_request(req, opts)
-        end
+        private def build_request(req, opts); end
 
         # @api private
         sig { params(headers: T::Hash[String, String], retry_count: Integer).returns(Float) }
-        private def retry_delay(headers, retry_count:)
-        end
+        private def retry_delay(headers, retry_count:); end
 
         # @api private
         sig do
@@ -158,11 +148,10 @@ module Lithic
           )
             .returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
         end
-        private def send_request(request, redirect_count:, retry_count:, send_retry_header:)
-        end
+        private def send_request(request, redirect_count:, retry_count:, send_retry_header:); end
 
         # Execute the request specified by `req`. This is the method that all resource
-        #   methods call into.
+        # methods call into.
         #
         # @overload request(method, path, query: {}, headers: {}, body: nil, unwrap: nil, page: nil, stream: nil, model: Lithic::Internal::Type::Unknown, options: {})
         sig do
@@ -200,12 +189,9 @@ module Lithic
           stream: nil,
           model: Lithic::Internal::Type::Unknown,
           options: {}
-        )
-        end
-
+        ); end
         sig { returns(String) }
-        def inspect
-        end
+        def inspect; end
       end
     end
   end

data/rbi/lib/lithic/internal/transport/pooled_net_requester.rbi

@@ -17,19 +17,17 @@ module Lithic
           end
 
         # from the golang stdlib
-        #   https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
+        # https://github.com/golang/go/blob/c8eced8580028328fde7c03cbfcb720ce15b2358/src/net/http/transport.go#L49
         KEEP_ALIVE_TIMEOUT = 30
 
         class << self
           # @api private
           sig { params(url: URI::Generic).returns(Net::HTTP) }
-          def connect(url)
-          end
+          def connect(url); end
 
           # @api private
           sig { params(conn: Net::HTTP, deadline: Float).void }
-          def calibrate_socket_timeout(conn, deadline)
-          end
+          def calibrate_socket_timeout(conn, deadline); end
 
           # @api private
           sig do
@@ -39,27 +37,23 @@ module Lithic
             )
               .returns(Net::HTTPGenericRequest)
           end
-          def build_request(request, &blk)
-          end
+          def build_request(request, &blk); end
         end
 
         # @api private
         sig { params(url: URI::Generic, deadline: Float, blk: T.proc.params(arg0: Net::HTTP).void).void }
-        private def with_pool(url, deadline:, &blk)
-        end
+        private def with_pool(url, deadline:, &blk); end
 
         # @api private
         sig do
           params(request: Lithic::Internal::Transport::PooledNetRequester::RequestShape)
             .returns([Integer, Net::HTTPResponse, T::Enumerable[String]])
         end
-        def execute(request)
-        end
+        def execute(request); end
 
         # @api private
         sig { params(size: Integer).returns(T.attached_class) }
-        def self.new(size: Etc.nprocessors)
-        end
+        def self.new(size: Etc.nprocessors); end
       end
     end
   end

data/rbi/lib/lithic/internal/type/array_of.rbi

@@ -25,16 +25,13 @@ module Lithic
           )
             .returns(T.attached_class)
         end
-        def self.[](type_info, spec = {})
-        end
+        def self.[](type_info, spec = {}); end
 
         sig(:final) { params(other: T.anything).returns(T::Boolean) }
-        def ===(other)
-        end
+        def ===(other); end
 
         sig(:final) { params(other: T.anything).returns(T::Boolean) }
-        def ==(other)
-        end
+        def ==(other); end
 
         # @api private
         sig(:final) do
@@ -46,8 +43,7 @@ module Lithic
                     state: Lithic::Internal::Type::Converter::State)
             .returns(T.any(T::Array[T.anything], T.anything))
         end
-        def coerce(value, state:)
-        end
+        def coerce(value, state:); end
 
         # @api private
         sig(:final) do
@@ -55,18 +51,15 @@ module Lithic
             .params(value: T.any(T::Array[T.anything], T.anything))
             .returns(T.any(T::Array[T.anything], T.anything))
         end
-        def dump(value)
-        end
+        def dump(value); end
 
         # @api private
         sig(:final) { returns(Elem) }
-        protected def item_type
-        end
+        protected def item_type; end
 
         # @api private
         sig(:final) { returns(T::Boolean) }
-        protected def nilable?
-        end
+        protected def nilable?; end
 
         # @api private
         sig(:final) do
@@ -80,8 +73,7 @@ module Lithic
           )
             .void
         end
-        def initialize(type_info, spec = {})
-        end
+        def initialize(type_info, spec = {}); end
       end
     end
   end

data/rbi/lib/lithic/internal/type/base_model.rbi

@@ -16,35 +16,33 @@ module Lithic
           # @api private
           #
           # Assumes superclass fields are totally defined before fields are accessed /
-          #   defined on subclasses.
+          # defined on subclasses.
           sig do
             returns(
               T::Hash[
-              Symbol,
-              T.all(
-                Lithic::Internal::Type::BaseModel::KnownFieldShape,
-                {type_fn: T.proc.returns(Lithic::Internal::Type::Converter::Input)}
-              )
+                Symbol,
+                T.all(
+                  Lithic::Internal::Type::BaseModel::KnownFieldShape,
+                  {type_fn: T.proc.returns(Lithic::Internal::Type::Converter::Input)}
+                )
               ]
             )
           end
-          def known_fields
-          end
+          def known_fields; end
 
           # @api private
           sig do
             returns(
               T::Hash[
-              Symbol,
-              T.all(
-                Lithic::Internal::Type::BaseModel::KnownFieldShape,
-                {type: Lithic::Internal::Type::Converter::Input}
-              )
+                Symbol,
+                T.all(
+                  Lithic::Internal::Type::BaseModel::KnownFieldShape,
+                  {type: Lithic::Internal::Type::Converter::Input}
+                )
               ]
             )
           end
-          def fields
-          end
+          def fields; end
 
           # @api private
           sig do
@@ -66,8 +64,7 @@ module Lithic
             )
               .void
           end
-          private def add_field(name_sym, required:, type_info:, spec:)
-          end
+          private def add_field(name_sym, required:, type_info:, spec:); end
 
           # @api private
           sig do
@@ -82,8 +79,7 @@ module Lithic
             )
               .void
           end
-          def required(name_sym, type_info, spec = {})
-          end
+          def required(name_sym, type_info, spec = {}); end
 
           # @api private
           sig do
@@ -98,32 +94,27 @@ module Lithic
             )
               .void
           end
-          def optional(name_sym, type_info, spec = {})
-          end
+          def optional(name_sym, type_info, spec = {}); end
 
           # @api private
           #
           # `request_only` attributes not excluded from `.#coerce` when receiving responses
-          #   even if well behaved servers should not send them
+          # even if well behaved servers should not send them
           sig { params(blk: T.proc.void).void }
-          private def request_only(&blk)
-          end
+          private def request_only(&blk); end
 
           # @api private
           #
           # `response_only` attributes are omitted from `.#dump` when making requests
           sig { params(blk: T.proc.void).void }
-          private def response_only(&blk)
-          end
+          private def response_only(&blk); end
 
           sig { params(other: T.anything).returns(T::Boolean) }
-          def ==(other)
-          end
+          def ==(other); end
         end
 
         sig { params(other: T.anything).returns(T::Boolean) }
-        def ==(other)
-        end
+        def ==(other); end
 
         class << self
           # @api private
@@ -135,8 +126,7 @@ module Lithic
               )
               .returns(T.any(T.attached_class, T.anything))
           end
-          def coerce(value, state:)
-          end
+          def coerce(value, state:); end
 
           # @api private
           sig do
@@ -144,64 +134,55 @@ module Lithic
               .params(value: T.any(T.attached_class, T.anything))
               .returns(T.any(T::Hash[T.anything, T.anything], T.anything))
           end
-          def dump(value)
-          end
+          def dump(value); end
         end
 
         # Returns the raw value associated with the given key, if found. Otherwise, nil is
-        #   returned.
+        # returned.
         #
-        #   It is valid to lookup keys that are not in the API spec, for example to access
-        #   undocumented features. This method does not parse response data into
-        #   higher-level types. Lookup by anything other than a Symbol is an ArgumentError.
+        # It is valid to lookup keys that are not in the API spec, for example to access
+        # undocumented features. This method does not parse response data into
+        # higher-level types. Lookup by anything other than a Symbol is an ArgumentError.
         sig { params(key: Symbol).returns(T.nilable(T.anything)) }
-        def [](key)
-        end
+        def [](key); end
 
         # Returns a Hash of the data underlying this object. O(1)
         #
-        #   Keys are Symbols and values are the raw values from the response. The return
-        #   value indicates which values were ever set on the object. i.e. there will be a
-        #   key in this hash if they ever were, even if the set value was nil.
+        # Keys are Symbols and values are the raw values from the response. The return
+        # value indicates which values were ever set on the object. i.e. there will be a
+        # key in this hash if they ever were, even if the set value was nil.
         #
-        #   This method is not recursive. The returned value is shared by the object, so it
-        #   should not be mutated.
+        # This method is not recursive. The returned value is shared by the object, so it
+        # should not be mutated.
         sig { overridable.returns(Lithic::Internal::AnyHash) }
-        def to_h
-        end
+        def to_h; end
 
         # Returns a Hash of the data underlying this object. O(1)
         #
-        #   Keys are Symbols and values are the raw values from the response. The return
-        #   value indicates which values were ever set on the object. i.e. there will be a
-        #   key in this hash if they ever were, even if the set value was nil.
+        # Keys are Symbols and values are the raw values from the response. The return
+        # value indicates which values were ever set on the object. i.e. there will be a
+        # key in this hash if they ever were, even if the set value was nil.
         #
-        #   This method is not recursive. The returned value is shared by the object, so it
-        #   should not be mutated.
+        # This method is not recursive. The returned value is shared by the object, so it
+        # should not be mutated.
         sig { overridable.returns(Lithic::Internal::AnyHash) }
-        def to_hash
-        end
+        def to_hash; end
 
         sig { params(keys: T.nilable(T::Array[Symbol])).returns(Lithic::Internal::AnyHash) }
-        def deconstruct_keys(keys)
-        end
+        def deconstruct_keys(keys); end
 
         sig { params(a: T.anything).returns(String) }
-        def to_json(*a)
-        end
+        def to_json(*a); end
 
         sig { params(a: T.anything).returns(String) }
-        def to_yaml(*a)
-        end
+        def to_yaml(*a); end
 
         # Create a new instance of a model.
         sig { params(data: T.any(T::Hash[Symbol, T.anything], T.self_type)).returns(T.attached_class) }
-        def self.new(data = {})
-        end
+        def self.new(data = {}); end
 
         sig { returns(String) }
-        def inspect
-        end
+        def inspect; end
       end
     end
   end