DhanHQ 2.4.0 → 2.6.0

data/lib/DhanHQ/models/historical_data.rb

@@ -181,14 +181,6 @@ module DhanHQ
           resource.intraday(params)
         end
       end
-
-      ##
-      # HistoricalData objects are read-only, so no validation contract is applied.
-      #
-      # @return [nil] No validation contract needed for read-only data
-      def validation_contract
-        nil
-      end
     end
   end
 end

data/lib/DhanHQ/models/instrument.rb

@@ -69,7 +69,7 @@ module DhanHQ
 
           instruments.find do |instrument|
             # For equity instruments, prefer underlying_symbol over symbol_name
-            instrument_symbol = if instrument.instrument == "EQUITY" && instrument.underlying_symbol
+            instrument_symbol = if instrument.instrument == DhanHQ::Constants::InstrumentType::EQUITY && instrument.underlying_symbol
                                   case_sensitive ? instrument.underlying_symbol : instrument.underlying_symbol.upcase
                                 else
                                   case_sensitive ? instrument.symbol_name : instrument.symbol_name.upcase
@@ -155,12 +155,6 @@ module DhanHQ
           }
         end
       end
-
-      private
-
-      def validation_contract
-        nil
-      end
     end
   end
 end

data/lib/DhanHQ/models/instrument_helpers.rb

@@ -161,14 +161,14 @@ module DhanHQ
         return seg if %w[IDX_I NSE_FNO BSE_FNO MCX_FO].include?(seg)
 
         # Index detection by instrument kind or segment
-        return "IDX_I" if ins == "INDEX" || seg == "IDX_I"
+        return DhanHQ::Constants::ExchangeSegment::IDX_I if ins == DhanHQ::Constants::InstrumentType::INDEX || seg == DhanHQ::Constants::ExchangeSegment::IDX_I
 
         # Map equities/stock-related segments to respective FNO
-        return "NSE_FNO" if seg.start_with?("NSE")
-        return "BSE_FNO" if seg.start_with?("BSE")
+        return DhanHQ::Constants::ExchangeSegment::NSE_FNO if seg.start_with?("NSE")
+        return DhanHQ::Constants::ExchangeSegment::BSE_FNO if seg.start_with?("BSE")
 
         # Fallback to IDX_I to avoid contract rejection
-        "IDX_I"
+        DhanHQ::Constants::ExchangeSegment::IDX_I
       end
     end
   end

data/lib/DhanHQ/models/kill_switch.rb

@@ -68,7 +68,7 @@ module DhanHQ
         #   end
         #
         def update(status)
-          resource.update(kill_switch_status: status)
+          resource.update(status)
         end
 
         ##
@@ -132,20 +132,32 @@ module DhanHQ
         def deactivate
           update("DEACTIVATE")
         end
+
+        ##
+        # Fetches the current kill switch status for your account.
+        #
+        # Checks whether the kill switch is currently active or inactive for
+        # the current trading day.
+        #
+        # @return [Hash{Symbol => String}] Response hash containing kill switch status.
+        #   - **:dhan_client_id** [String] User-specific identification generated by Dhan
+        #   - **:kill_switch_status** [String] Current status: "ACTIVATE" or "DEACTIVATE"
+        #
+        # @example Check if kill switch is active
+        #   response = DhanHQ::Models::KillSwitch.status
+        #   if response[:kill_switch_status] == "ACTIVATE"
+        #     puts "Kill switch is active — trading disabled"
+        #   else
+        #     puts "Kill switch is inactive — trading enabled"
+        #   end
+        #
+        def status
+          resource.status
+        end
       end
 
       ##
       # No explicit validation contract is required for kill switch updates.
-      #
-      # Kill switch operations are simple status updates that don't require complex validation.
-      # The API handles validation server-side.
-      #
-      # @return [nil] Always returns nil as no validation contract is needed
-      #
-      # @api private
-      def validation_contract
-        nil
-      end
     end
   end
 end

data/lib/DhanHQ/models/margin.rb

@@ -47,8 +47,8 @@ module DhanHQ
       # Base path used to invoke the calculator.
       HTTP_PATH = "/v2/margincalculator"
 
-      attr_reader :total_margin, :span_margin, :exposure_margin, :available_balance,
-                  :variable_margin, :insufficient_balance, :brokerage, :leverage
+      attributes :total_margin, :span_margin, :exposure_margin, :available_balance,
+                 :variable_margin, :insufficient_balance, :brokerage, :leverage
 
       class << self
         ##
@@ -139,6 +139,55 @@ module DhanHQ
           response = resource.calculate(formatted_params)
           new(response, skip_validation: true)
         end
+
+        ##
+        # Calculates margin requirements for multiple scripts in a single request.
+        #
+        # Provides combined margin calculation including hedge benefit across multiple
+        # instruments. Useful for portfolio-level margin analysis.
+        #
+        # @param params [Hash{Symbol => Object}] Request parameters
+        #   @option params [Boolean] :include_position Whether to include existing positions
+        #   @option params [Boolean] :include_order Whether to include existing orders
+        #   @option params [String] :dhan_client_id User-specific identification
+        #   @option params [Array<Hash>] :scrip_list Array of instrument margin params, each with:
+        #     - :exchange_segment [String]
+        #     - :transaction_type [String]
+        #     - :quantity [Integer]
+        #     - :product_type [String]
+        #     - :security_id [String]
+        #     - :price [Float]
+        #     - :trigger_price [Float] (optional)
+        #
+        # @return [Hash{Symbol => String}] Response hash containing:
+        #   - **:total_margin** [String] Total margin required
+        #   - **:span_margin** [String] SPAN margin
+        #   - **:exposure_margin** [String] Exposure margin
+        #   - **:equity_margin** [String] Equity margin
+        #   - **:fo_margin** [String] F&O margin
+        #   - **:commodity_margin** [String] Commodity margin
+        #   - **:currency** [String] Currency (e.g., "INR")
+        #   - **:hedge_benefit** [String] Hedge benefit amount
+        #
+        # @example Calculate margin for multiple scripts
+        #   result = DhanHQ::Models::Margin.calculate_multi(
+        #     include_position: true,
+        #     include_order: true,
+        #     dhan_client_id: "1000000132",
+        #     scrip_list: [
+        #       { exchange_segment: "NSE_EQ", transaction_type: "BUY",
+        #         quantity: 100, product_type: "CNC", security_id: "1333", price: 1428.0 },
+        #       { exchange_segment: "NSE_FNO", transaction_type: "SELL",
+        #         quantity: 50, product_type: "INTRADAY", security_id: "43492", price: 200.0 }
+        #     ]
+        #   )
+        #   puts "Total margin: #{result[:total_margin]}"
+        #   puts "Hedge benefit: #{result[:hedge_benefit]}"
+        #
+        def calculate_multi(params)
+          formatted_params = camelize_keys(params)
+          resource.calculate_multi(formatted_params)
+        end
       end
 
       ##

data/lib/DhanHQ/models/order.rb

@@ -46,6 +46,8 @@ module DhanHQ
     #   puts "Pending orders: #{pending_orders.count}"
     #
     class Order < BaseModel
+      include Concerns::ApiResponseHandler
+
       # Attributes eligible for modification requests.
       MODIFIABLE_FIELDS = %i[
         dhan_client_id
@@ -57,10 +59,10 @@ module DhanHQ
         disclosed_quantity
         validity
         leg_name
+        bo_profit_value
+        bo_stop_loss_value
       ].freeze
 
-      attr_reader :order_id, :order_status
-
       # Define attributes that are part of an order
       attributes :dhan_client_id, :order_id, :correlation_id, :order_status,
                  :transaction_type, :exchange_segment, :product_type, :order_type,
@@ -168,9 +170,10 @@ module DhanHQ
         #
         def find(order_id)
           response = resource.find(order_id)
-          return nil unless response.is_a?(Hash) || (response.is_a?(Array) && response.any?)
+          is_array = response.is_a?(Array)
+          return nil unless response.is_a?(Hash) || (is_array && response.any?)
 
-          order_data = response.is_a?(Array) ? response.first : response
+          order_data = is_array ? response.first : response
           new(order_data, skip_validation: true)
         end
 
@@ -286,15 +289,19 @@ module DhanHQ
         # @raise [DhanHQ::ValidationError] If validation fails for any parameter
         def place(params)
           normalized_params = snake_case(params)
+          config = DhanHQ.configuration
           # Auto-inject dhan_client_id from configuration if not provided
-          normalized_params[:dhan_client_id] ||= DhanHQ.configuration.client_id if DhanHQ.configuration.client_id
+          normalized_params[:dhan_client_id] ||= config.client_id if config&.client_id
           validate_params!(normalized_params, DhanHQ::Contracts::PlaceOrderContract)
 
           response = resource.create(camelize_keys(normalized_params))
-          return nil unless response.is_a?(Hash) && response["orderId"]
+          return nil unless response.is_a?(Hash)
+
+          order_id = response["orderId"]
+          return nil unless order_id
 
           # Fetch the complete order details
-          find(response["orderId"])
+          find(order_id)
         end
 
         ##
@@ -366,25 +373,12 @@ module DhanHQ
       def modify(new_params)
         raise "Order ID is required to modify an order" unless id
 
-        # Log warning for invalid states but still attempt API call (let API handle validation)
-        # This maintains backward compatibility - API will return appropriate error
-        if order_status && %w[TRADED CANCELLED EXPIRED CLOSED].include?(order_status)
-          DhanHQ.logger&.warn("[DhanHQ::Models::Order] Attempting to modify order #{id} in #{order_status} state - API will reject")
-        end
-
-        base_payload = attributes.merge(new_params)
-        normalized_payload = snake_case(base_payload).merge(order_id: id)
-        filtered_payload = normalized_payload.each_with_object({}) do |(key, value), memo|
-          symbolized_key = key.respond_to?(:to_sym) ? key.to_sym : key
-          memo[symbolized_key] = value if MODIFIABLE_FIELDS.include?(symbolized_key)
-        end
-        filtered_payload[:order_id] ||= id
-        filtered_payload[:dhan_client_id] ||= attributes[:dhan_client_id] || DhanHQ.configuration&.client_id
+        warn_invalid_state if order_status_invalid_for_modification?
 
-        cleaned_payload = filtered_payload.compact
-        formatted_payload = camelize_keys(cleaned_payload)
-        validate_params!(formatted_payload, DhanHQ::Contracts::ModifyOrderContract)
+        filtered_payload = prepare_modify_payload(new_params)
+        validate_params!(filtered_payload, DhanHQ::Contracts::ModifyOrderContract)
 
+        formatted_payload = camelize_keys(filtered_payload)
         response = self.class.resource.update(id, formatted_payload)
         response = response.with_indifferent_access if response.respond_to?(:with_indifferent_access)
 
@@ -415,8 +409,15 @@ module DhanHQ
       def cancel
         raise "Order ID is required to cancel an order" unless id
 
+        DhanHQ.logger&.info("[DhanHQ::Models::Order] Cancelling order #{id}")
         response = self.class.resource.cancel(id)
-        response["orderStatus"] == "CANCELLED"
+        if response["orderStatus"] == DhanHQ::Constants::OrderStatus::CANCELLED
+          DhanHQ.logger&.info("[DhanHQ::Models::Order] Order #{id} cancelled successfully")
+          true
+        else
+          DhanHQ.logger&.error("[DhanHQ::Models::Order] Cancel failed for order #{id}: #{response.inspect}")
+          false
+        end
       end
 
       ##
@@ -453,6 +454,44 @@ module DhanHQ
         order_id.nil? || order_id.to_s.empty?
       end
 
+      def destroy
+        return false if new_record?
+
+        DhanHQ.logger&.info("[DhanHQ::Models::Order] Destroying order #{id}")
+        response = self.class.resource.delete(id)
+        if success_response?(response) && response["orderStatus"] == DhanHQ::Constants::OrderStatus::CANCELLED
+          @attributes[:order_status] = DhanHQ::Constants::OrderStatus::CANCELLED
+          DhanHQ.logger&.info("[DhanHQ::Models::Order] Order #{id} destroyed successfully")
+          true
+        else
+          DhanHQ.logger&.error("[DhanHQ::Models::Order] Destroy failed for order #{id}")
+          false
+        end
+      end
+      alias delete destroy
+
+      def slice_order(params)
+        raise "Order ID is required to slice an order" unless id
+
+        normalized = snake_case(params)
+        normalized[:dhan_client_id] ||= DhanHQ.configuration&.client_id
+        base_payload = normalized.merge(order_id: id)
+        formatted_payload = camelize_keys(base_payload)
+
+        validate_params!(formatted_payload, DhanHQ::Contracts::SliceOrderContract)
+
+        self.class.resource.slicing(formatted_payload)
+      end
+
+      def validation_contract
+        order_id_val = @attributes[:order_id] || @attributes[:orderId]
+        if order_id_val.nil? || order_id_val.to_s.empty?
+          DhanHQ::Contracts::PlaceOrderContract.new
+        else
+          DhanHQ::Contracts::ModifyOrderContract.new
+        end
+      end
+
       ##
       # Returns the order ID used for resource calls.
       #
@@ -495,40 +534,53 @@ module DhanHQ
         return false unless valid?
 
         if new_record?
-          # PLACE ORDER
-          DhanHQ.logger&.info("[DhanHQ::Models::Order] Placing order: #{attributes.slice(:transaction_type,
-                                                                                         :exchange_segment, :security_id, :quantity, :price).inspect}")
-          response = self.class.resource.create(to_request_params)
-          if success_response?(response) && response["orderId"]
-            @attributes.merge!(normalize_keys(response))
-            assign_attributes
-            DhanHQ.logger&.info("[DhanHQ::Models::Order] Order placed successfully: #{response["orderId"]}")
-            true
-          else
-            error_msg = response.is_a?(Hash) ? response[:errorMessage] || response[:message] || "Unknown error" : "Invalid response format"
-            DhanHQ.logger&.error("[DhanHQ::Models::Order] Order placement failed: #{error_msg}")
-            @errors = response if response.is_a?(Hash)
-            false
-          end
+          save_new_order
         else
-          # MODIFY ORDER
-          DhanHQ.logger&.info("[DhanHQ::Models::Order] Modifying order #{id}: #{attributes.slice(:price, :quantity,
-                                                                                                 :order_type).inspect}")
-          response = self.class.resource.update(id, to_request_params)
-          if success_response?(response) && response["orderStatus"]
-            @attributes.merge!(normalize_keys(response))
-            assign_attributes
-            DhanHQ.logger&.info("[DhanHQ::Models::Order] Order modified successfully: #{id}")
-            true
-          else
-            error_msg = response.is_a?(Hash) ? response[:errorMessage] || response[:message] || "Unknown error" : "Invalid response format"
-            DhanHQ.logger&.error("[DhanHQ::Models::Order] Order modification failed for #{id}: #{error_msg}")
-            @errors = response if response.is_a?(Hash)
-            false
-          end
+          modify_existing_order
         end
       end
 
+      private
+
+      def save_new_order
+        DhanHQ.logger&.info("[DhanHQ::Models::Order] Placing order: #{attributes.slice(:transaction_type, :exchange_segment, :security_id, :quantity, :price).inspect}")
+        response = self.class.resource.create(to_request_params)
+        handle_api_response(response, success_key: "orderId", context: "[DhanHQ::Models::Order] Order placement")
+      end
+
+      def modify_existing_order
+        DhanHQ.logger&.info("[DhanHQ::Models::Order] Modifying order #{id}: #{attributes.slice(:price, :quantity, :order_type).inspect}")
+        response = self.class.resource.update(id, to_request_params)
+        handle_api_response(response, success_key: "orderStatus", context: "[DhanHQ::Models::Order] Order modification")
+      end
+
+      def order_status_invalid_for_modification?
+        order_status && %w[TRADED CANCELLED EXPIRED CLOSED].include?(order_status)
+      end
+
+      def warn_invalid_state
+        DhanHQ.logger&.warn("[DhanHQ::Models::Order] Attempting to modify order #{id} in #{order_status} state - API will reject")
+      end
+
+      def prepare_modify_payload(new_params)
+        base_payload = attributes.merge(new_params)
+        normalized_payload = snake_case(base_payload).merge(order_id: id)
+
+        filtered_payload = normalized_payload.each_with_object({}) do |(key, value), memo|
+          symbolized_key = key.respond_to?(:to_sym) ? key.to_sym : key
+          memo[symbolized_key] = value if MODIFIABLE_FIELDS.include?(symbolized_key)
+        end
+
+        filtered_payload[:order_id] ||= id
+        filtered_payload[:dhan_client_id] ||= attributes[:dhan_client_id] || DhanHQ.configuration&.client_id
+
+        # Don't send trigger_price when it's 0 for non–stop-loss orders (API default; avoids validation noise).
+        order_type = filtered_payload[:order_type].to_s
+        filtered_payload.delete(:trigger_price) if !%w[STOP_LOSS STOP_LOSS_MARKET].include?(order_type) && filtered_payload[:trigger_price].to_f.zero?
+
+        filtered_payload.compact
+      end
+
       ##
       # Cancels (destroys) the order.
       #
@@ -545,77 +597,6 @@ module DhanHQ
       #   end
       #
       # @note This method does nothing for new (unsaved) orders.
-      def destroy
-        return false if new_record?
-
-        response = self.class.resource.delete(id)
-        if success_response?(response) && response["orderStatus"] == "CANCELLED"
-          @attributes[:order_status] = "CANCELLED"
-          true
-        else
-          false
-        end
-      end
-      alias delete destroy
-
-      ##
-      # Slices an order into multiple legs to place orders over freeze limit quantity.
-      #
-      # This API helps you slice your order request into multiple orders to allow you
-      # to place over freeze limit quantity for F&O instruments. Returns an array of
-      # orders created from the slice operation.
-      #
-      # @param params [Hash{Symbol => String, Integer, Float, Boolean}] Order parameters for slicing.
-      #   Same parameters as {place}, but quantity can exceed freeze limits as it will be
-      #   automatically split into multiple orders.
-      #
-      # @return [Array<Hash>] Array of order objects created from the slice operation.
-      #   Each hash contains:
-      #   - **:order_id** [String] Order-specific identification generated by Dhan
-      #   - **:order_status** [String] Order status. Valid values: "TRANSIT", "PENDING",
-      #     "REJECTED", "CANCELLED", "TRADED", "EXPIRED", "CONFIRM"
-      #
-      # @example Slice a large order
-      #   order = DhanHQ::Models::Order.find("112111182045")
-      #   sliced_orders = order.slice_order(
-      #     dhan_client_id: "1000000003",
-      #     transaction_type: "BUY",
-      #     exchange_segment: "NSE_FNO",
-      #     product_type: "INTRADAY",
-      #     order_type: "MARKET",
-      #     validity: "DAY",
-      #     security_id: "49081",
-      #     quantity: 50000  # Will be split into multiple orders
-      #   )
-      #   puts "Created #{sliced_orders.count} orders"
-      #
-      # @raise [RuntimeError] If order ID is missing
-      # @raise [DhanHQ::ValidationError] If validation fails for any parameter
-      def slice_order(params)
-        raise "Order ID is required to slice an order" unless id
-
-        base_payload = params.merge(order_id: id)
-        formatted_payload = camelize_keys(base_payload)
-
-        validate_params!(formatted_payload, DhanHQ::Contracts::SliceOrderContract)
-
-        self.class.resource.slicing(formatted_payload)
-      end
-
-      ##
-      # Returns the appropriate validation contract based on order state.
-      #
-      # For new records, returns PlaceOrderContract. For existing records, returns
-      # ModifyOrderContract. This allows the same validation logic to be used for
-      # both creating and modifying orders.
-      #
-      # @return [DhanHQ::Contracts::PlaceOrderContract, DhanHQ::Contracts::ModifyOrderContract]
-      #   The appropriate validation contract based on whether this is a new or existing order
-      #
-      # @api private
-      def validation_contract
-        new_record? ? DhanHQ::Contracts::PlaceOrderContract.new : DhanHQ::Contracts::ModifyOrderContract.new
-      end
     end
   end
 end

data/lib/DhanHQ/models/order_update.rb

@@ -31,12 +31,6 @@ module DhanHQ
         new(data, skip_validation: true)
       end
 
-      ##
-      # OrderUpdate objects are read-only, so no validation contract needed
-      def validation_contract
-        nil
-      end
-
       ##
       # Helper methods for transaction type
       def buy?
@@ -94,33 +88,33 @@ module DhanHQ
       ##
       # Helper methods for order status
       def transit?
-        status == "TRANSIT"
+        status == DhanHQ::Constants::OrderStatus::TRANSIT
       end
 
       def pending?
-        status == "PENDING"
+        status == DhanHQ::Constants::OrderStatus::PENDING
       end
 
       def rejected?
-        status == "REJECTED"
+        status == DhanHQ::Constants::OrderStatus::REJECTED
       end
 
       def cancelled?
-        status == "CANCELLED"
+        status == DhanHQ::Constants::OrderStatus::CANCELLED
       end
 
       def traded?
-        status == "TRADED"
+        status == DhanHQ::Constants::OrderStatus::TRADED
       end
 
       def expired?
-        status == "EXPIRED"
+        status == DhanHQ::Constants::OrderStatus::EXPIRED
       end
 
       ##
       # Helper methods for instrument type
       def equity?
-        instrument == "EQUITY"
+        instrument == DhanHQ::Constants::InstrumentType::EQUITY
       end
 
       def derivative?

data/lib/DhanHQ/models/pnl_exit.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module DhanHQ
+  module Models
+    ##
+    # Model for managing P&L-based automatic position exit.
+    #
+    # The P&L Based Exit API allows users to configure automatic exit rules based on
+    # cumulative profit or loss thresholds. When the defined limits are breached, all
+    # applicable positions are exited automatically.
+    #
+    # @note The configured P&L based exit remains active for the current day and is
+    #   reset at the end of the trading session.
+    #
+    # @example Configure P&L-based exit
+    #   response = DhanHQ::Models::PnlExit.configure(
+    #     profit_value: 1500.0,
+    #     loss_value: 500.0,
+    #     product_type: ["INTRADAY", "DELIVERY"],
+    #     enable_kill_switch: true
+    #   )
+    #   puts response[:pnl_exit_status] # => "ACTIVE"
+    #
+    # @example Check current P&L exit configuration
+    #   config = DhanHQ::Models::PnlExit.status
+    #   puts "Status: #{config.pnl_exit_status}"
+    #   puts "Profit threshold: ₹#{config.profit}"
+    #   puts "Loss threshold: ₹#{config.loss}"
+    #
+    # @example Stop P&L-based exit
+    #   response = DhanHQ::Models::PnlExit.stop
+    #   puts response[:pnl_exit_status] # => "DISABLED"
+    #
+    class PnlExit < BaseModel
+      HTTP_PATH = "/v2/pnlExit"
+
+      attributes :pnl_exit_status, :profit, :loss, :segments, :enable_kill_switch
+
+      class << self
+        ##
+        # Provides a shared instance of the PnlExit resource.
+        #
+        # @return [DhanHQ::Resources::PnlExit] The PnlExit resource client instance
+        def resource
+          @resource ||= DhanHQ::Resources::PnlExit.new
+        end
+
+        ##
+        # Configure automatic P&L-based position exit.
+        #
+        # When the defined profit or loss thresholds are breached during the trading day,
+        # all applicable positions are exited automatically.
+        #
+        # @param profit_value [Float] Profit threshold that triggers exit (e.g., 1500.0)
+        # @param loss_value [Float] Loss threshold that triggers exit (e.g., 500.0)
+        # @param product_type [Array<String>] Product types to apply. e.g., ["INTRADAY", "DELIVERY"]
+        # @param enable_kill_switch [Boolean] Whether to activate kill switch after exit
+        #
+        # @return [Hash{Symbol => String}] Response hash containing:
+        #   - **:pnl_exit_status** [String] "ACTIVE" on success
+        #   - **:message** [String] Confirmation message
+        #
+        # @example Configure with kill switch
+        #   DhanHQ::Models::PnlExit.configure(
+        #     profit_value: 2000.0,
+        #     loss_value: 1000.0,
+        #     product_type: ["INTRADAY"],
+        #     enable_kill_switch: true
+        #   )
+        #
+        def configure(profit_value:, loss_value:, product_type:, enable_kill_switch: false)
+          params = {
+            profitValue: profit_value.to_s,
+            lossValue: loss_value.to_s,
+            productType: product_type,
+            enableKillSwitch: enable_kill_switch
+          }
+          params[:dhanClientId] = DhanHQ.configuration.client_id if DhanHQ.configuration&.client_id.to_s != ""
+          resource.configure(params)
+        end
+
+        ##
+        # Stop/disable the active P&L-based exit configuration.
+        #
+        # @return [Hash{Symbol => String}] Response hash containing:
+        #   - **:pnl_exit_status** [String] "DISABLED"
+        #   - **:message** [String] Confirmation message
+        #
+        # @example Disable P&L exit
+        #   response = DhanHQ::Models::PnlExit.stop
+        #   puts response[:pnl_exit_status] # => "DISABLED"
+        #
+        def stop
+          resource.stop
+        end
+
+        ##
+        # Fetch the currently active P&L-based exit configuration.
+        #
+        # @return [PnlExit] PnlExit object with current configuration.
+        #   - **:pnl_exit_status** [String] "ACTIVE" or "DISABLED"
+        #   - **:profit** [String] Configured profit threshold
+        #   - **:loss** [String] Configured loss threshold
+        #   - **:segments** [Array<String>] Active product types
+        #   - **:enable_kill_switch** [Boolean] Whether kill switch is enabled
+        #
+        # @example Check configuration
+        #   config = DhanHQ::Models::PnlExit.status
+        #   if config.pnl_exit_status == "ACTIVE"
+        #     puts "P&L exit active: profit=₹#{config.profit}, loss=₹#{config.loss}"
+        #   end
+        #
+        def status
+          response = resource.status
+          return nil unless response.is_a?(Hash)
+
+          new(response, skip_validation: true)
+        end
+      end
+    end
+  end
+end