plaid 13.0.0 → 14.0.0.beta.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e1b3a6dd1a43a81dec93cc841fa8272f94fd53e604d6f2826035c221ac0cd1e
-  data.tar.gz: 920032b3617aae75fecbe0e0288e0279ad99ca215103e4e5825322d198560e4f
+  metadata.gz: d269c375cfd825a37b956cea548a0472994d1444ce58e0f77202393d151a988f
+  data.tar.gz: 254b6f581c142a5f21f82d43b224733384b0d611a1789b7e35ff81a5a9a9c082
 SHA512:
-  metadata.gz: 1ed91a6d2994ea510d2830e2b002f839098328ef7ece3fe1ed84458e2554f1a5138f5e51b009c32b7367f691b16e3ed94ce0d33497e9adb8eb9d868d2fa278d9
-  data.tar.gz: c2cef50ce789faf7a22d97e0d381f07b3b029ad5406613b3df6bb41cd8402c4552fcf6b852146a8a0c7bf10eceed8460aadc722e292da4cab915ef1af4fd8df5
+  metadata.gz: 19b95f6dd4b6120dd9e4011de5e476533514d307cfed5432d766c9006db8e904b9365dec761dd3850632937e38fe6fe02f849cc211e252c8d33d446818ae2928
+  data.tar.gz: 8b04a282197deabf1702f52cbbf68b92b18f8ad70d6812791cfebaa610ae007f045068fb80ebf7bc8dd11e83986d9a768a01ef7cb9a062ce9f0a71428a344f79

data/CHANGELOG.md

@@ -1,3 +1,83 @@
+# 14.0.0.beta.4
+See full changelog [here](https://github.com/plaid/plaid-openapi/blob/master/CHANGELOG.md).
+- Remove validation for `maxProperties` due to generator bug.
+
+# 14.0.0.beta.3
+Type fixes, see full changelog [here](https://github.com/plaid/plaid-openapi/blob/master/CHANGELOG.md).
+
+# 14.0.0.beta.1
+
+This version represents a transition in how we maintain our external client libraries. We are now using an [API spec](https://github.com/plaid/plaid-openapi) written in `OpenAPI 3.0.0` and running our definition file through [OpenAPITool's `python` generator](https://github.com/OpenAPITools/openapi-generator).
+
+The minimum required ruby version is 2.7.1.
+
+**Ruby Migration Guide:**
+
+### Client initialization
+From:
+```ruby
+client = Plaid::Client.new(env: :sandbox,
+                            client_id: client_id,
+                            secret: secret)
+```
+
+To:
+```ruby
+configuration = Plaid::Configuration.new
+configuration.server_index = Plaid::Configuration::Environment["sandbox"]
+configuration.api_key["PLAID-CLIENT-ID"] = ENV["PLAID_RUBY_CLIENT_ID"]
+configuration.api_key["PLAID-SECRET"] = ENV["PLAID_RUBY_SECRET"]
+configuration.api_key["Plaid-Version"] = "2020-09-14"
+
+api_client = Plaid::ApiClient.new(
+  configuration
+)
+
+client = Plaid::PlaidApi.new(api_client)
+```
+
+### Endpoints
+All endpoint requests now take a request model and the functions have been renamed to include `_`.
+
+From:
+```ruby
+response = client.auth.get(access_token)
+```
+
+To:
+```ruby
+auth_get_request = Plaid::AuthGetRequest.new
+auth_get_request.access_token = access_token
+
+or
+
+auth_get_request = Plaid::AuthGetRequest.new({:access_token => access_token})
+
+response = client.auth_get(auth_get_request)
+```
+
+### Errors
+
+From:
+```ruby
+begin
+  client.auth.get(auth_get_request)
+rescue Plaid::PlaidAPIError => e
+  raise e if e.error_code != 'PRODUCT_NOT_READY'
+  sleep 1
+end
+```
+
+To:
+```ruby
+begin
+  client.auth_get(auth_get_request)
+rescue Plaid::ApiError => e
+  json_response = JSON.parse(e.response_body)
+  if json_response["error_code"] != "PRODUCT_NOT_READY"
+end
+```
+
 # 13.0.0
 - Add support for providing a payment initiation schedule
 - Add back the (now deprecated) `/item/public_token/create` endpoint
@@ -196,4 +276,4 @@ BREAKING CHANGES:
 
 # 2.0.0.alpha. 06-May-2016
 
-- Rewrite everything.
+- Rewrite everything.

data/CONTRIBUTING.md

@@ -1,67 +1,23 @@
-## Development
+# Contributing
 
-After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+Instructions for contributing to [plaid-ruby][1]. A ruby client library for the [Plaid API][2]. This library is fully generated from the [Plaid OpenAPI spec](3).
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+## Setup
 
-## Running tests
+1. Run `make pull-openapi`.
+2. Install [Docker](https://docs.docker.com/desktop/) if you do not have it on your machine, this helps to isolate any dependency issues.
+3. Run `make build-openapi` after you have finished your Docker setup. This generates all the code necessary to run the library.
 
-The gem test suite can be run in two modes. By default, it runs against the
-live sandbox environment, creating items on the fly and calling various API
-endpoints for them. For this to work you'll need real `client_id` and `secret`
-from your Plaid dashboard. Create a file named `.env` based on `.env.sample`
-which is provided:
+If you find an issue, please investigate whether it is a type problem with [OpenAPI](3) or a problem with the [ruby faraday](https://github.com/OpenAPITools/openapi-generator/blob/master/docs/generators/ruby.md) generator. Then open an issue and Plaid will investigate further.
 
-```text
-PLAID_RUBY_CLIENT_ID=the_real_client_id
-PLAID_RUBY_SECRET=the_real_secret
-```
-This file will be loaded during the tests.
+## Running Tests
 
-Another mode employs pre-recorded API responses using the
-[vcr](https://github.com/vcr/vcr) gem. It runs much faster. Just use
-`rake test_stubbed` and you're good to go even without `.env`!
+1. To build the docker image for the client tests, run `docker build -t plaid-ruby .`.
+2. Go to the [Plaid Dashboard](https://dashboard.plaid.com/) and copy and paste your `client_id` and sandbox `secret` into the following command.
+3. Run `docker run --rm -e PLAID_RUBY_CLIENT_ID=$CLIENT_ID -e PLAID_RUBY_SECRET=$SECRET plaid-ruby`.
 
-## Updating VCR "cassettes"
+If you wish to run a single test, edit the `Rakefile` and rebuild the docker image using the command from step 1.
 
-In case you're adding new API endpoints or when there were any substantial
-changes in API you'll need to update the pre-recorded responses. Here's how:
-
-1. Make sure that `STUB_API=1 rake test` fails. It will fail saying something
-   like "... An HTTP request has been made that VCR does not know how to
-   handle".
-2. Run `RECORD_MODE=all STUB_API=1 rake test`. This will run the whole suite
-   and re-record everything. If you only need to update data for one test class,
-   use this:
-
-   ```
-   RECORD_MODE=all STUB_API=1 ruby -w -I"lib:test" -rminitest/pride -rdotenv/load test/test_which_fails.rb
-   ```
-3. Run `rake vcr_hide_credentials`. This step is essential, because
-   newly recorded files will contain your real `client_id` and friends. This
-   Rake task will go over all recorded files and replace real values with
-   stubbed ones used by `STUB_API=1 rake test`.
-4. Run `STUB_API=1 rake test` and verify that everything works.
-
-
-## Running lint
-
-```bash
-bundle exec rubocop
-```
-
-## Contributing
-
-1.  Make one or more atomic commits, and ensure that each commit has a
-    descriptive commit message. Commit messages should be line wrapped
-    at 72 characters.
-
-2.  Make sure that there are tests for the code you wrote.
-
-3.  Make sure that you've documented all public methods using [TomDoc](http://tomdoc.org/).
-
-4.  Run tests (in both modes, see above) and address any errors. Preferably,
-    fix commits in place using `git rebase` or `git commit --amend` to make the
-    changes easier to review.
-
-5.  Open a pull request.
+[1]: https://github.com/plaid/plaid-ruby
+[2]: https://plaid.com
+[3]: https://github.com/plaid/plaid-openapi

data/Dockerfile

@@ -0,0 +1,12 @@
+FROM ruby:2.7.1
+
+# Create app directory
+WORKDIR /usr/src/app
+
+# Copy app to directory
+COPY . /usr/src/app
+
+RUN gem install bundler:2.2.9
+RUN bundle install
+
+CMD ["bundle", "exec", "rake", "test"]

data/Gemfile.lock

@@ -1,62 +1,71 @@
 PATH
   remote: .
   specs:
-    plaid (13.0.0)
-      faraday
-      faraday_middleware
-      hashie (>= 3.4.3)
+    plaid (14.0.0.beta.4)
+      faraday (~> 1.0, >= 1.0.1)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    ast (2.4.0)
-    dotenv (2.4.0)
+    ast (2.4.1)
+    diff-lcs (1.4.4)
+    dotenv (2.7.6)
     faraday (1.3.0)
       faraday-net_http (~> 1.0)
       multipart-post (>= 1.2, < 3)
       ruby2_keywords
-    faraday-net_http (1.0.0)
-    faraday_middleware (1.0.0)
-      faraday (~> 1.0)
-    hashie (4.1.0)
-    minitest (5.11.3)
-    minitest-around (0.4.1)
+    faraday-net_http (1.0.1)
+    minitest (5.14.2)
+    minitest-around (0.5.0)
       minitest (~> 5.0)
     multipart-post (2.1.1)
-    parallel (1.12.1)
-    parser (2.5.1.0)
-      ast (~> 2.4.0)
-    powerpack (0.1.1)
+    parallel (1.20.1)
+    parser (2.7.2.0)
+      ast (~> 2.4.1)
     rainbow (3.0.0)
-    rake (12.3.3)
-    rdoc (6.0.4)
-    rubocop (0.53.0)
+    rake (13.0.1)
+    regexp_parser (1.8.0)
+    rexml (3.2.4)
+    rspec (3.10.0)
+      rspec-core (~> 3.10.0)
+      rspec-expectations (~> 3.10.0)
+      rspec-mocks (~> 3.10.0)
+    rspec-core (3.10.0)
+      rspec-support (~> 3.10.0)
+    rspec-expectations (3.10.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-mocks (3.10.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.10.0)
+    rspec-support (3.10.0)
+    rubocop (0.91.1)
       parallel (~> 1.10)
-      parser (>= 2.5)
-      powerpack (~> 0.1)
+      parser (>= 2.7.1.1)
       rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.7)
+      rexml
+      rubocop-ast (>= 0.4.0, < 1.0)
       ruby-progressbar (~> 1.7)
-      unicode-display_width (~> 1.0, >= 1.0.1)
-    ruby-progressbar (1.9.0)
-    ruby2_keywords (0.0.2)
-    sdoc (1.0.0)
-      rdoc (>= 5.0)
-    unicode-display_width (1.3.2)
-    vcr (4.0.0)
+      unicode-display_width (>= 1.4.0, < 2.0)
+    rubocop-ast (0.4.2)
+      parser (>= 2.7.1.4)
+    ruby-progressbar (1.10.1)
+    ruby2_keywords (0.0.4)
+    unicode-display_width (1.7.0)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.7)
+  bundler (~> 2.2.9)
   dotenv
-  minitest (~> 5.10)
-  minitest-around (~> 0.4.0)
+  minitest (~> 5.14)
+  minitest-around (~> 0.5.0)
   plaid!
-  rake (>= 10.0)
-  rubocop (~> 0.53.0)
-  sdoc (~> 1.0.0)
-  vcr (~> 4.0.0)
+  rake (>= 13.0)
+  rspec (~> 3.6, >= 3.6.0)
+  rubocop (~> 0.91.0)
 
 BUNDLED WITH
-   1.17.2
+   2.2.9

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 Plaid Technologies, Inc.
+Copyright (c) 2020 Plaid Technologies, Inc.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/Makefile

@@ -0,0 +1,2 @@
+# Ruby embeds the version in the generator where as others dont os its not possible to cat for it.
+RUBY_PACKAGE_VERSION=14.0.0.beta.4

data/PUBLISH.md

@@ -4,17 +4,16 @@ The module is published to [RubyGems][1] under the gem name [plaid][2].
 
 Prepare release:
 
-1. update `lib/plaid/version.rb`, and `CHANGELOG.md` files.
-2. run `bundle` to bump the version in `Gemfile.lock`
-3. create and merge a PR with the changes from 1 and 2.
-4. authenticate with rubygems with `gem signin` or manually set up your `~/.gem/credentials`
+1. Update `Makefile -> RUBY_PACKAGE_VERSION`, and `CHANGELOG.md` files.
+2. Run `bundle` to bump the version in `Gemfile.lock`.
+3. Create and merge a PR with the changes from 1 and 2.
+4. Authenticate with rubygems with `gem signin` or manually set up your `~/.gem/credentials`.
 
 Publish:
 
 1. `git checkout master` and `git pull` (makes sure your `HEAD` is up-to-date).
-2. Check that tests are passing on latest `master` build and (optional) `bundle exec rake test` to run tests locally
-3. `bundle exec rake release` (builds the gem, creates a tag, pushes the gem to RubyGems and tag to GitHub). **NOTE:** if this step hangs indefinitely, you need to set your MFA settings to "UI Only" [here](https://rubygems.org/profile/edit)
-4. `bundle exec rake update_github_docs` (generates RDoc files, updates `gh-pages` branch and pushes it to GitHub). (If you run into a `gh-pages` branch error, you may need to manually run `git checkout gh-pages` to ensure the branch is checked out locally.)
+2. Check that tests are passing on latest `master` build and (optional) `docker build -t plaid-ruby . && docker run -e PLAID_RUBY_CLIENT_ID=$(CLIENT_ID) -e PLAID_RUBY_SECRET=$(SECRET) plaid-ruby)` run tests locally.
+4. `bundle exec rake release` (builds the gem, creates a tag, pushes the gem to RubyGems and tag to GitHub). **NOTE:** if this step hangs indefinitely, you need to set your MFA settings to "UI Only" [here](https://rubygems.org/profile/edit).
 
 [1]: https://rubygems.org/
 [2]: https://rubygems.org/gems/plaid

data/README.md

@@ -16,9 +16,9 @@ And then execute:
 
 Or install it yourself as:
 
-    $ gem install plaid
+    $ gem install plaid --pre
 
-The gem supports Ruby 2.2+ only.
+The gem supports Ruby 2.4.0+ only.
 
 ### Versioning
 
@@ -26,8 +26,8 @@ Each major version of `plaid-ruby` targets a specific version of the Plaid API:
 
 | API version | plaid-ruby release |
 | ----------- | ------------------ |
-| [`2020-09-14`][api-version-2020-09-14] (**latest**) | `12.x.x` |
-| [`2019-05-29`][api-version-2019-05-29] (**latest**) | `11.x.x`, `10.x.x`, `9.x.x`, `8.x.x`, `7.x.x` |
+| [`2020-09-14`][api-version-2020-09-14] (**latest**) | `12.x.x`, `13.x.x`, `14.x.x` |
+| [`2019-05-29`][api-version-2019-05-29] | `11.x.x`, `10.x.x`, `9.x.x`, `8.x.x`, `7.x.x` |
 | [`2018-05-22`][api-version-2018-05-22] | `6.x.x` |
 | `2017-03-08` | `5.x.x` |
 
@@ -36,9 +36,7 @@ For information about what has changed between versions and how to update your i
 
 ## Usage
 
-This gem wraps the Plaid API, which is fully described in the [documentation](https://plaid.com/docs/api).
-
-The RubyDoc for the gem is available [here](http://plaid.github.io/plaid-ruby/).
+This gem wraps the Plaid API, which is fully described in the [documentation](https://plaid.com/docs/api) and in the [plaid-openapi](https://github.com/plaid/plaid-openapi) spec.
 
 ### Creating a Plaid client
 
@@ -47,24 +45,32 @@ Create an instance of the client using the `client_id` and `secret` from your Pl
 ```ruby
 require 'plaid'
 
-client = Plaid::Client.new(env: :sandbox,
-                           client_id: '***',
-                           secret: '***')
+configuration = Plaid::Configuration.new
+configuration.server_index = Plaid::Configuration::Environment["sandbox"]
+configuration.api_key["PLAID-CLIENT-ID"] = "***"
+configuration.api_key["PLAID-SECRET"] = "***"
+configuration.api_key["Plaid-Version"] = "2020-09-14"
+
+api_client = Plaid::ApiClient.new(
+  configuration
+)
+
+client = Plaid::PlaidApi.new(api_client)
 ```
 
-The `env` field is the environment which the client will be running in. Your choices for the `env` field include:
+The `server_index` field is the environment which the client will be running in. Your choices for the `server_index` field include:
 
-- `:sandbox` allows you to do your initial integrations tests against preloaded data without being billed or making expensive API calls. More information about using the API sandbox can be found on the [API Sandbox documentation](https://plaid.com/docs/api#sandbox).
-- `:development` allows you to test against both real and test accounts without being billed. More information about Plaid test accounts can be found in our [API documentation](https://plaid.com/docs/api/#sandbox).
-- `:production` is the production environment where you can launch your production ready application and be charged for your Plaid usage.
+- `Plaid::Configuration::Environment["sandbox"]` allows you to do your initial integrations tests against preloaded data without being billed or making expensive API calls. More information about using the API sandbox can be found on the [API Sandbox documentation](https://plaid.com/docs/api#sandbox).
+- `Plaid::Configuration::Environment["development"]` allows you to test against both real and test accounts without being billed. More information about Plaid test accounts can be found in our [API documentation](https://plaid.com/docs/api/#sandbox).
+- `Plaid::Configuration::Environment["production"]` is the production environment where you can launch your production ready application and be charged for your Plaid usage.
 
 ### Tuning Faraday
 
 The gem uses Faraday to wrap HTTPS connections, which allows you to tune certain params:
 
 ```ruby
-client = Plaid::Client.new(env: :sandbox, client_id: '***', secret: '***') do |builder|
-  Plaid::Client.build_default_connection(builder)
+client = Plaid::Configuration.new do |builder|
+  Plaid::Configuration.default()
 
   # Increase network timeout
   builder.options[:timeout] = 60*20    # 20 minutes
@@ -81,12 +87,16 @@ user = User.find_by!(email: '***')
 client_user_id = user.id
 
 # Create the link_token with all of your configurations
-link_token_response = client.link_token.create(
-  user: { client_user_id: client_user_id.to_s },
-  client_name: 'My app',
-  products: %w[auth transactions],
-  country_codes: ['US'],
-  language: 'en'
+link_token_create_request = Plaid::LinkTokenCreateRequest.new({
+  :user => { :client_user_id => client_user_id.to_s },
+  :client_name => 'My app',
+  :products => %w[auth transactions],
+  :country_codes => ['US'],
+  :language => 'en'
+})
+
+link_token_response = client.link_token_create(
+  link_token_create_request
 )
 
 # Pass the result to your client-side app to initialize Link
@@ -96,53 +106,62 @@ link_token = link_token_response.link_token
 
 ### Exchanging a Link public_token for a Plaid access_token
 
-If you have a [Link](https://github.com/plaid/link) `public token`, use this function to get an `access_token`: `client.item.public_token.exchange(public_token)`
+If you have a [Link](https://github.com/plaid/link) `public token`, use this function to get an `access_token`: `client.item_public_token_exchange(request)`
 
 An example of the function's usage if you have a `public_token` in hand:
 
 ```ruby
-response = client.item.public_token.exchange(public_token)
+request = Plaid::ItemPublicTokenExchangeRequest.new
+request.public_token = public_token
+
+response = client.item.public_token_exchange(request)
 access_token = response.access_token
 ```
 
-
 ### Deleting an item
 
 ```ruby
-require 'plaid'
+request = Plaid::ItemPublicTokenExchangeRequest.new
+request.public_token = public_token
 
-client = Plaid::Client.new(env: :sandbox,
-                           client_id: '***',
-                           secret: '***')
-
-exchange_token_response = client.item.public_token.exchange('[Plaid Link public_token]')
-access_token = exchange_token_response.access_token
+response = client.item.public_token_exchange(request)
+access_token = response.access_token
 
 # Provide the access_token for the Item you want to remove
-client.item.remove(access_token)
+item_remove_request = Plaid::ItemRemoveRequest.new
+item_remove_request.access_token = access_token
+
+client.item_remove(item_remove_request)
 ```
 
 ### Get paginated transactions
 ```ruby
-require 'plaid'
+request = Plaid::ItemPublicTokenExchangeRequest.new
+request.public_token = public_token
 
-client = Plaid::Client.new(env: :sandbox,
-                           client_id: '***',
-                           secret: '***')
+response = client.item.public_token_exchange(request)
+access_token = response.access_token
 
-exchange_token_response = client.item.public_token.exchange('[Plaid Link public_token]')
-access_token = exchange_token_response.access_token
+transactions_get_request = Plaid::TransactionsGetRequest.new
+transactions_get_request.access_token = access_token
+transactions_get_request.start_date = "2020-01-01"
+transactions_get_request.end_date = "2021-01-01"
 
-transaction_response = client.transactions.get(access_token, '2016-07-12', '2017-01-09')
+transaction_response = client.transactions_get(transactions_get_request)
 transactions = transaction_response.transactions
 
 # the transactions in the response are paginated, so make multiple calls while
 # increasing the offset to retrieve all transactions
 while transactions.length < transaction_response['total_transactions']
-  transaction_response = client.transactions.get(access_token,
-                                                 '2016-07-12',
-                                                 '2017-01-09',
-                                                 offset: transactions.length)
+  options_payload = {}
+  options_payload[:offset] = transactions.length
+
+  transactions_get_request = Plaid::TransactionsGetRequest.new
+  transactions_get_request.access_token = access_token
+  transactions_get_request.start_date = "2020-01-01"
+  transactions_get_request.end_date = "2021-01-01"
+
+  transaction_response = client.transactions_get(transactions_get_request)
   transactions += transaction_response.transactions
 end
 
@@ -152,55 +171,55 @@ end
 
 If you have an `access_token`, you can use following code to retreive data:
 ```ruby
-require 'plaid'
+request = Plaid::ItemPublicTokenExchangeRequest.new
+request.public_token = public_token
 
-client = Plaid::Client.new(env: :sandbox,
-                           client_id: '***',
-                           secret: '***')
+response = client.item.public_token_exchange(request)
+access_token = response.access_token
 
-exchange_token_response = client.item.public_token.exchange('[Plaid Link public_token]')
-access_token = exchange_token_response.access_token
+auth_get_request = Plaid::AuthGetRequest.new
+auth_get_request.access_token = access_token
 
-auth_response = client.auth.get(access_token)
+auth_response = client.auth_get(access_token)
 auth = auth_response.auth
 ```
 
+There are also a number of other methods you can use to retrieve data:
+
+* `client.accounts_get(Plaid::AccountsGetRequest({:access_token => access_token, ...}))`: accounts
+* `client.accounts_balance_get(Plaid::AccountsBalanceGetRequest({:access_token => access_token, ...}))`: real-time balances
+* `client.auth_get(Plaid::AuthGetRequest({:access_token => access_token, ...}))`: auth
+* `client.identity_get(Plaid::IdentityGetRequest({:access_token => access_token, ...}))`: identity
+* `client.transactions_get(Plaid::TransactionsGetRequest({:access_token => access_token, ...}))`: transactions
+* `client.investments_transactions_get(Plaid::InvestmentsTransactionsGetRequest({:access_token => access_token, ...}))`: investment-account transactions
+* `client.investments_holdings_get(Plaid::InvestmentsHoldingsGetRequest({:access_token => access_token, ...}))`: investment-account holdings
+
+All of these methods return appropriate data. More information can be found on the [API documentation](https://plaid.com/docs/api).
+
 ### Create a Stripe bank_account_token
 
 Exchange a Plaid Link `public_token` for an API `access_token` and a Stripe `bank_account_token`:
 ```ruby
-require 'plaid'
+request = Plaid::ItemPublicTokenExchangeRequest.new
+request.public_token = public_token
 
-client = Plaid::Client.new(env: :sandbox,
-                           client_id: '***',
-                           secret: '***')
+response = client.item.public_token.exchange(request)
+access_token = response.access_token
 
-exchange_token_response = client.item.public_token.exchange('[Plaid Link public_token]')
-access_token = exchange_token_response.access_token
+processor_token_create_request = Plaid::ProcessorStripeBankAccountTokenCreateRequest.new
+processor_token_create_request.access_token = access_token
+processor_token_create_request.account_id = '[Account ID]'
 
-stripe_response = client.processor.stripe.bank_account_token.create(access_token, '[Account ID]')
+stripe_response = client.processor_stripe_bank_account_token_create(processor_token_create_request)
 bank_account_token = stripe_response.stripe_bank_account_token
 ```
 
-There are also a number of other methods you can use to retrieve data:
-
-* `client.accounts.get(access_token, ...)`: accounts
-* `client.accounts.balance.get(access_token, ...)`: real-time balances
-* `client.auth.get(access_token, ...)`: auth
-* `client.identity.get(access_token, ...)`: identity
-* `client.transactions.get(access_token, ...)`: transactions
-* `client.credit_details.get(access_token, ...)`: credit details
-* `client.investments.transactions.get(access_token, ...)`: investment-account transactions
-* `client.investments.holdings.get(access_token, ...)`: investment-account holdings
-
-All of these methods return appropriate data. More information can be found on the [API documentation](https://plaid.com/docs/api).
-
 ### Categories
 
 You can request category information:
 
 ```ruby
-categories = client.categories.get             # Array of all known categories
+categories = client.categories_get             # Array of all known categories
 ```
 
 ### Institutions
@@ -208,7 +227,13 @@ categories = client.categories.get             # Array of all known categories
 Financial institution information is available as shown below where the function arguments represent count and offset:
 
 ```ruby
-institutions = client.institutions.get(count: 3, offset: 1)
+institutions_get_request = Plaid::InstitutionsGetRequest.new({
+  :count => 3,
+  :offset => 1,
+  :country_codes => ["US"],
+})
+
+response = client.institutions_get(institutions_get_request)
 ```
 
 ## Errors
@@ -216,17 +241,7 @@ institutions = client.institutions.get(count: 3, offset: 1)
 Any methods making API calls will result in an exception raised unless the response code is "200: Success" or
 "210: MFA Required".
 
-`Plaid::InvalidRequestError` is returned when the request is malformed and cannot be processed.
-
-`Plaid::InvalidInputError` is returned when all fields are provided and are in the correct format, but the values provided are incorrect in some way.
-
-`Plaid::RateLimitExceededError` returned when the request is valid but has exceeded established rate limits.
-
-`Plaid::APIError` is returned during planned maintenance windows and in response to API internal server errors.
-
-`Plaid::ItemError` indicates that information provided for the Item (such as credentials or MFA) may be invalid or that the Item is not supported on Plaid's platform.
-
-`Plaid::InstitutionError` is returned when there are errors for the requested financial institution.
+`Plaid::Error` is returned in response to API internal server errors.
 
 Read more about response codes and their meaning in the
 [Plaid documentation](https://plaid.com/docs/api).
@@ -238,13 +253,6 @@ Any API call returns a response object which is accessible by dot notation
 and `response['foo']['bar']`. Expected keys for all types of responses are defined,
 and any attempt to access an unknown key will cause `NoMethodError` exception.
 
-## Network Timeout
-
-A network timeout value is currently defaulted at 600 seconds = 10 minutes.
-Some requests from the Plaid API may take longer than others and we want to
-make sure that all valid requests have a chance to complete. Adjust this value
-if necessary (see "Tuning Faraday").
-
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/plaid/plaid-ruby. See also [contributing guidelines](CONTRIBUTING.md).
@@ -261,4 +269,4 @@ If you're looking for a Ruby client that works with the legacy Plaid API, use th
 [version-changelog]: https://plaid.com/docs/api/versioning/
 [api-version-2018-05-22]: https://plaid.com/docs/api/versioning/#2018-05-22
 [api-version-2019-05-29]: https://plaid.com/docs/api/versioning/#2019-05-29
-[api-version-2020-09-14]: https://plaid.com/docs/api/versioning/#2020-09-14
+[api-version-2020-09-14]: https://plaid.com/docs/api/versioning/#2020-09-14