snaptrade 2.0.69 → 2.0.70

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd705b5a44a2c0f1c21353df0fef822943c839612d2ade5059236606570d9b0f
-  data.tar.gz: 28cd6478a9a9cbb078ccf658716f0bbb5de4b44ef36db490612ebd324dff746f
+  metadata.gz: da123b4dad2c9f58ab7798b61dbb8ef30a91d460b07812d6b543379566060604
+  data.tar.gz: 6d6cc15423db03518ce7f72bcc41c2b7c9b83480031dcaf00e93ea61088868a4
 SHA512:
-  metadata.gz: b607e11aa615fc10e5a29c18bdc4341b00ed7c1042dc69e7cc14af18aa1fa72910c647db53e5d44f64f7bdb3ce50f2273fae649e949976c3209da2e741254c38
-  data.tar.gz: 830212f7b8385cf721c8cc2b4d0e136084b245fe90094bcd45f6a65816995f11e14856f13fc80c05cadb1072d034668b4d6ea2eca08b53d256c6a5adf4cdf287
+  metadata.gz: 7b86acfca1bba55bb392ac96f1a0af69832463a8a58c4d91e667e4249e20d408d901e4011884c93742f2922e0673a84319810d6f2690f3cb447b4aa10266ee8e
+  data.tar.gz: 11a7c70a57fabbbe2ebce450c78e1bf0e24c7a5742444ae539deee0e5f6f0ed80e446dbe3918ba04a89288b163deb6badc71dde655c01da6e04732bfaabd732b

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    snaptrade (2.0.69)
+    snaptrade (2.0.70)
       faraday (>= 1.0.1, < 3.0)
       faraday-multipart (~> 1.0, >= 1.0.4)
 

data/README.md

@@ -6,7 +6,7 @@
 
 Connect brokerage accounts to your app for live positions and trading
 
-[![npm](https://img.shields.io/badge/gem-v2.0.69-blue)](https://rubygems.org/gems/snaptrade/versions/2.0.69)
+[![npm](https://img.shields.io/badge/gem-v2.0.70-blue)](https://rubygems.org/gems/snaptrade/versions/2.0.70)
 [![More Info](https://img.shields.io/badge/More%20Info-Click%20Here-orange)](https://snaptrade.com/)
 
 </div>
@@ -73,7 +73,7 @@ Connect brokerage accounts to your app for live positions and trading
 Add to Gemfile:
 
 ```ruby
-gem 'snaptrade', '~> 2.0.69'
+gem 'snaptrade', '~> 2.0.70'
 ```
 
 ## Getting Started<a id="getting-started"></a>
@@ -1663,6 +1663,14 @@ result = snaptrade.trading.place_force_order(
   stop: 31.33,
   units: 10.5,
   notional_value: None,
+  order_class: "BRACKET",
+  stop_loss: {
+        "stop_price" => "48.55",
+        "limit_price" => "48.50",
+    },
+  take_profit: {
+        "limit_price" => "49.95",
+    },
 )
 p result
 ```
@@ -1718,6 +1726,15 @@ provided. If placing an Option order, this field represents the number of
 contracts to buy or sell. (e.g., 1 contract = 100 shares).
 
 ##### notional_value: [`ManualTradeFormNotionalValue`](./lib/snaptrade/models/manual_trade_form_notional_value.rb)<a id="notional_value-manualtradeformnotionalvaluelibsnaptrademodelsmanual_trade_form_notional_valuerb"></a>
+##### order_class: [`OrderClass`](./lib/snaptrade/models/order_class.rb)<a id="order_class-orderclasslibsnaptrademodelsorder_classrb"></a>
+The class of order intended to be placed. Defaults to SIMPLE for regular, one
+legged trades. Set to BRACKET if looking to place a bracket
+(One-triggers-a-one-cancels-the-other) order, then specify take profit and stop
+loss conditions. Bracket orders currently only supported on Alpaca, Tradier, and
+Tradestation, contact us for more details
+
+##### stop_loss: [`ManualTradeFormWithOptionsStopLoss`](./lib/snaptrade/models/manual_trade_form_with_options_stop_loss.rb)<a id="stop_loss-manualtradeformwithoptionsstoplosslibsnaptrademodelsmanual_trade_form_with_options_stop_lossrb"></a>
+##### take_profit: [`ManualTradeFormWithOptionsTakeProfit`](./lib/snaptrade/models/manual_trade_form_with_options_take_profit.rb)<a id="take_profit-manualtradeformwithoptionstakeprofitlibsnaptrademodelsmanual_trade_form_with_options_take_profitrb"></a>
 #### 🔄 Return<a id="🔄-return"></a>
 
 [AccountOrderRecord](./lib/snaptrade/models/account_order_record.rb)

data/lib/snaptrade/api/trading_api.rb

@@ -428,9 +428,12 @@ module SnapTrade
     # @param stop [Float] The price at which a stop order is triggered for `Stop` and `StopLimit` orders.
     # @param units [Float] For Equity orders, this represents the number of shares for the order. This can be a decimal for fractional orders. Must be `null` if `notional_value` is provided. If placing an Option order, this field represents the number of contracts to buy or sell. (e.g., 1 contract = 100 shares).
     # @param notional_value [ManualTradeFormNotionalValue] 
+    # @param order_class [OrderClass] The class of order intended to be placed. Defaults to SIMPLE for regular, one legged trades. Set to BRACKET if looking to place a bracket (One-triggers-a-one-cancels-the-other) order, then specify take profit and stop loss conditions. Bracket orders currently only supported on Alpaca, Tradier, and Tradestation, contact us for more details
+    # @param stop_loss [ManualTradeFormWithOptionsStopLoss] 
+    # @param take_profit [ManualTradeFormWithOptionsTakeProfit] 
     # @param body [ManualTradeFormWithOptions] 
     # @param [Hash] extra additional parameters to pass along through :header_params, :query_params, or parameter name
-    def place_force_order(account_id:, action:, order_type:, time_in_force:, user_id:, user_secret:, universal_symbol_id: SENTINEL, symbol: SENTINEL, price: SENTINEL, stop: SENTINEL, units: SENTINEL, notional_value: SENTINEL, extra: {})
+    def place_force_order(account_id:, action:, order_type:, time_in_force:, user_id:, user_secret:, universal_symbol_id: SENTINEL, symbol: SENTINEL, price: SENTINEL, stop: SENTINEL, units: SENTINEL, notional_value: SENTINEL, order_class: SENTINEL, stop_loss: SENTINEL, take_profit: SENTINEL, extra: {})
       _body = {}
       _body[:account_id] = account_id if account_id != SENTINEL
       _body[:action] = action if action != SENTINEL
@@ -442,6 +445,9 @@ module SnapTrade
       _body[:stop] = stop if stop != SENTINEL
       _body[:units] = units if units != SENTINEL
       _body[:notional_value] = notional_value if notional_value != SENTINEL
+      _body[:order_class] = order_class if order_class != SENTINEL
+      _body[:stop_loss] = stop_loss if stop_loss != SENTINEL
+      _body[:take_profit] = take_profit if take_profit != SENTINEL
       manual_trade_form_with_options = _body
       data, _status_code, _headers = place_force_order_with_http_info_impl(user_id, user_secret, manual_trade_form_with_options, extra)
       data
@@ -467,9 +473,12 @@ module SnapTrade
     # @param stop [Float] The price at which a stop order is triggered for `Stop` and `StopLimit` orders.
     # @param units [Float] For Equity orders, this represents the number of shares for the order. This can be a decimal for fractional orders. Must be `null` if `notional_value` is provided. If placing an Option order, this field represents the number of contracts to buy or sell. (e.g., 1 contract = 100 shares).
     # @param notional_value [ManualTradeFormNotionalValue] 
+    # @param order_class [OrderClass] The class of order intended to be placed. Defaults to SIMPLE for regular, one legged trades. Set to BRACKET if looking to place a bracket (One-triggers-a-one-cancels-the-other) order, then specify take profit and stop loss conditions. Bracket orders currently only supported on Alpaca, Tradier, and Tradestation, contact us for more details
+    # @param stop_loss [ManualTradeFormWithOptionsStopLoss] 
+    # @param take_profit [ManualTradeFormWithOptionsTakeProfit] 
     # @param body [ManualTradeFormWithOptions] 
     # @param [Hash] extra additional parameters to pass along through :header_params, :query_params, or parameter name
-    def place_force_order_with_http_info(account_id:, action:, order_type:, time_in_force:, user_id:, user_secret:, universal_symbol_id: SENTINEL, symbol: SENTINEL, price: SENTINEL, stop: SENTINEL, units: SENTINEL, notional_value: SENTINEL, extra: {})
+    def place_force_order_with_http_info(account_id:, action:, order_type:, time_in_force:, user_id:, user_secret:, universal_symbol_id: SENTINEL, symbol: SENTINEL, price: SENTINEL, stop: SENTINEL, units: SENTINEL, notional_value: SENTINEL, order_class: SENTINEL, stop_loss: SENTINEL, take_profit: SENTINEL, extra: {})
       _body = {}
       _body[:account_id] = account_id if account_id != SENTINEL
       _body[:action] = action if action != SENTINEL
@@ -481,6 +490,9 @@ module SnapTrade
       _body[:stop] = stop if stop != SENTINEL
       _body[:units] = units if units != SENTINEL
       _body[:notional_value] = notional_value if notional_value != SENTINEL
+      _body[:order_class] = order_class if order_class != SENTINEL
+      _body[:stop_loss] = stop_loss if stop_loss != SENTINEL
+      _body[:take_profit] = take_profit if take_profit != SENTINEL
       manual_trade_form_with_options = _body
       place_force_order_with_http_info_impl(user_id, user_secret, manual_trade_form_with_options, extra)
     end

data/lib/snaptrade/models/manual_trade_form_with_options.rb

@@ -42,6 +42,13 @@ module SnapTrade
 
     attr_accessor :notional_value
 
+    # The class of order intended to be placed. Defaults to SIMPLE for regular, one legged trades. Set to BRACKET if looking to place a bracket (One-triggers-a-one-cancels-the-other) order, then specify take profit and stop loss conditions. Bracket orders currently only supported on Alpaca, Tradier, and Tradestation, contact us for more details
+    attr_accessor :order_class
+
+    attr_accessor :stop_loss
+
+    attr_accessor :take_profit
+
     # Attribute mapping from ruby-style variable name to JSON key.
     def self.attribute_map
       {
@@ -54,7 +61,10 @@ module SnapTrade
         :'price' => :'price',
         :'stop' => :'stop',
         :'units' => :'units',
-        :'notional_value' => :'notional_value'
+        :'notional_value' => :'notional_value',
+        :'order_class' => :'order_class',
+        :'stop_loss' => :'stop_loss',
+        :'take_profit' => :'take_profit'
       }
     end
 
@@ -75,7 +85,10 @@ module SnapTrade
         :'price' => :'Float',
         :'stop' => :'Float',
         :'units' => :'Float',
-        :'notional_value' => :'ManualTradeFormNotionalValue'
+        :'notional_value' => :'ManualTradeFormNotionalValue',
+        :'order_class' => :'OrderClass',
+        :'stop_loss' => :'ManualTradeFormWithOptionsStopLoss',
+        :'take_profit' => :'ManualTradeFormWithOptionsTakeProfit'
       }
     end
 
@@ -87,7 +100,10 @@ module SnapTrade
         :'price',
         :'stop',
         :'units',
-        :'notional_value'
+        :'notional_value',
+        :'order_class',
+        :'stop_loss',
+        :'take_profit'
       ])
     end
 
@@ -145,6 +161,18 @@ module SnapTrade
       if attributes.key?(:'notional_value')
         self.notional_value = attributes[:'notional_value']
       end
+
+      if attributes.key?(:'order_class')
+        self.order_class = attributes[:'order_class']
+      end
+
+      if attributes.key?(:'stop_loss')
+        self.stop_loss = attributes[:'stop_loss']
+      end
+
+      if attributes.key?(:'take_profit')
+        self.take_profit = attributes[:'take_profit']
+      end
     end
 
     # Show invalid properties with the reasons. Usually used together with valid?
@@ -194,7 +222,10 @@ module SnapTrade
           price == o.price &&
           stop == o.stop &&
           units == o.units &&
-          notional_value == o.notional_value
+          notional_value == o.notional_value &&
+          order_class == o.order_class &&
+          stop_loss == o.stop_loss &&
+          take_profit == o.take_profit
     end
 
     # @see the `==` method
@@ -206,7 +237,7 @@ module SnapTrade
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [account_id, action, universal_symbol_id, symbol, order_type, time_in_force, price, stop, units, notional_value].hash
+      [account_id, action, universal_symbol_id, symbol, order_type, time_in_force, price, stop, units, notional_value, order_class, stop_loss, take_profit].hash
     end
 
     # Builds the object from hash

data/lib/snaptrade/models/manual_trade_form_with_options_stop_loss.rb

@@ -0,0 +1,233 @@
+=begin
+#SnapTrade
+
+#Connect brokerage accounts to your app for live positions and trading
+
+The version of the OpenAPI document: 1.0.0
+Contact: api@snaptrade.com
+=end
+
+require 'date'
+require 'time'
+
+module SnapTrade
+  class ManualTradeFormWithOptionsStopLoss
+    attr_accessor :stop_price
+
+    attr_accessor :limit_price
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'stop_price' => :'stop_price',
+        :'limit_price' => :'limit_price'
+      }
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'stop_price' => :'String',
+        :'limit_price' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'limit_price'
+      ])
+    end
+
+    # List of class defined in allOf (OpenAPI v3)
+    def self.openapi_all_of
+      [
+      :'StopLoss'
+      ]
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `SnapTrade::ManualTradeFormWithOptionsStopLoss` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!self.class.attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `SnapTrade::ManualTradeFormWithOptionsStopLoss`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'stop_price')
+        self.stop_price = attributes[:'stop_price']
+      end
+
+      if attributes.key?(:'limit_price')
+        self.limit_price = attributes[:'limit_price']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          stop_price == o.stop_price &&
+          limit_price == o.limit_price
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [stop_price, limit_price].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      new.build_from_hash(attributes)
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      self.class.openapi_types.each_pair do |key, type|
+        if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
+          self.send("#{key}=", nil)
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = SnapTrade.const_get(type)
+        klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end

data/lib/snaptrade/models/manual_trade_form_with_options_take_profit.rb

@@ -0,0 +1,223 @@
+=begin
+#SnapTrade
+
+#Connect brokerage accounts to your app for live positions and trading
+
+The version of the OpenAPI document: 1.0.0
+Contact: api@snaptrade.com
+=end
+
+require 'date'
+require 'time'
+
+module SnapTrade
+  class ManualTradeFormWithOptionsTakeProfit
+    attr_accessor :limit_price
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'limit_price' => :'limit_price'
+      }
+    end
+
+    # Returns all the JSON keys this model knows about
+    def self.acceptable_attributes
+      attribute_map.values
+    end
+
+    # Attribute type mapping.
+    def self.openapi_types
+      {
+        :'limit_price' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    end
+
+    # List of class defined in allOf (OpenAPI v3)
+    def self.openapi_all_of
+      [
+      :'TakeProfit'
+      ]
+    end
+
+    # Initializes the object
+    # @param [Hash] attributes Model attributes in the form of hash
+    def initialize(attributes = {})
+      if (!attributes.is_a?(Hash))
+        fail ArgumentError, "The input argument (attributes) must be a hash in `SnapTrade::ManualTradeFormWithOptionsTakeProfit` initialize method"
+      end
+
+      # check to see if the attribute exists and convert string to symbol for hash key
+      attributes = attributes.each_with_object({}) { |(k, v), h|
+        if (!self.class.attribute_map.key?(k.to_sym))
+          fail ArgumentError, "`#{k}` is not a valid attribute in `SnapTrade::ManualTradeFormWithOptionsTakeProfit`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
+        end
+        h[k.to_sym] = v
+      }
+
+      if attributes.key?(:'limit_price')
+        self.limit_price = attributes[:'limit_price']
+      end
+    end
+
+    # Show invalid properties with the reasons. Usually used together with valid?
+    # @return Array for valid properties with the reasons
+    def list_invalid_properties
+      invalid_properties = Array.new
+      invalid_properties
+    end
+
+    # Check to see if the all the properties in the model are valid
+    # @return true if the model is valid
+    def valid?
+      true
+    end
+
+    # Checks equality by comparing each attribute.
+    # @param [Object] Object to be compared
+    def ==(o)
+      return true if self.equal?(o)
+      self.class == o.class &&
+          limit_price == o.limit_price
+    end
+
+    # @see the `==` method
+    # @param [Object] Object to be compared
+    def eql?(o)
+      self == o
+    end
+
+    # Calculates hash code according to all attributes.
+    # @return [Integer] Hash code
+    def hash
+      [limit_price].hash
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def self.build_from_hash(attributes)
+      new.build_from_hash(attributes)
+    end
+
+    # Builds the object from hash
+    # @param [Hash] attributes Model attributes in the form of hash
+    # @return [Object] Returns the model itself
+    def build_from_hash(attributes)
+      return nil unless attributes.is_a?(Hash)
+      attributes = attributes.transform_keys(&:to_sym)
+      self.class.openapi_types.each_pair do |key, type|
+        if attributes[self.class.attribute_map[key]].nil? && self.class.openapi_nullable.include?(key)
+          self.send("#{key}=", nil)
+        elsif type =~ /\AArray<(.*)>/i
+          # check to ensure the input is an array given that the attribute
+          # is documented as an array but the input is not
+          if attributes[self.class.attribute_map[key]].is_a?(Array)
+            self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
+          end
+        elsif !attributes[self.class.attribute_map[key]].nil?
+          self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
+        end
+      end
+
+      self
+    end
+
+    # Deserializes the data based on type
+    # @param string type Data type
+    # @param string value Value to be deserialized
+    # @return [Object] Deserialized data
+    def _deserialize(type, value)
+      case type.to_sym
+      when :Time
+        Time.parse(value)
+      when :Date
+        Date.parse(value)
+      when :String
+        value.to_s
+      when :Integer
+        value.to_i
+      when :Float
+        value.to_f
+      when :Boolean
+        if value.to_s =~ /\A(true|t|yes|y|1)\z/i
+          true
+        else
+          false
+        end
+      when :Object
+        # generic object (usually a Hash), return directly
+        value
+      when /\AArray<(?<inner_type>.+)>\z/
+        inner_type = Regexp.last_match[:inner_type]
+        value.map { |v| _deserialize(inner_type, v) }
+      when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+        k_type = Regexp.last_match[:k_type]
+        v_type = Regexp.last_match[:v_type]
+        {}.tap do |hash|
+          value.each do |k, v|
+            hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
+          end
+        end
+      else # model
+        # models (e.g. Pet) or oneOf
+        klass = SnapTrade.const_get(type)
+        klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
+      end
+    end
+
+    # Returns the string representation of the object
+    # @return [String] String presentation of the object
+    def to_s
+      to_hash.to_s
+    end
+
+    # to_body is an alias to to_hash (backward compatibility)
+    # @return [Hash] Returns the object in the form of hash
+    def to_body
+      to_hash
+    end
+
+    # Returns the object in the form of hash
+    # @return [Hash] Returns the object in the form of hash
+    def to_hash
+      hash = {}
+      self.class.attribute_map.each_pair do |attr, param|
+        value = self.send(attr)
+        if value.nil?
+          is_nullable = self.class.openapi_nullable.include?(attr)
+          next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
+        end
+
+        hash[param] = _to_hash(value)
+      end
+      hash
+    end
+
+    # Outputs non-array value in the form of hash
+    # For object, use to_hash. Otherwise, just return the value
+    # @param [Object] value Any valid value
+    # @return [Hash] Returns the value in the form of hash
+    def _to_hash(value)
+      if value.is_a?(Array)
+        value.compact.map { |v| _to_hash(v) }
+      elsif value.is_a?(Hash)
+        {}.tap do |hash|
+          value.each { |k, v| hash[k] = _to_hash(v) }
+        end
+      elsif value.respond_to? :to_hash
+        value.to_hash
+      else
+        value
+      end
+    end
+
+  end
+
+end