plaid 13.2.0 → 17.1.0

data/CONTRIBUTING.md

@@ -1,67 +1,19 @@
-## 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
+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.
 
-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:
+## Running Tests
 
-```text
-PLAID_RUBY_CLIENT_ID=the_real_client_id
-PLAID_RUBY_SECRET=the_real_secret
-```
-This file will be loaded during the tests.
+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`.
 
-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`!
+If you wish to run a single test, edit the `Rakefile` and rebuild the docker image using the command from step 1.
 
-## Updating VCR "cassettes"
-
-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,14 @@
+FROM ruby:3.0.0
+
+# Create app directory
+WORKDIR /usr/src/app
+
+# Copy app to directory
+COPY . /usr/src/app
+
+ENV BUNDLER_VERSION 2.2.9
+RUN gem update --system
+RUN gem install bundler:2.2.9
+RUN bundle install
+
+CMD ["bundle", "exec", "rake", "test"]

data/Gemfile.lock

@@ -1,66 +1,73 @@
 PATH
   remote: .
   specs:
-    plaid (13.2.0)
-      faraday
-      faraday_middleware
-      hashie (>= 3.4.3)
+    plaid (17.1.0)
+      faraday (>= 1.0.1, < 3.0)
+      faraday-multipart (>= 1.0.1, < 2.0)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    ast (2.4.0)
-    dotenv (2.4.0)
-    faraday (1.4.1)
-      faraday-excon (~> 1.1)
-      faraday-net_http (~> 1.0)
-      faraday-net_http_persistent (~> 1.1)
-      multipart-post (>= 1.2, < 3)
+    ast (2.4.1)
+    diff-lcs (1.4.4)
+    dotenv (2.7.6)
+    faraday (2.7.0)
+      faraday-net_http (>= 2.0, < 3.1)
       ruby2_keywords (>= 0.0.4)
-    faraday-excon (1.1.0)
-    faraday-net_http (1.0.1)
-    faraday-net_http_persistent (1.1.0)
-    faraday_middleware (1.0.0)
-      faraday (~> 1.0)
-    hashie (4.1.0)
-    minitest (5.11.3)
-    minitest-around (0.4.1)
+    faraday-multipart (1.0.4)
+      multipart-post (~> 2)
+    faraday-net_http (3.0.2)
+    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)
+    multipart-post (2.2.3)
+    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.4)
-    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.5)
+    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.33

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2017 Plaid Technologies, Inc.
+Copyright (c) 2021 Plaid 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,11 @@
+# Ruby embeds the version in the generator where as others don't so it's not possible to cat for it.
+RUBY_PACKAGE_VERSION=17.1.0
+
+.PHONY: release
+release:
+# Remove previously released versions of plaid-ruby
+	rm -rf pkg
+# Release
+	bundle config set --local path 'vendor/bundle' && \
+	bundle && \
+	bundle exec rake release

data/README.md

@@ -1,8 +1,6 @@
 # plaid-ruby [![Circle CI](https://circleci.com/gh/plaid/plaid-ruby.svg?style=svg&circle-token=30ee002ac2021da5b5b5a701d45fe2888af124a5)](https://circleci.com/gh/plaid/plaid-ruby) [![Gem Version](https://badge.fury.io/rb/plaid.svg)](http://badge.fury.io/rb/plaid)
 
-:warning: After 7/12/21, this major version of the library will only receive critical security patches. Please consider trying out our new [beta version](https://github.com/plaid/plaid-ruby/tree/14.0.0-beta-release).
-
-The official Ruby bindings for the [Plaid API](https://plaid.com/docs).
+The official Ruby bindings for the [Plaid API](https://plaid.com/docs). It's generated from our [OpenAPI schema](https://github.com/plaid/plaid-openapi).
 
 ## Installation
 
@@ -20,27 +18,28 @@ Or install it yourself as:
 
     $ gem install plaid
 
-The gem supports Ruby 2.2+ only.
+The gem supports Ruby 3.0.0+ only.
 
 ### Versioning
 
+Versions > 14 are generated from our OpenAPI schema. For previous non-generated versions, check out [13.2.0](https://github.com/plaid/plaid-ruby/releases/tag/v13.2.0).
+
 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` |
 
 For information about what has changed between versions and how to update your integration, head to the [version changelog][version-changelog].
 
+The plaid-ruby client library is typically updated on a monthly basis. The canonical source for the latest version number is the [client library changelog](https://github.com/plaid/plaid-ruby/blob/master/CHANGELOG.md).
 
 ## 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
 
@@ -49,29 +48,74 @@ 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"] = "***"
+
+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)
+configuration = Plaid::Configuration.new
+api_client = Plaid::ApiClient.new(
+  configuration
+)
+api_client.connection.options[:timeout] = 60*20 # 20 minutes
+```
 
-  # Increase network timeout
-  builder.options[:timeout] = 60*20    # 20 minutes
+To use custom middleware, reinitialize the Faraday::Connection object:
+```
+configuration = Plaid::Configuration.new
+api_client = Plaid::ApiClient.new(configuration)
+api_client.create_connection do |builder|
+  builder.use Faraday::Response::Logger
 end
 ```
+## Data type differences from API and from previous versions
+
+### Dates
+
+Dates and datetimes in requests, which are represented as strings in the API and in previous client library versions, are represented in this version of the Ruby client library as Ruby `Date` or `DateTime` objects. 
+
+Time zone information is required for request fields that accept datetimes. Failing to include time zone information (or passing in a string, instead of a `Date` or `DateTime` object) will result in an error. See the following examples for guidance on `Date` and `DateTime` usage.
+
+If the API reference documentation for a field specifies `format: date`, any of following are acceptable:
+
+```rb
+require 'date'
+
+# Not an exhaustive list of possible options
+a = Date.new(2022, 5, 5)
+b = Date.new(2022, 5, 5).to_date
+c = Date.parse('2022-05-05')
+d = Date.parse('2022-05-05').to_date
+e = Date.today
+```
+
+If the API reference documentation for a field specifies `format: date-time`, either of the following are acceptable:
+
+```rb
+require 'time'
+
+# Not an exhaustive list of possible options
+a = Time.parse("2022-05-06T22:35:49Z").to_datetime
+b = Date.parse("2022-05-06T22:35:49Z").to_datetime
+```
 
 ## Examples
 
@@ -83,12 +127,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
@@ -98,53 +146,89 @@ 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
+### Get paginated transactions (preferred method)
 ```ruby
-require 'plaid'
+request = Plaid::ItemPublicTokenExchangeRequest.new
+request.public_token = public_token
+
+response = client.item_public_token_exchange(request)
+access_token = response.access_token
+
+transactions_sync_request = Plaid::TransactionsSyncRequest.new
+transactions_sync_request.access_token = access_token
+
+transaction_response = client.transactions_sync(transactions_sync_request)
+transactions = transaction_response.transactions
+
+# the transactions in the response are paginated, so make multiple calls while
+# updating the cursor to retrieve all transactions
+while transaction_response.has_more
+  transactions_sync_request = Plaid::TransactionsSyncRequest.new
+  transactions_sync_request.access_token = access_token
+  transactions_sync_request.cursor = transaction_response.next_cursor
 
-client = Plaid::Client.new(env: :sandbox,
-                           client_id: '***',
-                           secret: '***')
+  transaction_response = client.transactions_sync(transactions_sync_request)
+  transactions += transaction_response.transactions
+end
+```
 
-exchange_token_response = client.item.public_token.exchange('[Plaid Link public_token]')
-access_token = exchange_token_response.access_token
+### Get paginated transactions (older method)
+```ruby
+request = Plaid::ItemPublicTokenExchangeRequest.new
+request.public_token = public_token
 
-transaction_response = client.transactions.get(access_token, '2016-07-12', '2017-01-09')
+response = client.item_public_token_exchange(request)
+access_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(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)
+while transactions.length < transaction_response.total_transactions
+  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"
+  transactions_get_request.options = options_payload
+
+  transaction_response = client.transactions_get(transactions_get_request)
   transactions += transaction_response.transactions
 end
 
@@ -154,55 +238,56 @@ 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(auth_get_request)
 auth = auth_response.auth
 ```
 
+There are also a number of other methods you can use to retrieve data:
+
+* `client.accounts_get(Plaid::AccountsGetRequest.new({:access_token => access_token, ...}))`: accounts
+* `client.accounts_balance_get(Plaid::AccountsBalanceGetRequest.new({:access_token => access_token, ...}))`: real-time balances
+* `client.auth_get(Plaid::AuthGetRequest.new({:access_token => access_token, ...}))`: auth
+* `client.identity_get(Plaid::IdentityGetRequest.new({:access_token => access_token, ...}))`: identity
+* `client.transactions_get(Plaid::TransactionsGetRequest.new({:access_token => access_token, ...}))`: transactions
+* `client.investments_transactions_get(Plaid::InvestmentsTransactionsGetRequest.new({:access_token => access_token, ...}))`: investment-account transactions
+* `client.investments_holdings_get(Plaid::InvestmentsHoldingsGetRequest.new({: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
@@ -210,7 +295,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
@@ -218,38 +309,20 @@ 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::ApiError` 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).
 
 ## Response Objects
 
-Any API call returns a response object which is accessible by dot notation
-(`response.foo.bar`) or Symbols and Strings as keys: `response[:foo][:bar]`
-and `response['foo']['bar']`. Expected keys for all types of responses are defined,
+All API calls return a response object that is accessible only with dot notation
+(i.e., `response.foo.bar`) and not with bracket notation. 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).
+Bug reports are welcome on GitHub at https://github.com/plaid/plaid-ruby. See also [contributing guidelines](CONTRIBUTING.md). As the library is auto-generated, pull requests are automatically closed.
 
 ## License