snaptrade 2.0.217 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9b12d3207e97475d1d855d8adb86c139d4abc8cdab5d64220158a8a6686df327
-  data.tar.gz: 9316e9b555efed30ceb1ebaf72162878e8a9c387212b6ed6ad224b2580497dd7
+  metadata.gz: 5349d61ab043f9918af1b6472dfc08b04af0a69c9c331eeb8f7d87c2ef71b298
+  data.tar.gz: c58ec1366f413c0803ee8803ab9e126eae8dc9bf8b0a9d69f9a46d3d74071560
 SHA512:
-  metadata.gz: ad6a49682812402cfdfc0f95ba5ee652277d2b373c4a0961bde7d0b217a0044080209fe81f80e4298ef5faf211741699aed5eb1c8816ac41e291b9a535a73ebb
-  data.tar.gz: 12ca9e303d15c7d59d906e2bfebc3878100fbdbc863e06020535e640912b50f916049e4ead2b8ba996b3906cc6cb314f58f13b5562f61fee8af7640fd584979e
+  metadata.gz: b14a96eb2edc26421da21e317aa6f857d50759e0bfe4c52c0d9a2a946e5c5a58ffc4820d3c0cabfb933e0f898e4203172d3d9c5e58c9f2fbb55b5768e06ae83b
+  data.tar.gz: a01ea3893a7d22b6e054f24030a9a79035e57cc65c16e0aebd5ff8877f6ab99c0ef9b1261953321d9685f2f8e0752a6119de3a1a3059c727581caef357469343

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    snaptrade (2.0.217)
+    snaptrade (2.1.0)
       faraday (>= 1.0.1, < 3.0)
       faraday-multipart (~> 1.0, >= 1.0.4)
 
@@ -43,7 +43,7 @@ GEM
     rainbow (3.1.1)
     rake (13.0.6)
     regexp_parser (2.12.0)
-    reline (0.6.3)
+    reline (0.7.0)
       io-console (~> 0.5)
     rexml (3.4.4)
     rspec (3.13.2)

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.217-blue)](https://rubygems.org/gems/snaptrade/versions/2.0.217)
+[![npm](https://img.shields.io/badge/gem-v2.1.0-blue)](https://rubygems.org/gems/snaptrade/versions/2.1.0)
 [![More Info](https://img.shields.io/badge/More%20Info-Click%20Here-orange)](https://snaptrade.com/)
 
 </div>
@@ -54,6 +54,7 @@ Connect brokerage accounts to your app for live positions and trading
   * [`snaptrade.experimental_endpoints.get_user_account_order_detail_v2`](#snaptradeexperimental_endpointsget_user_account_order_detail_v2)
   * [`snaptrade.experimental_endpoints.get_user_account_orders_v2`](#snaptradeexperimental_endpointsget_user_account_orders_v2)
   * [`snaptrade.experimental_endpoints.get_user_account_recent_orders_v2`](#snaptradeexperimental_endpointsget_user_account_recent_orders_v2)
+  * [`snaptrade.experimental_endpoints.list_connection_accounts`](#snaptradeexperimental_endpointslist_connection_accounts)
   * [`snaptrade.experimental_endpoints.list_subscriptions`](#snaptradeexperimental_endpointslist_subscriptions)
   * [`snaptrade.options.list_option_holdings`](#snaptradeoptionslist_option_holdings)
   * [`snaptrade.reference_data.get_currency_exchange_rate_pair`](#snaptradereference_dataget_currency_exchange_rate_pair)
@@ -94,7 +95,7 @@ Connect brokerage accounts to your app for live positions and trading
 Add to Gemfile:
 
 ```ruby
-gem 'snaptrade', '~> 2.0.217'
+gem 'snaptrade', '~> 2.1.0'
 ```
 
 ## Getting Started<a id="getting-started"></a>
@@ -1554,6 +1555,50 @@ false to retrieve non executed orders as well
 ---
 
 
+### `snaptrade.experimental_endpoints.list_connection_accounts`<a id="snaptradeexperimental_endpointslist_connection_accounts"></a>
+
+Experimental and subject to change without notice.
+
+Returns the accounts that belong to the specified connection for the authenticated user, using the `kind`-discriminated account shape.
+
+Each item in the response carries a `kind` field (currently only `investment` is implemented) that determines which additional fields are present -- see the `ConnectionAccount` schema.
+
+On Pay as you Go / Real-time, this endpoint refreshes each account's opening date, funding date, and market value live from the brokerage on each call.
+
+On Pay as you Go / Daily, this endpoint returns Daily data. Daily data is cached and refreshed once a day. Exact refresh timing may vary by brokerage. To force a refresh, use the [manual refresh endpoint](/reference/Connections/Connections_refreshBrokerageAuthorization).
+
+Check your API key on the [Customer Dashboard billing page](https://dashboard.snaptrade.com/settings/billing) to see whether your plan includes real-time data.
+
+
+#### 🛠️ Usage<a id="🛠️-usage"></a>
+
+```ruby
+result = snaptrade.experimental_endpoints.list_connection_accounts(
+  authorization_id: "87b24961-b51e-4db8-9226-f198f6518a89",
+  user_id: "snaptrade-user-123",
+  user_secret: "adf2aa34-8219-40f7-a6b3-60156985cc61",
+)
+p result
+```
+
+#### ⚙️ Parameters<a id="⚙️-parameters"></a>
+
+##### authorization_id: `String`<a id="authorization_id-string"></a>
+##### user_id: `String`<a id="user_id-string"></a>
+##### user_secret: `String`<a id="user_secret-string"></a>
+#### 🔄 Return<a id="🔄-return"></a>
+
+[ConnectionAccount](./lib/snaptrade/models/connection_account.rb)
+
+#### 🌐 Endpoint<a id="🌐-endpoint"></a>
+
+`/connections/{authorizationId}/accounts` `GET`
+
+[🔙 **Back to Table of Contents**](#table-of-contents)
+
+---
+
+
 ### `snaptrade.experimental_endpoints.list_subscriptions`<a id="snaptradeexperimental_endpointslist_subscriptions"></a>
 
 Returns active Trade Detection subscriptions for your Client ID. Cancelled subscriptions are not returned.

data/lib/snaptrade/api/experimental_endpoints_api.rb

@@ -619,6 +619,129 @@ module SnapTrade
     end
 
 
+    # List accounts for a connection (discriminated union)
+    #
+    # Experimental and subject to change without notice.
+    # 
+    # Returns the accounts that belong to the specified connection for the authenticated user, using the `kind`-discriminated account shape.
+    # 
+    # Each item in the response carries a `kind` field (currently only `investment` is implemented) that determines which additional fields are present -- see the `ConnectionAccount` schema.
+    # 
+    # On Pay as you Go / Real-time, this endpoint refreshes each account's opening date, funding date, and market value live from the brokerage on each call.
+    # 
+    # On Pay as you Go / Daily, this endpoint returns Daily data. Daily data is cached and refreshed once a day. Exact refresh timing may vary by brokerage. To force a refresh, use the [manual refresh endpoint](/reference/Connections/Connections_refreshBrokerageAuthorization).
+    # 
+    # Check your API key on the [Customer Dashboard billing page](https://dashboard.snaptrade.com/settings/billing) to see whether your plan includes real-time data.
+    #
+    # @param authorization_id [String] 
+    # @param user_id [String] 
+    # @param user_secret [String] 
+    # @param [Hash] extra additional parameters to pass along through :header_params, :query_params, or parameter name
+    def list_connection_accounts(authorization_id:, user_id:, user_secret:, extra: {})
+      data, _status_code, _headers = list_connection_accounts_with_http_info_impl(authorization_id, user_id, user_secret, extra)
+      data
+    end
+
+    # List accounts for a connection (discriminated union)
+    #
+    # Experimental and subject to change without notice.
+    # 
+    # Returns the accounts that belong to the specified connection for the authenticated user, using the `kind`-discriminated account shape.
+    # 
+    # Each item in the response carries a `kind` field (currently only `investment` is implemented) that determines which additional fields are present -- see the `ConnectionAccount` schema.
+    # 
+    # On Pay as you Go / Real-time, this endpoint refreshes each account's opening date, funding date, and market value live from the brokerage on each call.
+    # 
+    # On Pay as you Go / Daily, this endpoint returns Daily data. Daily data is cached and refreshed once a day. Exact refresh timing may vary by brokerage. To force a refresh, use the [manual refresh endpoint](/reference/Connections/Connections_refreshBrokerageAuthorization).
+    # 
+    # Check your API key on the [Customer Dashboard billing page](https://dashboard.snaptrade.com/settings/billing) to see whether your plan includes real-time data.
+    #
+    # @param authorization_id [String] 
+    # @param user_id [String] 
+    # @param user_secret [String] 
+    # @param [Hash] extra additional parameters to pass along through :header_params, :query_params, or parameter name
+    def list_connection_accounts_with_http_info(authorization_id:, user_id:, user_secret:, extra: {})
+      list_connection_accounts_with_http_info_impl(authorization_id, user_id, user_secret, extra)
+    end
+
+    # List accounts for a connection (discriminated union)
+    # Experimental and subject to change without notice.  Returns the accounts that belong to the specified connection for the authenticated user, using the `kind`-discriminated account shape.  Each item in the response carries a `kind` field (currently only `investment` is implemented) that determines which additional fields are present -- see the `ConnectionAccount` schema.  On Pay as you Go / Real-time, this endpoint refreshes each account's opening date, funding date, and market value live from the brokerage on each call.  On Pay as you Go / Daily, this endpoint returns Daily data. Daily data is cached and refreshed once a day. Exact refresh timing may vary by brokerage. To force a refresh, use the [manual refresh endpoint](/reference/Connections/Connections_refreshBrokerageAuthorization).  Check your API key on the [Customer Dashboard billing page](https://dashboard.snaptrade.com/settings/billing) to see whether your plan includes real-time data. 
+    # @param authorization_id [String] 
+    # @param user_id [String] 
+    # @param user_secret [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<ConnectionAccount>]
+    private def list_connection_accounts_impl(authorization_id, user_id, user_secret, opts = {})
+      data, _status_code, _headers = list_connection_accounts_with_http_info(authorization_id, user_id, user_secret, opts)
+      data
+    end
+
+    # List accounts for a connection (discriminated union)
+    # Experimental and subject to change without notice.  Returns the accounts that belong to the specified connection for the authenticated user, using the &#x60;kind&#x60;-discriminated account shape.  Each item in the response carries a &#x60;kind&#x60; field (currently only &#x60;investment&#x60; is implemented) that determines which additional fields are present -- see the &#x60;ConnectionAccount&#x60; schema.  On Pay as you Go / Real-time, this endpoint refreshes each account&#39;s opening date, funding date, and market value live from the brokerage on each call.  On Pay as you Go / Daily, this endpoint returns Daily data. Daily data is cached and refreshed once a day. Exact refresh timing may vary by brokerage. To force a refresh, use the [manual refresh endpoint](/reference/Connections/Connections_refreshBrokerageAuthorization).  Check your API key on the [Customer Dashboard billing page](https://dashboard.snaptrade.com/settings/billing) to see whether your plan includes real-time data. 
+    # @param authorization_id [String] 
+    # @param user_id [String] 
+    # @param user_secret [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(Array<ConnectionAccount>, Integer, Hash)>] Array<ConnectionAccount> data, response status code and response headers
+    private def list_connection_accounts_with_http_info_impl(authorization_id, user_id, user_secret, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: ExperimentalEndpointsApi.list_connection_accounts ...'
+      end
+      # verify the required parameter 'authorization_id' is set
+      if @api_client.config.client_side_validation && authorization_id.nil?
+        fail ArgumentError, "Missing the required parameter 'authorization_id' when calling ExperimentalEndpointsApi.list_connection_accounts"
+      end
+      # verify the required parameter 'user_id' is set
+      if @api_client.config.client_side_validation && user_id.nil?
+        fail ArgumentError, "Missing the required parameter 'user_id' when calling ExperimentalEndpointsApi.list_connection_accounts"
+      end
+      # verify the required parameter 'user_secret' is set
+      if @api_client.config.client_side_validation && user_secret.nil?
+        fail ArgumentError, "Missing the required parameter 'user_secret' when calling ExperimentalEndpointsApi.list_connection_accounts"
+      end
+      # resource path
+      local_var_path = '/connections/{authorizationId}/accounts'.sub('{' + 'authorizationId' + '}', CGI.escape(authorization_id.to_s))
+
+      # query parameters
+      query_params = opts[:query_params] || {}
+      query_params[:'userId'] = user_id
+      query_params[:'userSecret'] = user_secret
+
+      # header parameters
+      header_params = opts[:header_params] || {}
+      # HTTP header 'Accept' (if needed)
+      header_params['Accept'] = @api_client.select_header_accept(['application/json'])
+
+      # form parameters
+      form_params = opts[:form_params] || {}
+
+      # http body (model)
+      post_body = opts[:debug_body]
+
+      # return_type
+      return_type = opts[:debug_return_type] || 'Array<ConnectionAccount>'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['PartnerClientId', 'PartnerSignature', 'PartnerTimestamp']
+
+      new_options = opts.merge(
+        :operation => :"ExperimentalEndpointsApi.list_connection_accounts",
+        :header_params => header_params,
+        :query_params => query_params,
+        :form_params => form_params,
+        :body => post_body,
+        :auth_names => auth_names,
+        :return_type => return_type
+      )
+
+      data, status_code, headers, response = @api_client.call_api(:GET, local_var_path, new_options)
+      if @api_client.config.debugging
+        @api_client.config.logger.debug "API called: ExperimentalEndpointsApi#list_connection_accounts\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers, response
+    end
+
+
     # List active Trade Detection subscriptions
     #
     # Returns active Trade Detection subscriptions for your Client ID. Cancelled subscriptions are not returned.

data/lib/snaptrade/models/account_order_record_leg_instrument.rb

@@ -22,7 +22,7 @@ module SnapTrade
     # Type of instrument for the leg. - EQUITY - OPTION - CRYPTO 
     attr_accessor :asset_type
 
-    # Market Identifier Code (MIC) for the exchange on which the instrument trades.
+    # Market Identifier Code (MIC) for the exchange on which the instrument trades. Omitted for instruments with no listing exchange, such as index options (VIX, SPX). 
     attr_accessor :exchange_mic_code
 
     # Financial Instrument Global Identifier (FIGI) if available.

data/lib/snaptrade/models/account_position.rb

@@ -21,7 +21,7 @@ module SnapTrade
     # Last known market price _per share_. The freshness of this price depends on the brokerage. Some brokerages provide real-time prices, while others provide delayed prices. It is recommended that you rely on your own third-party market data provider for most up to date prices.
     attr_accessor :price
 
-    # Book price or average purchase price for the position. For options, this is per-contract.
+    # Book price or average purchase price for the position. For options, this is per-share.
     attr_accessor :cost_basis
 
     # ISO-4217 currency code for the position `price` and `cost_basis`.

data/lib/snaptrade/models/connection_account.rb

@@ -0,0 +1,51 @@
+=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
+  # A single account under a connection, from the `kind`-discriminated union used by `Connections_listConnectionAccounts`. Use `kind` to determine which schema is present.  Only `investment` is implemented today; `deposit` and `line_of_credit` will be added as additional variants in a future release. 
+  module ConnectionAccount
+    class << self
+      # List of class defined in oneOf (OpenAPI v3)
+      def openapi_one_of
+        [
+          :'InvestmentAccount'
+        ]
+      end
+
+      # Discriminator's property name (OpenAPI v3)
+      def openapi_discriminator_name
+        :'kind'
+      end
+
+      # Discriminator's mapping (OpenAPI v3)
+      def openapi_discriminator_mapping
+        {
+          :'investment' => :'InvestmentAccount'
+        }
+      end
+
+      # Builds the object
+      # @param [Mixed] Data to be matched against the list of oneOf items
+      # @return [Object] Returns the model or the data itself
+      def build(data)
+        discriminator_value = data[openapi_discriminator_name]
+        return nil if discriminator_value.nil?
+
+        klass = openapi_discriminator_mapping[discriminator_value.to_s.to_sym]
+        return nil unless klass
+
+        SnapTrade.const_get(klass).build_from_hash(data)
+      end
+    end
+  end
+
+end

data/lib/snaptrade/models/connection_account_sync_status.rb

@@ -0,0 +1,250 @@
+=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
+  # Contains status updates for the account sync process between SnapTrade and the brokerage, used only by `Connections_listConnectionAccounts`. Each property is optional -- a brokerage may not report sync status for every data type. `orders`/`positions`/`balances` are the timestamp of the last successful sync of that data type (null if never synced). 
+  class ConnectionAccountSyncStatus
+    attr_accessor :transactions
+
+    # The last time orders were successfully synced by SnapTrade.
+    attr_accessor :orders
+
+    # The last time positions were successfully synced by SnapTrade.
+    attr_accessor :positions
+
+    # The last time balances were successfully synced by SnapTrade.
+    attr_accessor :balances
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'transactions' => :'transactions',
+        :'orders' => :'orders',
+        :'positions' => :'positions',
+        :'balances' => :'balances'
+      }
+    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
+      {
+        :'transactions' => :'TransactionsStatus',
+        :'orders' => :'Time',
+        :'positions' => :'Time',
+        :'balances' => :'Time'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+        :'orders',
+        :'positions',
+        :'balances'
+      ])
+    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::ConnectionAccountSyncStatus` 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::ConnectionAccountSyncStatus`. 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?(:'transactions')
+        self.transactions = attributes[:'transactions']
+      end
+
+      if attributes.key?(:'orders')
+        self.orders = attributes[:'orders']
+      end
+
+      if attributes.key?(:'positions')
+        self.positions = attributes[:'positions']
+      end
+
+      if attributes.key?(:'balances')
+        self.balances = attributes[:'balances']
+      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 &&
+          transactions == o.transactions &&
+          orders == o.orders &&
+          positions == o.positions &&
+          balances == o.balances
+    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
+      [transactions, orders, positions, balances].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