snaptrade 3.0.3 → 3.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9eb41837fba388ae89f7ab2fa9aa827af8d8c794f3c73a55e844af9610f580cb
-  data.tar.gz: 34b4dbe47256bf59ba913962e86c6ff93c9549398a303e9de5ab3150463c51be
+  metadata.gz: 42c6cbd8d70b68fbeaaec9a26b5a4de57bf2439e2c745084657e48ed2b62ecb4
+  data.tar.gz: 86de1c293648872d90ba719e82609fbe77a0b626437255f6312e1b3976721272
 SHA512:
-  metadata.gz: dae2772d34c712eb5849f2f67d604f0a1a71c92bbdda4c2ff8639ccbb344bd07a778683a98d7b1145af06b5de2411464b8603272db4387ff72395ef4f94b7b6f
-  data.tar.gz: b12fd9fe328d9ff3f8a590caa0d9bfbbad10e979db80552d640e90613b5894ee218b39a153dd000e9ffa14ff1d0070ce398743526d72465f662c3f64231b1f0e
+  metadata.gz: 35e1dbe18c59245ffd5c4235054957ce92e17fdbc78ca34b2e1fa7f6fa7857cf2b7c1d92170fe7089e38bbfccd14c05a563a33fda615f311438dfe3e332ab136
+  data.tar.gz: b2e5526daa65b2c159d6692ab4a1141c4e56031d0640c9d16b113d1672b544c3f9a3031048c8f580a70a04f26fcc065be80f67cd1b2abdcffd23ec85ef56001e

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    snaptrade (3.0.3)
+    snaptrade (3.0.4)
       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-v3.0.3-blue)](https://rubygems.org/gems/snaptrade/versions/3.0.3)
+[![npm](https://img.shields.io/badge/gem-v3.0.4-blue)](https://rubygems.org/gems/snaptrade/versions/3.0.4)
 [![More Info](https://img.shields.io/badge/More%20Info-Click%20Here-orange)](https://snaptrade.com/)
 
 </div>
@@ -28,6 +28,7 @@ Connect brokerage accounts to your app for live positions and trading
   * [`snaptrade.account_information.get_user_account_orders`](#snaptradeaccount_informationget_user_account_orders)
   * [`snaptrade.account_information.get_user_account_recent_orders`](#snaptradeaccount_informationget_user_account_recent_orders)
   * [`snaptrade.account_information.get_user_account_return_rates`](#snaptradeaccount_informationget_user_account_return_rates)
+  * [`snaptrade.account_information.get_user_aum_percentile`](#snaptradeaccount_informationget_user_aum_percentile)
   * [`snaptrade.account_information.get_user_holdings`](#snaptradeaccount_informationget_user_holdings)
   * [`snaptrade.account_information.list_user_accounts`](#snaptradeaccount_informationlist_user_accounts)
   * [`snaptrade.account_information.update_user_account`](#snaptradeaccount_informationupdate_user_account)
@@ -82,7 +83,7 @@ Connect brokerage accounts to your app for live positions and trading
 Add to Gemfile:
 
 ```ruby
-gem 'snaptrade', '~> 3.0.3'
+gem 'snaptrade', '~> 3.0.4'
 ```
 
 ## Getting Started<a id="getting-started"></a>
@@ -542,6 +543,42 @@ returns all six supported timeframes.
 ---
 
 
+### `snaptrade.account_information.get_user_aum_percentile`<a id="snaptradeaccount_informationget_user_aum_percentile"></a>
+
+Returns where the user's total assets sit within the distribution of a cohort of comparable users, as a coarse bucket plus an integer percentile.
+
+The cohort is scoped to your own book: a user is only ever compared against your other users, never across SnapTrade customers. (Users on personal-use keys are the exception — they are compared against all other personal-use users, since a personal key has a single user and cannot form a distribution of its own.) The distribution is recomputed monthly, and `as_of` reports which month's distribution the placement came from.
+
+`data` is `null` — a 200, not an error — when SnapTrade declines to place the user. That happens when the cohort is too small to publish a distribution, or when the user's own holdings are incomplete or stale (for example they hold a disabled connection). A placement computed from a partial view of a user's assets would understate them, so none is returned.
+
+
+#### 🛠️ Usage<a id="🛠️-usage"></a>
+
+```ruby
+result = snaptrade.account_information.get_user_aum_percentile(
+  user_id: "snaptrade-user-123",
+  user_secret: "adf2aa34-8219-40f7-a6b3-60156985cc61",
+)
+p result
+```
+
+#### ⚙️ Parameters<a id="⚙️-parameters"></a>
+
+##### user_id: `String`<a id="user_id-string"></a>
+##### user_secret: `String`<a id="user_secret-string"></a>
+#### 🔄 Return<a id="🔄-return"></a>
+
+[UserAumPercentileResponse](./lib/snaptrade/models/user_aum_percentile_response.rb)
+
+#### 🌐 Endpoint<a id="🌐-endpoint"></a>
+
+`/aumPercentile` `GET`
+
+[🔙 **Back to Table of Contents**](#table-of-contents)
+
+---
+
+
 ### `snaptrade.account_information.get_user_holdings`<a id="snaptradeaccount_informationget_user_holdings"></a>
 ![Deprecated](https://img.shields.io/badge/deprecated-yellow)
 
@@ -749,6 +786,7 @@ result = snaptrade.authentication.login_snap_trade_user(
   connection_type: "read",
   show_close_button: true,
   dark_mode: true,
+  locale: "pt-BR",
   connection_portal_version: "v4",
 )
 p result
@@ -793,6 +831,16 @@ When false, you control closing behavior from your app. Defaults to true.
 ##### darkMode: `Boolean`<a id="darkmode-boolean"></a>
 Enable dark mode for the connection portal. Defaults to false.
 
+##### locale: `String`<a id="locale-string"></a>
+Language the connection portal renders in. `en` and `pt-BR` are the languages we
+ship; any other language is rejected with a 400. Matching is case- and
+separator-insensitive, so `pt-br`, `pt-BR` and `pt_BR` are equivalent, and a
+regional tag resolves to the language when we ship it, so `en-US` renders `en`.
+Deliberately not an enum: those equivalent spellings are all accepted by the
+API, and an enum would have generated SDKs reject them before the request is
+sent. Screens without translated copy fall back to English individually.
+Defaults to `en`.
+
 ##### connectionPortalVersion: [`ConnectionPortalVersion`](./lib/snaptrade/models/connection_portal_version.rb)<a id="connectionportalversion-connectionportalversionlibsnaptrademodelsconnection_portal_versionrb"></a>
 Sets the connection portal version to render. Currently only `v4` is supported
 and is the default. All other versions are deprecated and will automatically be

data/lib/snaptrade/api/account_information_api.rb

@@ -1134,6 +1134,109 @@ module SnapTrade
     end
 
 
+    # Get the user's AUM percentile
+    #
+    # Returns where the user's total assets sit within the distribution of a cohort of comparable users, as a coarse bucket plus an integer percentile.
+    # 
+    # The cohort is scoped to your own book: a user is only ever compared against your other users, never across SnapTrade customers. (Users on personal-use keys are the exception — they are compared against all other personal-use users, since a personal key has a single user and cannot form a distribution of its own.) The distribution is recomputed monthly, and `as_of` reports which month's distribution the placement came from.
+    # 
+    # `data` is `null` — a 200, not an error — when SnapTrade declines to place the user. That happens when the cohort is too small to publish a distribution, or when the user's own holdings are incomplete or stale (for example they hold a disabled connection). A placement computed from a partial view of a user's assets would understate them, so none is returned.
+    #
+    # @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 get_user_aum_percentile(user_id:, user_secret:, extra: {})
+      data, _status_code, _headers = get_user_aum_percentile_with_http_info_impl(user_id, user_secret, extra)
+      data
+    end
+
+    # Get the user's AUM percentile
+    #
+    # Returns where the user's total assets sit within the distribution of a cohort of comparable users, as a coarse bucket plus an integer percentile.
+    # 
+    # The cohort is scoped to your own book: a user is only ever compared against your other users, never across SnapTrade customers. (Users on personal-use keys are the exception — they are compared against all other personal-use users, since a personal key has a single user and cannot form a distribution of its own.) The distribution is recomputed monthly, and `as_of` reports which month's distribution the placement came from.
+    # 
+    # `data` is `null` — a 200, not an error — when SnapTrade declines to place the user. That happens when the cohort is too small to publish a distribution, or when the user's own holdings are incomplete or stale (for example they hold a disabled connection). A placement computed from a partial view of a user's assets would understate them, so none is returned.
+    #
+    # @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 get_user_aum_percentile_with_http_info(user_id:, user_secret:, extra: {})
+      get_user_aum_percentile_with_http_info_impl(user_id, user_secret, extra)
+    end
+
+    # Get the user's AUM percentile
+    # Returns where the user's total assets sit within the distribution of a cohort of comparable users, as a coarse bucket plus an integer percentile.  The cohort is scoped to your own book: a user is only ever compared against your other users, never across SnapTrade customers. (Users on personal-use keys are the exception — they are compared against all other personal-use users, since a personal key has a single user and cannot form a distribution of its own.) The distribution is recomputed monthly, and `as_of` reports which month's distribution the placement came from.  `data` is `null` — a 200, not an error — when SnapTrade declines to place the user. That happens when the cohort is too small to publish a distribution, or when the user's own holdings are incomplete or stale (for example they hold a disabled connection). A placement computed from a partial view of a user's assets would understate them, so none is returned. 
+    # @param user_id [String] 
+    # @param user_secret [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [UserAumPercentileResponse]
+    private def get_user_aum_percentile_impl(user_id, user_secret, opts = {})
+      data, _status_code, _headers = get_user_aum_percentile_with_http_info(user_id, user_secret, opts)
+      data
+    end
+
+    # Get the user's AUM percentile
+    # Returns where the user's total assets sit within the distribution of a cohort of comparable users, as a coarse bucket plus an integer percentile.  The cohort is scoped to your own book: a user is only ever compared against your other users, never across SnapTrade customers. (Users on personal-use keys are the exception — they are compared against all other personal-use users, since a personal key has a single user and cannot form a distribution of its own.) The distribution is recomputed monthly, and `as_of` reports which month's distribution the placement came from.  `data` is `null` — a 200, not an error — when SnapTrade declines to place the user. That happens when the cohort is too small to publish a distribution, or when the user's own holdings are incomplete or stale (for example they hold a disabled connection). A placement computed from a partial view of a user's assets would understate them, so none is returned. 
+    # @param user_id [String] 
+    # @param user_secret [String] 
+    # @param [Hash] opts the optional parameters
+    # @return [Array<(UserAumPercentileResponse, Integer, Hash)>] UserAumPercentileResponse data, response status code and response headers
+    private def get_user_aum_percentile_with_http_info_impl(user_id, user_secret, opts = {})
+      if @api_client.config.debugging
+        @api_client.config.logger.debug 'Calling API: AccountInformationApi.get_user_aum_percentile ...'
+      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 AccountInformationApi.get_user_aum_percentile"
+      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 AccountInformationApi.get_user_aum_percentile"
+      end
+      # resource path
+      local_var_path = '/aumPercentile'
+
+      # 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] || 'UserAumPercentileResponse'
+
+      # auth_names
+      auth_names = opts[:debug_auth_names] || ['PartnerClientId', 'PartnerSignature', 'PartnerTimestamp']
+
+      new_options = opts.merge(
+        :operation => :"AccountInformationApi.get_user_aum_percentile",
+        :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: AccountInformationApi#get_user_aum_percentile\nData: #{data.inspect}\nStatus code: #{status_code}\nHeaders: #{headers}"
+      end
+      return data, status_code, headers, response
+    end
+
+
     # List account holdings
     #
     # **Deprecated.** Use the finer-grained account data endpoints instead: [balances](/reference/Account%20Information/AccountInformation_getUserAccountBalance), [positions](/reference/Account%20Information/AccountInformation_getAllAccountPositions), and [orders](/reference/Account%20Information/AccountInformation_getUserAccountOrders).

data/lib/snaptrade/api/authentication_api.rb

@@ -195,10 +195,11 @@ module SnapTrade
     # @param connection_type [ConnectionType] Determines connection permissions (default: read) - `read`: Data access only. - `trade`: Data and trading access. - `trade-if-available`: Attempts to establish a trading connection if the brokerage supports it, otherwise falls back to read-only access automatically. 
     # @param show_close_button [Boolean] Controls whether the close (X) button is displayed in the connection portal. When false, you control closing behavior from your app. Defaults to true.
     # @param dark_mode [Boolean] Enable dark mode for the connection portal. Defaults to false.
+    # @param locale [String] Language the connection portal renders in. `en` and `pt-BR` are the languages we ship; any other language is rejected with a 400. Matching is case- and separator-insensitive, so `pt-br`, `pt-BR` and `pt_BR` are equivalent, and a regional tag resolves to the language when we ship it, so `en-US` renders `en`. Deliberately not an enum: those equivalent spellings are all accepted by the API, and an enum would have generated SDKs reject them before the request is sent. Screens without translated copy fall back to English individually. Defaults to `en`. 
     # @param connection_portal_version [ConnectionPortalVersion] Sets the connection portal version to render. Currently only `v4` is supported and is the default. All other versions are deprecated and will automatically be set to v4.
     # @param body [SnapTradeLoginUserRequestBody] 
     # @param [Hash] extra additional parameters to pass along through :header_params, :query_params, or parameter name
-    def login_snap_trade_user(user_id:, user_secret:, broker: SENTINEL, immediate_redirect: SENTINEL, custom_redirect: SENTINEL, reconnect: SENTINEL, connection_type: 'read', show_close_button: SENTINEL, dark_mode: SENTINEL, connection_portal_version: 'v4', extra: {})
+    def login_snap_trade_user(user_id:, user_secret:, broker: SENTINEL, immediate_redirect: SENTINEL, custom_redirect: SENTINEL, reconnect: SENTINEL, connection_type: 'read', show_close_button: SENTINEL, dark_mode: SENTINEL, locale: 'en', connection_portal_version: 'v4', extra: {})
       _body = {}
       _body[:broker] = broker if broker != SENTINEL
       _body[:immediateRedirect] = immediate_redirect if immediate_redirect != SENTINEL
@@ -207,6 +208,7 @@ module SnapTrade
       _body[:connectionType] = connection_type if connection_type != SENTINEL
       _body[:showCloseButton] = show_close_button if show_close_button != SENTINEL
       _body[:darkMode] = dark_mode if dark_mode != SENTINEL
+      _body[:locale] = locale if locale != SENTINEL
       _body[:connectionPortalVersion] = connection_portal_version if connection_portal_version != SENTINEL
       extra[:snap_trade_login_user_request_body] = _body if !_body.empty?
       data, _status_code, _headers = login_snap_trade_user_with_http_info_impl(user_id, user_secret, extra)
@@ -228,10 +230,11 @@ module SnapTrade
     # @param connection_type [ConnectionType] Determines connection permissions (default: read) - `read`: Data access only. - `trade`: Data and trading access. - `trade-if-available`: Attempts to establish a trading connection if the brokerage supports it, otherwise falls back to read-only access automatically. 
     # @param show_close_button [Boolean] Controls whether the close (X) button is displayed in the connection portal. When false, you control closing behavior from your app. Defaults to true.
     # @param dark_mode [Boolean] Enable dark mode for the connection portal. Defaults to false.
+    # @param locale [String] Language the connection portal renders in. `en` and `pt-BR` are the languages we ship; any other language is rejected with a 400. Matching is case- and separator-insensitive, so `pt-br`, `pt-BR` and `pt_BR` are equivalent, and a regional tag resolves to the language when we ship it, so `en-US` renders `en`. Deliberately not an enum: those equivalent spellings are all accepted by the API, and an enum would have generated SDKs reject them before the request is sent. Screens without translated copy fall back to English individually. Defaults to `en`. 
     # @param connection_portal_version [ConnectionPortalVersion] Sets the connection portal version to render. Currently only `v4` is supported and is the default. All other versions are deprecated and will automatically be set to v4.
     # @param body [SnapTradeLoginUserRequestBody] 
     # @param [Hash] extra additional parameters to pass along through :header_params, :query_params, or parameter name
-    def login_snap_trade_user_with_http_info(user_id:, user_secret:, broker: SENTINEL, immediate_redirect: SENTINEL, custom_redirect: SENTINEL, reconnect: SENTINEL, connection_type: 'read', show_close_button: SENTINEL, dark_mode: SENTINEL, connection_portal_version: 'v4', extra: {})
+    def login_snap_trade_user_with_http_info(user_id:, user_secret:, broker: SENTINEL, immediate_redirect: SENTINEL, custom_redirect: SENTINEL, reconnect: SENTINEL, connection_type: 'read', show_close_button: SENTINEL, dark_mode: SENTINEL, locale: 'en', connection_portal_version: 'v4', extra: {})
       _body = {}
       _body[:broker] = broker if broker != SENTINEL
       _body[:immediateRedirect] = immediate_redirect if immediate_redirect != SENTINEL
@@ -240,6 +243,7 @@ module SnapTrade
       _body[:connectionType] = connection_type if connection_type != SENTINEL
       _body[:showCloseButton] = show_close_button if show_close_button != SENTINEL
       _body[:darkMode] = dark_mode if dark_mode != SENTINEL
+      _body[:locale] = locale if locale != SENTINEL
       _body[:connectionPortalVersion] = connection_portal_version if connection_portal_version != SENTINEL
       extra[:snap_trade_login_user_request_body] = _body if !_body.empty?
       login_snap_trade_user_with_http_info_impl(user_id, user_secret, extra)

data/lib/snaptrade/models/bucket.rb

@@ -0,0 +1,41 @@
+=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 Bucket
+    TOP_1_PERCENT = "TOP_1_PERCENT".freeze
+    TOP_5_PERCENT = "TOP_5_PERCENT".freeze
+    TOP_10_PERCENT = "TOP_10_PERCENT".freeze
+    TOP_25_PERCENT = "TOP_25_PERCENT".freeze
+    TOP_50_PERCENT = "TOP_50_PERCENT".freeze
+    BOTTOM_50_PERCENT = "BOTTOM_50_PERCENT".freeze
+
+    def self.all_vars
+      @all_vars ||= [TOP_1_PERCENT, TOP_5_PERCENT, TOP_10_PERCENT, TOP_25_PERCENT, TOP_50_PERCENT, BOTTOM_50_PERCENT].freeze
+    end
+
+    # Builds the enum from string
+    # @param [String] The enum value in the form of the string
+    # @return [String] The enum value
+    def self.build_from_hash(value)
+      new.build_from_hash(value)
+    end
+
+    # Builds the enum from string
+    # @param [String] The enum value in the form of the string
+    # @return [String] The enum value
+    def build_from_hash(value)
+      return value if Bucket.all_vars.include?(value)
+      raise "Invalid ENUM value #{value} for class #Bucket"
+    end
+  end
+end

data/lib/snaptrade/models/snap_trade_login_user_request_body.rb

@@ -34,6 +34,9 @@ module SnapTrade
     # Enable dark mode for the connection portal. Defaults to false.
     attr_accessor :dark_mode
 
+    # Language the connection portal renders in. `en` and `pt-BR` are the languages we ship; any other language is rejected with a 400. Matching is case- and separator-insensitive, so `pt-br`, `pt-BR` and `pt_BR` are equivalent, and a regional tag resolves to the language when we ship it, so `en-US` renders `en`. Deliberately not an enum: those equivalent spellings are all accepted by the API, and an enum would have generated SDKs reject them before the request is sent. Screens without translated copy fall back to English individually. Defaults to `en`. 
+    attr_accessor :locale
+
     # Sets the connection portal version to render. Currently only `v4` is supported and is the default. All other versions are deprecated and will automatically be set to v4.
     attr_accessor :connection_portal_version
 
@@ -47,6 +50,7 @@ module SnapTrade
         :'connection_type' => :'connectionType',
         :'show_close_button' => :'showCloseButton',
         :'dark_mode' => :'darkMode',
+        :'locale' => :'locale',
         :'connection_portal_version' => :'connectionPortalVersion'
       }
     end
@@ -66,6 +70,7 @@ module SnapTrade
         :'connection_type' => :'ConnectionType',
         :'show_close_button' => :'Boolean',
         :'dark_mode' => :'Boolean',
+        :'locale' => :'String',
         :'connection_portal_version' => :'ConnectionPortalVersion'
       }
     end
@@ -121,6 +126,12 @@ module SnapTrade
         self.dark_mode = attributes[:'dark_mode']
       end
 
+      if attributes.key?(:'locale')
+        self.locale = attributes[:'locale']
+      else
+        self.locale = 'en'
+      end
+
       if attributes.key?(:'connection_portal_version')
         self.connection_portal_version = attributes[:'connection_portal_version']
       else
@@ -153,6 +164,7 @@ module SnapTrade
           connection_type == o.connection_type &&
           show_close_button == o.show_close_button &&
           dark_mode == o.dark_mode &&
+          locale == o.locale &&
           connection_portal_version == o.connection_portal_version
     end
 
@@ -165,7 +177,7 @@ module SnapTrade
     # Calculates hash code according to all attributes.
     # @return [Integer] Hash code
     def hash
-      [broker, immediate_redirect, custom_redirect, reconnect, connection_type, show_close_button, dark_mode, connection_portal_version].hash
+      [broker, immediate_redirect, custom_redirect, reconnect, connection_type, show_close_button, dark_mode, locale, connection_portal_version].hash
     end
 
     # Builds the object from hash

data/lib/snaptrade/models/user_aum_percentile_object.rb

@@ -0,0 +1,282 @@
+=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 user's AUM placement within a single SnapTrade customer's book
+  class UserAumPercentileObject
+    # The band the user falls into. Deliberately coarse: the underlying totals are only as current as each brokerage's last sync, so an exact percentile would imply more precision than the data supports. 
+    attr_accessor :bucket
+
+    # The percent of the cohort the user's assets are strictly above, 0-100. Integer by design: the distribution is stored as 101 interpolated cutoffs, so a fractional percentile would not mean anything.  Prefer `bucket` for anything you display prominently. The distribution is recomputed monthly, so a user's percentile can move a few points on its own as other users' holdings refresh, while their bucket stays put. Users tied on the same total all receive the lowest percentile that total spans. 
+    attr_accessor :percentile
+
+    # Number of your users the distribution was computed from.
+    attr_accessor :cohort_size
+
+    # The month whose distribution produced this placement.
+    attr_accessor :as_of
+
+    # The currency the distribution was computed in.
+    attr_accessor :currency
+
+    # Attribute mapping from ruby-style variable name to JSON key.
+    def self.attribute_map
+      {
+        :'bucket' => :'bucket',
+        :'percentile' => :'percentile',
+        :'cohort_size' => :'cohort_size',
+        :'as_of' => :'as_of',
+        :'currency' => :'currency'
+      }
+    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
+      {
+        :'bucket' => :'Bucket',
+        :'percentile' => :'Integer',
+        :'cohort_size' => :'Integer',
+        :'as_of' => :'Date',
+        :'currency' => :'String'
+      }
+    end
+
+    # List of attributes with nullable: true
+    def self.openapi_nullable
+      Set.new([
+      ])
+    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::UserAumPercentileObject` 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::UserAumPercentileObject`. 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?(:'bucket')
+        self.bucket = attributes[:'bucket']
+      end
+
+      if attributes.key?(:'percentile')
+        self.percentile = attributes[:'percentile']
+      end
+
+      if attributes.key?(:'cohort_size')
+        self.cohort_size = attributes[:'cohort_size']
+      end
+
+      if attributes.key?(:'as_of')
+        self.as_of = attributes[:'as_of']
+      end
+
+      if attributes.key?(:'currency')
+        self.currency = attributes[:'currency']
+      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
+      if !@percentile.nil? && @percentile > 100
+        invalid_properties.push('invalid value for "percentile", must be smaller than or equal to 100.')
+      end
+
+      if !@percentile.nil? && @percentile < 0
+        invalid_properties.push('invalid value for "percentile", must be greater than or equal to 0.')
+      end
+
+      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?
+      return false if !@percentile.nil? && @percentile > 100
+      return false if !@percentile.nil? && @percentile < 0
+      true
+    end
+
+    # Custom attribute writer method with validation
+    # @param [Object] percentile Value to be assigned
+    def percentile=(percentile)
+      if !percentile.nil? && percentile > 100
+        fail ArgumentError, 'invalid value for "percentile", must be smaller than or equal to 100.'
+      end
+
+      if !percentile.nil? && percentile < 0
+        fail ArgumentError, 'invalid value for "percentile", must be greater than or equal to 0.'
+      end
+
+      @percentile = percentile
+    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 &&
+          bucket == o.bucket &&
+          percentile == o.percentile &&
+          cohort_size == o.cohort_size &&
+          as_of == o.as_of &&
+          currency == o.currency
+    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
+      [bucket, percentile, cohort_size, as_of, currency].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