pinelabs 0.1.0

data/lib/pinelabs/card_payments/types/otp_generate_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module CardPayments
+    module Types
+      class OtpGenerateRequest < Internal::Types::Model
+        field :payment_id, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/pinelabs/checkout/client.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module Checkout
+    class Client
+      # @param client [Pinelabs::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Generate an Infinity Checkout link. Returns a redirect URL where
+      # the customer can complete payment on Pine Labs' hosted checkout page.
+      #
+      # @param request_options [Hash]
+      # @param params [Pinelabs::Checkout::Types::GenerateCheckoutLinkRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @return [Pinelabs::Types::GenerateCheckoutLinkResponse]
+      def generate_checkout_link(request_options: {}, **params)
+        params = Pinelabs::Internal::Types::Utils.normalize_keys(params)
+        request = Pinelabs::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "api/checkout/v1/orders",
+          body: Pinelabs::Checkout::Types::GenerateCheckoutLinkRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinelabs::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinelabs::Types::GenerateCheckoutLinkResponse.load(response.body)
+        else
+          error_class = Pinelabs::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/lib/pinelabs/checkout/types/generate_checkout_link_request.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module Checkout
+    module Types
+      class GenerateCheckoutLinkRequest < Internal::Types::Model
+        field :merchant_order_reference, -> { String }, optional: false, nullable: false
+        field :order_amount, -> { Pinelabs::Types::Amount }, optional: false, nullable: false
+        field :integration_mode, -> { Pinelabs::Checkout::Types::GenerateCheckoutLinkRequestIntegrationMode }, optional: true, nullable: false
+        field :pre_auth, -> { Internal::Types::Boolean }, optional: true, nullable: false
+        field :allowed_payment_methods, -> { Internal::Types::Array[Pinelabs::Checkout::Types::GenerateCheckoutLinkRequestAllowedPaymentMethodsItem] }, optional: true, nullable: false
+        field :notes, -> { String }, optional: true, nullable: false
+        field :callback_url, -> { String }, optional: true, nullable: false
+        field :purchase_details, -> { Pinelabs::Types::CheckoutPurchaseDetails }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/pinelabs/checkout/types/generate_checkout_link_request_allowed_payment_methods_item.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module Checkout
+    module Types
+      module GenerateCheckoutLinkRequestAllowedPaymentMethodsItem
+        extend Pinelabs::Internal::Types::Enum
+
+        CARD = "CARD"
+        UPI = "UPI"
+        POINTS = "POINTS"
+        NETBANKING = "NETBANKING"
+        WALLET = "WALLET"
+        CREDIT_EMI = "CREDIT_EMI"
+        DEBIT_EMI = "DEBIT_EMI"
+        BNPL = "BNPL"
+      end
+    end
+  end
+end

data/lib/pinelabs/checkout/types/generate_checkout_link_request_integration_mode.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module Checkout
+    module Types
+      module GenerateCheckoutLinkRequestIntegrationMode
+        extend Pinelabs::Internal::Types::Enum
+
+        REDIRECT = "REDIRECT"
+        IFRAME = "IFRAME"
+        SDK = "SDK"
+      end
+    end
+  end
+end

data/lib/pinelabs/client.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  class Client
+    # @param base_url [String, nil]
+    # @param token [String]
+    #
+    # @return [void]
+    def initialize(token:, base_url: nil)
+      @raw_client = Pinelabs::Internal::Http::RawClient.new(
+        base_url: base_url || Pinelabs::Environment::PRODUCTION,
+        headers: {
+          "X-Fern-Language" => "Ruby",
+          Authorization: "Bearer #{token}"
+        }
+      )
+    end
+
+    # @return [Pinelabs::Authentication::Client]
+    def authentication
+      @authentication ||= Pinelabs::Authentication::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::Orders::Client]
+    def orders
+      @orders ||= Pinelabs::Orders::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::Refunds::Client]
+    def refunds
+      @refunds ||= Pinelabs::Refunds::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::Settlements::Client]
+    def settlements
+      @settlements ||= Pinelabs::Settlements::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::SplitSettlements::Client]
+    def split_settlements
+      @split_settlements ||= Pinelabs::SplitSettlements::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::AffordabilitySuite::Client]
+    def affordability_suite
+      @affordability_suite ||= Pinelabs::AffordabilitySuite::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::CardPayments::Client]
+    def card_payments
+      @card_payments ||= Pinelabs::CardPayments::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::PayByPoints::Client]
+    def pay_by_points
+      @pay_by_points ||= Pinelabs::PayByPoints::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::EChallans::Client]
+    def e_challans
+      @e_challans ||= Pinelabs::EChallans::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::ApplePay::Client]
+    def apple_pay
+      @apple_pay ||= Pinelabs::ApplePay::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::InternationalPayments::Client]
+    def international_payments
+      @international_payments ||= Pinelabs::InternationalPayments::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::Bnpl::Client]
+    def bnpl
+      @bnpl ||= Pinelabs::Bnpl::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::ConvenienceFee::Client]
+    def convenience_fee
+      @convenience_fee ||= Pinelabs::ConvenienceFee::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::Checkout::Client]
+    def checkout
+      @checkout ||= Pinelabs::Checkout::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::PaymentLinks::Client]
+    def payment_links
+      @payment_links ||= Pinelabs::PaymentLinks::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::Customers::Client]
+    def customers
+      @customers ||= Pinelabs::Customers::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::Tokenization::Client]
+    def tokenization
+      @tokenization ||= Pinelabs::Tokenization::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::Payouts::Client]
+    def payouts
+      @payouts ||= Pinelabs::Payouts::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::SubscriptionsPlans::Client]
+    def subscriptions_plans
+      @subscriptions_plans ||= Pinelabs::SubscriptionsPlans::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::SubscriptionsSubscriptions::Client]
+    def subscriptions_subscriptions
+      @subscriptions_subscriptions ||= Pinelabs::SubscriptionsSubscriptions::Client.new(client: @raw_client)
+    end
+
+    # @return [Pinelabs::SubscriptionsPresentations::Client]
+    def subscriptions_presentations
+      @subscriptions_presentations ||= Pinelabs::SubscriptionsPresentations::Client.new(client: @raw_client)
+    end
+  end
+end

data/lib/pinelabs/convenience_fee/client.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module ConvenienceFee
+    class Client
+      # @param client [Pinelabs::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Calculate the convenience fee for a payment against an order based on
+      # the payment method and amount.
+      #
+      # @param request_options [Hash]
+      # @param params [Pinelabs::ConvenienceFee::Types::CalculateConvenienceFeeRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @return [Pinelabs::Types::CalculateConvenienceFeeResponse]
+      def calculate_convenience_fee(request_options: {}, **params)
+        params = Pinelabs::Internal::Types::Utils.normalize_keys(params)
+        request = Pinelabs::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "api/v1/fees",
+          body: Pinelabs::ConvenienceFee::Types::CalculateConvenienceFeeRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinelabs::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinelabs::Types::CalculateConvenienceFeeResponse.load(response.body)
+        else
+          error_class = Pinelabs::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/lib/pinelabs/convenience_fee/types/calculate_convenience_fee_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module ConvenienceFee
+    module Types
+      class CalculateConvenienceFeeRequest < Internal::Types::Model
+        field :amount, -> { Pinelabs::Types::Amount }, optional: false, nullable: false
+        field :payment_method, -> { String }, optional: false, nullable: false
+        field :network_type, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/pinelabs/customers/client.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module Customers
+    class Client
+      # @param client [Pinelabs::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Retrieve customer details by querying with country code, mobile number, and merchant customer reference.
+      # All three query parameters are required.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :country_code
+      # @option params [String] :mobile_number
+      # @option params [String] :merchant_customer_reference
+      #
+      # @return [Pinelabs::Types::CustomerResponse]
+      def get_customer_details(request_options: {}, **params)
+        params = Pinelabs::Internal::Types::Utils.normalize_keys(params)
+        query_param_names = %i[country_code mobile_number merchant_customer_reference]
+        query_params = {}
+        query_params["country_code"] = params[:country_code] if params.key?(:country_code)
+        query_params["mobile_number"] = params[:mobile_number] if params.key?(:mobile_number)
+        query_params["merchant_customer_reference"] = params[:merchant_customer_reference] if params.key?(:merchant_customer_reference)
+        params.except(*query_param_names)
+
+        request = Pinelabs::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "api/v1/customer",
+          query: query_params,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinelabs::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinelabs::Types::CustomerResponse.load(response.body)
+        else
+          error_class = Pinelabs::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Create a new customer profile in the Pine Labs Online system. The customer profile
+      # can be used for tokenization and recurring payment operations.
+      #
+      # @param request_options [Hash]
+      # @param params [Pinelabs::Customers::Types::CreateCustomerRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      #
+      # @return [Pinelabs::Types::CustomerResponse]
+      def create_customer(request_options: {}, **params)
+        params = Pinelabs::Internal::Types::Utils.normalize_keys(params)
+        request = Pinelabs::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "api/v1/customer",
+          body: Pinelabs::Customers::Types::CreateCustomerRequest.new(params).to_h,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinelabs::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinelabs::Types::CustomerResponse.load(response.body)
+        else
+          error_class = Pinelabs::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Retrieve a customer profile by the unique customer ID.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :customer_id
+      #
+      # @return [Pinelabs::Types::CustomerResponse]
+      def get_customer_by_id(request_options: {}, **params)
+        params = Pinelabs::Internal::Types::Utils.normalize_keys(params)
+        request = Pinelabs::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "api/v1/customer/#{URI.encode_uri_component(params[:customer_id].to_s)}",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinelabs::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinelabs::Types::CustomerResponse.load(response.body)
+        else
+          error_class = Pinelabs::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Update an existing customer profile. All fields in the request body are optional;
+      # only the provided fields will be updated.
+      #
+      # @param request_options [Hash]
+      # @param params [Pinelabs::Customers::Types::UpdateCustomerRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :customer_id
+      #
+      # @return [Pinelabs::Types::CustomerResponse]
+      def update_customer(request_options: {}, **params)
+        params = Pinelabs::Internal::Types::Utils.normalize_keys(params)
+        request_data = Pinelabs::Customers::Types::UpdateCustomerRequest.new(params).to_h
+        non_body_param_names = ["customer_id"]
+        body = request_data.except(*non_body_param_names)
+
+        request = Pinelabs::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "PATCH",
+          path: "api/v1/customer/#{URI.encode_uri_component(params[:customer_id].to_s)}",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinelabs::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinelabs::Types::CustomerResponse.load(response.body)
+        else
+          error_class = Pinelabs::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+    end
+  end
+end

data/lib/pinelabs/customers/types/create_customer_request.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module Customers
+    module Types
+      class CreateCustomerRequest < Internal::Types::Model
+        field :merchant_customer_reference, -> { String }, optional: true, nullable: false
+        field :first_name, -> { String }, optional: true, nullable: false
+        field :last_name, -> { String }, optional: true, nullable: false
+        field :country_code, -> { String }, optional: true, nullable: false
+        field :mobile_number, -> { String }, optional: true, nullable: false
+        field :email_id, -> { String }, optional: true, nullable: false
+        field :billing_address, -> { Pinelabs::Types::Address }, optional: true, nullable: false
+        field :shipping_address, -> { Pinelabs::Types::Address }, optional: true, nullable: false
+        field :gstin, -> { String }, optional: true, nullable: false
+        field :merchant_metadata, -> { Internal::Types::Hash[String, String] }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/pinelabs/customers/types/get_customer_by_id_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module Customers
+    module Types
+      class GetCustomerByIDRequest < Internal::Types::Model
+        field :customer_id, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/pinelabs/customers/types/get_customer_details_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module Customers
+    module Types
+      class GetCustomerDetailsRequest < Internal::Types::Model
+        field :country_code, -> { String }, optional: false, nullable: false
+        field :mobile_number, -> { String }, optional: false, nullable: false
+        field :merchant_customer_reference, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/pinelabs/customers/types/update_customer_request.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module Customers
+    module Types
+      class UpdateCustomerRequest < Internal::Types::Model
+        field :customer_id, -> { String }, optional: false, nullable: false
+        field :merchant_customer_reference, -> { String }, optional: true, nullable: false
+        field :first_name, -> { String }, optional: true, nullable: false
+        field :last_name, -> { String }, optional: true, nullable: false
+        field :country_code, -> { String }, optional: true, nullable: false
+        field :mobile_number, -> { String }, optional: true, nullable: false
+        field :email_id, -> { String }, optional: true, nullable: false
+        field :billing_address, -> { Pinelabs::Types::Address }, optional: true, nullable: false
+        field :shipping_address, -> { Pinelabs::Types::Address }, optional: true, nullable: false
+        field :status, -> { Pinelabs::Customers::Types::UpdateCustomerRequestStatus }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/pinelabs/customers/types/update_customer_request_status.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module Customers
+    module Types
+      module UpdateCustomerRequestStatus
+        extend Pinelabs::Internal::Types::Enum
+
+        ACTIVE = "ACTIVE"
+        INACTIVE = "INACTIVE"
+        SUSPENDED = "SUSPENDED"
+        DELETED = "DELETED"
+      end
+    end
+  end
+end

data/lib/pinelabs/e_challans/client.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+module Pinelabs
+  module EChallans
+    class Client
+      # @param client [Pinelabs::Internal::Http::RawClient]
+      #
+      # @return [void]
+      def initialize(client:)
+        @client = client
+      end
+
+      # Retrieves the e-challan details for a given order.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :order_id
+      #
+      # @return [Pinelabs::Types::ChallanResponse]
+      def get_challan(request_options: {}, **params)
+        params = Pinelabs::Internal::Types::Utils.normalize_keys(params)
+        request = Pinelabs::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "api/pay/v1/order/#{URI.encode_uri_component(params[:order_id].to_s)}/challan",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinelabs::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinelabs::Types::ChallanResponse.load(response.body)
+        else
+          error_class = Pinelabs::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Creates an e-challan for a given order. The challan contains virtual account details
+      # that customers can use for payment.
+      #
+      # @param request_options [Hash]
+      # @param params [Pinelabs::EChallans::Types::CreateChallanRequest]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :order_id
+      #
+      # @return [Pinelabs::Types::ChallanResponse]
+      def create_challan(request_options: {}, **params)
+        params = Pinelabs::Internal::Types::Utils.normalize_keys(params)
+        request_data = Pinelabs::EChallans::Types::CreateChallanRequest.new(params).to_h
+        non_body_param_names = ["order_id"]
+        body = request_data.except(*non_body_param_names)
+
+        request = Pinelabs::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "POST",
+          path: "api/pay/v1/order/#{URI.encode_uri_component(params[:order_id].to_s)}/challan",
+          body: body,
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinelabs::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        if code.between?(200, 299)
+          Pinelabs::Types::ChallanResponse.load(response.body)
+        else
+          error_class = Pinelabs::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      # Downloads the e-challan in PDF format for a given order.
+      #
+      # @param request_options [Hash]
+      # @param params [Hash]
+      # @option request_options [String] :base_url
+      # @option request_options [Hash{String => Object}] :additional_headers
+      # @option request_options [Hash{String => Object}] :additional_query_parameters
+      # @option request_options [Hash{String => Object}] :additional_body_parameters
+      # @option request_options [Integer] :timeout_in_seconds
+      # @option params [String] :order_id
+      #
+      # @return [untyped]
+      def get_challan_pdf(request_options: {}, **params)
+        params = Pinelabs::Internal::Types::Utils.normalize_keys(params)
+        request = Pinelabs::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: "GET",
+          path: "api/pay/v1/order/#{URI.encode_uri_component(params[:order_id].to_s)}/challan/pdf",
+          request_options: request_options
+        )
+        begin
+          response = @client.send(request)
+        rescue Net::HTTPRequestTimeout
+          raise Pinelabs::Errors::TimeoutError
+        end
+        code = response.code.to_i
+        return if code.between?(200, 299)
+
+        error_class = Pinelabs::Errors::ResponseError.subclass_for_code(code)
+        raise error_class.new(response.body, code: code)
+      end
+    end
+  end
+end