update vendor/ for linode builder

2026-06-11 01:30:06 -04:00 · 2019-04-15 20:42:02 -04:00 · 2019-04-15 20:42:02 -04:00 · 4b36659fcb
commit 4b36659fcb
parent 99987c2d56
71 changed files with 22312 additions and 0 deletions
--- a/vendor/github.com/linode/linodego/.gitignore
+++ b/vendor/github.com/linode/linodego/.gitignore
@ -0,0 +1,19 @@
+# Binaries for programs and plugins
+*.exe
+*.dll
+*.so
+*.dylib
+
+# Test binary, build with `go test -c`
+*.test
+
+# Output of the go coverage tool, specifically when used with LiteIDE
+*.out
+
+# Project-local glide cache, RE: https://github.com/Masterminds/glide/issues/736
+.glide/
+
+vendor/**/
+.env
+coverage.txt
+
--- a/vendor/github.com/linode/linodego/.travis.yml
+++ b/vendor/github.com/linode/linodego/.travis.yml
@ -0,0 +1,22 @@
+language: "go"
+
+matrix:
+  allow_failures:
+  - go: tip
+
+go:
+  - "1.10"
+  - tip
+
+install:
+  - go get -u gopkg.in/alecthomas/gometalinter.v2
+  - gometalinter.v2 --install
+
+script:
+  - touch .env
+  - make test ARGS='-v -race -count=2 -coverprofile=coverage.txt -covermode=atomic ./...'
+  - gometalinter.v2 --enable-all --disable=vetshadow --disable=gocyclo --disable=unparam --disable=nakedret --disable=lll --disable=dupl --disable=gosec --disable=gochecknoinits --disable=gochecknoglobals --disable=test --deadline=120s
+  - gometalinter.v2 --disable-all --enable=vetshadow --enable=gocyclo --enable=unparam --enable=nakedret --enable=lll --enable=dupl --enable=gosec --enable=gochecknoinits --enable=gochecknoglobals --deadline=120s || true
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)
--- a/vendor/github.com/linode/linodego/API_SUPPORT.md
+++ b/vendor/github.com/linode/linodego/API_SUPPORT.md
@ -0,0 +1,379 @@
+# API Support
+
+## Linodes
+
+- `/linode/instances`
+  - [x] `GET`
+  - [X] `POST`
+- `/linode/instances/$id`
+  - [x] `GET`
+  - [X] `PUT`
+  - [X] `DELETE`
+- `/linode/instances/$id/boot`
+  - [x] `POST`
+- `/linode/instances/$id/clone`
+  - [x] `POST`
+- `/linode/instances/$id/mutate`
+  - [X] `POST`
+- `/linode/instances/$id/reboot`
+  - [x] `POST`
+- `/linode/instances/$id/rebuild`
+  - [X] `POST`
+- `/linode/instances/$id/rescue`
+  - [X] `POST`
+- `/linode/instances/$id/resize`
+  - [x] `POST`
+- `/linode/instances/$id/shutdown`
+  - [x] `POST`
+- `/linode/instances/$id/volumes`
+  - [X] `GET`
+
+### Backups
+
+- `/linode/instances/$id/backups`
+  - [X] `GET`
+  - [ ] `POST`
+- `/linode/instances/$id/backups/$id/restore`
+  - [ ] `POST`
+- `/linode/instances/$id/backups/cancel`
+  - [ ] `POST`
+- `/linode/instances/$id/backups/enable`
+  - [ ] `POST`
+
+### Configs
+
+- `/linode/instances/$id/configs`
+  - [X] `GET`
+  - [X] `POST`
+- `/linode/instances/$id/configs/$id`
+  - [X] `GET`
+  - [X] `PUT`
+  - [X] `DELETE`
+
+### Disks
+
+- `/linode/instances/$id/disks`
+  - [X] `GET`
+  - [X] `POST`
+- `/linode/instances/$id/disks/$id`
+  - [X] `GET`
+  - [X] `PUT`
+  - [X] `POST`
+  - [X] `DELETE`
+- `/linode/instances/$id/disks/$id/password`
+  - [X] `POST`
+- `/linode/instances/$id/disks/$id/resize`
+  - [X] `POST`
+
+### IPs
+
+- `/linode/instances/$id/ips`
+  - [ ] `GET`
+  - [ ] `POST`
+- `/linode/instances/$id/ips/$ip_address`
+  - [ ] `GET`
+  - [ ] `PUT`
+  - [ ] `DELETE`
+- `/linode/instances/$id/ips/sharing`
+  - [ ] `POST`
+
+### Kernels
+
+- `/linode/kernels`
+  - [X] `GET`
+- `/linode/kernels/$id`
+  - [X] `GET`
+
+### StackScripts
+
+- `/linode/stackscripts`
+  - [x] `GET`
+  - [X] `POST`
+- `/linode/stackscripts/$id`
+  - [x] `GET`
+  - [X] `PUT`
+  - [X] `DELETE`
+
+### Stats
+
+- `/linode/instances/$id/stats`
+  - [ ] `GET`
+- `/linode/instances/$id/stats/$year/$month`
+  - [ ] `GET`
+
+### Types
+
+- `/linode/types`
+  - [X] `GET`
+- `/linode/types/$id`
+  - [X] `GET`
+
+## Domains
+
+- `/domains`
+  - [X] `GET`
+  - [X] `POST`
+- `/domains/$id`
+  - [X] `GET`
+  - [X] `PUT`
+  - [X] `DELETE`
+- `/domains/$id/clone`
+  - [ ] `POST`
+- `/domains/$id/records`
+  - [X] `GET`
+  - [X] `POST`
+- `/domains/$id/records/$id`
+  - [X] `GET`
+  - [X] `PUT`
+  - [X] `DELETE`
+
+## Longview
+
+- `/longview/clients`
+  - [X] `GET`
+  - [ ] `POST`
+- `/longview/clients/$id`
+  - [X] `GET`
+  - [ ] `PUT`
+  - [ ] `DELETE`
+
+### Subscriptions
+
+- `/longview/subscriptions`
+  - [ ] `GET`
+- `/longview/subscriptions/$id`
+  - [ ] `GET`
+
+### NodeBalancers
+
+- `/nodebalancers`
+  - [X] `GET`
+  - [X] `POST`
+- `/nodebalancers/$id`
+  - [X] `GET`
+  - [X] `PUT`
+  - [X] `DELETE`
+
+### NodeBalancer Configs
+
+- `/nodebalancers/$id/configs`
+  - [X] `GET`
+  - [X] `POST`
+- `/nodebalancers/$id/configs/$id`
+  - [X] `GET`
+  - [X] `DELETE`
+- `/nodebalancers/$id/configs/$id/nodes`
+  - [X] `GET`
+  - [X] `POST`
+- `/nodebalancers/$id/configs/$id/nodes/$id`
+  - [X] `GET`
+  - [X] `PUT`
+  - [X] `DELETE`
+- `/nodebalancers/$id/configs/$id/rebuild`
+  - [X] `POST`
+
+## Networking
+
+- `/networking/ip-assign`
+  - [ ] `POST`
+- `/networking/ips`
+  - [X] `GET`
+  - [ ] `POST`
+- `/networking/ips/$address`
+  - [X] `GET`
+  - [ ] `PUT`
+  - [ ] `DELETE`
+
+### IPv6
+
+- `/networking/ips`
+  - [X] `GET`
+- `/networking/ips/$address`
+  - [X] `GET`
+  - [ ] `PUT`
+- /networking/ipv6/ranges
+  - [X] `GET`
+- /networking/ipv6/pools
+  - [X] `GET`
+
+## Regions
+
+- `/regions`
+  - [x] `GET`
+- `/regions/$id`
+  - [x] `GET`
+
+## Support
+
+- `/support/tickets`
+  - [X] `GET`
+  - [ ] `POST`
+- `/support/tickets/$id`
+  - [X] `GET`
+- `/support/tickets/$id/attachments`
+  - [ ] `POST`
+- `/support/tickets/$id/replies`
+  - [ ] `GET`
+  - [ ] `POST`
+
+## Tags
+
+- `/tags/`
+  - [X] `GET`
+  - [X] `POST`
+- `/tags/$id`
+  - [X] `GET`
+  - [X] `DELETE`
+
+## Account
+
+### Events
+
+- `/account/events`
+  - [X] `GET`
+- `/account/events/$id`
+  - [X] `GET`
+- `/account/events/$id/read`
+  - [X] `POST`
+- `/account/events/$id/seen`
+  - [X] `POST`
+
+### Invoices
+
+- `/account/invoices/`
+  - [X] `GET`
+- `/account/invoices/$id`
+  - [X] `GET`
+- `/account/invoices/$id/items`
+  - [X] `GET`
+
+### Notifications
+
+- `/account/notifications`
+  - [X] `GET`
+
+### OAuth Clients
+
+- `/account/oauth-clients`
+  - [ ] `GET`
+  - [ ] `POST`
+- `/account/oauth-clients/$id`
+  - [ ] `GET`
+  - [ ] `PUT`
+  - [ ] `DELETE`
+- `/account/oauth-clients/$id/reset_secret`
+  - [ ] `POST`
+- `/account/oauth-clients/$id/thumbnail`
+  - [ ] `GET`
+  - [ ] `PUT`
+
+### Payments
+
+- `/account/payments`
+  - [ ] `GET`
+  - [ ] `POST`
+- `/account/payments/$id`
+  - [ ] `GET`
+- `/account/payments/paypal`
+  - [ ] `GET`
+- `/account/payments/paypal/execute`
+  - [ ] `POST`
+
+### Settings
+
+- `/account/settings`
+  - [ ] `GET`
+  - [ ] `PUT`
+
+### Users
+
+- `/account/users`
+  - [X] `GET`
+  - [X] `POST`
+- `/account/users/$username`
+  - [X] `GET`
+  - [X] `PUT`
+  - [X] `DELETE`
+- `/account/users/$username/grants`
+  - [ ] `GET`
+  - [ ] `PUT`
+- `/account/users/$username/password`
+  - [ ] `POST`
+
+## Profile
+
+### Personalized User Settings
+
+- `/profile`
+  - [X] `GET`
+  - [X] `PUT`
+
+### Granted OAuth Apps
+
+- `/profile/apps`
+  - [ ] `GET`
+- `/profile/apps/$id`
+  - [ ] `GET`
+  - [ ] `DELETE`
+
+### Grants to Linode Resources
+
+- `/profile/grants`
+  - [ ] `GET`
+
+### SSH Keys
+
+- `/profile/sshkeys`
+  - [x] `GET`
+  - [x] `POST`
+- `/profile/sshkeys/$id`
+  - [x] `GET`
+  - [x] `PUT`
+  - [x] `DELETE`
+  
+### Two-Factor
+
+- `/profile/tfa-disable`
+  - [ ] `POST`
+- `/profile/tfa-enable`
+  - [ ] `POST`
+- `/profile/tfa-enable-confirm`
+  - [ ] `POST`
+
+### Personal Access API Tokens
+
+- `/profile/tokens`
+  - [X] `GET`
+  - [X] `POST`
+- `/profile/tokens/$id`
+  - [X] `GET`
+  - [X] `PUT`
+  - [X] `DELETE`
+
+## Images
+
+- `/images`
+  - [x] `GET`
+- `/images/$id`
+  - [x] `GET`
+  - [X] `POST`
+  - [X] `PUT`
+  - [X] `DELETE`
+
+## Volumes
+
+- `/volumes`
+  - [X] `GET`
+  - [X] `POST`
+- `/volumes/$id`
+  - [X] `GET`
+  - [X] `PUT`
+  - [X] `DELETE`
+- `/volumes/$id/attach`
+  - [X] `POST`
+- `/volumes/$id/clone`
+  - [X] `POST`
+- `/volumes/$id/detach`
+  - [X] `POST`
+- `/volumes/$id/resize`
+  - [X] `POST`
--- a/vendor/github.com/linode/linodego/CHANGELOG.md
+++ b/vendor/github.com/linode/linodego/CHANGELOG.md
@ -0,0 +1,239 @@
+# Change Log
+
+## Unreleased
+
+### Fixes
+
+### Features
+
+<a name-"v0.7.1"></a>
+
+## [v0.7.1](https://github.com/linode/linodego/compare/v0.7.0..v0.7.1) (2018-02-05)
+
+### Features
+
+* add `ClassDedicated` constant (`dedicated`) for use in `LinodeType` `Class` values
+  See the [Dedicated CPU Announcement](https://blog.linode.com/2019/02/05/introducing-linode-dedicated-cpu-instances/)
+
+<a name-"v0.7.0"></a>
+
+## [v0.7.0](https://github.com/linode/linodego/compare/v0.6.2..v0.7.0) (2018-12-03)
+
+### Features
+
+* add `Tags` field in: `NodeBalancer`, `Domain`, `Volume`
+* add `UpdateIPAddress` (for setting RDNS)
+
+### Fixes
+
+* invalid URL for `/v4/networking/` enpoints (IPv6 Ranges and Pools) has been correcrted
+
+<a name-"v0.6.2"></a>
+
+## [v0.6.2](https://github.com/linode/linodego/compare/v0.6.1..v0.6.2) (2018-10-26)
+
+### Fixes
+
+* add missing `Account` fields: `address_1`, `address_2`, `phone`
+
+<a name-"v0.6.1"></a>
+## [v0.6.1](https://github.com/linode/linodego/compare/v0.6.0..v0.6.1) (2018-10-26)
+
+### Features
+
+* Adds support for fetching and updating basic Profile information
+
+<a name-"v0.6.0"></a>
+## [v0.6.0](https://github.com/linode/linodego/compare/v0.5.1..v0.6.0) (2018-10-25)
+
+### Fixes
+
+* Fixes Image date handling
+* Fixes broken example code in README
+* Fixes WaitForEventFinished when encountering events without entity
+* Fixes ResizeInstanceDisk which was executing CloneInstanceDisk
+* Fixes go-resty import path to gopkg.in version for future go module support
+
+### Features
+
+* Adds support for user account operations
+* Adds support for profile tokens
+* Adds support for Tags
+* Adds PasswordResetInstanceDisk
+* Adds DiskStatus constants
+* Adds WaitForInstanceDiskStatus
+* Adds SetPollDelay for configuring poll duration
+
+  * Reduced polling time to millisecond granularity
+  * Change polling default to 3s to avoid 429 conditions
+  * Use poll delay in waitfor functions
+
+<a name="v0.5.1"></a>
+## [v0.5.1](https://github.com/linode/linodego/compare/v0.5.0...v0.5.1) (2018-09-10)
+
+### Fixes
+
+* Domain.Status was not imported from API responses correctly
+
+<a name="v0.5.0"></a>
+## [v0.5.0](https://github.com/linode/linodego/compare/v0.4.0...v0.5.0) (2018-09-09)
+
+### Breaking Changes
+
+* List functions return slice of thing instead of slice of pointer to thing
+
+### Feature
+
+* add SSHKeys methods to client (also affects InstanceCreate, InstanceDiskCreate)
+* add RebuildNodeBalancerConfig (and CreateNodeBalancerConfig with Nodes)
+
+### Fixes
+
+* Event.TimeRemaining wouldn't parse all possible API value
+* Tests no longer rely on known/special instance and volume ids
+
+<a name="0.4.0"></a>
+## [0.4.0](https://github.com/linode/linodego/compare/v0.3.0...0.4.0) (2018-08-27)
+
+### Breaking Changes
+
+Replaces bool, error results with error results, for:
+
+* instance\_snapshots.go: EnableInstanceBackups
+* instance\_snapshots.go: CancelInstanceBackups
+* instance\_snapshots.go: RestoreInstanceBackup
+* instances.go: BootInstance
+* instances.go: RebootInstance
+* instances.go: MutateInstance
+* instances.go: RescueInstance
+* instances.go: ResizeInstance
+* instances.go: ShutdownInstance
+* volumes.go: DetachVolume
+* volumes.go: ResizeVolume
+
+
+### Docs
+
+* reword text about breaking changes until first tag
+
+### Feat
+
+* added MigrateInstance and InstanceResizing from 4.0.1-4.0.3 API Changelog
+* added gometalinter to travis builds
+* added missing function and type comments as reported by linting tools
+* supply json values for all fields, useful for mocking responses using linodego types
+* use context channels in WaitFor\* functions
+* add LinodeTypeClass type (enum)
+* add TicketStatus type (enum)
+* update template thing and add a test template
+
+### Fix
+
+* TransferQuota was TransferQuote (and not parsed from the api correctly)
+* stackscripts udf was not parsed correctly
+* add InstanceCreateOptions.PrivateIP
+* check the WaitFor timeout before sleeping to avoid extra sleep
+* various linting warnings and unhandled err results as reported by linting tools
+* fix GetStackscript 404 handling
+
+
+<a name="0.3.0"></a>
+
+## [0.3.0](https://github.com/linode/linodego/compare/v0.2.0...0.3.0) (2018-08-15)
+
+### Breaking Changes
+
+* WaitForVolumeLinodeID return fetch volume for consistency with out WaitFors
+* Moved linodego from chiefy to github.com/linode. Thanks [@chiefy](https://github.com/chiefy)!
+
+<a name="v0.2.0"></a>
+
+## [v0.2.0](https://github.com/linode/linodego/compare/v0.1.1...v0.2.0) (2018-08-11)
+
+### Breaking Changes
+
+* WaitFor\* should be client methods
+  *use `client.WaitFor...` rather than `linodego.WaitFor(..., client, ...)`*
+
+* remove ListInstanceSnapshots (does not exist in the API)
+  *this never worked, so shouldn't cause a problem*
+
+* Changes UpdateOptions and CreateOptions and similar Options parameters to values instead of pointers
+  *these were never optional and the function never updated any values in the Options structures*
+
+* fixed various optional/zero Update and Create options
+  *some values are now pointers, and vice-versa*
+
+  * Changes InstanceUpdateOptions to use pointers for optional fields Backups and Alerts
+  * Changes InstanceClone's Disks and Configs to ints instead of strings
+
+* using new enum string aliased types where appropriate
+  *`InstanceSnapshotStatus`, `DiskFilesystem`, `NodeMode`*
+
+### Feature
+
+* add RescueInstance and RescueInstanceOptions
+* add CreateImage, UpdateImage, DeleteImage
+* add EnableInstanceBackups, CancelInstanceBackups, RestoreInstanceBackup
+* add WatchdogEnabled to InstanceUpdateOptions
+
+### Fix
+
+* return Volume from AttachVolume instead of bool
+* add more boilerplate to template.go
+* nodebalancers and domain records had no pagination support
+* NodeBalancer transfer stats are not int
+
+### Tests
+
+* add fixtures and tests for NodeBalancerNodes
+* fix nodebalancer tests to handle changes due to random labels
+* add tests for nodebalancers and nodebalancer configs
+* added tests for Backups flow
+* TestListInstanceBackups fixture is hand tweaked because repeated polled events
+  appear to get the tests stuck
+
+### Deps
+
+* update all dependencies to latest
+
+<a name="v0.1.1"></a>
+
+## [v0.1.1](https://github.com/linode/linodego/compare/v0.0.1...v0.1.0) (2018-07-30)
+
+Adds more Domain handling
+
+### Fixed
+
+* go-resty doesnt pass errors when content-type is not set
+* Domain, DomainRecords, tests and fixtures
+
+### Added
+
+* add CreateDomainRecord, UpdateDomainRecord, and DeleteDomainRecord
+
+<a name="v0.1.0"></a>
+
+## [v0.1.0](https://github.com/linode/linodego/compare/v0.0.1...v0.1.0) (2018-07-23)
+
+Deals with NewClient and context for all http requests
+
+### Breaking Changes
+
+* changed `NewClient(token, *http.RoundTripper)` to `NewClient(*http.Client)`
+* changed all `Client` `Get`, `List`, `Create`, `Update`, `Delete`, and `Wait` calls to take context as the first parameter
+
+### Fixed
+
+* fixed docs should now show Examples for more functions
+
+### Added
+
+* added `Client.SetBaseURL(url string)`
+
+<a name="v0.0.1"></a>
+## v0.0.1 (2018-07-20)
+
+### Changed
+
+* Initial tagged release
--- a/vendor/github.com/linode/linodego/Gopkg.lock
+++ b/vendor/github.com/linode/linodego/Gopkg.lock
@ -0,0 +1,111 @@
+# This file is autogenerated, do not edit; changes may be undone by the next 'dep ensure'.
+
+
+[[projects]]
+  branch = "master"
+  digest = "1:6e1c13bc32e58ccb4afa1115a3ba4fc071d918ed897b40dfa323ffb3fcc6619d"
+  name = "github.com/dnaeon/go-vcr"
+  packages = [
+    "cassette",
+    "recorder",
+  ]
+  pruneopts = "UT"
+  revision = "aafff18a5cc28fa0b2f26baf6a14472cda9b54c6"
+
+[[projects]]
+  digest = "1:97df918963298c287643883209a2c3f642e6593379f97ab400c2a2e219ab647d"
+  name = "github.com/golang/protobuf"
+  packages = ["proto"]
+  pruneopts = "UT"
+  revision = "aa810b61a9c79d51363740d207bb46cf8e620ed5"
+  version = "v1.2.0"
+
+[[projects]]
+  branch = "master"
+  digest = "1:33b9d71d1dde2106309484a388eb7ba53cd1f67014e34a71f7b3dbc20bd186e5"
+  name = "golang.org/x/net"
+  packages = [
+    "context",
+    "context/ctxhttp",
+    "idna",
+    "publicsuffix",
+  ]
+  pruneopts = "UT"
+  revision = "8a410e7b638dca158bf9e766925842f6651ff828"
+
+[[projects]]
+  branch = "master"
+  digest = "1:363b547c971a2b07474c598b6e9ebcb238d556d8a27f37b3895ad20cd50e7281"
+  name = "golang.org/x/oauth2"
+  packages = [
+    ".",
+    "internal",
+  ]
+  pruneopts = "UT"
+  revision = "d2e6202438beef2727060aa7cabdd924d92ebfd9"
+
+[[projects]]
+  digest = "1:a2ab62866c75542dd18d2b069fec854577a20211d7c0ea6ae746072a1dccdd18"
+  name = "golang.org/x/text"
+  packages = [
+    "collate",
+    "collate/build",
+    "internal/colltab",
+    "internal/gen",
+    "internal/tag",
+    "internal/triegen",
+    "internal/ucd",
+    "language",
+    "secure/bidirule",
+    "transform",
+    "unicode/bidi",
+    "unicode/cldr",
+    "unicode/norm",
+    "unicode/rangetable",
+  ]
+  pruneopts = "UT"
+  revision = "f21a4dfb5e38f5895301dc265a8def02365cc3d0"
+  version = "v0.3.0"
+
+[[projects]]
+  digest = "1:328b5e4f197d928c444a51a75385f4b978915c0e75521f0ad6a3db976c97a7d3"
+  name = "google.golang.org/appengine"
+  packages = [
+    "internal",
+    "internal/base",
+    "internal/datastore",
+    "internal/log",
+    "internal/remote_api",
+    "internal/urlfetch",
+    "urlfetch",
+  ]
+  pruneopts = "UT"
+  revision = "b1f26356af11148e710935ed1ac8a7f5702c7612"
+  version = "v1.1.0"
+
+[[projects]]
+  digest = "1:b7fc4c3fd91df516486f53cc86f4b55a0c815782dbe852c5a19cce8e6c577aac"
+  name = "gopkg.in/resty.v1"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "d4920dcf5b7689548a6db640278a9b35a5b48ec6"
+  version = "v1.9.1"
+
+[[projects]]
+  digest = "1:342378ac4dcb378a5448dd723f0784ae519383532f5e70ade24132c4c8693202"
+  name = "gopkg.in/yaml.v2"
+  packages = ["."]
+  pruneopts = "UT"
+  revision = "5420a8b6744d3b0345ab293f6fcba19c978f1183"
+  version = "v2.2.1"
+
+[solve-meta]
+  analyzer-name = "dep"
+  analyzer-version = 1
+  input-imports = [
+    "github.com/dnaeon/go-vcr/recorder",
+    "golang.org/x/oauth2",
+    "gopkg.in/resty.v1",
+  ]
+  solver-name = "gps-cdcl"
+  solver-version = 1
--- a/vendor/github.com/linode/linodego/Gopkg.toml
+++ b/vendor/github.com/linode/linodego/Gopkg.toml
@ -0,0 +1,29 @@
+# Gopkg.toml example
+#
+# Refer to https://golang.github.io/dep/docs/Gopkg.toml.html
+# for detailed Gopkg.toml documentation.
+#
+# required = ["github.com/user/thing/cmd/thing"]
+# ignored = ["github.com/user/project/pkgX", "bitbucket.org/user/project/pkgA/pkgY"]
+#
+# [[constraint]]
+#   name = "github.com/user/project"
+#   version = "1.0.0"
+#
+# [[constraint]]
+#   name = "github.com/user/project2"
+#   branch = "dev"
+#   source = "github.com/myfork/project2"
+#
+# [[override]]
+#   name = "github.com/x/y"
+#   version = "2.4.0"
+#
+# [prune]
+#   non-go = false
+#   go-tests = true
+#   unused-packages = true
+
+[prune]
+  go-tests = true
+  unused-packages = true
--- a/vendor/github.com/linode/linodego/LICENSE
+++ b/vendor/github.com/linode/linodego/LICENSE
@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 Christopher "Chief" Najewicz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/vendor/github.com/linode/linodego/Makefile
+++ b/vendor/github.com/linode/linodego/Makefile
@ -0,0 +1,43 @@
+include .env
+
+.PHONY: vendor example refresh-fixtures clean-fixtures
+
+.PHONY: test
+test: vendor
+	@LINODE_FIXTURE_MODE="play" \
+	LINODE_TOKEN="awesometokenawesometokenawesometoken" \
+	go test $(ARGS)
+
+$(GOPATH)/bin/dep:
+	@go get -u github.com/golang/dep/cmd/dep
+
+vendor: $(GOPATH)/bin/dep
+	@dep ensure
+
+example:
+	@go run example/main.go
+
+clean-fixtures:
+	@-rm fixtures/*.yaml
+
+refresh-fixtures: clean-fixtures fixtures
+
+.PHONY: fixtures
+fixtures:
+	@echo "* Running fixtures"
+	@LINODE_TOKEN=$(LINODE_TOKEN) \
+	LINODE_FIXTURE_MODE="record" go test $(ARGS)
+	@echo "* Santizing fixtures"
+	@for yaml in fixtures/*yaml; do \
+		sed -E -i "" -e "s/$(LINODE_TOKEN)/awesometokenawesometokenawesometoken/g" \
+			-e 's/20[0-9]{2}-[01][0-9]-[0-3][0-9]T[0-2][0-9]:[0-9]{2}:[0-9]{2}/2018-01-02T03:04:05/g' \
+			-e 's/nb-[0-9]{1,3}-[0-9]{1,3}-[0-9]{1,3}-[0-9]{1,3}\./nb-10-20-30-40./g' \
+			-e 's/192\.168\.((1?[0-9][0-9]?|2[0-4][0-9]|25[0-5])\.)(1?[0-9][0-9]?|2[0-4][0-9]|25[0-5])/192.168.030.040/g' \
+			-e '/^192\.168/!s/((1?[0-9][0-9]?|2[0-4][0-9]|25[0-5])\.){3}(1?[0-9][0-9]?|2[0-4][0-9]|25[0-5])/10.20.30.40/g' \
+			-e 's/(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))/1234::5678/g' \
+			$$yaml; \
+	done
+
+.PHONY: godoc
+godoc:
+	@godoc -http=:6060
--- a/vendor/github.com/linode/linodego/README.md
+++ b/vendor/github.com/linode/linodego/README.md
@ -0,0 +1,178 @@
+# linodego
+
+[![Build Status](https://travis-ci.org/linode/linodego.svg?branch=master)](https://travis-ci.org/linode/linodego)
+[![GoDoc](https://godoc.org/github.com/linode/linodego?status.svg)](https://godoc.org/github.com/linode/linodego)
+[![Go Report Card](https://goreportcard.com/badge/github.com/linode/linodego)](https://goreportcard.com/report/github.com/linode/linodego)
+[![codecov](https://codecov.io/gh/linode/linodego/branch/master/graph/badge.svg)](https://codecov.io/gh/linode/linodego)
+
+Go client for [Linode REST v4 API](https://developers.linode.com/api/v4)
+
+## Installation
+
+```sh
+go get -u github.com/linode/linodego
+```
+
+## API Support
+
+Check [API_SUPPORT.md](API_SUPPORT.md) for current support of the Linode `v4` API endpoints.
+
+** Note: This project will change and break until we release a v1.0.0 tagged version. Breaking changes in v0.x.x will be denoted with a minor version bump (v0.2.4 -> v0.3.0) **
+
+## Documentation
+
+See [godoc](https://godoc.org/github.com/linode/linodego) for a complete reference.
+
+The API generally follows the naming patterns prescribed in the [OpenAPIv3 document for Linode APIv4](https://developers.linode.com/api/v4).
+
+Deviations in naming have been made to avoid using "Linode" and "Instance" redundantly or inconsistently.
+
+A brief summary of the features offered in this API client are shown here.
+
+## Examples
+
+### General Usage
+
+```go
+package main
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/linode/linodego"
+	"golang.org/x/oauth2"
+
+	"log"
+	"net/http"
+	"os"
+)
+
+func main() {
+  apiKey, ok := os.LookupEnv("LINODE_TOKEN")
+  if !ok {
+    log.Fatal("Could not find LINODE_TOKEN, please assert it is set.")
+  }
+  tokenSource := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: apiKey})
+
+  oauth2Client := &http.Client{
+    Transport: &oauth2.Transport{
+      Source: tokenSource,
+    },
+  }
+
+  linodeClient := linodego.NewClient(oauth2Client)
+  linodeClient.SetDebug(true)
+  
+  res, err := linodeClient.GetInstance(context.Background(), 4090913)
+  if err != nil {
+    log.Fatal(err)
+  }
+  fmt.Printf("%v", res)
+}
+```
+
+### Pagination
+
+#### Auto-Pagination Requests
+
+```go
+kernels, err := linodego.ListKernels(context.Background(), nil)
+// len(kernels) == 218
+```
+
+Or, use a page value of "0":
+
+```go
+opts := NewListOptions(0,"")
+kernels, err := linodego.ListKernels(context.Background(), opts)
+// len(kernels) == 218
+```
+
+#### Single Page
+
+```go
+opts := NewListOptions(2,"")
+// or opts := ListOptions{PageOptions: &PageOptions: {Page: 2 }}
+kernels, err := linodego.ListKernels(context.Background(), opts)
+// len(kernels) == 100
+```
+
+ListOptions are supplied as a pointer because the Pages and Results
+values are set in the supplied ListOptions.
+
+```go
+// opts.Results == 218
+```
+
+#### Filtering
+
+```go
+opts := ListOptions{Filter: "{\"mine\":true}"}
+// or opts := NewListOptions(0, "{\"mine\":true}")
+stackscripts, err := linodego.ListStackscripts(context.Background(), opts)
+```
+
+### Error Handling
+
+#### Getting Single Entities
+
+```go
+linode, err := linodego.GetLinode(context.Background(), 555) // any Linode ID that does not exist or is not yours
+// linode == nil: true
+// err.Error() == "[404] Not Found"
+// err.Code == "404"
+// err.Message == "Not Found"
+```
+
+#### Lists
+
+For lists, the list is still returned as `[]`, but `err` works the same way as on the `Get` request.
+
+```go
+linodes, err := linodego.ListLinodes(context.Background(), NewListOptions(0, "{\"foo\":bar}"))
+// linodes == []
+// err.Error() == "[400] [X-Filter] Cannot filter on foo"
+```
+
+Otherwise sane requests beyond the last page do not trigger an error, just an empty result:
+
+```go
+linodes, err := linodego.ListLinodes(context.Background(), NewListOptions(9999, ""))
+// linodes == []
+// err = nil
+```
+
+### Writes
+
+When performing a `POST` or `PUT` request, multiple field related errors will be returned as a single error, currently like:
+
+```go
+// err.Error() == "[400] [field1] foo problem; [field2] bar problem; [field3] baz problem"
+```
+
+## Tests
+
+Run `make test` to run the unit tests.  This is the same as running `go test` except that `make test` will
+execute the tests while playing back API response fixtures that were recorded during a previous development build.
+
+`go test` can be used without the fixtures. Copy `env.sample` to `.env` and configure your persistent test
+settings, including an API token.
+
+`go test -short` can be used to run live API tests that do not require an account token.
+
+This will be simplified in future versions.
+
+To update the test fixtures, run `make fixtures`.  This will record the API responses into the `fixtures/` directory.
+Be careful about committing any sensitive account details.  An attempt has been made to sanitize IP addresses and
+dates, but no automated sanitization will be performed against `fixtures/*Account*.yaml`, for example.
+
+To prevent disrupting unaffected fixtures, target fixture generation like so: `make ARGS="-run TestListVolumes" fixtures`.
+
+## Discussion / Help
+
+Join us at [#linodego](https://gophers.slack.com/messages/CAG93EB2S) on the [gophers slack](https://gophers.slack.com)
+
+## License
+
+[MIT License](LICENSE)
--- a/vendor/github.com/linode/linodego/account.go
+++ b/vendor/github.com/linode/linodego/account.go
@ -0,0 +1,45 @@
+package linodego
+
+import "context"
+
+// Account associated with the token in use
+type Account struct {
+	FirstName  string      `json:"first_name"`
+	LastName   string      `json:"last_name"`
+	Email      string      `json:"email"`
+	Company    string      `json:"company"`
+	Address1   string      `json:"address_1"`
+	Address2   string      `json:"address_2"`
+	Balance    float32     `json:"balance"`
+	City       string      `json:"city"`
+	State      string      `json:"state"`
+	Zip        string      `json:"zip"`
+	Country    string      `json:"country"`
+	TaxID      string      `json:"tax_id"`
+	Phone      string      `json:"phone"`
+	CreditCard *CreditCard `json:"credit_card"`
+}
+
+// CreditCard information associated with the Account.
+type CreditCard struct {
+	LastFour string `json:"last_four"`
+	Expiry   string `json:"expiry"`
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *Account) fixDates() *Account {
+	return v
+}
+
+// GetAccount gets the contact and billing information related to the Account
+func (c *Client) GetAccount(ctx context.Context) (*Account, error) {
+	e, err := c.Account.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Account{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Account).fixDates(), nil
+}
--- a/vendor/github.com/linode/linodego/account_events.go
+++ b/vendor/github.com/linode/linodego/account_events.go
@ -0,0 +1,277 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Event represents an action taken on the Account.
+type Event struct {
+	CreatedStr string `json:"created"`
+
+	// The unique ID of this Event.
+	ID int `json:"id"`
+
+	// Current status of the Event, Enum: "failed" "finished" "notification" "scheduled" "started"
+	Status EventStatus `json:"status"`
+
+	// The action that caused this Event. New actions may be added in the future.
+	Action EventAction `json:"action"`
+
+	// A percentage estimating the amount of time remaining for an Event. Returns null for notification events.
+	PercentComplete int `json:"percent_complete"`
+
+	// The rate of completion of the Event. Only some Events will return rate; for example, migration and resize Events.
+	Rate *string `json:"rate"`
+
+	// If this Event has been read.
+	Read bool `json:"read"`
+
+	// If this Event has been seen.
+	Seen bool `json:"seen"`
+
+	// The estimated time remaining until the completion of this Event. This value is only returned for in-progress events.
+	TimeRemainingMsg json.RawMessage `json:"time_remaining"`
+	TimeRemaining    *int            `json:"-"`
+
+	// The username of the User who caused the Event.
+	Username string `json:"username"`
+
+	// Detailed information about the Event's entity, including ID, type, label, and URL used to access it.
+	Entity *EventEntity `json:"entity"`
+
+	// When this Event was created.
+	Created *time.Time `json:"-"`
+}
+
+// EventAction constants start with Action and include all known Linode API Event Actions.
+type EventAction string
+
+// EventAction constants represent the actions that cause an Event. New actions may be added in the future.
+const (
+	ActionBackupsEnable            EventAction = "backups_enable"
+	ActionBackupsCancel            EventAction = "backups_cancel"
+	ActionBackupsRestore           EventAction = "backups_restore"
+	ActionCommunityQuestionReply   EventAction = "community_question_reply"
+	ActionCreateCardUpdated        EventAction = "credit_card_updated"
+	ActionDiskCreate               EventAction = "disk_create"
+	ActionDiskDelete               EventAction = "disk_delete"
+	ActionDiskDuplicate            EventAction = "disk_duplicate"
+	ActionDiskImagize              EventAction = "disk_imagize"
+	ActionDiskResize               EventAction = "disk_resize"
+	ActionDNSRecordCreate          EventAction = "dns_record_create"
+	ActionDNSRecordDelete          EventAction = "dns_record_delete"
+	ActionDNSZoneCreate            EventAction = "dns_zone_create"
+	ActionDNSZoneDelete            EventAction = "dns_zone_delete"
+	ActionImageDelete              EventAction = "image_delete"
+	ActionLinodeAddIP              EventAction = "linode_addip"
+	ActionLinodeBoot               EventAction = "linode_boot"
+	ActionLinodeClone              EventAction = "linode_clone"
+	ActionLinodeCreate             EventAction = "linode_create"
+	ActionLinodeDelete             EventAction = "linode_delete"
+	ActionLinodeDeleteIP           EventAction = "linode_deleteip"
+	ActionLinodeMigrate            EventAction = "linode_migrate"
+	ActionLinodeMutate             EventAction = "linode_mutate"
+	ActionLinodeReboot             EventAction = "linode_reboot"
+	ActionLinodeRebuild            EventAction = "linode_rebuild"
+	ActionLinodeResize             EventAction = "linode_resize"
+	ActionLinodeShutdown           EventAction = "linode_shutdown"
+	ActionLinodeSnapshot           EventAction = "linode_snapshot"
+	ActionLongviewClientCreate     EventAction = "longviewclient_create"
+	ActionLongviewClientDelete     EventAction = "longviewclient_delete"
+	ActionManagedDisabled          EventAction = "managed_disabled"
+	ActionManagedEnabled           EventAction = "managed_enabled"
+	ActionManagedServiceCreate     EventAction = "managed_service_create"
+	ActionManagedServiceDelete     EventAction = "managed_service_delete"
+	ActionNodebalancerCreate       EventAction = "nodebalancer_create"
+	ActionNodebalancerDelete       EventAction = "nodebalancer_delete"
+	ActionNodebalancerConfigCreate EventAction = "nodebalancer_config_create"
+	ActionNodebalancerConfigDelete EventAction = "nodebalancer_config_delete"
+	ActionPasswordReset            EventAction = "password_reset"
+	ActionPaymentSubmitted         EventAction = "payment_submitted"
+	ActionStackScriptCreate        EventAction = "stackscript_create"
+	ActionStackScriptDelete        EventAction = "stackscript_delete"
+	ActionStackScriptPublicize     EventAction = "stackscript_publicize"
+	ActionStackScriptRevise        EventAction = "stackscript_revise"
+	ActionTFADisabled              EventAction = "tfa_disabled"
+	ActionTFAEnabled               EventAction = "tfa_enabled"
+	ActionTicketAttachmentUpload   EventAction = "ticket_attachment_upload"
+	ActionTicketCreate             EventAction = "ticket_create"
+	ActionTicketReply              EventAction = "ticket_reply"
+	ActionVolumeAttach             EventAction = "volume_attach"
+	ActionVolumeClone              EventAction = "volume_clone"
+	ActionVolumeCreate             EventAction = "volume_create"
+	ActionVolumeDelte              EventAction = "volume_delete"
+	ActionVolumeDetach             EventAction = "volume_detach"
+	ActionVolumeResize             EventAction = "volume_resize"
+)
+
+// EntityType constants start with Entity and include Linode API Event Entity Types
+type EntityType string
+
+// EntityType contants are the entities an Event can be related to
+const (
+	EntityLinode EntityType = "linode"
+	EntityDisk   EntityType = "disk"
+)
+
+// EventStatus constants start with Event and include Linode API Event Status values
+type EventStatus string
+
+// EventStatus constants reflect the current status of an Event
+const (
+	EventFailed       EventStatus = "failed"
+	EventFinished     EventStatus = "finished"
+	EventNotification EventStatus = "notification"
+	EventScheduled    EventStatus = "scheduled"
+	EventStarted      EventStatus = "started"
+)
+
+// EventEntity provides detailed information about the Event's
+// associated entity, including ID, Type, Label, and a URL that
+// can be used to access it.
+type EventEntity struct {
+	// ID may be a string or int, it depends on the EntityType
+	ID    interface{} `json:"id"`
+	Label string      `json:"label"`
+	Type  EntityType  `json:"type"`
+	URL   string      `json:"url"`
+}
+
+// EventsPagedResponse represents a paginated Events API response
+type EventsPagedResponse struct {
+	*PageOptions
+	Data []Event `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Event
+func (EventsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Events.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// endpointWithID gets the endpoint URL for a specific Event
+func (e Event) endpointWithID(c *Client) string {
+	endpoint, err := c.Events.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	endpoint = fmt.Sprintf("%s/%d", endpoint, e.ID)
+	return endpoint
+}
+
+// appendData appends Events when processing paginated Event responses
+func (resp *EventsPagedResponse) appendData(r *EventsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListEvents gets a collection of Event objects representing actions taken
+// on the Account. The Events returned depend on the token grants and the grants
+// of the associated user.
+func (c *Client) ListEvents(ctx context.Context, opts *ListOptions) ([]Event, error) {
+	response := EventsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetEvent gets the Event with the Event ID
+func (c *Client) GetEvent(ctx context.Context, id int) (*Event, error) {
+	e, err := c.Events.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := c.R(ctx).SetResult(&Event{}).Get(e)
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Event).fixDates(), nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (e *Event) fixDates() *Event {
+	e.Created, _ = parseDates(e.CreatedStr)
+	e.TimeRemaining = unmarshalTimeRemaining(e.TimeRemainingMsg)
+	return e
+}
+
+// MarkEventRead marks a single Event as read.
+func (c *Client) MarkEventRead(ctx context.Context, event *Event) error {
+	e := event.endpointWithID(c)
+	e = fmt.Sprintf("%s/read", e)
+
+	_, err := coupleAPIErrors(c.R(ctx).Post(e))
+
+	return err
+}
+
+// MarkEventsSeen marks all Events up to and including this Event by ID as seen.
+func (c *Client) MarkEventsSeen(ctx context.Context, event *Event) error {
+	e := event.endpointWithID(c)
+	e = fmt.Sprintf("%s/seen", e)
+
+	_, err := coupleAPIErrors(c.R(ctx).Post(e))
+
+	return err
+}
+
+func unmarshalTimeRemaining(m json.RawMessage) *int {
+	jsonBytes, err := m.MarshalJSON()
+	if err != nil {
+		panic(jsonBytes)
+	}
+
+	if len(jsonBytes) == 4 && string(jsonBytes) == "null" {
+		return nil
+	}
+
+	var timeStr string
+	if err := json.Unmarshal(jsonBytes, &timeStr); err == nil && len(timeStr) > 0 {
+		if dur, err := durationToSeconds(timeStr); err != nil {
+			panic(err)
+		} else {
+			return &dur
+		}
+	} else {
+		var intPtr int
+		if err := json.Unmarshal(jsonBytes, &intPtr); err == nil {
+			return &intPtr
+		}
+	}
+
+	log.Println("[WARN] Unexpected unmarshalTimeRemaining value: ", jsonBytes)
+	return nil
+}
+
+// durationToSeconds takes a hh:mm:ss string and returns the number of seconds
+func durationToSeconds(s string) (int, error) {
+	multipliers := [3]int{60 * 60, 60, 1}
+	segs := strings.Split(s, ":")
+	if len(segs) > len(multipliers) {
+		return 0, fmt.Errorf("too many ':' separators in time duration: %s", s)
+	}
+	var d int
+	l := len(segs)
+	for i := 0; i < l; i++ {
+		m, err := strconv.Atoi(segs[i])
+		if err != nil {
+			return 0, err
+		}
+		d += m * multipliers[i+len(multipliers)-l]
+	}
+	return d, nil
+}
--- a/vendor/github.com/linode/linodego/account_invoices.go
+++ b/vendor/github.com/linode/linodego/account_invoices.go
@ -0,0 +1,125 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// Invoice structs reflect an invoice for billable activity on the account.
+type Invoice struct {
+	DateStr string `json:"date"`
+
+	ID    int        `json:"id"`
+	Label string     `json:"label"`
+	Total float32    `json:"total"`
+	Date  *time.Time `json:"-"`
+}
+
+// InvoiceItem structs reflect an single billable activity associate with an Invoice
+type InvoiceItem struct {
+	FromStr string `json:"from"`
+	ToStr   string `json:"to"`
+
+	Label     string     `json:"label"`
+	Type      string     `json:"type"`
+	UnitPrice int        `json:"unitprice"`
+	Quantity  int        `json:"quantity"`
+	Amount    float32    `json:"amount"`
+	From      *time.Time `json:"-"`
+	To        *time.Time `json:"-"`
+}
+
+// InvoicesPagedResponse represents a paginated Invoice API response
+type InvoicesPagedResponse struct {
+	*PageOptions
+	Data []Invoice `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Invoice
+func (InvoicesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Invoices.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Invoices when processing paginated Invoice responses
+func (resp *InvoicesPagedResponse) appendData(r *InvoicesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListInvoices gets a paginated list of Invoices against the Account
+func (c *Client) ListInvoices(ctx context.Context, opts *ListOptions) ([]Invoice, error) {
+	response := InvoicesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *Invoice) fixDates() *Invoice {
+	v.Date, _ = parseDates(v.DateStr)
+	return v
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *InvoiceItem) fixDates() *InvoiceItem {
+	v.From, _ = parseDates(v.FromStr)
+	v.To, _ = parseDates(v.ToStr)
+	return v
+}
+
+// GetInvoice gets the a single Invoice matching the provided ID
+func (c *Client) GetInvoice(ctx context.Context, id int) (*Invoice, error) {
+	e, err := c.Invoices.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Invoice{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Invoice).fixDates(), nil
+}
+
+// InvoiceItemsPagedResponse represents a paginated Invoice Item API response
+type InvoiceItemsPagedResponse struct {
+	*PageOptions
+	Data []InvoiceItem `json:"data"`
+}
+
+// endpointWithID gets the endpoint URL for InvoiceItems associated with a specific Invoice
+func (InvoiceItemsPagedResponse) endpointWithID(c *Client, id int) string {
+	endpoint, err := c.InvoiceItems.endpointWithID(id)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends InvoiceItems when processing paginated Invoice Item responses
+func (resp *InvoiceItemsPagedResponse) appendData(r *InvoiceItemsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListInvoiceItems gets the invoice items associated with a specific Invoice
+func (c *Client) ListInvoiceItems(ctx context.Context, id int, opts *ListOptions) ([]InvoiceItem, error) {
+	response := InvoiceItemsPagedResponse{}
+	err := c.listHelperWithID(ctx, &response, id, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
--- a/vendor/github.com/linode/linodego/account_notifications.go
+++ b/vendor/github.com/linode/linodego/account_notifications.go
@ -0,0 +1,101 @@
+package linodego
+
+import (
+	"context"
+	"time"
+)
+
+// Notification represents a notification on an Account
+type Notification struct {
+	UntilStr string `json:"until"`
+	WhenStr  string `json:"when"`
+
+	Label    string               `json:"label"`
+	Body     *string              `json:"body"`
+	Message  string               `json:"message"`
+	Type     NotificationType     `json:"type"`
+	Severity NotificationSeverity `json:"severity"`
+	Entity   *NotificationEntity  `json:"entity"`
+	Until    *time.Time           `json:"-"`
+	When     *time.Time           `json:"-"`
+}
+
+// NotificationEntity adds detailed information about the Notification.
+// This could refer to the ticket that triggered the notification, for example.
+type NotificationEntity struct {
+	ID    int    `json:"id"`
+	Label string `json:"label"`
+	Type  string `json:"type"`
+	URL   string `json:"url"`
+}
+
+// NotificationSeverity constants start with Notification and include all known Linode API Notification Severities.
+type NotificationSeverity string
+
+// NotificationSeverity constants represent the actions that cause a Notification. New severities may be added in the future.
+const (
+	NotificationMinor    NotificationSeverity = "minor"
+	NotificationMajor    NotificationSeverity = "major"
+	NotificationCritical NotificationSeverity = "critical"
+)
+
+// NotificationType constants start with Notification and include all known Linode API Notification Types.
+type NotificationType string
+
+// NotificationType constants represent the actions that cause a Notification. New types may be added in the future.
+const (
+	NotificationMigrationScheduled NotificationType = "migration_scheduled"
+	NotificationMigrationImminent  NotificationType = "migration_imminent"
+	NotificationMigrationPending   NotificationType = "migration_pending"
+	NotificationRebootScheduled    NotificationType = "reboot_scheduled"
+	NotificationOutage             NotificationType = "outage"
+	NotificationPaymentDue         NotificationType = "payment_due"
+	NotificationTicketImportant    NotificationType = "ticket_important"
+	NotificationTicketAbuse        NotificationType = "ticket_abuse"
+	NotificationNotice             NotificationType = "notice"
+	NotificationMaintenance        NotificationType = "maintenance"
+)
+
+// NotificationsPagedResponse represents a paginated Notifications API response
+type NotificationsPagedResponse struct {
+	*PageOptions
+	Data []Notification `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Notification
+func (NotificationsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Notifications.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Notifications when processing paginated Notification responses
+func (resp *NotificationsPagedResponse) appendData(r *NotificationsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListNotifications gets a collection of Notification objects representing important,
+// often time-sensitive items related to the Account. An account cannot interact directly with
+// Notifications, and a Notification will disappear when the circumstances causing it
+// have been resolved. For example, if the account has an important Ticket open, a response
+// to the Ticket will dismiss the Notification.
+func (c *Client) ListNotifications(ctx context.Context, opts *ListOptions) ([]Notification, error) {
+	response := NotificationsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *Notification) fixDates() *Notification {
+	v.Until, _ = parseDates(v.UntilStr)
+	v.When, _ = parseDates(v.WhenStr)
+	return v
+}
--- a/vendor/github.com/linode/linodego/account_users.go
+++ b/vendor/github.com/linode/linodego/account_users.go
@ -0,0 +1,164 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// User represents a User object
+type User struct {
+	Username   string   `json:"username"`
+	Email      string   `json:"email"`
+	Restricted bool     `json:"restricted"`
+	SSHKeys    []string `json:"ssh_keys"`
+}
+
+// UserCreateOptions fields are those accepted by CreateUser
+type UserCreateOptions struct {
+	Username   string `json:"username"`
+	Email      string `json:"email"`
+	Restricted bool   `json:"restricted,omitempty"`
+}
+
+// UserUpdateOptions fields are those accepted by UpdateUser
+type UserUpdateOptions struct {
+	Username   string    `json:"username,omitempty"`
+	Email      string    `json:"email,omitempty"`
+	Restricted *bool     `json:"restricted,omitempty"`
+	SSHKeys    *[]string `json:"ssh_keys,omitempty"`
+}
+
+// GetCreateOptions converts a User to UserCreateOptions for use in CreateUser
+func (i User) GetCreateOptions() (o UserCreateOptions) {
+	o.Username = i.Username
+	o.Email = i.Email
+	o.Restricted = i.Restricted
+	return
+}
+
+// GetUpdateOptions converts a User to UserUpdateOptions for use in UpdateUser
+func (i User) GetUpdateOptions() (o UserUpdateOptions) {
+	o.Username = i.Username
+	o.Email = i.Email
+	o.Restricted = copyBool(&i.Restricted)
+	return
+}
+
+// UsersPagedResponse represents a paginated User API response
+type UsersPagedResponse struct {
+	*PageOptions
+	Data []User `json:"data"`
+}
+
+// endpoint gets the endpoint URL for User
+func (UsersPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Users.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Users when processing paginated User responses
+func (resp *UsersPagedResponse) appendData(r *UsersPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListUsers lists Users on the account
+func (c *Client) ListUsers(ctx context.Context, opts *ListOptions) ([]User, error) {
+	response := UsersPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *User) fixDates() *User {
+	return i
+}
+
+// GetUser gets the user with the provided ID
+func (c *Client) GetUser(ctx context.Context, id string) (*User, error) {
+	e, err := c.Users.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&User{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*User).fixDates(), nil
+}
+
+// CreateUser creates a User.  The email address must be confirmed before the
+// User account can be accessed.
+func (c *Client) CreateUser(ctx context.Context, createOpts UserCreateOptions) (*User, error) {
+	var body string
+	e, err := c.Users.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&User{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*User).fixDates(), nil
+}
+
+// UpdateUser updates the User with the specified id
+func (c *Client) UpdateUser(ctx context.Context, id string, updateOpts UserUpdateOptions) (*User, error) {
+	var body string
+	e, err := c.Users.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+
+	req := c.R(ctx).SetResult(&User{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*User).fixDates(), nil
+}
+
+// DeleteUser deletes the User with the specified id
+func (c *Client) DeleteUser(ctx context.Context, id string) error {
+	e, err := c.Users.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
--- a/vendor/github.com/linode/linodego/client.go
+++ b/vendor/github.com/linode/linodego/client.go
@ -0,0 +1,257 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
+
+	"gopkg.in/resty.v1"
+)
+
+const (
+	// APIHost Linode API hostname
+	APIHost = "api.linode.com"
+	// APIVersion Linode API version
+	APIVersion = "v4"
+	// APIProto connect to API with http(s)
+	APIProto = "https"
+	// Version of linodego
+	Version = "0.7.0"
+	// APIEnvVar environment var to check for API token
+	APIEnvVar = "LINODE_TOKEN"
+	// APISecondsPerPoll how frequently to poll for new Events or Status in WaitFor functions
+	APISecondsPerPoll = 3
+	// DefaultUserAgent is the default User-Agent sent in HTTP request headers
+	DefaultUserAgent = "linodego " + Version + " https://github.com/linode/linodego"
+)
+
+var (
+	envDebug = false
+)
+
+// Client is a wrapper around the Resty client
+type Client struct {
+	resty     *resty.Client
+	userAgent string
+	resources map[string]*Resource
+	debug     bool
+
+	millisecondsPerPoll time.Duration
+
+	Images                *Resource
+	InstanceDisks         *Resource
+	InstanceConfigs       *Resource
+	InstanceSnapshots     *Resource
+	InstanceIPs           *Resource
+	InstanceVolumes       *Resource
+	Instances             *Resource
+	IPAddresses           *Resource
+	IPv6Pools             *Resource
+	IPv6Ranges            *Resource
+	Regions               *Resource
+	StackScripts          *Resource
+	Volumes               *Resource
+	Kernels               *Resource
+	Types                 *Resource
+	Domains               *Resource
+	DomainRecords         *Resource
+	Longview              *Resource
+	LongviewClients       *Resource
+	LongviewSubscriptions *Resource
+	NodeBalancers         *Resource
+	NodeBalancerConfigs   *Resource
+	NodeBalancerNodes     *Resource
+	SSHKeys               *Resource
+	Tickets               *Resource
+	Tokens                *Resource
+	Token                 *Resource
+	Account               *Resource
+	Invoices              *Resource
+	InvoiceItems          *Resource
+	Events                *Resource
+	Notifications         *Resource
+	Profile               *Resource
+	Managed               *Resource
+	Tags                  *Resource
+	Users                 *Resource
+}
+
+func init() {
+	// Wether or not we will enable Resty debugging output
+	if apiDebug, ok := os.LookupEnv("LINODE_DEBUG"); ok {
+		if parsed, err := strconv.ParseBool(apiDebug); err == nil {
+			envDebug = parsed
+			log.Println("[INFO] LINODE_DEBUG being set to", envDebug)
+		} else {
+			log.Println("[WARN] LINODE_DEBUG should be an integer, 0 or 1")
+		}
+	}
+
+}
+
+// SetUserAgent sets a custom user-agent for HTTP requests
+func (c *Client) SetUserAgent(ua string) *Client {
+	c.userAgent = ua
+	c.resty.SetHeader("User-Agent", c.userAgent)
+
+	return c
+}
+
+// R wraps resty's R method
+func (c *Client) R(ctx context.Context) *resty.Request {
+	return c.resty.R().
+		ExpectContentType("application/json").
+		SetHeader("Content-Type", "application/json").
+		SetContext(ctx).
+		SetError(APIError{})
+}
+
+// SetDebug sets the debug on resty's client
+func (c *Client) SetDebug(debug bool) *Client {
+	c.debug = debug
+	c.resty.SetDebug(debug)
+	return c
+}
+
+// SetBaseURL sets the base URL of the Linode v4 API (https://api.linode.com/v4)
+func (c *Client) SetBaseURL(url string) *Client {
+	c.resty.SetHostURL(url)
+	return c
+}
+
+// SetPollDelay sets the number of milliseconds to wait between events or status polls.
+// Affects all WaitFor* functions.
+func (c *Client) SetPollDelay(delay time.Duration) *Client {
+	c.millisecondsPerPoll = delay
+	return c
+}
+
+// Resource looks up a resource by name
+func (c Client) Resource(resourceName string) *Resource {
+	selectedResource, ok := c.resources[resourceName]
+	if !ok {
+		log.Fatalf("Could not find resource named '%s', exiting.", resourceName)
+	}
+	return selectedResource
+}
+
+// NewClient factory to create new Client struct
+func NewClient(hc *http.Client) (client Client) {
+	restyClient := resty.NewWithClient(hc)
+	client.resty = restyClient
+	client.SetUserAgent(DefaultUserAgent)
+	client.SetBaseURL(fmt.Sprintf("%s://%s/%s", APIProto, APIHost, APIVersion))
+	client.SetPollDelay(1000 * APISecondsPerPoll)
+
+	resources := map[string]*Resource{
+		stackscriptsName:          NewResource(&client, stackscriptsName, stackscriptsEndpoint, false, Stackscript{}, StackscriptsPagedResponse{}),
+		imagesName:                NewResource(&client, imagesName, imagesEndpoint, false, Image{}, ImagesPagedResponse{}),
+		instancesName:             NewResource(&client, instancesName, instancesEndpoint, false, Instance{}, InstancesPagedResponse{}),
+		instanceDisksName:         NewResource(&client, instanceDisksName, instanceDisksEndpoint, true, InstanceDisk{}, InstanceDisksPagedResponse{}),
+		instanceConfigsName:       NewResource(&client, instanceConfigsName, instanceConfigsEndpoint, true, InstanceConfig{}, InstanceConfigsPagedResponse{}),
+		instanceSnapshotsName:     NewResource(&client, instanceSnapshotsName, instanceSnapshotsEndpoint, true, InstanceSnapshot{}, nil),
+		instanceIPsName:           NewResource(&client, instanceIPsName, instanceIPsEndpoint, true, InstanceIP{}, nil),                           // really?
+		instanceVolumesName:       NewResource(&client, instanceVolumesName, instanceVolumesEndpoint, true, nil, InstanceVolumesPagedResponse{}), // really?
+		ipaddressesName:           NewResource(&client, ipaddressesName, ipaddressesEndpoint, false, nil, IPAddressesPagedResponse{}),            // really?
+		ipv6poolsName:             NewResource(&client, ipv6poolsName, ipv6poolsEndpoint, false, nil, IPv6PoolsPagedResponse{}),                  // really?
+		ipv6rangesName:            NewResource(&client, ipv6rangesName, ipv6rangesEndpoint, false, IPv6Range{}, IPv6RangesPagedResponse{}),
+		regionsName:               NewResource(&client, regionsName, regionsEndpoint, false, Region{}, RegionsPagedResponse{}),
+		volumesName:               NewResource(&client, volumesName, volumesEndpoint, false, Volume{}, VolumesPagedResponse{}),
+		kernelsName:               NewResource(&client, kernelsName, kernelsEndpoint, false, LinodeKernel{}, LinodeKernelsPagedResponse{}),
+		typesName:                 NewResource(&client, typesName, typesEndpoint, false, LinodeType{}, LinodeTypesPagedResponse{}),
+		domainsName:               NewResource(&client, domainsName, domainsEndpoint, false, Domain{}, DomainsPagedResponse{}),
+		domainRecordsName:         NewResource(&client, domainRecordsName, domainRecordsEndpoint, true, DomainRecord{}, DomainRecordsPagedResponse{}),
+		longviewName:              NewResource(&client, longviewName, longviewEndpoint, false, nil, nil), // really?
+		longviewclientsName:       NewResource(&client, longviewclientsName, longviewclientsEndpoint, false, LongviewClient{}, LongviewClientsPagedResponse{}),
+		longviewsubscriptionsName: NewResource(&client, longviewsubscriptionsName, longviewsubscriptionsEndpoint, false, LongviewSubscription{}, LongviewSubscriptionsPagedResponse{}),
+		nodebalancersName:         NewResource(&client, nodebalancersName, nodebalancersEndpoint, false, NodeBalancer{}, NodeBalancerConfigsPagedResponse{}),
+		nodebalancerconfigsName:   NewResource(&client, nodebalancerconfigsName, nodebalancerconfigsEndpoint, true, NodeBalancerConfig{}, NodeBalancerConfigsPagedResponse{}),
+		nodebalancernodesName:     NewResource(&client, nodebalancernodesName, nodebalancernodesEndpoint, true, NodeBalancerNode{}, NodeBalancerNodesPagedResponse{}),
+		notificationsName:         NewResource(&client, notificationsName, notificationsEndpoint, false, Notification{}, NotificationsPagedResponse{}),
+		sshkeysName:               NewResource(&client, sshkeysName, sshkeysEndpoint, false, SSHKey{}, SSHKeysPagedResponse{}),
+		ticketsName:               NewResource(&client, ticketsName, ticketsEndpoint, false, Ticket{}, TicketsPagedResponse{}),
+		tokensName:                NewResource(&client, tokensName, tokensEndpoint, false, Token{}, TokensPagedResponse{}),
+		accountName:               NewResource(&client, accountName, accountEndpoint, false, Account{}, nil), // really?
+		eventsName:                NewResource(&client, eventsName, eventsEndpoint, false, Event{}, EventsPagedResponse{}),
+		invoicesName:              NewResource(&client, invoicesName, invoicesEndpoint, false, Invoice{}, InvoicesPagedResponse{}),
+		invoiceItemsName:          NewResource(&client, invoiceItemsName, invoiceItemsEndpoint, true, InvoiceItem{}, InvoiceItemsPagedResponse{}),
+		profileName:               NewResource(&client, profileName, profileEndpoint, false, nil, nil), // really?
+		managedName:               NewResource(&client, managedName, managedEndpoint, false, nil, nil), // really?
+		tagsName:                  NewResource(&client, tagsName, tagsEndpoint, false, Tag{}, TagsPagedResponse{}),
+		usersName:                 NewResource(&client, usersName, usersEndpoint, false, User{}, UsersPagedResponse{}),
+	}
+
+	client.resources = resources
+
+	client.SetDebug(envDebug)
+	client.Images = resources[imagesName]
+	client.StackScripts = resources[stackscriptsName]
+	client.Instances = resources[instancesName]
+	client.Regions = resources[regionsName]
+	client.InstanceDisks = resources[instanceDisksName]
+	client.InstanceConfigs = resources[instanceConfigsName]
+	client.InstanceSnapshots = resources[instanceSnapshotsName]
+	client.InstanceIPs = resources[instanceIPsName]
+	client.InstanceVolumes = resources[instanceVolumesName]
+	client.IPAddresses = resources[ipaddressesName]
+	client.IPv6Pools = resources[ipv6poolsName]
+	client.IPv6Ranges = resources[ipv6rangesName]
+	client.Volumes = resources[volumesName]
+	client.Kernels = resources[kernelsName]
+	client.Types = resources[typesName]
+	client.Domains = resources[domainsName]
+	client.DomainRecords = resources[domainRecordsName]
+	client.Longview = resources[longviewName]
+	client.LongviewSubscriptions = resources[longviewsubscriptionsName]
+	client.NodeBalancers = resources[nodebalancersName]
+	client.NodeBalancerConfigs = resources[nodebalancerconfigsName]
+	client.NodeBalancerNodes = resources[nodebalancernodesName]
+	client.Notifications = resources[notificationsName]
+	client.SSHKeys = resources[sshkeysName]
+	client.Tickets = resources[ticketsName]
+	client.Tokens = resources[tokensName]
+	client.Account = resources[accountName]
+	client.Events = resources[eventsName]
+	client.Invoices = resources[invoicesName]
+	client.Profile = resources[profileName]
+	client.Managed = resources[managedName]
+	client.Tags = resources[tagsName]
+	client.Users = resources[usersName]
+	return
+}
+
+func copyBool(bPtr *bool) *bool {
+	if bPtr == nil {
+		return nil
+	}
+	var t = *bPtr
+	return &t
+}
+
+func copyInt(iPtr *int) *int {
+	if iPtr == nil {
+		return nil
+	}
+	var t = *iPtr
+	return &t
+}
+
+func copyString(sPtr *string) *string {
+	if sPtr == nil {
+		return nil
+	}
+	var t = *sPtr
+	return &t
+}
+
+func copyTime(tPtr *time.Time) *time.Time {
+	if tPtr == nil {
+		return nil
+	}
+	var t = *tPtr
+	return &t
+}
--- a/vendor/github.com/linode/linodego/domain_records.go
+++ b/vendor/github.com/linode/linodego/domain_records.go
@ -0,0 +1,195 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// DomainRecord represents a DomainRecord object
+type DomainRecord struct {
+	ID       int              `json:"id"`
+	Type     DomainRecordType `json:"type"`
+	Name     string           `json:"name"`
+	Target   string           `json:"target"`
+	Priority int              `json:"priority"`
+	Weight   int              `json:"weight"`
+	Port     int              `json:"port"`
+	Service  *string          `json:"service"`
+	Protocol *string          `json:"protocol"`
+	TTLSec   int              `json:"ttl_sec"`
+	Tag      *string          `json:"tag"`
+}
+
+// DomainRecordCreateOptions fields are those accepted by CreateDomainRecord
+type DomainRecordCreateOptions struct {
+	Type     DomainRecordType `json:"type"`
+	Name     string           `json:"name"`
+	Target   string           `json:"target"`
+	Priority *int             `json:"priority,omitempty"`
+	Weight   *int             `json:"weight,omitempty"`
+	Port     *int             `json:"port,omitempty"`
+	Service  *string          `json:"service,omitempty"`
+	Protocol *string          `json:"protocol,omitempty"`
+	TTLSec   int              `json:"ttl_sec,omitempty"` // 0 is not accepted by Linode, so can be omitted
+	Tag      *string          `json:"tag,omitempty"`
+}
+
+// DomainRecordUpdateOptions fields are those accepted by UpdateDomainRecord
+type DomainRecordUpdateOptions struct {
+	Type     DomainRecordType `json:"type,omitempty"`
+	Name     string           `json:"name,omitempty"`
+	Target   string           `json:"target,omitempty"`
+	Priority *int             `json:"priority,omitempty"` // 0 is valid, so omit only nil values
+	Weight   *int             `json:"weight,omitempty"`   // 0 is valid, so omit only nil values
+	Port     *int             `json:"port,omitempty"`     // 0 is valid to spec, so omit only nil values
+	Service  *string          `json:"service,omitempty"`
+	Protocol *string          `json:"protocol,omitempty"`
+	TTLSec   int              `json:"ttl_sec,omitempty"` // 0 is not accepted by Linode, so can be omitted
+	Tag      *string          `json:"tag,omitempty"`
+}
+
+// DomainRecordType constants start with RecordType and include Linode API Domain Record Types
+type DomainRecordType string
+
+// DomainRecordType contants are the DNS record types a DomainRecord can assign
+const (
+	RecordTypeA     DomainRecordType = "A"
+	RecordTypeAAAA  DomainRecordType = "AAAA"
+	RecordTypeNS    DomainRecordType = "NS"
+	RecordTypeMX    DomainRecordType = "MX"
+	RecordTypeCNAME DomainRecordType = "CNAME"
+	RecordTypeTXT   DomainRecordType = "TXT"
+	RecordTypeSRV   DomainRecordType = "SRV"
+	RecordTypePTR   DomainRecordType = "PTR"
+	RecordTypeCAA   DomainRecordType = "CAA"
+)
+
+// GetUpdateOptions converts a DomainRecord to DomainRecordUpdateOptions for use in UpdateDomainRecord
+func (d DomainRecord) GetUpdateOptions() (du DomainRecordUpdateOptions) {
+	du.Type = d.Type
+	du.Name = d.Name
+	du.Target = d.Target
+	du.Priority = copyInt(&d.Priority)
+	du.Weight = copyInt(&d.Weight)
+	du.Port = copyInt(&d.Port)
+	du.Service = copyString(d.Service)
+	du.Protocol = copyString(d.Protocol)
+	du.TTLSec = d.TTLSec
+	du.Tag = copyString(d.Tag)
+	return
+}
+
+// DomainRecordsPagedResponse represents a paginated DomainRecord API response
+type DomainRecordsPagedResponse struct {
+	*PageOptions
+	Data []DomainRecord `json:"data"`
+}
+
+// endpoint gets the endpoint URL for InstanceConfig
+func (DomainRecordsPagedResponse) endpointWithID(c *Client, id int) string {
+	endpoint, err := c.DomainRecords.endpointWithID(id)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends DomainRecords when processing paginated DomainRecord responses
+func (resp *DomainRecordsPagedResponse) appendData(r *DomainRecordsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListDomainRecords lists DomainRecords
+func (c *Client) ListDomainRecords(ctx context.Context, domainID int, opts *ListOptions) ([]DomainRecord, error) {
+	response := DomainRecordsPagedResponse{}
+	err := c.listHelperWithID(ctx, &response, domainID, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (d *DomainRecord) fixDates() *DomainRecord {
+	return d
+}
+
+// GetDomainRecord gets the domainrecord with the provided ID
+func (c *Client) GetDomainRecord(ctx context.Context, domainID int, id int) (*DomainRecord, error) {
+	e, err := c.DomainRecords.endpointWithID(domainID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&DomainRecord{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*DomainRecord), nil
+}
+
+// CreateDomainRecord creates a DomainRecord
+func (c *Client) CreateDomainRecord(ctx context.Context, domainID int, domainrecord DomainRecordCreateOptions) (*DomainRecord, error) {
+	var body string
+	e, err := c.DomainRecords.endpointWithID(domainID)
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&DomainRecord{})
+
+	bodyData, err := json.Marshal(domainrecord)
+	if err != nil {
+		return nil, NewError(err)
+	}
+	body = string(bodyData)
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*DomainRecord).fixDates(), nil
+}
+
+// UpdateDomainRecord updates the DomainRecord with the specified id
+func (c *Client) UpdateDomainRecord(ctx context.Context, domainID int, id int, domainrecord DomainRecordUpdateOptions) (*DomainRecord, error) {
+	var body string
+	e, err := c.DomainRecords.endpointWithID(domainID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&DomainRecord{})
+
+	if bodyData, err := json.Marshal(domainrecord); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*DomainRecord).fixDates(), nil
+}
+
+// DeleteDomainRecord deletes the DomainRecord with the specified id
+func (c *Client) DeleteDomainRecord(ctx context.Context, domainID int, id int) error {
+	e, err := c.DomainRecords.endpointWithID(domainID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
--- a/vendor/github.com/linode/linodego/domains.go
+++ b/vendor/github.com/linode/linodego/domains.go
@ -0,0 +1,295 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// Domain represents a Domain object
+type Domain struct {
+	//	This Domain's unique ID
+	ID int `json:"id"`
+
+	// The domain this Domain represents. These must be unique in our system; you cannot have two Domains representing the same domain.
+	Domain string `json:"domain"`
+
+	// If this Domain represents the authoritative source of information for the domain it describes, or if it is a read-only copy of a master (also called a slave).
+	Type DomainType `json:"type"` // Enum:"master" "slave"
+
+	// Deprecated: The group this Domain belongs to. This is for display purposes only.
+	Group string `json:"group"`
+
+	// Used to control whether this Domain is currently being rendered.
+	Status DomainStatus `json:"status"` // Enum:"disabled" "active" "edit_mode" "has_errors"
+
+	// A description for this Domain. This is for display purposes only.
+	Description string `json:"description"`
+
+	// Start of Authority email address. This is required for master Domains.
+	SOAEmail string `json:"soa_email"`
+
+	// The interval, in seconds, at which a failed refresh should be retried.
+	// Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	RetrySec int `json:"retry_sec"`
+
+	// The IP addresses representing the master DNS for this Domain.
+	MasterIPs []string `json:"master_ips"`
+
+	// The list of IPs that may perform a zone transfer for this Domain. This is potentially dangerous, and should be set to an empty list unless you intend to use it.
+	AXfrIPs []string `json:"axfr_ips"`
+
+	// An array of tags applied to this object. Tags are for organizational purposes only.
+	Tags []string `json:"tags"`
+
+	// The amount of time in seconds that may pass before this Domain is no longer authoritative. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	ExpireSec int `json:"expire_sec"`
+
+	// The amount of time in seconds before this Domain should be refreshed. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	RefreshSec int `json:"refresh_sec"`
+
+	// "Time to Live" - the amount of time in seconds that this Domain's records may be cached by resolvers or other domain servers. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	TTLSec int `json:"ttl_sec"`
+}
+
+// DomainCreateOptions fields are those accepted by CreateDomain
+type DomainCreateOptions struct {
+	// The domain this Domain represents. These must be unique in our system; you cannot have two Domains representing the same domain.
+	Domain string `json:"domain"`
+
+	// If this Domain represents the authoritative source of information for the domain it describes, or if it is a read-only copy of a master (also called a slave).
+	// Enum:"master" "slave"
+	Type DomainType `json:"type"`
+
+	// Deprecated: The group this Domain belongs to. This is for display purposes only.
+	Group string `json:"group,omitempty"`
+
+	// Used to control whether this Domain is currently being rendered.
+	// Enum:"disabled" "active" "edit_mode" "has_errors"
+	Status DomainStatus `json:"status,omitempty"`
+
+	// A description for this Domain. This is for display purposes only.
+	Description string `json:"description,omitempty"`
+
+	// Start of Authority email address. This is required for master Domains.
+	SOAEmail string `json:"soa_email,omitempty"`
+
+	// The interval, in seconds, at which a failed refresh should be retried.
+	// Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	RetrySec int `json:"retry_sec,omitempty"`
+
+	// The IP addresses representing the master DNS for this Domain.
+	MasterIPs []string `json:"master_ips,omitempty"`
+
+	// The list of IPs that may perform a zone transfer for this Domain. This is potentially dangerous, and should be set to an empty list unless you intend to use it.
+	AXfrIPs []string `json:"axfr_ips,omitempty"`
+
+	// An array of tags applied to this object. Tags are for organizational purposes only.
+	Tags []string `json:"tags"`
+
+	// The amount of time in seconds that may pass before this Domain is no longer authoritative. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	ExpireSec int `json:"expire_sec,omitempty"`
+
+	// The amount of time in seconds before this Domain should be refreshed. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	RefreshSec int `json:"refresh_sec,omitempty"`
+
+	// "Time to Live" - the amount of time in seconds that this Domain's records may be cached by resolvers or other domain servers. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	TTLSec int `json:"ttl_sec,omitempty"`
+}
+
+// DomainUpdateOptions converts a Domain to DomainUpdateOptions for use in UpdateDomain
+type DomainUpdateOptions struct {
+	// The domain this Domain represents. These must be unique in our system; you cannot have two Domains representing the same domain.
+	Domain string `json:"domain,omitempty"`
+
+	// If this Domain represents the authoritative source of information for the domain it describes, or if it is a read-only copy of a master (also called a slave).
+	// Enum:"master" "slave"
+	Type DomainType `json:"type,omitempty"`
+
+	// Deprecated: The group this Domain belongs to. This is for display purposes only.
+	Group string `json:"group,omitempty"`
+
+	// Used to control whether this Domain is currently being rendered.
+	// Enum:"disabled" "active" "edit_mode" "has_errors"
+	Status DomainStatus `json:"status,omitempty"`
+
+	// A description for this Domain. This is for display purposes only.
+	Description string `json:"description,omitempty"`
+
+	// Start of Authority email address. This is required for master Domains.
+	SOAEmail string `json:"soa_email,omitempty"`
+
+	// The interval, in seconds, at which a failed refresh should be retried.
+	// Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	RetrySec int `json:"retry_sec,omitempty"`
+
+	// The IP addresses representing the master DNS for this Domain.
+	MasterIPs []string `json:"master_ips,omitempty"`
+
+	// The list of IPs that may perform a zone transfer for this Domain. This is potentially dangerous, and should be set to an empty list unless you intend to use it.
+	AXfrIPs []string `json:"axfr_ips,omitempty"`
+
+	// An array of tags applied to this object. Tags are for organizational purposes only.
+	Tags []string `json:"tags"`
+
+	// The amount of time in seconds that may pass before this Domain is no longer authoritative. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	ExpireSec int `json:"expire_sec,omitempty"`
+
+	// The amount of time in seconds before this Domain should be refreshed. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	RefreshSec int `json:"refresh_sec,omitempty"`
+
+	// "Time to Live" - the amount of time in seconds that this Domain's records may be cached by resolvers or other domain servers. Valid values are 300, 3600, 7200, 14400, 28800, 57600, 86400, 172800, 345600, 604800, 1209600, and 2419200 - any other value will be rounded to the nearest valid value.
+	TTLSec int `json:"ttl_sec,omitempty"`
+}
+
+// DomainType constants start with DomainType and include Linode API Domain Type values
+type DomainType string
+
+// DomainType constants reflect the DNS zone type of a Domain
+const (
+	DomainTypeMaster DomainType = "master"
+	DomainTypeSlave  DomainType = "slave"
+)
+
+// DomainStatus constants start with DomainStatus and include Linode API Domain Status values
+type DomainStatus string
+
+// DomainStatus constants reflect the current status of a Domain
+const (
+	DomainStatusDisabled  DomainStatus = "disabled"
+	DomainStatusActive    DomainStatus = "active"
+	DomainStatusEditMode  DomainStatus = "edit_mode"
+	DomainStatusHasErrors DomainStatus = "has_errors"
+)
+
+// GetUpdateOptions converts a Domain to DomainUpdateOptions for use in UpdateDomain
+func (d Domain) GetUpdateOptions() (du DomainUpdateOptions) {
+	du.Domain = d.Domain
+	du.Type = d.Type
+	du.Group = d.Group
+	du.Status = d.Status
+	du.Description = d.Description
+	du.SOAEmail = d.SOAEmail
+	du.RetrySec = d.RetrySec
+	du.MasterIPs = d.MasterIPs
+	du.AXfrIPs = d.AXfrIPs
+	du.Tags = d.Tags
+	du.ExpireSec = d.ExpireSec
+	du.RefreshSec = d.RefreshSec
+	du.TTLSec = d.TTLSec
+	return
+}
+
+// DomainsPagedResponse represents a paginated Domain API response
+type DomainsPagedResponse struct {
+	*PageOptions
+	Data []Domain `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Domain
+func (DomainsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Domains.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Domains when processing paginated Domain responses
+func (resp *DomainsPagedResponse) appendData(r *DomainsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListDomains lists Domains
+func (c *Client) ListDomains(ctx context.Context, opts *ListOptions) ([]Domain, error) {
+	response := DomainsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (d *Domain) fixDates() *Domain {
+	return d
+}
+
+// GetDomain gets the domain with the provided ID
+func (c *Client) GetDomain(ctx context.Context, id int) (*Domain, error) {
+	e, err := c.Domains.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Domain{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Domain).fixDates(), nil
+}
+
+// CreateDomain creates a Domain
+func (c *Client) CreateDomain(ctx context.Context, domain DomainCreateOptions) (*Domain, error) {
+	var body string
+	e, err := c.Domains.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Domain{})
+
+	bodyData, err := json.Marshal(domain)
+	if err != nil {
+		return nil, NewError(err)
+	}
+	body = string(bodyData)
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Domain).fixDates(), nil
+}
+
+// UpdateDomain updates the Domain with the specified id
+func (c *Client) UpdateDomain(ctx context.Context, id int, domain DomainUpdateOptions) (*Domain, error) {
+	var body string
+	e, err := c.Domains.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&Domain{})
+
+	if bodyData, err := json.Marshal(domain); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Domain).fixDates(), nil
+}
+
+// DeleteDomain deletes the Domain with the specified id
+func (c *Client) DeleteDomain(ctx context.Context, id int) error {
+	e, err := c.Domains.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
--- a/vendor/github.com/linode/linodego/env.sample
+++ b/vendor/github.com/linode/linodego/env.sample
@ -0,0 +1,2 @@
+LINODE_TOKEN=
+LINODE_DEBUG=0
--- a/vendor/github.com/linode/linodego/errors.go
+++ b/vendor/github.com/linode/linodego/errors.go
@ -0,0 +1,109 @@
+package linodego
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"strings"
+
+	"gopkg.in/resty.v1"
+)
+
+const (
+	// ErrorFromString is the Code identifying Errors created by string types
+	ErrorFromString = 1
+	// ErrorFromError is the Code identifying Errors created by error types
+	ErrorFromError = 2
+	// ErrorFromStringer is the Code identifying Errors created by fmt.Stringer types
+	ErrorFromStringer = 3
+)
+
+// Error wraps the LinodeGo error with the relevant http.Response
+type Error struct {
+	Response *http.Response
+	Code     int
+	Message  string
+}
+
+// APIErrorReason is an individual invalid request message returned by the Linode API
+type APIErrorReason struct {
+	Reason string `json:"reason"`
+	Field  string `json:"field"`
+}
+
+func (r APIErrorReason) Error() string {
+	if len(r.Field) == 0 {
+		return r.Reason
+	}
+	return fmt.Sprintf("[%s] %s", r.Field, r.Reason)
+}
+
+// APIError is the error-set returned by the Linode API when presented with an invalid request
+type APIError struct {
+	Errors []APIErrorReason `json:"errors"`
+}
+
+func coupleAPIErrors(r *resty.Response, err error) (*resty.Response, error) {
+	if err != nil {
+		return nil, NewError(err)
+	}
+
+	if r.Error() != nil {
+		apiError, ok := r.Error().(*APIError)
+		if !ok || (ok && len(apiError.Errors) == 0) {
+			return r, nil
+		}
+		return nil, NewError(r)
+	}
+
+	return r, nil
+}
+
+func (e APIError) Error() string {
+	var x []string
+	for _, msg := range e.Errors {
+		x = append(x, msg.Error())
+	}
+	return strings.Join(x, "; ")
+}
+
+func (g Error) Error() string {
+	return fmt.Sprintf("[%03d] %s", g.Code, g.Message)
+}
+
+// NewError creates a linodego.Error with a Code identifying the source err type,
+// - ErrorFromString   (1) from a string
+// - ErrorFromError    (2) for an error
+// - ErrorFromStringer (3) for a Stringer
+// - HTTP Status Codes (100-600) for a resty.Response object
+func NewError(err interface{}) *Error {
+	if err == nil {
+		return nil
+	}
+
+	switch e := err.(type) {
+	case *Error:
+		return e
+	case *resty.Response:
+		apiError, ok := e.Error().(*APIError)
+
+		if !ok {
+			log.Fatalln("Unexpected Resty Error Response")
+		}
+
+		return &Error{
+			Code:     e.RawResponse.StatusCode,
+			Message:  apiError.Error(),
+			Response: e.RawResponse,
+		}
+	case error:
+		return &Error{Code: ErrorFromError, Message: e.Error()}
+	case string:
+		return &Error{Code: ErrorFromString, Message: e}
+	case fmt.Stringer:
+		return &Error{Code: ErrorFromStringer, Message: e.String()}
+	default:
+		log.Fatalln("Unsupported type to linodego.NewError")
+		panic(err)
+	}
+}
--- a/vendor/github.com/linode/linodego/images.go
+++ b/vendor/github.com/linode/linodego/images.go
@ -0,0 +1,168 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// Image represents a deployable Image object for use with Linode Instances
+type Image struct {
+	CreatedStr  string `json:"created"`
+	ExpiryStr   string `json:"expiry"`
+	ID          string `json:"id"`
+	CreatedBy   string `json:"created_by"`
+	Label       string `json:"label"`
+	Description string `json:"description"`
+	Type        string `json:"type"`
+	Vendor      string `json:"vendor"`
+	Size        int    `json:"size"`
+	IsPublic    bool   `json:"is_public"`
+	Deprecated  bool   `json:"deprecated"`
+
+	Created *time.Time `json:"-"`
+	Expiry  *time.Time `json:"-"`
+}
+
+// ImageCreateOptions fields are those accepted by CreateImage
+type ImageCreateOptions struct {
+	DiskID      int    `json:"disk_id"`
+	Label       string `json:"label"`
+	Description string `json:"description,omitempty"`
+}
+
+// ImageUpdateOptions fields are those accepted by UpdateImage
+type ImageUpdateOptions struct {
+	Label       string  `json:"label,omitempty"`
+	Description *string `json:"description,omitempty"`
+}
+
+func (i *Image) fixDates() *Image {
+	i.Created, _ = parseDates(i.CreatedStr)
+
+	if len(i.ExpiryStr) > 0 {
+		i.Expiry, _ = parseDates(i.ExpiryStr)
+	} else {
+		i.Expiry = nil
+	}
+	return i
+}
+
+// GetUpdateOptions converts an Image to ImageUpdateOptions for use in UpdateImage
+func (i Image) GetUpdateOptions() (iu ImageUpdateOptions) {
+	iu.Label = i.Label
+	iu.Description = copyString(&i.Description)
+	return
+}
+
+// ImagesPagedResponse represents a linode API response for listing of images
+type ImagesPagedResponse struct {
+	*PageOptions
+	Data []Image `json:"data"`
+}
+
+func (ImagesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Images.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+func (resp *ImagesPagedResponse) appendData(r *ImagesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListImages lists Images
+func (c *Client) ListImages(ctx context.Context, opts *ListOptions) ([]Image, error) {
+	response := ImagesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+
+}
+
+// GetImage gets the Image with the provided ID
+func (c *Client) GetImage(ctx context.Context, id string) (*Image, error) {
+	e, err := c.Images.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := coupleAPIErrors(c.Images.R(ctx).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Image).fixDates(), nil
+}
+
+// CreateImage creates a Image
+func (c *Client) CreateImage(ctx context.Context, createOpts ImageCreateOptions) (*Image, error) {
+	var body string
+	e, err := c.Images.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Image{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Image).fixDates(), nil
+}
+
+// UpdateImage updates the Image with the specified id
+func (c *Client) UpdateImage(ctx context.Context, id string, updateOpts ImageUpdateOptions) (*Image, error) {
+	var body string
+	e, err := c.Images.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+
+	req := c.R(ctx).SetResult(&Image{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Image).fixDates(), nil
+}
+
+// DeleteImage deletes the Image with the specified id
+func (c *Client) DeleteImage(ctx context.Context, id string) error {
+	e, err := c.Images.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
--- a/vendor/github.com/linode/linodego/instance_configs.go
+++ b/vendor/github.com/linode/linodego/instance_configs.go
@ -0,0 +1,246 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// InstanceConfig represents all of the settings that control the boot and run configuration of a Linode Instance
+type InstanceConfig struct {
+	CreatedStr string `json:"created"`
+	UpdatedStr string `json:"updated"`
+
+	ID          int                      `json:"id"`
+	Label       string                   `json:"label"`
+	Comments    string                   `json:"comments"`
+	Devices     *InstanceConfigDeviceMap `json:"devices"`
+	Helpers     *InstanceConfigHelpers   `json:"helpers"`
+	MemoryLimit int                      `json:"memory_limit"`
+	Kernel      string                   `json:"kernel"`
+	InitRD      *int                     `json:"init_rd"`
+	RootDevice  string                   `json:"root_device"`
+	RunLevel    string                   `json:"run_level"`
+	VirtMode    string                   `json:"virt_mode"`
+	Created     *time.Time               `json:"-"`
+	Updated     *time.Time               `json:"-"`
+}
+
+// InstanceConfigDevice contains either the DiskID or VolumeID assigned to a Config Device
+type InstanceConfigDevice struct {
+	DiskID   int `json:"disk_id,omitempty"`
+	VolumeID int `json:"volume_id,omitempty"`
+}
+
+// InstanceConfigDeviceMap contains SDA-SDH InstanceConfigDevice settings
+type InstanceConfigDeviceMap struct {
+	SDA *InstanceConfigDevice `json:"sda,omitempty"`
+	SDB *InstanceConfigDevice `json:"sdb,omitempty"`
+	SDC *InstanceConfigDevice `json:"sdc,omitempty"`
+	SDD *InstanceConfigDevice `json:"sdd,omitempty"`
+	SDE *InstanceConfigDevice `json:"sde,omitempty"`
+	SDF *InstanceConfigDevice `json:"sdf,omitempty"`
+	SDG *InstanceConfigDevice `json:"sdg,omitempty"`
+	SDH *InstanceConfigDevice `json:"sdh,omitempty"`
+}
+
+// InstanceConfigHelpers are Instance Config options that control Linux distribution specific tweaks
+type InstanceConfigHelpers struct {
+	UpdateDBDisabled  bool `json:"updatedb_disabled"`
+	Distro            bool `json:"distro"`
+	ModulesDep        bool `json:"modules_dep"`
+	Network           bool `json:"network"`
+	DevTmpFsAutomount bool `json:"devtmpfs_automount"`
+}
+
+// InstanceConfigsPagedResponse represents a paginated InstanceConfig API response
+type InstanceConfigsPagedResponse struct {
+	*PageOptions
+	Data []InstanceConfig `json:"data"`
+}
+
+// InstanceConfigCreateOptions are InstanceConfig settings that can be used at creation
+type InstanceConfigCreateOptions struct {
+	Label       string                  `json:"label,omitempty"`
+	Comments    string                  `json:"comments,omitempty"`
+	Devices     InstanceConfigDeviceMap `json:"devices"`
+	Helpers     *InstanceConfigHelpers  `json:"helpers,omitempty"`
+	MemoryLimit int                     `json:"memory_limit,omitempty"`
+	Kernel      string                  `json:"kernel,omitempty"`
+	InitRD      int                     `json:"init_rd,omitempty"`
+	RootDevice  *string                 `json:"root_device,omitempty"`
+	RunLevel    string                  `json:"run_level,omitempty"`
+	VirtMode    string                  `json:"virt_mode,omitempty"`
+}
+
+// InstanceConfigUpdateOptions are InstanceConfig settings that can be used in updates
+type InstanceConfigUpdateOptions struct {
+	Label    string                   `json:"label,omitempty"`
+	Comments string                   `json:"comments"`
+	Devices  *InstanceConfigDeviceMap `json:"devices,omitempty"`
+	Helpers  *InstanceConfigHelpers   `json:"helpers,omitempty"`
+	// MemoryLimit 0 means unlimitted, this is not omitted
+	MemoryLimit int    `json:"memory_limit"`
+	Kernel      string `json:"kernel,omitempty"`
+	// InitRD is nullable, permit the sending of null
+	InitRD     *int   `json:"init_rd"`
+	RootDevice string `json:"root_device,omitempty"`
+	RunLevel   string `json:"run_level,omitempty"`
+	VirtMode   string `json:"virt_mode,omitempty"`
+}
+
+// GetCreateOptions converts a InstanceConfig to InstanceConfigCreateOptions for use in CreateInstanceConfig
+func (i InstanceConfig) GetCreateOptions() InstanceConfigCreateOptions {
+	initrd := 0
+	if i.InitRD != nil {
+		initrd = *i.InitRD
+	}
+	return InstanceConfigCreateOptions{
+		Label:       i.Label,
+		Comments:    i.Comments,
+		Devices:     *i.Devices,
+		Helpers:     i.Helpers,
+		MemoryLimit: i.MemoryLimit,
+		Kernel:      i.Kernel,
+		InitRD:      initrd,
+		RootDevice:  copyString(&i.RootDevice),
+		RunLevel:    i.RunLevel,
+		VirtMode:    i.VirtMode,
+	}
+}
+
+// GetUpdateOptions converts a InstanceConfig to InstanceConfigUpdateOptions for use in UpdateInstanceConfig
+func (i InstanceConfig) GetUpdateOptions() InstanceConfigUpdateOptions {
+	return InstanceConfigUpdateOptions{
+		Label:       i.Label,
+		Comments:    i.Comments,
+		Devices:     i.Devices,
+		Helpers:     i.Helpers,
+		MemoryLimit: i.MemoryLimit,
+		Kernel:      i.Kernel,
+		InitRD:      copyInt(i.InitRD),
+		RootDevice:  i.RootDevice,
+		RunLevel:    i.RunLevel,
+		VirtMode:    i.VirtMode,
+	}
+}
+
+// endpointWithID gets the endpoint URL for InstanceConfigs of a given Instance
+func (InstanceConfigsPagedResponse) endpointWithID(c *Client, id int) string {
+	endpoint, err := c.InstanceConfigs.endpointWithID(id)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends InstanceConfigs when processing paginated InstanceConfig responses
+func (resp *InstanceConfigsPagedResponse) appendData(r *InstanceConfigsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListInstanceConfigs lists InstanceConfigs
+func (c *Client) ListInstanceConfigs(ctx context.Context, linodeID int, opts *ListOptions) ([]InstanceConfig, error) {
+	response := InstanceConfigsPagedResponse{}
+	err := c.listHelperWithID(ctx, &response, linodeID, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *InstanceConfig) fixDates() *InstanceConfig {
+	i.Created, _ = parseDates(i.CreatedStr)
+	i.Updated, _ = parseDates(i.UpdatedStr)
+	return i
+}
+
+// GetInstanceConfig gets the template with the provided ID
+func (c *Client) GetInstanceConfig(ctx context.Context, linodeID int, configID int) (*InstanceConfig, error) {
+	e, err := c.InstanceConfigs.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&InstanceConfig{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceConfig).fixDates(), nil
+}
+
+// CreateInstanceConfig creates a new InstanceConfig for the given Instance
+func (c *Client) CreateInstanceConfig(ctx context.Context, linodeID int, createOpts InstanceConfigCreateOptions) (*InstanceConfig, error) {
+	var body string
+	e, err := c.InstanceConfigs.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&InstanceConfig{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, err
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*InstanceConfig).fixDates(), nil
+}
+
+// UpdateInstanceConfig update an InstanceConfig for the given Instance
+func (c *Client) UpdateInstanceConfig(ctx context.Context, linodeID int, configID int, updateOpts InstanceConfigUpdateOptions) (*InstanceConfig, error) {
+	var body string
+	e, err := c.InstanceConfigs.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+	req := c.R(ctx).SetResult(&InstanceConfig{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, err
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*InstanceConfig).fixDates(), nil
+}
+
+// RenameInstanceConfig renames an InstanceConfig
+func (c *Client) RenameInstanceConfig(ctx context.Context, linodeID int, configID int, label string) (*InstanceConfig, error) {
+	return c.UpdateInstanceConfig(ctx, linodeID, configID, InstanceConfigUpdateOptions{Label: label})
+}
+
+// DeleteInstanceConfig deletes a Linode InstanceConfig
+func (c *Client) DeleteInstanceConfig(ctx context.Context, linodeID int, configID int) error {
+	e, err := c.InstanceConfigs.endpointWithID(linodeID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
--- a/vendor/github.com/linode/linodego/instance_disks.go
+++ b/vendor/github.com/linode/linodego/instance_disks.go
@ -0,0 +1,251 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// InstanceDisk represents an Instance Disk object
+type InstanceDisk struct {
+	CreatedStr string `json:"created"`
+	UpdatedStr string `json:"updated"`
+
+	ID         int            `json:"id"`
+	Label      string         `json:"label"`
+	Status     DiskStatus     `json:"status"`
+	Size       int            `json:"size"`
+	Filesystem DiskFilesystem `json:"filesystem"`
+	Created    time.Time      `json:"-"`
+	Updated    time.Time      `json:"-"`
+}
+
+// DiskFilesystem constants start with Filesystem and include Linode API Filesystems
+type DiskFilesystem string
+
+// DiskFilesystem constants represent the filesystems types an Instance Disk may use
+const (
+	FilesystemRaw    DiskFilesystem = "raw"
+	FilesystemSwap   DiskFilesystem = "swap"
+	FilesystemExt3   DiskFilesystem = "ext3"
+	FilesystemExt4   DiskFilesystem = "ext4"
+	FilesystemInitrd DiskFilesystem = "initrd"
+)
+
+// DiskStatus constants have the prefix "Disk" and include Linode API Instance Disk Status
+type DiskStatus string
+
+// DiskStatus constants represent the status values an Instance Disk may have
+const (
+	DiskReady    DiskStatus = "ready"
+	DiskNotReady DiskStatus = "not ready"
+	DiskDeleting DiskStatus = "deleting"
+)
+
+// InstanceDisksPagedResponse represents a paginated InstanceDisk API response
+type InstanceDisksPagedResponse struct {
+	*PageOptions
+	Data []InstanceDisk `json:"data"`
+}
+
+// InstanceDiskCreateOptions are InstanceDisk settings that can be used at creation
+type InstanceDiskCreateOptions struct {
+	Label string `json:"label"`
+	Size  int    `json:"size"`
+
+	// Image is optional, but requires RootPass if provided
+	Image    string `json:"image,omitempty"`
+	RootPass string `json:"root_pass,omitempty"`
+
+	Filesystem      string            `json:"filesystem,omitempty"`
+	AuthorizedKeys  []string          `json:"authorized_keys,omitempty"`
+	AuthorizedUsers []string          `json:"authorized_users,omitempty"`
+	ReadOnly        bool              `json:"read_only,omitempty"`
+	StackscriptID   int               `json:"stackscript_id,omitempty"`
+	StackscriptData map[string]string `json:"stackscript_data,omitempty"`
+}
+
+// InstanceDiskUpdateOptions are InstanceDisk settings that can be used in updates
+type InstanceDiskUpdateOptions struct {
+	Label    string `json:"label"`
+	ReadOnly bool   `json:"read_only"`
+}
+
+// endpointWithID gets the endpoint URL for InstanceDisks of a given Instance
+func (InstanceDisksPagedResponse) endpointWithID(c *Client, id int) string {
+	endpoint, err := c.InstanceDisks.endpointWithID(id)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends InstanceDisks when processing paginated InstanceDisk responses
+func (resp *InstanceDisksPagedResponse) appendData(r *InstanceDisksPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListInstanceDisks lists InstanceDisks
+func (c *Client) ListInstanceDisks(ctx context.Context, linodeID int, opts *ListOptions) ([]InstanceDisk, error) {
+	response := InstanceDisksPagedResponse{}
+	err := c.listHelperWithID(ctx, &response, linodeID, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *InstanceDisk) fixDates() *InstanceDisk {
+	if created, err := parseDates(v.CreatedStr); err == nil {
+		v.Created = *created
+	}
+	if updated, err := parseDates(v.UpdatedStr); err == nil {
+		v.Updated = *updated
+	}
+	return v
+}
+
+// GetInstanceDisk gets the template with the provided ID
+func (c *Client) GetInstanceDisk(ctx context.Context, linodeID int, configID int) (*InstanceDisk, error) {
+	e, err := c.InstanceDisks.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&InstanceDisk{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceDisk).fixDates(), nil
+}
+
+// CreateInstanceDisk creates a new InstanceDisk for the given Instance
+func (c *Client) CreateInstanceDisk(ctx context.Context, linodeID int, createOpts InstanceDiskCreateOptions) (*InstanceDisk, error) {
+	var body string
+	e, err := c.InstanceDisks.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&InstanceDisk{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*InstanceDisk).fixDates(), nil
+}
+
+// UpdateInstanceDisk creates a new InstanceDisk for the given Instance
+func (c *Client) UpdateInstanceDisk(ctx context.Context, linodeID int, diskID int, updateOpts InstanceDiskUpdateOptions) (*InstanceDisk, error) {
+	var body string
+	e, err := c.InstanceDisks.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, diskID)
+
+	req := c.R(ctx).SetResult(&InstanceDisk{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*InstanceDisk).fixDates(), nil
+}
+
+// RenameInstanceDisk renames an InstanceDisk
+func (c *Client) RenameInstanceDisk(ctx context.Context, linodeID int, diskID int, label string) (*InstanceDisk, error) {
+	return c.UpdateInstanceDisk(ctx, linodeID, diskID, InstanceDiskUpdateOptions{Label: label})
+}
+
+// ResizeInstanceDisk resizes the size of the Instance disk
+func (c *Client) ResizeInstanceDisk(ctx context.Context, linodeID int, diskID int, size int) error {
+	var body string
+	e, err := c.InstanceDisks.endpointWithID(linodeID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d/resize", e, diskID)
+
+	req := c.R(ctx).SetResult(&InstanceDisk{})
+	updateOpts := map[string]interface{}{
+		"size": size,
+	}
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return NewError(err)
+	}
+
+	_, err = coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	return err
+}
+
+// PasswordResetInstanceDisk resets the "root" account password on the Instance disk
+func (c *Client) PasswordResetInstanceDisk(ctx context.Context, linodeID int, diskID int, password string) error {
+	var body string
+	e, err := c.InstanceDisks.endpointWithID(linodeID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d/password", e, diskID)
+
+	req := c.R(ctx).SetResult(&InstanceDisk{})
+	updateOpts := map[string]interface{}{
+		"password": password,
+	}
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return NewError(err)
+	}
+
+	_, err = coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	return err
+}
+
+// DeleteInstanceDisk deletes a Linode Instance Disk
+func (c *Client) DeleteInstanceDisk(ctx context.Context, linodeID int, diskID int) error {
+	e, err := c.InstanceDisks.endpointWithID(linodeID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, diskID)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
--- a/vendor/github.com/linode/linodego/instance_ips.go
+++ b/vendor/github.com/linode/linodego/instance_ips.go
@ -0,0 +1,106 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// InstanceIPAddressResponse contains the IPv4 and IPv6 details for an Instance
+type InstanceIPAddressResponse struct {
+	IPv4 *InstanceIPv4Response `json:"ipv4"`
+	IPv6 *InstanceIPv6Response `json:"ipv6"`
+}
+
+// InstanceIPv4Response contains the details of all IPv4 addresses associated with an Instance
+type InstanceIPv4Response struct {
+	Public  []*InstanceIP `json:"public"`
+	Private []*InstanceIP `json:"private"`
+	Shared  []*InstanceIP `json:"shared"`
+}
+
+// InstanceIP represents an Instance IP with additional DNS and networking details
+type InstanceIP struct {
+	Address    string `json:"address"`
+	Gateway    string `json:"gateway"`
+	SubnetMask string `json:"subnet_mask"`
+	Prefix     int    `json:"prefix"`
+	Type       string `json:"type"`
+	Public     bool   `json:"public"`
+	RDNS       string `json:"rdns"`
+	LinodeID   int    `json:"linode_id"`
+	Region     string `json:"region"`
+}
+
+// InstanceIPv6Response contains the IPv6 addresses and ranges for an Instance
+type InstanceIPv6Response struct {
+	LinkLocal *InstanceIP  `json:"link_local"`
+	SLAAC     *InstanceIP  `json:"slaac"`
+	Global    []*IPv6Range `json:"global"`
+}
+
+// IPv6Range represents a range of IPv6 addresses routed to a single Linode in a given Region
+type IPv6Range struct {
+	Range  string `json:"range"`
+	Region string `json:"region"`
+}
+
+// GetInstanceIPAddresses gets the IPAddresses for a Linode instance
+func (c *Client) GetInstanceIPAddresses(ctx context.Context, linodeID int) (*InstanceIPAddressResponse, error) {
+	e, err := c.InstanceIPs.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&InstanceIPAddressResponse{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceIPAddressResponse), nil
+}
+
+// GetInstanceIPAddress gets the IPAddress for a Linode instance matching a supplied IP address
+func (c *Client) GetInstanceIPAddress(ctx context.Context, linodeID int, ipaddress string) (*InstanceIP, error) {
+	e, err := c.InstanceIPs.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, ipaddress)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&InstanceIP{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceIP), nil
+}
+
+// AddInstanceIPAddress adds a public or private IP to a Linode instance
+func (c *Client) AddInstanceIPAddress(ctx context.Context, linodeID int, public bool) (*InstanceIP, error) {
+	var body string
+	e, err := c.InstanceIPs.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&InstanceIP{})
+
+	instanceipRequest := struct {
+		Type   string `json:"type"`
+		Public bool   `json:"public"`
+	}{"ipv4", public}
+
+	if bodyData, err := json.Marshal(instanceipRequest); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetHeader("Content-Type", "application/json").
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*InstanceIP), nil
+}
--- a/vendor/github.com/linode/linodego/instance_snapshots.go
+++ b/vendor/github.com/linode/linodego/instance_snapshots.go
@ -0,0 +1,188 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// InstanceBackupsResponse response struct for backup snapshot
+type InstanceBackupsResponse struct {
+	Automatic []*InstanceSnapshot             `json:"automatic"`
+	Snapshot  *InstanceBackupSnapshotResponse `json:"snapshot"`
+}
+
+// InstanceBackupSnapshotResponse fields are those representing Instance Backup Snapshots
+type InstanceBackupSnapshotResponse struct {
+	Current    *InstanceSnapshot `json:"current"`
+	InProgress *InstanceSnapshot `json:"in_progress"`
+}
+
+// RestoreInstanceOptions fields are those accepted by InstanceRestore
+type RestoreInstanceOptions struct {
+	LinodeID  int  `json:"linode_id"`
+	Overwrite bool `json:"overwrite"`
+}
+
+// InstanceSnapshot represents a linode backup snapshot
+type InstanceSnapshot struct {
+	CreatedStr  string `json:"created"`
+	UpdatedStr  string `json:"updated"`
+	FinishedStr string `json:"finished"`
+
+	ID       int                     `json:"id"`
+	Label    string                  `json:"label"`
+	Status   InstanceSnapshotStatus  `json:"status"`
+	Type     string                  `json:"type"`
+	Created  *time.Time              `json:"-"`
+	Updated  *time.Time              `json:"-"`
+	Finished *time.Time              `json:"-"`
+	Configs  []string                `json:"configs"`
+	Disks    []*InstanceSnapshotDisk `json:"disks"`
+}
+
+// InstanceSnapshotDisk fields represent the source disk of a Snapshot
+type InstanceSnapshotDisk struct {
+	Label      string `json:"label"`
+	Size       int    `json:"size"`
+	Filesystem string `json:"filesystem"`
+}
+
+// InstanceSnapshotStatus constants start with Snapshot and include Linode API Instance Backup Snapshot status values
+type InstanceSnapshotStatus string
+
+// InstanceSnapshotStatus constants reflect the current status of an Instance Snapshot
+var (
+	SnapshotPaused              InstanceSnapshotStatus = "paused"
+	SnapshotPending             InstanceSnapshotStatus = "pending"
+	SnapshotRunning             InstanceSnapshotStatus = "running"
+	SnapshotNeedsPostProcessing InstanceSnapshotStatus = "needsPostProcessing"
+	SnapshotSuccessful          InstanceSnapshotStatus = "successful"
+	SnapshotFailed              InstanceSnapshotStatus = "failed"
+	SnapshotUserAborted         InstanceSnapshotStatus = "userAborted"
+)
+
+func (l *InstanceSnapshot) fixDates() *InstanceSnapshot {
+	l.Created, _ = parseDates(l.CreatedStr)
+	l.Updated, _ = parseDates(l.UpdatedStr)
+	l.Finished, _ = parseDates(l.FinishedStr)
+	return l
+}
+
+// GetInstanceSnapshot gets the snapshot with the provided ID
+func (c *Client) GetInstanceSnapshot(ctx context.Context, linodeID int, snapshotID int) (*InstanceSnapshot, error) {
+	e, err := c.InstanceSnapshots.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, snapshotID)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&InstanceSnapshot{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceSnapshot).fixDates(), nil
+}
+
+// CreateInstanceSnapshot Creates or Replaces the snapshot Backup of a Linode. If a previous snapshot exists for this Linode, it will be deleted.
+func (c *Client) CreateInstanceSnapshot(ctx context.Context, linodeID int, label string) (*InstanceSnapshot, error) {
+	o, err := json.Marshal(map[string]string{"label": label})
+	if err != nil {
+		return nil, err
+	}
+	body := string(o)
+	e, err := c.InstanceSnapshots.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetBody(body).
+		SetResult(&InstanceSnapshot{}).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*InstanceSnapshot).fixDates(), nil
+}
+
+// GetInstanceBackups gets the Instance's available Backups.
+// This is not called ListInstanceBackups because a single object is returned, matching the API response.
+func (c *Client) GetInstanceBackups(ctx context.Context, linodeID int) (*InstanceBackupsResponse, error) {
+	e, err := c.InstanceSnapshots.endpointWithID(linodeID)
+	if err != nil {
+		return nil, err
+	}
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&InstanceBackupsResponse{}).
+		Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceBackupsResponse).fixDates(), nil
+}
+
+// EnableInstanceBackups Enables backups for the specified Linode.
+func (c *Client) EnableInstanceBackups(ctx context.Context, linodeID int) error {
+	e, err := c.InstanceSnapshots.endpointWithID(linodeID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/enable", e)
+
+	_, err = coupleAPIErrors(c.R(ctx).Post(e))
+	return err
+}
+
+// CancelInstanceBackups Cancels backups for the specified Linode.
+func (c *Client) CancelInstanceBackups(ctx context.Context, linodeID int) error {
+	e, err := c.InstanceSnapshots.endpointWithID(linodeID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/cancel", e)
+
+	_, err = coupleAPIErrors(c.R(ctx).Post(e))
+	return err
+}
+
+// RestoreInstanceBackup Restores a Linode's Backup to the specified Linode.
+func (c *Client) RestoreInstanceBackup(ctx context.Context, linodeID int, backupID int, opts RestoreInstanceOptions) error {
+	o, err := json.Marshal(opts)
+	if err != nil {
+		return NewError(err)
+	}
+	body := string(o)
+	e, err := c.InstanceSnapshots.endpointWithID(linodeID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d/restore", e, backupID)
+
+	_, err = coupleAPIErrors(c.R(ctx).SetBody(body).Post(e))
+
+	return err
+
+}
+
+func (l *InstanceBackupSnapshotResponse) fixDates() *InstanceBackupSnapshotResponse {
+	if l.Current != nil {
+		l.Current.fixDates()
+	}
+	if l.InProgress != nil {
+		l.InProgress.fixDates()
+	}
+	return l
+}
+
+func (l *InstanceBackupsResponse) fixDates() *InstanceBackupsResponse {
+	for i := range l.Automatic {
+		l.Automatic[i].fixDates()
+	}
+	if l.Snapshot != nil {
+		l.Snapshot.fixDates()
+	}
+	return l
+}
--- a/vendor/github.com/linode/linodego/instance_volumes.go
+++ b/vendor/github.com/linode/linodego/instance_volumes.go
@ -0,0 +1,38 @@
+package linodego
+
+import (
+	"context"
+)
+
+// InstanceVolumesPagedResponse represents a paginated InstanceVolume API response
+type InstanceVolumesPagedResponse struct {
+	*PageOptions
+	Data []Volume `json:"data"`
+}
+
+// endpoint gets the endpoint URL for InstanceVolume
+func (InstanceVolumesPagedResponse) endpointWithID(c *Client, id int) string {
+	endpoint, err := c.InstanceVolumes.endpointWithID(id)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends InstanceVolumes when processing paginated InstanceVolume responses
+func (resp *InstanceVolumesPagedResponse) appendData(r *InstanceVolumesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListInstanceVolumes lists InstanceVolumes
+func (c *Client) ListInstanceVolumes(ctx context.Context, linodeID int, opts *ListOptions) ([]Volume, error) {
+	response := InstanceVolumesPagedResponse{}
+	err := c.listHelperWithID(ctx, &response, linodeID, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
--- a/vendor/github.com/linode/linodego/instances.go
+++ b/vendor/github.com/linode/linodego/instances.go
@ -0,0 +1,454 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net"
+	"time"
+)
+
+/*
+ * https://developers.linode.com/v4/reference/endpoints/linode/instances
+ */
+
+// InstanceStatus constants start with Instance and include Linode API Instance Status values
+type InstanceStatus string
+
+// InstanceStatus constants reflect the current status of an Instance
+const (
+	InstanceBooting      InstanceStatus = "booting"
+	InstanceRunning      InstanceStatus = "running"
+	InstanceOffline      InstanceStatus = "offline"
+	InstanceShuttingDown InstanceStatus = "shutting_down"
+	InstanceRebooting    InstanceStatus = "rebooting"
+	InstanceProvisioning InstanceStatus = "provisioning"
+	InstanceDeleting     InstanceStatus = "deleting"
+	InstanceMigrating    InstanceStatus = "migrating"
+	InstanceRebuilding   InstanceStatus = "rebuilding"
+	InstanceCloning      InstanceStatus = "cloning"
+	InstanceRestoring    InstanceStatus = "restoring"
+	InstanceResizing     InstanceStatus = "resizing"
+)
+
+// Instance represents a linode object
+type Instance struct {
+	CreatedStr string `json:"created"`
+	UpdatedStr string `json:"updated"`
+
+	ID              int             `json:"id"`
+	Created         *time.Time      `json:"-"`
+	Updated         *time.Time      `json:"-"`
+	Region          string          `json:"region"`
+	Alerts          *InstanceAlert  `json:"alerts"`
+	Backups         *InstanceBackup `json:"backups"`
+	Image           string          `json:"image"`
+	Group           string          `json:"group"`
+	IPv4            []*net.IP       `json:"ipv4"`
+	IPv6            string          `json:"ipv6"`
+	Label           string          `json:"label"`
+	Type            string          `json:"type"`
+	Status          InstanceStatus  `json:"status"`
+	Hypervisor      string          `json:"hypervisor"`
+	Specs           *InstanceSpec   `json:"specs"`
+	WatchdogEnabled bool            `json:"watchdog_enabled"`
+	Tags            []string        `json:"tags"`
+}
+
+// InstanceSpec represents a linode spec
+type InstanceSpec struct {
+	Disk     int `json:"disk"`
+	Memory   int `json:"memory"`
+	VCPUs    int `json:"vcpus"`
+	Transfer int `json:"transfer"`
+}
+
+// InstanceAlert represents a metric alert
+type InstanceAlert struct {
+	CPU           int `json:"cpu"`
+	IO            int `json:"io"`
+	NetworkIn     int `json:"network_in"`
+	NetworkOut    int `json:"network_out"`
+	TransferQuota int `json:"transfer_quota"`
+}
+
+// InstanceBackup represents backup settings for an instance
+type InstanceBackup struct {
+	Enabled  bool `json:"enabled"`
+	Schedule struct {
+		Day    string `json:"day,omitempty"`
+		Window string `json:"window,omitempty"`
+	}
+}
+
+// InstanceCreateOptions require only Region and Type
+type InstanceCreateOptions struct {
+	Region          string            `json:"region"`
+	Type            string            `json:"type"`
+	Label           string            `json:"label,omitempty"`
+	Group           string            `json:"group,omitempty"`
+	RootPass        string            `json:"root_pass,omitempty"`
+	AuthorizedKeys  []string          `json:"authorized_keys,omitempty"`
+	AuthorizedUsers []string          `json:"authorized_users,omitempty"`
+	StackScriptID   int               `json:"stackscript_id,omitempty"`
+	StackScriptData map[string]string `json:"stackscript_data,omitempty"`
+	BackupID        int               `json:"backup_id,omitempty"`
+	Image           string            `json:"image,omitempty"`
+	BackupsEnabled  bool              `json:"backups_enabled,omitempty"`
+	PrivateIP       bool              `json:"private_ip,omitempty"`
+	Tags            []string          `json:"tags,omitempty"`
+
+	// Creation fields that need to be set explicitly false, "", or 0 use pointers
+	SwapSize *int  `json:"swap_size,omitempty"`
+	Booted   *bool `json:"booted,omitempty"`
+}
+
+// InstanceUpdateOptions is an options struct used when Updating an Instance
+type InstanceUpdateOptions struct {
+	Label           string          `json:"label,omitempty"`
+	Group           string          `json:"group,omitempty"`
+	Backups         *InstanceBackup `json:"backups,omitempty"`
+	Alerts          *InstanceAlert  `json:"alerts,omitempty"`
+	WatchdogEnabled *bool           `json:"watchdog_enabled,omitempty"`
+	Tags            *[]string       `json:"tags,omitempty"`
+}
+
+// GetUpdateOptions converts an Instance to InstanceUpdateOptions for use in UpdateInstance
+func (l *Instance) GetUpdateOptions() InstanceUpdateOptions {
+	return InstanceUpdateOptions{
+		Label:           l.Label,
+		Group:           l.Group,
+		Backups:         l.Backups,
+		Alerts:          l.Alerts,
+		WatchdogEnabled: &l.WatchdogEnabled,
+		Tags:            &l.Tags,
+	}
+}
+
+// InstanceCloneOptions is an options struct sent when Cloning an Instance
+type InstanceCloneOptions struct {
+	Region string `json:"region,omitempty"`
+	Type   string `json:"type,omitempty"`
+
+	// LinodeID is an optional existing instance to use as the target of the clone
+	LinodeID       int    `json:"linode_id,omitempty"`
+	Label          string `json:"label,omitempty"`
+	Group          string `json:"group,omitempty"`
+	BackupsEnabled bool   `json:"backups_enabled"`
+	Disks          []int  `json:"disks,omitempty"`
+	Configs        []int  `json:"configs,omitempty"`
+}
+
+func (l *Instance) fixDates() *Instance {
+	l.Created, _ = parseDates(l.CreatedStr)
+	l.Updated, _ = parseDates(l.UpdatedStr)
+	return l
+}
+
+// InstancesPagedResponse represents a linode API response for listing
+type InstancesPagedResponse struct {
+	*PageOptions
+	Data []Instance `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Instance
+func (InstancesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Instances.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Instances when processing paginated Instance responses
+func (resp *InstancesPagedResponse) appendData(r *InstancesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListInstances lists linode instances
+func (c *Client) ListInstances(ctx context.Context, opts *ListOptions) ([]Instance, error) {
+	response := InstancesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetInstance gets the instance with the provided ID
+func (c *Client) GetInstance(ctx context.Context, linodeID int) (*Instance, error) {
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, linodeID)
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetResult(Instance{}).
+		Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Instance).fixDates(), nil
+}
+
+// CreateInstance creates a Linode instance
+func (c *Client) CreateInstance(ctx context.Context, instance InstanceCreateOptions) (*Instance, error) {
+	var body string
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Instance{})
+
+	if bodyData, err := json.Marshal(instance); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Instance).fixDates(), nil
+}
+
+// UpdateInstance creates a Linode instance
+func (c *Client) UpdateInstance(ctx context.Context, id int, instance InstanceUpdateOptions) (*Instance, error) {
+	var body string
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&Instance{})
+
+	if bodyData, err := json.Marshal(instance); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Instance).fixDates(), nil
+}
+
+// RenameInstance renames an Instance
+func (c *Client) RenameInstance(ctx context.Context, linodeID int, label string) (*Instance, error) {
+	return c.UpdateInstance(ctx, linodeID, InstanceUpdateOptions{Label: label})
+}
+
+// DeleteInstance deletes a Linode instance
+func (c *Client) DeleteInstance(ctx context.Context, id int) error {
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
+
+// BootInstance will boot a Linode instance
+// A configID of 0 will cause Linode to choose the last/best config
+func (c *Client) BootInstance(ctx context.Context, id int, configID int) error {
+	bodyStr := ""
+
+	if configID != 0 {
+		bodyMap := map[string]int{"config_id": configID}
+		bodyJSON, err := json.Marshal(bodyMap)
+		if err != nil {
+			return NewError(err)
+		}
+		bodyStr = string(bodyJSON)
+	}
+
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return err
+	}
+
+	e = fmt.Sprintf("%s/%d/boot", e, id)
+	_, err = coupleAPIErrors(c.R(ctx).
+		SetBody(bodyStr).
+		Post(e))
+
+	return err
+}
+
+// CloneInstance clone an existing Instances Disks and Configuration profiles to another Linode Instance
+func (c *Client) CloneInstance(ctx context.Context, id int, options InstanceCloneOptions) (*Instance, error) {
+	var body string
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d/clone", e, id)
+
+	req := c.R(ctx).SetResult(&Instance{})
+
+	if bodyData, err := json.Marshal(options); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return r.Result().(*Instance).fixDates(), nil
+}
+
+// RebootInstance reboots a Linode instance
+// A configID of 0 will cause Linode to choose the last/best config
+func (c *Client) RebootInstance(ctx context.Context, id int, configID int) error {
+	bodyStr := "{}"
+
+	if configID != 0 {
+		bodyMap := map[string]int{"config_id": configID}
+		bodyJSON, err := json.Marshal(bodyMap)
+		if err != nil {
+			return NewError(err)
+		}
+		bodyStr = string(bodyJSON)
+	}
+
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return err
+	}
+
+	e = fmt.Sprintf("%s/%d/reboot", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).
+		SetBody(bodyStr).
+		Post(e))
+
+	return err
+}
+
+// RebuildInstanceOptions is a struct representing the options to send to the rebuild linode endpoint
+type RebuildInstanceOptions struct {
+	Image           string            `json:"image"`
+	RootPass        string            `json:"root_pass"`
+	AuthorizedKeys  []string          `json:"authorized_keys"`
+	AuthorizedUsers []string          `json:"authorized_users"`
+	StackscriptID   int               `json:"stackscript_id"`
+	StackscriptData map[string]string `json:"stackscript_data"`
+	Booted          bool              `json:"booted"`
+}
+
+// RebuildInstance Deletes all Disks and Configs on this Linode,
+// then deploys a new Image to this Linode with the given attributes.
+func (c *Client) RebuildInstance(ctx context.Context, id int, opts RebuildInstanceOptions) (*Instance, error) {
+	o, err := json.Marshal(opts)
+	if err != nil {
+		return nil, NewError(err)
+	}
+	b := string(o)
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d/rebuild", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetBody(b).
+		SetResult(&Instance{}).
+		Post(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Instance).fixDates(), nil
+}
+
+// RescueInstanceOptions fields are those accepted by RescueInstance
+type RescueInstanceOptions struct {
+	Devices InstanceConfigDeviceMap `json:"devices"`
+}
+
+// RescueInstance reboots an instance into a safe environment for performing many system recovery and disk management tasks.
+// Rescue Mode is based on the Finnix recovery distribution, a self-contained and bootable Linux distribution.
+// You can also use Rescue Mode for tasks other than disaster recovery, such as formatting disks to use different filesystems,
+// copying data between disks, and downloading files from a disk via SSH and SFTP.
+func (c *Client) RescueInstance(ctx context.Context, id int, opts RescueInstanceOptions) error {
+	o, err := json.Marshal(opts)
+	if err != nil {
+		return NewError(err)
+	}
+	b := string(o)
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d/rescue", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).
+		SetBody(b).
+		Post(e))
+
+	return err
+}
+
+// ResizeInstance resizes an instance to new Linode type
+func (c *Client) ResizeInstance(ctx context.Context, id int, linodeType string) error {
+	body := fmt.Sprintf("{\"type\":\"%s\"}", linodeType)
+
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d/resize", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).
+		SetBody(body).
+		Post(e))
+
+	return err
+}
+
+// ShutdownInstance - Shutdown an instance
+func (c *Client) ShutdownInstance(ctx context.Context, id int) error {
+	return c.simpleInstanceAction(ctx, "shutdown", id)
+}
+
+// MutateInstance Upgrades a Linode to its next generation.
+func (c *Client) MutateInstance(ctx context.Context, id int) error {
+	return c.simpleInstanceAction(ctx, "mutate", id)
+}
+
+// MigrateInstance - Migrate an instance
+func (c *Client) MigrateInstance(ctx context.Context, id int) error {
+	return c.simpleInstanceAction(ctx, "migrate", id)
+}
+
+// simpleInstanceAction is a helper for Instance actions that take no parameters
+// and return empty responses `{}` unless they return a standard error
+func (c *Client) simpleInstanceAction(ctx context.Context, action string, id int) error {
+	e, err := c.Instances.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d/%s", e, id, action)
+	_, err = coupleAPIErrors(c.R(ctx).Post(e))
+	return err
+}
--- a/vendor/github.com/linode/linodego/kernels.go
+++ b/vendor/github.com/linode/linodego/kernels.go
@ -0,0 +1,61 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// LinodeKernel represents a Linode Instance kernel object
+type LinodeKernel struct {
+	ID           string `json:"id"`
+	Label        string `json:"label"`
+	Version      string `json:"version"`
+	Architecture string `json:"architecture"`
+	KVM          bool   `json:"kvm"`
+	XEN          bool   `json:"xen"`
+	PVOPS        bool   `json:"pvops"`
+}
+
+// LinodeKernelsPagedResponse represents a Linode kernels API response for listing
+type LinodeKernelsPagedResponse struct {
+	*PageOptions
+	Data []LinodeKernel `json:"data"`
+}
+
+// ListKernels lists linode kernels
+func (c *Client) ListKernels(ctx context.Context, opts *ListOptions) ([]LinodeKernel, error) {
+	response := LinodeKernelsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+func (LinodeKernelsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Kernels.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+func (resp *LinodeKernelsPagedResponse) appendData(r *LinodeKernelsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// GetKernel gets the kernel with the provided ID
+func (c *Client) GetKernel(ctx context.Context, kernelID string) (*LinodeKernel, error) {
+	e, err := c.Kernels.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, kernelID)
+	r, err := c.R(ctx).
+		SetResult(&LinodeKernel{}).
+		Get(e)
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*LinodeKernel), nil
+}
--- a/vendor/github.com/linode/linodego/longview.go
+++ b/vendor/github.com/linode/linodego/longview.go
@ -0,0 +1,67 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// LongviewClient represents a LongviewClient object
+type LongviewClient struct {
+	ID int `json:"id"`
+	// UpdatedStr string `json:"updated"`
+	// Updated *time.Time `json:"-"`
+}
+
+// LongviewClientsPagedResponse represents a paginated LongviewClient API response
+type LongviewClientsPagedResponse struct {
+	*PageOptions
+	Data []LongviewClient `json:"data"`
+}
+
+// endpoint gets the endpoint URL for LongviewClient
+func (LongviewClientsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.LongviewClients.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends LongviewClients when processing paginated LongviewClient responses
+func (resp *LongviewClientsPagedResponse) appendData(r *LongviewClientsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListLongviewClients lists LongviewClients
+func (c *Client) ListLongviewClients(ctx context.Context, opts *ListOptions) ([]LongviewClient, error) {
+	response := LongviewClientsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *LongviewClient) fixDates() *LongviewClient {
+	// v.Created, _ = parseDates(v.CreatedStr)
+	// v.Updated, _ = parseDates(v.UpdatedStr)
+	return v
+}
+
+// GetLongviewClient gets the template with the provided ID
+func (c *Client) GetLongviewClient(ctx context.Context, id string) (*LongviewClient, error) {
+	e, err := c.LongviewClients.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := c.R(ctx).SetResult(&LongviewClient{}).Get(e)
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*LongviewClient).fixDates(), nil
+}
--- a/vendor/github.com/linode/linodego/longview_subscriptions.go
+++ b/vendor/github.com/linode/linodego/longview_subscriptions.go
@ -0,0 +1,70 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// LongviewSubscription represents a LongviewSubscription object
+type LongviewSubscription struct {
+	ID              string       `json:"id"`
+	Label           string       `json:"label"`
+	ClientsIncluded int          `json:"clients_included"`
+	Price           *LinodePrice `json:"price"`
+	// UpdatedStr string `json:"updated"`
+	// Updated *time.Time `json:"-"`
+}
+
+// LongviewSubscriptionsPagedResponse represents a paginated LongviewSubscription API response
+type LongviewSubscriptionsPagedResponse struct {
+	*PageOptions
+	Data []LongviewSubscription `json:"data"`
+}
+
+// endpoint gets the endpoint URL for LongviewSubscription
+func (LongviewSubscriptionsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.LongviewSubscriptions.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends LongviewSubscriptions when processing paginated LongviewSubscription responses
+func (resp *LongviewSubscriptionsPagedResponse) appendData(r *LongviewSubscriptionsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListLongviewSubscriptions lists LongviewSubscriptions
+func (c *Client) ListLongviewSubscriptions(ctx context.Context, opts *ListOptions) ([]LongviewSubscription, error) {
+	response := LongviewSubscriptionsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *LongviewSubscription) fixDates() *LongviewSubscription {
+	// v.Created, _ = parseDates(v.CreatedStr)
+	// v.Updated, _ = parseDates(v.UpdatedStr)
+	return v
+}
+
+// GetLongviewSubscription gets the template with the provided ID
+func (c *Client) GetLongviewSubscription(ctx context.Context, id string) (*LongviewSubscription, error) {
+	e, err := c.LongviewSubscriptions.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := c.R(ctx).SetResult(&LongviewSubscription{}).Get(e)
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*LongviewSubscription).fixDates(), nil
+}
--- a/vendor/github.com/linode/linodego/managed.go
+++ b/vendor/github.com/linode/linodego/managed.go
@ -0,0 +1 @@
+package linodego
--- a/vendor/github.com/linode/linodego/network_ips.go
+++ b/vendor/github.com/linode/linodego/network_ips.go
@ -0,0 +1,90 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// IPAddressesPagedResponse represents a paginated IPAddress API response
+type IPAddressesPagedResponse struct {
+	*PageOptions
+	Data []InstanceIP `json:"data"`
+}
+
+// IPAddressUpdateOptions fields are those accepted by UpdateToken
+type IPAddressUpdateOptions struct {
+	// The reverse DNS assigned to this address. For public IPv4 addresses, this will be set to a default value provided by Linode if set to nil.
+	RDNS *string `json:"rdns"`
+}
+
+// GetUpdateOptions converts a IPAddress to IPAddressUpdateOptions for use in UpdateIPAddress
+func (i InstanceIP) GetUpdateOptions() (o IPAddressUpdateOptions) {
+	o.RDNS = copyString(&i.RDNS)
+	return
+}
+
+// endpoint gets the endpoint URL for IPAddress
+func (IPAddressesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.IPAddresses.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends IPAddresses when processing paginated InstanceIPAddress responses
+func (resp *IPAddressesPagedResponse) appendData(r *IPAddressesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListIPAddresses lists IPAddresses
+func (c *Client) ListIPAddresses(ctx context.Context, opts *ListOptions) ([]InstanceIP, error) {
+	response := IPAddressesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetIPAddress gets the template with the provided ID
+func (c *Client) GetIPAddress(ctx context.Context, id string) (*InstanceIP, error) {
+	e, err := c.IPAddresses.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&InstanceIP{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceIP), nil
+}
+
+// UpdateIPAddress updates the IPAddress with the specified id
+func (c *Client) UpdateIPAddress(ctx context.Context, id string, updateOpts IPAddressUpdateOptions) (*InstanceIP, error) {
+	var body string
+	e, err := c.IPAddresses.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+
+	req := c.R(ctx).SetResult(&InstanceIP{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*InstanceIP), nil
+}
--- a/vendor/github.com/linode/linodego/network_pools.go
+++ b/vendor/github.com/linode/linodego/network_pools.go
@ -0,0 +1,50 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// IPv6PoolsPagedResponse represents a paginated IPv6Pool API response
+type IPv6PoolsPagedResponse struct {
+	*PageOptions
+	Data []IPv6Range `json:"data"`
+}
+
+// endpoint gets the endpoint URL for IPv6Pool
+func (IPv6PoolsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.IPv6Pools.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends IPv6Pools when processing paginated IPv6Pool responses
+func (resp *IPv6PoolsPagedResponse) appendData(r *IPv6PoolsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListIPv6Pools lists IPv6Pools
+func (c *Client) ListIPv6Pools(ctx context.Context, opts *ListOptions) ([]IPv6Range, error) {
+	response := IPv6PoolsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetIPv6Pool gets the template with the provided ID
+func (c *Client) GetIPv6Pool(ctx context.Context, id string) (*IPv6Range, error) {
+	e, err := c.IPv6Pools.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&IPv6Range{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*IPv6Range), nil
+}
--- a/vendor/github.com/linode/linodego/network_ranges.go
+++ b/vendor/github.com/linode/linodego/network_ranges.go
@ -0,0 +1,50 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// IPv6RangesPagedResponse represents a paginated IPv6Range API response
+type IPv6RangesPagedResponse struct {
+	*PageOptions
+	Data []IPv6Range `json:"data"`
+}
+
+// endpoint gets the endpoint URL for IPv6Range
+func (IPv6RangesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.IPv6Ranges.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends IPv6Ranges when processing paginated IPv6Range responses
+func (resp *IPv6RangesPagedResponse) appendData(r *IPv6RangesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListIPv6Ranges lists IPv6Ranges
+func (c *Client) ListIPv6Ranges(ctx context.Context, opts *ListOptions) ([]IPv6Range, error) {
+	response := IPv6RangesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetIPv6Range gets the template with the provided ID
+func (c *Client) GetIPv6Range(ctx context.Context, id string) (*IPv6Range, error) {
+	e, err := c.IPv6Ranges.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&IPv6Range{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*IPv6Range), nil
+}
--- a/vendor/github.com/linode/linodego/nodebalancer.go
+++ b/vendor/github.com/linode/linodego/nodebalancer.go
@ -0,0 +1,199 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// NodeBalancer represents a NodeBalancer object
+type NodeBalancer struct {
+	CreatedStr string `json:"created"`
+	UpdatedStr string `json:"updated"`
+	// This NodeBalancer's unique ID.
+	ID int `json:"id"`
+	// This NodeBalancer's label. These must be unique on your Account.
+	Label *string `json:"label"`
+	// The Region where this NodeBalancer is located. NodeBalancers only support backends in the same Region.
+	Region string `json:"region"`
+	// This NodeBalancer's hostname, ending with .nodebalancer.linode.com
+	Hostname *string `json:"hostname"`
+	// This NodeBalancer's public IPv4 address.
+	IPv4 *string `json:"ipv4"`
+	// This NodeBalancer's public IPv6 address.
+	IPv6 *string `json:"ipv6"`
+	// Throttle connections per second (0-20). Set to 0 (zero) to disable throttling.
+	ClientConnThrottle int `json:"client_conn_throttle"`
+	// Information about the amount of transfer this NodeBalancer has had so far this month.
+	Transfer NodeBalancerTransfer `json:"transfer"`
+
+	// An array of tags applied to this object. Tags are for organizational purposes only.
+	Tags []string `json:"tags"`
+
+	Created *time.Time `json:"-"`
+	Updated *time.Time `json:"-"`
+}
+
+// NodeBalancerTransfer contains information about the amount of transfer a NodeBalancer has had in the current month
+type NodeBalancerTransfer struct {
+	// The total transfer, in MB, used by this NodeBalancer this month.
+	Total *float64 `json:"total"`
+	// The total inbound transfer, in MB, used for this NodeBalancer this month.
+	Out *float64 `json:"out"`
+	// The total outbound transfer, in MB, used for this NodeBalancer this month.
+	In *float64 `json:"in"`
+}
+
+// NodeBalancerCreateOptions are the options permitted for CreateNodeBalancer
+type NodeBalancerCreateOptions struct {
+	Label              *string                            `json:"label,omitempty"`
+	Region             string                             `json:"region,omitempty"`
+	ClientConnThrottle *int                               `json:"client_conn_throttle,omitempty"`
+	Configs            []*NodeBalancerConfigCreateOptions `json:"configs,omitempty"`
+	Tags               []string                           `json:"tags"`
+}
+
+// NodeBalancerUpdateOptions are the options permitted for UpdateNodeBalancer
+type NodeBalancerUpdateOptions struct {
+	Label              *string   `json:"label,omitempty"`
+	ClientConnThrottle *int      `json:"client_conn_throttle,omitempty"`
+	Tags               *[]string `json:"tags,omitempty"`
+}
+
+// GetCreateOptions converts a NodeBalancer to NodeBalancerCreateOptions for use in CreateNodeBalancer
+func (i NodeBalancer) GetCreateOptions() NodeBalancerCreateOptions {
+	return NodeBalancerCreateOptions{
+		Label:              i.Label,
+		Region:             i.Region,
+		ClientConnThrottle: &i.ClientConnThrottle,
+		Tags:               i.Tags,
+	}
+}
+
+// GetUpdateOptions converts a NodeBalancer to NodeBalancerUpdateOptions for use in UpdateNodeBalancer
+func (i NodeBalancer) GetUpdateOptions() NodeBalancerUpdateOptions {
+	return NodeBalancerUpdateOptions{
+		Label:              i.Label,
+		ClientConnThrottle: &i.ClientConnThrottle,
+		Tags:               &i.Tags,
+	}
+}
+
+// NodeBalancersPagedResponse represents a paginated NodeBalancer API response
+type NodeBalancersPagedResponse struct {
+	*PageOptions
+	Data []NodeBalancer `json:"data"`
+}
+
+func (NodeBalancersPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.NodeBalancers.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+func (resp *NodeBalancersPagedResponse) appendData(r *NodeBalancersPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListNodeBalancers lists NodeBalancers
+func (c *Client) ListNodeBalancers(ctx context.Context, opts *ListOptions) ([]NodeBalancer, error) {
+	response := NodeBalancersPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *NodeBalancer) fixDates() *NodeBalancer {
+	i.Created, _ = parseDates(i.CreatedStr)
+	i.Updated, _ = parseDates(i.UpdatedStr)
+	return i
+}
+
+// GetNodeBalancer gets the NodeBalancer with the provided ID
+func (c *Client) GetNodeBalancer(ctx context.Context, id int) (*NodeBalancer, error) {
+	e, err := c.NodeBalancers.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&NodeBalancer{}).
+		Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancer).fixDates(), nil
+}
+
+// CreateNodeBalancer creates a NodeBalancer
+func (c *Client) CreateNodeBalancer(ctx context.Context, nodebalancer NodeBalancerCreateOptions) (*NodeBalancer, error) {
+	var body string
+	e, err := c.NodeBalancers.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&NodeBalancer{})
+
+	if bodyData, err := json.Marshal(nodebalancer); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetHeader("Content-Type", "application/json").
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancer).fixDates(), nil
+}
+
+// UpdateNodeBalancer updates the NodeBalancer with the specified id
+func (c *Client) UpdateNodeBalancer(ctx context.Context, id int, updateOpts NodeBalancerUpdateOptions) (*NodeBalancer, error) {
+	var body string
+	e, err := c.NodeBalancers.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&NodeBalancer{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancer).fixDates(), nil
+}
+
+// DeleteNodeBalancer deletes the NodeBalancer with the specified id
+func (c *Client) DeleteNodeBalancer(ctx context.Context, id int) error {
+	e, err := c.NodeBalancers.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+
+	return err
+}
--- a/vendor/github.com/linode/linodego/nodebalancer_config_nodes.go
+++ b/vendor/github.com/linode/linodego/nodebalancer_config_nodes.go
@ -0,0 +1,186 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// NodeBalancerNode objects represent a backend that can accept traffic for a NodeBalancer Config
+type NodeBalancerNode struct {
+	ID             int      `json:"id"`
+	Address        string   `json:"address"`
+	Label          string   `json:"label"`
+	Status         string   `json:"status"`
+	Weight         int      `json:"weight"`
+	Mode           NodeMode `json:"mode"`
+	ConfigID       int      `json:"config_id"`
+	NodeBalancerID int      `json:"nodebalancer_id"`
+}
+
+// NodeMode is the mode a NodeBalancer should use when sending traffic to a NodeBalancer Node
+type NodeMode string
+
+var (
+	// ModeAccept is the NodeMode indicating a NodeBalancer Node is accepting traffic
+	ModeAccept NodeMode = "accept"
+
+	// ModeReject is the NodeMode indicating a NodeBalancer Node is not receiving traffic
+	ModeReject NodeMode = "reject"
+
+	// ModeDrain is the NodeMode indicating a NodeBalancer Node is not receiving new traffic, but may continue receiving traffic from pinned connections
+	ModeDrain NodeMode = "drain"
+)
+
+// NodeBalancerNodeCreateOptions fields are those accepted by CreateNodeBalancerNode
+type NodeBalancerNodeCreateOptions struct {
+	Address string   `json:"address"`
+	Label   string   `json:"label"`
+	Weight  int      `json:"weight,omitempty"`
+	Mode    NodeMode `json:"mode,omitempty"`
+}
+
+// NodeBalancerNodeUpdateOptions fields are those accepted by UpdateNodeBalancerNode
+type NodeBalancerNodeUpdateOptions struct {
+	Address string   `json:"address,omitempty"`
+	Label   string   `json:"label,omitempty"`
+	Weight  int      `json:"weight,omitempty"`
+	Mode    NodeMode `json:"mode,omitempty"`
+}
+
+// GetCreateOptions converts a NodeBalancerNode to NodeBalancerNodeCreateOptions for use in CreateNodeBalancerNode
+func (i NodeBalancerNode) GetCreateOptions() NodeBalancerNodeCreateOptions {
+	return NodeBalancerNodeCreateOptions{
+		Address: i.Address,
+		Label:   i.Label,
+		Weight:  i.Weight,
+		Mode:    i.Mode,
+	}
+}
+
+// GetUpdateOptions converts a NodeBalancerNode to NodeBalancerNodeUpdateOptions for use in UpdateNodeBalancerNode
+func (i NodeBalancerNode) GetUpdateOptions() NodeBalancerNodeUpdateOptions {
+	return NodeBalancerNodeUpdateOptions{
+		Address: i.Address,
+		Label:   i.Label,
+		Weight:  i.Weight,
+		Mode:    i.Mode,
+	}
+}
+
+// NodeBalancerNodesPagedResponse represents a paginated NodeBalancerNode API response
+type NodeBalancerNodesPagedResponse struct {
+	*PageOptions
+	Data []NodeBalancerNode `json:"data"`
+}
+
+// endpoint gets the endpoint URL for NodeBalancerNode
+func (NodeBalancerNodesPagedResponse) endpointWithTwoIDs(c *Client, nodebalancerID int, configID int) string {
+	endpoint, err := c.NodeBalancerNodes.endpointWithID(nodebalancerID, configID)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends NodeBalancerNodes when processing paginated NodeBalancerNode responses
+func (resp *NodeBalancerNodesPagedResponse) appendData(r *NodeBalancerNodesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListNodeBalancerNodes lists NodeBalancerNodes
+func (c *Client) ListNodeBalancerNodes(ctx context.Context, nodebalancerID int, configID int, opts *ListOptions) ([]NodeBalancerNode, error) {
+	response := NodeBalancerNodesPagedResponse{}
+	err := c.listHelperWithTwoIDs(ctx, &response, nodebalancerID, configID, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *NodeBalancerNode) fixDates() *NodeBalancerNode {
+	return i
+}
+
+// GetNodeBalancerNode gets the template with the provided ID
+func (c *Client) GetNodeBalancerNode(ctx context.Context, nodebalancerID int, configID int, nodeID int) (*NodeBalancerNode, error) {
+	e, err := c.NodeBalancerNodes.endpointWithID(nodebalancerID, configID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, nodeID)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&NodeBalancerNode{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerNode).fixDates(), nil
+}
+
+// CreateNodeBalancerNode creates a NodeBalancerNode
+func (c *Client) CreateNodeBalancerNode(ctx context.Context, nodebalancerID int, configID int, createOpts NodeBalancerNodeCreateOptions) (*NodeBalancerNode, error) {
+	var body string
+	e, err := c.NodeBalancerNodes.endpointWithID(nodebalancerID, configID)
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&NodeBalancerNode{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerNode).fixDates(), nil
+}
+
+// UpdateNodeBalancerNode updates the NodeBalancerNode with the specified id
+func (c *Client) UpdateNodeBalancerNode(ctx context.Context, nodebalancerID int, configID int, nodeID int, updateOpts NodeBalancerNodeUpdateOptions) (*NodeBalancerNode, error) {
+	var body string
+	e, err := c.NodeBalancerNodes.endpointWithID(nodebalancerID, configID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, nodeID)
+
+	req := c.R(ctx).SetResult(&NodeBalancerNode{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerNode).fixDates(), nil
+}
+
+// DeleteNodeBalancerNode deletes the NodeBalancerNode with the specified id
+func (c *Client) DeleteNodeBalancerNode(ctx context.Context, nodebalancerID int, configID int, nodeID int) error {
+	e, err := c.NodeBalancerNodes.endpointWithID(nodebalancerID, configID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, nodeID)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
--- a/vendor/github.com/linode/linodego/nodebalancer_configs.go
+++ b/vendor/github.com/linode/linodego/nodebalancer_configs.go
@ -0,0 +1,334 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// NodeBalancerConfig objects allow a NodeBalancer to accept traffic on a new port
+type NodeBalancerConfig struct {
+	ID             int                     `json:"id"`
+	Port           int                     `json:"port"`
+	Protocol       ConfigProtocol          `json:"protocol"`
+	Algorithm      ConfigAlgorithm         `json:"algorithm"`
+	Stickiness     ConfigStickiness        `json:"stickiness"`
+	Check          ConfigCheck             `json:"check"`
+	CheckInterval  int                     `json:"check_interval"`
+	CheckAttempts  int                     `json:"check_attempts"`
+	CheckPath      string                  `json:"check_path"`
+	CheckBody      string                  `json:"check_body"`
+	CheckPassive   bool                    `json:"check_passive"`
+	CheckTimeout   int                     `json:"check_timeout"`
+	CipherSuite    ConfigCipher            `json:"cipher_suite"`
+	NodeBalancerID int                     `json:"nodebalancer_id"`
+	SSLCommonName  string                  `json:"ssl_commonname"`
+	SSLFingerprint string                  `json:"ssl_fingerprint"`
+	SSLCert        string                  `json:"ssl_cert"`
+	SSLKey         string                  `json:"ssl_key"`
+	NodesStatus    *NodeBalancerNodeStatus `json:"nodes_status"`
+}
+
+// ConfigAlgorithm constants start with Algorithm and include Linode API NodeBalancer Config Algorithms
+type ConfigAlgorithm string
+
+// ConfigAlgorithm constants reflect the NodeBalancer Config Algorithm
+const (
+	AlgorithmRoundRobin ConfigAlgorithm = "roundrobin"
+	AlgorithmLeastConn  ConfigAlgorithm = "leastconn"
+	AlgorithmSource     ConfigAlgorithm = "source"
+)
+
+// ConfigStickiness constants start with Stickiness and include Linode API NodeBalancer Config Stickiness
+type ConfigStickiness string
+
+// ConfigStickiness constants reflect the node stickiness method for a NodeBalancer Config
+const (
+	StickinessNone       ConfigStickiness = "none"
+	StickinessTable      ConfigStickiness = "table"
+	StickinessHTTPCookie ConfigStickiness = "http_cookie"
+)
+
+// ConfigCheck constants start with Check and include Linode API NodeBalancer Config Check methods
+type ConfigCheck string
+
+// ConfigCheck constants reflect the node health status checking method for a NodeBalancer Config
+const (
+	CheckNone       ConfigCheck = "none"
+	CheckConnection ConfigCheck = "connection"
+	CheckHTTP       ConfigCheck = "http"
+	CheckHTTPBody   ConfigCheck = "http_body"
+)
+
+// ConfigProtocol constants start with Protocol and include Linode API Nodebalancer Config protocols
+type ConfigProtocol string
+
+// ConfigProtocol constants reflect the protocol used by a NodeBalancer Config
+const (
+	ProtocolHTTP  ConfigProtocol = "http"
+	ProtocolHTTPS ConfigProtocol = "https"
+	ProtocolTCP   ConfigProtocol = "tcp"
+)
+
+// ConfigCipher constants start with Cipher and include Linode API NodeBalancer Config Cipher values
+type ConfigCipher string
+
+// ConfigCipher constants reflect the preferred cipher set for a NodeBalancer Config
+const (
+	CipherRecommended ConfigCipher = "recommended"
+	CipherLegacy      ConfigCipher = "legacy"
+)
+
+// NodeBalancerNodeStatus represents the total number of nodes whose status is Up or Down
+type NodeBalancerNodeStatus struct {
+	Up   int `json:"up"`
+	Down int `json:"down"`
+}
+
+// NodeBalancerConfigCreateOptions are permitted by CreateNodeBalancerConfig
+type NodeBalancerConfigCreateOptions struct {
+	Port          int                             `json:"port"`
+	Protocol      ConfigProtocol                  `json:"protocol,omitempty"`
+	Algorithm     ConfigAlgorithm                 `json:"algorithm,omitempty"`
+	Stickiness    ConfigStickiness                `json:"stickiness,omitempty"`
+	Check         ConfigCheck                     `json:"check,omitempty"`
+	CheckInterval int                             `json:"check_interval,omitempty"`
+	CheckAttempts int                             `json:"check_attempts,omitempty"`
+	CheckPath     string                          `json:"check_path,omitempty"`
+	CheckBody     string                          `json:"check_body,omitempty"`
+	CheckPassive  *bool                           `json:"check_passive,omitempty"`
+	CheckTimeout  int                             `json:"check_timeout,omitempty"`
+	CipherSuite   ConfigCipher                    `json:"cipher_suite,omitempty"`
+	SSLCert       string                          `json:"ssl_cert,omitempty"`
+	SSLKey        string                          `json:"ssl_key,omitempty"`
+	Nodes         []NodeBalancerNodeCreateOptions `json:"nodes,omitempty"`
+}
+
+// NodeBalancerConfigRebuildOptions used by RebuildNodeBalancerConfig
+type NodeBalancerConfigRebuildOptions struct {
+	Port          int                             `json:"port"`
+	Protocol      ConfigProtocol                  `json:"protocol,omitempty"`
+	Algorithm     ConfigAlgorithm                 `json:"algorithm,omitempty"`
+	Stickiness    ConfigStickiness                `json:"stickiness,omitempty"`
+	Check         ConfigCheck                     `json:"check,omitempty"`
+	CheckInterval int                             `json:"check_interval,omitempty"`
+	CheckAttempts int                             `json:"check_attempts,omitempty"`
+	CheckPath     string                          `json:"check_path,omitempty"`
+	CheckBody     string                          `json:"check_body,omitempty"`
+	CheckPassive  *bool                           `json:"check_passive,omitempty"`
+	CheckTimeout  int                             `json:"check_timeout,omitempty"`
+	CipherSuite   ConfigCipher                    `json:"cipher_suite,omitempty"`
+	SSLCert       string                          `json:"ssl_cert,omitempty"`
+	SSLKey        string                          `json:"ssl_key,omitempty"`
+	Nodes         []NodeBalancerNodeCreateOptions `json:"nodes"`
+}
+
+// NodeBalancerConfigUpdateOptions are permitted by UpdateNodeBalancerConfig
+type NodeBalancerConfigUpdateOptions NodeBalancerConfigCreateOptions
+
+// GetCreateOptions converts a NodeBalancerConfig to NodeBalancerConfigCreateOptions for use in CreateNodeBalancerConfig
+func (i NodeBalancerConfig) GetCreateOptions() NodeBalancerConfigCreateOptions {
+	return NodeBalancerConfigCreateOptions{
+		Port:          i.Port,
+		Protocol:      i.Protocol,
+		Algorithm:     i.Algorithm,
+		Stickiness:    i.Stickiness,
+		Check:         i.Check,
+		CheckInterval: i.CheckInterval,
+		CheckAttempts: i.CheckAttempts,
+		CheckTimeout:  i.CheckTimeout,
+		CheckPath:     i.CheckPath,
+		CheckBody:     i.CheckBody,
+		CheckPassive:  copyBool(&i.CheckPassive),
+		CipherSuite:   i.CipherSuite,
+		SSLCert:       i.SSLCert,
+		SSLKey:        i.SSLKey,
+	}
+}
+
+// GetUpdateOptions converts a NodeBalancerConfig to NodeBalancerConfigUpdateOptions for use in UpdateNodeBalancerConfig
+func (i NodeBalancerConfig) GetUpdateOptions() NodeBalancerConfigUpdateOptions {
+	return NodeBalancerConfigUpdateOptions{
+		Port:          i.Port,
+		Protocol:      i.Protocol,
+		Algorithm:     i.Algorithm,
+		Stickiness:    i.Stickiness,
+		Check:         i.Check,
+		CheckInterval: i.CheckInterval,
+		CheckAttempts: i.CheckAttempts,
+		CheckPath:     i.CheckPath,
+		CheckBody:     i.CheckBody,
+		CheckPassive:  copyBool(&i.CheckPassive),
+		CheckTimeout:  i.CheckTimeout,
+		CipherSuite:   i.CipherSuite,
+		SSLCert:       i.SSLCert,
+		SSLKey:        i.SSLKey,
+	}
+}
+
+// GetRebuildOptions converts a NodeBalancerConfig to NodeBalancerConfigRebuildOptions for use in RebuildNodeBalancerConfig
+func (i NodeBalancerConfig) GetRebuildOptions() NodeBalancerConfigRebuildOptions {
+	return NodeBalancerConfigRebuildOptions{
+		Port:          i.Port,
+		Protocol:      i.Protocol,
+		Algorithm:     i.Algorithm,
+		Stickiness:    i.Stickiness,
+		Check:         i.Check,
+		CheckInterval: i.CheckInterval,
+		CheckAttempts: i.CheckAttempts,
+		CheckTimeout:  i.CheckTimeout,
+		CheckPath:     i.CheckPath,
+		CheckBody:     i.CheckBody,
+		CheckPassive:  copyBool(&i.CheckPassive),
+		CipherSuite:   i.CipherSuite,
+		SSLCert:       i.SSLCert,
+		SSLKey:        i.SSLKey,
+		Nodes:         make([]NodeBalancerNodeCreateOptions, 0),
+	}
+}
+
+// NodeBalancerConfigsPagedResponse represents a paginated NodeBalancerConfig API response
+type NodeBalancerConfigsPagedResponse struct {
+	*PageOptions
+	Data []NodeBalancerConfig `json:"data"`
+}
+
+// endpointWithID gets the endpoint URL for NodeBalancerConfig
+func (NodeBalancerConfigsPagedResponse) endpointWithID(c *Client, id int) string {
+	endpoint, err := c.NodeBalancerConfigs.endpointWithID(id)
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends NodeBalancerConfigs when processing paginated NodeBalancerConfig responses
+func (resp *NodeBalancerConfigsPagedResponse) appendData(r *NodeBalancerConfigsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListNodeBalancerConfigs lists NodeBalancerConfigs
+func (c *Client) ListNodeBalancerConfigs(ctx context.Context, nodebalancerID int, opts *ListOptions) ([]NodeBalancerConfig, error) {
+	response := NodeBalancerConfigsPagedResponse{}
+	err := c.listHelperWithID(ctx, &response, nodebalancerID, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *NodeBalancerConfig) fixDates() *NodeBalancerConfig {
+	return i
+}
+
+// GetNodeBalancerConfig gets the template with the provided ID
+func (c *Client) GetNodeBalancerConfig(ctx context.Context, nodebalancerID int, configID int) (*NodeBalancerConfig, error) {
+	e, err := c.NodeBalancerConfigs.endpointWithID(nodebalancerID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&NodeBalancerConfig{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerConfig).fixDates(), nil
+}
+
+// CreateNodeBalancerConfig creates a NodeBalancerConfig
+func (c *Client) CreateNodeBalancerConfig(ctx context.Context, nodebalancerID int, nodebalancerConfig NodeBalancerConfigCreateOptions) (*NodeBalancerConfig, error) {
+	var body string
+	e, err := c.NodeBalancerConfigs.endpointWithID(nodebalancerID)
+
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&NodeBalancerConfig{})
+
+	if bodyData, err := json.Marshal(nodebalancerConfig); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetHeader("Content-Type", "application/json").
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerConfig).fixDates(), nil
+}
+
+// UpdateNodeBalancerConfig updates the NodeBalancerConfig with the specified id
+func (c *Client) UpdateNodeBalancerConfig(ctx context.Context, nodebalancerID int, configID int, updateOpts NodeBalancerConfigUpdateOptions) (*NodeBalancerConfig, error) {
+	var body string
+	e, err := c.NodeBalancerConfigs.endpointWithID(nodebalancerID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+
+	req := c.R(ctx).SetResult(&NodeBalancerConfig{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerConfig).fixDates(), nil
+}
+
+// DeleteNodeBalancerConfig deletes the NodeBalancerConfig with the specified id
+func (c *Client) DeleteNodeBalancerConfig(ctx context.Context, nodebalancerID int, configID int) error {
+	e, err := c.NodeBalancerConfigs.endpointWithID(nodebalancerID)
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, configID)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
+
+// RebuildNodeBalancerConfig updates the NodeBalancer with the specified id
+func (c *Client) RebuildNodeBalancerConfig(ctx context.Context, nodeBalancerID int, configID int, rebuildOpts NodeBalancerConfigRebuildOptions) (*NodeBalancerConfig, error) {
+	var body string
+	e, err := c.NodeBalancerConfigs.endpointWithID(nodeBalancerID)
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d/rebuild", e, configID)
+
+	req := c.R(ctx).SetResult(&NodeBalancerConfig{})
+
+	if bodyData, err := json.Marshal(rebuildOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*NodeBalancerConfig).fixDates(), nil
+}
--- a/vendor/github.com/linode/linodego/pagination.go
+++ b/vendor/github.com/linode/linodego/pagination.go
@ -0,0 +1,430 @@
+package linodego
+
+/**
+ * Pagination and Filtering types and helpers
+ */
+
+import (
+	"context"
+	"fmt"
+	"log"
+	"strconv"
+
+	"gopkg.in/resty.v1"
+)
+
+// PageOptions are the pagination parameters for List endpoints
+type PageOptions struct {
+	Page    int `url:"page,omitempty" json:"page"`
+	Pages   int `url:"pages,omitempty" json:"pages"`
+	Results int `url:"results,omitempty" json:"results"`
+}
+
+// ListOptions are the pagination and filtering (TODO) parameters for endpoints
+type ListOptions struct {
+	*PageOptions
+	Filter string
+}
+
+// NewListOptions simplified construction of ListOptions using only
+// the two writable properties, Page and Filter
+func NewListOptions(Page int, Filter string) *ListOptions {
+	return &ListOptions{PageOptions: &PageOptions{Page: Page}, Filter: Filter}
+
+}
+
+// listHelper abstracts fetching and pagination for GET endpoints that
+// do not require any Ids (top level endpoints).
+// When opts (or opts.Page) is nil, all pages will be fetched and
+// returned in a single (endpoint-specific)PagedResponse
+// opts.results and opts.pages will be updated from the API response
+func (c *Client) listHelper(ctx context.Context, i interface{}, opts *ListOptions) error {
+	req := c.R(ctx)
+	if opts != nil && opts.PageOptions != nil && opts.Page > 0 {
+		req.SetQueryParam("page", strconv.Itoa(opts.Page))
+	}
+
+	var (
+		err     error
+		pages   int
+		results int
+		r       *resty.Response
+	)
+
+	if opts != nil && len(opts.Filter) > 0 {
+		req.SetHeader("X-Filter", opts.Filter)
+	}
+
+	switch v := i.(type) {
+	case *LinodeKernelsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(LinodeKernelsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*LinodeKernelsPagedResponse).Pages
+			results = r.Result().(*LinodeKernelsPagedResponse).Results
+			v.appendData(r.Result().(*LinodeKernelsPagedResponse))
+		}
+	case *LinodeTypesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(LinodeTypesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*LinodeTypesPagedResponse).Pages
+			results = r.Result().(*LinodeTypesPagedResponse).Results
+			v.appendData(r.Result().(*LinodeTypesPagedResponse))
+		}
+	case *ImagesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(ImagesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*ImagesPagedResponse).Pages
+			results = r.Result().(*ImagesPagedResponse).Results
+			v.appendData(r.Result().(*ImagesPagedResponse))
+		}
+	case *StackscriptsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(StackscriptsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*StackscriptsPagedResponse).Pages
+			results = r.Result().(*StackscriptsPagedResponse).Results
+			v.appendData(r.Result().(*StackscriptsPagedResponse))
+		}
+	case *InstancesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(InstancesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*InstancesPagedResponse).Pages
+			results = r.Result().(*InstancesPagedResponse).Results
+			v.appendData(r.Result().(*InstancesPagedResponse))
+		}
+	case *RegionsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(RegionsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*RegionsPagedResponse).Pages
+			results = r.Result().(*RegionsPagedResponse).Results
+			v.appendData(r.Result().(*RegionsPagedResponse))
+		}
+	case *VolumesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(VolumesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*VolumesPagedResponse).Pages
+			results = r.Result().(*VolumesPagedResponse).Results
+			v.appendData(r.Result().(*VolumesPagedResponse))
+		}
+	case *DomainsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(DomainsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			response, ok := r.Result().(*DomainsPagedResponse)
+			if !ok {
+				return fmt.Errorf("Response is not a *DomainsPagedResponse")
+			}
+			pages = response.Pages
+			results = response.Results
+			v.appendData(response)
+		}
+	case *EventsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(EventsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*EventsPagedResponse).Pages
+			results = r.Result().(*EventsPagedResponse).Results
+			v.appendData(r.Result().(*EventsPagedResponse))
+		}
+	case *LongviewSubscriptionsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(LongviewSubscriptionsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*LongviewSubscriptionsPagedResponse).Pages
+			results = r.Result().(*LongviewSubscriptionsPagedResponse).Results
+			v.appendData(r.Result().(*LongviewSubscriptionsPagedResponse))
+		}
+	case *LongviewClientsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(LongviewClientsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*LongviewClientsPagedResponse).Pages
+			results = r.Result().(*LongviewClientsPagedResponse).Results
+			v.appendData(r.Result().(*LongviewClientsPagedResponse))
+		}
+	case *IPAddressesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(IPAddressesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*IPAddressesPagedResponse).Pages
+			results = r.Result().(*IPAddressesPagedResponse).Results
+			v.appendData(r.Result().(*IPAddressesPagedResponse))
+		}
+	case *IPv6PoolsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(IPv6PoolsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*IPv6PoolsPagedResponse).Pages
+			results = r.Result().(*IPv6PoolsPagedResponse).Results
+			v.appendData(r.Result().(*IPv6PoolsPagedResponse))
+		}
+	case *IPv6RangesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(IPv6RangesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*IPv6RangesPagedResponse).Pages
+			results = r.Result().(*IPv6RangesPagedResponse).Results
+			v.appendData(r.Result().(*IPv6RangesPagedResponse))
+			// @TODO consolidate this type with IPv6PoolsPagedResponse?
+		}
+	case *SSHKeysPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(SSHKeysPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			response, ok := r.Result().(*SSHKeysPagedResponse)
+			if !ok {
+				return fmt.Errorf("Response is not a *SSHKeysPagedResponse")
+			}
+			pages = response.Pages
+			results = response.Results
+			v.appendData(response)
+		}
+	case *TicketsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(TicketsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*TicketsPagedResponse).Pages
+			results = r.Result().(*TicketsPagedResponse).Results
+			v.appendData(r.Result().(*TicketsPagedResponse))
+		}
+	case *InvoicesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(InvoicesPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*InvoicesPagedResponse).Pages
+			results = r.Result().(*InvoicesPagedResponse).Results
+			v.appendData(r.Result().(*InvoicesPagedResponse))
+		}
+	case *NotificationsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(NotificationsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*NotificationsPagedResponse).Pages
+			results = r.Result().(*NotificationsPagedResponse).Results
+			v.appendData(r.Result().(*NotificationsPagedResponse))
+		}
+	case *NodeBalancersPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(NodeBalancersPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*NodeBalancersPagedResponse).Pages
+			results = r.Result().(*NodeBalancersPagedResponse).Results
+			v.appendData(r.Result().(*NodeBalancersPagedResponse))
+		}
+	case *TagsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(TagsPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*TagsPagedResponse).Pages
+			results = r.Result().(*TagsPagedResponse).Results
+			v.appendData(r.Result().(*TagsPagedResponse))
+		}
+	case *TokensPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(TokensPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*TokensPagedResponse).Pages
+			results = r.Result().(*TokensPagedResponse).Results
+			v.appendData(r.Result().(*TokensPagedResponse))
+		}
+	case *UsersPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(UsersPagedResponse{}).Get(v.endpoint(c))); err == nil {
+			pages = r.Result().(*UsersPagedResponse).Pages
+			results = r.Result().(*UsersPagedResponse).Results
+			v.appendData(r.Result().(*UsersPagedResponse))
+		}
+	/**
+	case AccountOauthClientsPagedResponse:
+	case AccountPaymentsPagedResponse:
+	case ProfileAppsPagedResponse:
+	case ProfileWhitelistPagedResponse:
+	case ManagedContactsPagedResponse:
+	case ManagedCredentialsPagedResponse:
+	case ManagedIssuesPagedResponse:
+	case ManagedLinodeSettingsPagedResponse:
+	case ManagedServicesPagedResponse:
+	**/
+	default:
+		log.Fatalf("listHelper interface{} %+v used", i)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if opts == nil {
+		for page := 2; page <= pages; page = page + 1 {
+			if err := c.listHelper(ctx, i, &ListOptions{PageOptions: &PageOptions{Page: page}}); err != nil {
+				return err
+			}
+		}
+	} else {
+		if opts.PageOptions == nil {
+			opts.PageOptions = &PageOptions{}
+		}
+
+		if opts.Page == 0 {
+			for page := 2; page <= pages; page = page + 1 {
+				opts.Page = page
+				if err := c.listHelper(ctx, i, opts); err != nil {
+					return err
+				}
+			}
+		}
+		opts.Results = results
+		opts.Pages = pages
+	}
+
+	return nil
+}
+
+// listHelperWithID abstracts fetching and pagination for GET endpoints that
+// require an Id (second level endpoints).
+// When opts (or opts.Page) is nil, all pages will be fetched and
+// returned in a single (endpoint-specific)PagedResponse
+// opts.results and opts.pages will be updated from the API response
+func (c *Client) listHelperWithID(ctx context.Context, i interface{}, idRaw interface{}, opts *ListOptions) error {
+	req := c.R(ctx)
+	if opts != nil && opts.Page > 0 {
+		req.SetQueryParam("page", strconv.Itoa(opts.Page))
+	}
+
+	var (
+		err     error
+		pages   int
+		results int
+		r       *resty.Response
+	)
+
+	id, _ := idRaw.(int)
+
+	if opts != nil && len(opts.Filter) > 0 {
+		req.SetHeader("X-Filter", opts.Filter)
+	}
+
+	switch v := i.(type) {
+	case *InvoiceItemsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(InvoiceItemsPagedResponse{}).Get(v.endpointWithID(c, id))); err == nil {
+			pages = r.Result().(*InvoiceItemsPagedResponse).Pages
+			results = r.Result().(*InvoiceItemsPagedResponse).Results
+			v.appendData(r.Result().(*InvoiceItemsPagedResponse))
+		}
+	case *DomainRecordsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(DomainRecordsPagedResponse{}).Get(v.endpointWithID(c, id))); err == nil {
+			response, ok := r.Result().(*DomainRecordsPagedResponse)
+			if !ok {
+				return fmt.Errorf("Response is not a *DomainRecordsPagedResponse")
+			}
+			pages = response.Pages
+			results = response.Results
+			v.appendData(response)
+		}
+	case *InstanceConfigsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(InstanceConfigsPagedResponse{}).Get(v.endpointWithID(c, id))); err == nil {
+			pages = r.Result().(*InstanceConfigsPagedResponse).Pages
+			results = r.Result().(*InstanceConfigsPagedResponse).Results
+			v.appendData(r.Result().(*InstanceConfigsPagedResponse))
+		}
+	case *InstanceDisksPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(InstanceDisksPagedResponse{}).Get(v.endpointWithID(c, id))); err == nil {
+			pages = r.Result().(*InstanceDisksPagedResponse).Pages
+			results = r.Result().(*InstanceDisksPagedResponse).Results
+			v.appendData(r.Result().(*InstanceDisksPagedResponse))
+		}
+	case *NodeBalancerConfigsPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(NodeBalancerConfigsPagedResponse{}).Get(v.endpointWithID(c, id))); err == nil {
+			pages = r.Result().(*NodeBalancerConfigsPagedResponse).Pages
+			results = r.Result().(*NodeBalancerConfigsPagedResponse).Results
+			v.appendData(r.Result().(*NodeBalancerConfigsPagedResponse))
+		}
+	case *InstanceVolumesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(InstanceVolumesPagedResponse{}).Get(v.endpointWithID(c, id))); err == nil {
+			pages = r.Result().(*InstanceVolumesPagedResponse).Pages
+			results = r.Result().(*InstanceVolumesPagedResponse).Results
+			v.appendData(r.Result().(*InstanceVolumesPagedResponse))
+		}
+	case *TaggedObjectsPagedResponse:
+		idStr := idRaw.(string)
+
+		if r, err = coupleAPIErrors(req.SetResult(TaggedObjectsPagedResponse{}).Get(v.endpointWithID(c, idStr))); err == nil {
+			pages = r.Result().(*TaggedObjectsPagedResponse).Pages
+			results = r.Result().(*TaggedObjectsPagedResponse).Results
+			v.appendData(r.Result().(*TaggedObjectsPagedResponse))
+		}
+	/**
+	case TicketAttachmentsPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*TicketAttachmentsPagedResponse).Pages
+			results = r.Result().(*TicketAttachmentsPagedResponse).Results
+			v.appendData(r.Result().(*TicketAttachmentsPagedResponse))
+		}
+	case TicketRepliesPagedResponse:
+		if r, err = req.SetResult(v).Get(v.endpoint(c)); r.Error() != nil {
+			return NewError(r)
+		} else if err == nil {
+			pages = r.Result().(*TicketRepliesPagedResponse).Pages
+			results = r.Result().(*TicketRepliesPagedResponse).Results
+			v.appendData(r.Result().(*TicketRepliesPagedResponse))
+		}
+	**/
+	default:
+		log.Fatalf("Unknown listHelperWithID interface{} %T used", i)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if opts == nil {
+		for page := 2; page <= pages; page = page + 1 {
+			if err := c.listHelperWithID(ctx, i, id, &ListOptions{PageOptions: &PageOptions{Page: page}}); err != nil {
+				return err
+			}
+		}
+	} else {
+		if opts.PageOptions == nil {
+			opts.PageOptions = &PageOptions{}
+		}
+		if opts.Page == 0 {
+			for page := 2; page <= pages; page = page + 1 {
+				opts.Page = page
+				if err := c.listHelperWithID(ctx, i, id, opts); err != nil {
+					return err
+				}
+			}
+		}
+		opts.Results = results
+		opts.Pages = pages
+	}
+
+	return nil
+}
+
+// listHelperWithTwoIDs abstracts fetching and pagination for GET endpoints that
+// require twos IDs (third level endpoints).
+// When opts (or opts.Page) is nil, all pages will be fetched and
+// returned in a single (endpoint-specific)PagedResponse
+// opts.results and opts.pages will be updated from the API response
+func (c *Client) listHelperWithTwoIDs(ctx context.Context, i interface{}, firstID, secondID int, opts *ListOptions) error {
+	req := c.R(ctx)
+	if opts != nil && opts.Page > 0 {
+		req.SetQueryParam("page", strconv.Itoa(opts.Page))
+	}
+
+	var (
+		err     error
+		pages   int
+		results int
+		r       *resty.Response
+	)
+
+	if opts != nil && len(opts.Filter) > 0 {
+		req.SetHeader("X-Filter", opts.Filter)
+	}
+
+	switch v := i.(type) {
+	case *NodeBalancerNodesPagedResponse:
+		if r, err = coupleAPIErrors(req.SetResult(NodeBalancerNodesPagedResponse{}).Get(v.endpointWithTwoIDs(c, firstID, secondID))); err == nil {
+			pages = r.Result().(*NodeBalancerNodesPagedResponse).Pages
+			results = r.Result().(*NodeBalancerNodesPagedResponse).Results
+			v.appendData(r.Result().(*NodeBalancerNodesPagedResponse))
+		}
+
+	default:
+		log.Fatalf("Unknown listHelperWithTwoIDs interface{} %T used", i)
+	}
+
+	if err != nil {
+		return err
+	}
+
+	if opts == nil {
+		for page := 2; page <= pages; page = page + 1 {
+			if err := c.listHelper(ctx, i, &ListOptions{PageOptions: &PageOptions{Page: page}}); err != nil {
+				return err
+			}
+		}
+	} else {
+		if opts.PageOptions == nil {
+			opts.PageOptions = &PageOptions{}
+		}
+		if opts.Page == 0 {
+			for page := 2; page <= pages; page = page + 1 {
+				opts.Page = page
+				if err := c.listHelperWithTwoIDs(ctx, i, firstID, secondID, opts); err != nil {
+					return err
+				}
+			}
+		}
+		opts.Results = results
+		opts.Pages = pages
+	}
+
+	return nil
+}
--- a/vendor/github.com/linode/linodego/profile.go
+++ b/vendor/github.com/linode/linodego/profile.go
@ -0,0 +1,117 @@
+package linodego
+
+/*
+ - copy profile_test.go and do the same
+ - When updating Profile structs,
+   - use pointers where ever null'able would have a different meaning if the wrapper
+	 supplied "" or 0 instead
+ - Add "NameOfResource" to client.go, resources.go, pagination.go
+*/
+
+import (
+	"context"
+	"encoding/json"
+)
+
+// LishAuthMethod constants start with AuthMethod and include Linode API Lish Authentication Methods
+type LishAuthMethod string
+
+// LishAuthMethod constants are the methods of authentication allowed when connecting via Lish
+const (
+	AuthMethodPasswordKeys LishAuthMethod = "password_keys"
+	AuthMethodKeysOnly     LishAuthMethod = "keys_only"
+	AuthMethodDisabled     LishAuthMethod = "disabled"
+)
+
+// ProfileReferrals represent a User's status in the Referral Program
+type ProfileReferrals struct {
+	Total     int     `json:"total"`
+	Completed int     `json:"completed"`
+	Pending   int     `json:"pending"`
+	Credit    float64 `json:"credit"`
+	Code      string  `json:"code"`
+	URL       string  `json:"url"`
+}
+
+// Profile represents a Profile object
+type Profile struct {
+	UID                int              `json:"uid"`
+	Username           string           `json:"username"`
+	Email              string           `json:"email"`
+	Timezone           string           `json:"timezone"`
+	EmailNotifications bool             `json:"email_notifications"`
+	IPWhitelistEnabled bool             `json:"ip_whitelist_enabled"`
+	TwoFactorAuth      bool             `json:"two_factor_auth"`
+	Restricted         bool             `json:"restricted"`
+	LishAuthMethod     LishAuthMethod   `json:"lish_auth_method"`
+	Referrals          ProfileReferrals `json:"referrals"`
+	AuthorizedKeys     []string         `json:"authorized_keys"`
+}
+
+// ProfileUpdateOptions fields are those accepted by UpdateProfile
+type ProfileUpdateOptions struct {
+	Email              string         `json:"email,omitempty"`
+	Timezone           string         `json:"timezone,omitempty"`
+	EmailNotifications *bool          `json:"email_notifications,omitempty"`
+	IPWhitelistEnabled *bool          `json:"ip_whitelist_enabled,omitempty"`
+	LishAuthMethod     LishAuthMethod `json:"lish_auth_method,omitempty"`
+	AuthorizedKeys     *[]string      `json:"authorized_keys,omitempty"`
+	TwoFactorAuth      *bool          `json:"two_factor_auth,omitempty"`
+	Restricted         *bool          `json:"restricted,omitempty"`
+}
+
+// GetUpdateOptions converts a Profile to ProfileUpdateOptions for use in UpdateProfile
+func (i Profile) GetUpdateOptions() (o ProfileUpdateOptions) {
+	o.Email = i.Email
+	o.Timezone = i.Timezone
+	o.EmailNotifications = copyBool(&i.EmailNotifications)
+	o.IPWhitelistEnabled = copyBool(&i.IPWhitelistEnabled)
+	o.LishAuthMethod = i.LishAuthMethod
+	authorizedKeys := make([]string, len(i.AuthorizedKeys))
+	copy(authorizedKeys, i.AuthorizedKeys)
+	o.AuthorizedKeys = &authorizedKeys
+	o.TwoFactorAuth = copyBool(&i.TwoFactorAuth)
+	o.Restricted = copyBool(&i.Restricted)
+
+	return
+}
+
+// GetProfile gets the profile with the provided ID
+func (c *Client) GetProfile(ctx context.Context) (*Profile, error) {
+	e, err := c.Profile.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Profile{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Profile), nil
+}
+
+// UpdateProfile updates the Profile with the specified id
+func (c *Client) UpdateProfile(ctx context.Context, updateOpts ProfileUpdateOptions) (*Profile, error) {
+	var body string
+	e, err := c.Profile.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Profile{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Profile), nil
+}
--- a/vendor/github.com/linode/linodego/profile_sshkeys.go
+++ b/vendor/github.com/linode/linodego/profile_sshkeys.go
@ -0,0 +1,160 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// SSHKey represents a SSHKey object
+type SSHKey struct {
+	ID         int        `json:"id"`
+	Label      string     `json:"label"`
+	SSHKey     string     `json:"ssh_key"`
+	CreatedStr string     `json:"created"`
+	Created    *time.Time `json:"-"`
+}
+
+// SSHKeyCreateOptions fields are those accepted by CreateSSHKey
+type SSHKeyCreateOptions struct {
+	Label  string `json:"label"`
+	SSHKey string `json:"ssh_key"`
+}
+
+// SSHKeyUpdateOptions fields are those accepted by UpdateSSHKey
+type SSHKeyUpdateOptions struct {
+	Label string `json:"label"`
+}
+
+// GetCreateOptions converts a SSHKey to SSHKeyCreateOptions for use in CreateSSHKey
+func (i SSHKey) GetCreateOptions() (o SSHKeyCreateOptions) {
+	o.Label = i.Label
+	o.SSHKey = i.SSHKey
+	return
+}
+
+// GetUpdateOptions converts a SSHKey to SSHKeyCreateOptions for use in UpdateSSHKey
+func (i SSHKey) GetUpdateOptions() (o SSHKeyUpdateOptions) {
+	o.Label = i.Label
+	return
+}
+
+// SSHKeysPagedResponse represents a paginated SSHKey API response
+type SSHKeysPagedResponse struct {
+	*PageOptions
+	Data []SSHKey `json:"data"`
+}
+
+// endpoint gets the endpoint URL for SSHKey
+func (SSHKeysPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.SSHKeys.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends SSHKeys when processing paginated SSHKey responses
+func (resp *SSHKeysPagedResponse) appendData(r *SSHKeysPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListSSHKeys lists SSHKeys
+func (c *Client) ListSSHKeys(ctx context.Context, opts *ListOptions) ([]SSHKey, error) {
+	response := SSHKeysPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *SSHKey) fixDates() *SSHKey {
+	i.Created, _ = parseDates(i.CreatedStr)
+	return i
+}
+
+// GetSSHKey gets the sshkey with the provided ID
+func (c *Client) GetSSHKey(ctx context.Context, id int) (*SSHKey, error) {
+	e, err := c.SSHKeys.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&SSHKey{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*SSHKey).fixDates(), nil
+}
+
+// CreateSSHKey creates a SSHKey
+func (c *Client) CreateSSHKey(ctx context.Context, createOpts SSHKeyCreateOptions) (*SSHKey, error) {
+	var body string
+	e, err := c.SSHKeys.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&SSHKey{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*SSHKey).fixDates(), nil
+}
+
+// UpdateSSHKey updates the SSHKey with the specified id
+func (c *Client) UpdateSSHKey(ctx context.Context, id int, updateOpts SSHKeyUpdateOptions) (*SSHKey, error) {
+	var body string
+	e, err := c.SSHKeys.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&SSHKey{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*SSHKey).fixDates(), nil
+}
+
+// DeleteSSHKey deletes the SSHKey with the specified id
+func (c *Client) DeleteSSHKey(ctx context.Context, id int) error {
+	e, err := c.SSHKeys.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+
+}
--- a/vendor/github.com/linode/linodego/profile_tokens.go
+++ b/vendor/github.com/linode/linodego/profile_tokens.go
@ -0,0 +1,195 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// Token represents a Token object
+type Token struct {
+	// This token's unique ID, which can be used to revoke it.
+	ID int `json:"id"`
+
+	// The scopes this token was created with. These define what parts of the Account the token can be used to access. Many command-line tools, such as the Linode CLI, require tokens with access to *. Tokens with more restrictive scopes are generally more secure.
+	Scopes string `json:"scopes"`
+
+	// This token's label. This is for display purposes only, but can be used to more easily track what you're using each token for. (1-100 Characters)
+	Label string `json:"label"`
+
+	// The token used to access the API. When the token is created, the full token is returned here. Otherwise, only the first 16 characters are returned.
+	Token string `json:"token"`
+
+	// The date and time this token was created.
+	Created    *time.Time `json:"-"`
+	CreatedStr string     `json:"created"`
+
+	// When this token will expire. Personal Access Tokens cannot be renewed, so after this time the token will be completely unusable and a new token will need to be generated. Tokens may be created with "null" as their expiry and will never expire unless revoked.
+	Expiry    *time.Time `json:"-"`
+	ExpiryStr string     `json:"expiry"`
+}
+
+// TokenCreateOptions fields are those accepted by CreateToken
+type TokenCreateOptions struct {
+	// The scopes this token was created with. These define what parts of the Account the token can be used to access. Many command-line tools, such as the Linode CLI, require tokens with access to *. Tokens with more restrictive scopes are generally more secure.
+	Scopes string `json:"scopes"`
+
+	// This token's label. This is for display purposes only, but can be used to more easily track what you're using each token for. (1-100 Characters)
+	Label string `json:"label"`
+
+	// When this token will expire. Personal Access Tokens cannot be renewed, so after this time the token will be completely unusable and a new token will need to be generated. Tokens may be created with "null" as their expiry and will never expire unless revoked.
+	Expiry *time.Time `json:"expiry"`
+}
+
+// TokenUpdateOptions fields are those accepted by UpdateToken
+type TokenUpdateOptions struct {
+	// This token's label. This is for display purposes only, but can be used to more easily track what you're using each token for. (1-100 Characters)
+	Label string `json:"label"`
+}
+
+// GetCreateOptions converts a Token to TokenCreateOptions for use in CreateToken
+func (i Token) GetCreateOptions() (o TokenCreateOptions) {
+	o.Label = i.Label
+	o.Expiry = copyTime(i.Expiry)
+	o.Scopes = i.Scopes
+	return
+}
+
+// GetUpdateOptions converts a Token to TokenUpdateOptions for use in UpdateToken
+func (i Token) GetUpdateOptions() (o TokenUpdateOptions) {
+	o.Label = i.Label
+	return
+}
+
+// TokensPagedResponse represents a paginated Token API response
+type TokensPagedResponse struct {
+	*PageOptions
+	Data []Token `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Token
+func (TokensPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Tokens.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Tokens when processing paginated Token responses
+func (resp *TokensPagedResponse) appendData(r *TokensPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListTokens lists Tokens
+func (c *Client) ListTokens(ctx context.Context, opts *ListOptions) ([]Token, error) {
+	response := TokensPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *Token) fixDates() *Token {
+	i.Created, _ = parseDates(i.CreatedStr)
+	i.Expiry, _ = parseDates(i.ExpiryStr)
+	return i
+}
+
+// GetToken gets the token with the provided ID
+func (c *Client) GetToken(ctx context.Context, id int) (*Token, error) {
+	e, err := c.Tokens.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Token{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Token).fixDates(), nil
+}
+
+// CreateToken creates a Token
+func (c *Client) CreateToken(ctx context.Context, createOpts TokenCreateOptions) (*Token, error) {
+	var body string
+	e, err := c.Tokens.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Token{})
+
+	// Format the Time as a string to meet the ISO8601 requirement
+	createOptsFixed := struct {
+		Label  string  `json:"label"`
+		Scopes string  `json:"scopes"`
+		Expiry *string `json:"expiry"`
+	}{}
+	createOptsFixed.Label = createOpts.Label
+	createOptsFixed.Scopes = createOpts.Scopes
+	if createOpts.Expiry != nil {
+		iso8601Expiry := createOpts.Expiry.UTC().Format("2006-01-02T15:04:05")
+		createOptsFixed.Expiry = &iso8601Expiry
+	}
+
+	if bodyData, err := json.Marshal(createOptsFixed); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Token).fixDates(), nil
+}
+
+// UpdateToken updates the Token with the specified id
+func (c *Client) UpdateToken(ctx context.Context, id int, updateOpts TokenUpdateOptions) (*Token, error) {
+	var body string
+	e, err := c.Tokens.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&Token{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Token).fixDates(), nil
+}
+
+// DeleteToken deletes the Token with the specified id
+func (c *Client) DeleteToken(ctx context.Context, id int) error {
+	e, err := c.Tokens.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
--- a/vendor/github.com/linode/linodego/regions.go
+++ b/vendor/github.com/linode/linodego/regions.go
@ -0,0 +1,64 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// Region represents a linode region object
+type Region struct {
+	ID      string `json:"id"`
+	Country string `json:"country"`
+}
+
+// RegionsPagedResponse represents a linode API response for listing
+type RegionsPagedResponse struct {
+	*PageOptions
+	Data []Region `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Region
+func (RegionsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Regions.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Regions when processing paginated Region responses
+func (resp *RegionsPagedResponse) appendData(r *RegionsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListRegions lists Regions
+func (c *Client) ListRegions(ctx context.Context, opts *ListOptions) ([]Region, error) {
+	response := RegionsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *Region) fixDates() *Region {
+	return v
+}
+
+// GetRegion gets the template with the provided ID
+func (c *Client) GetRegion(ctx context.Context, id string) (*Region, error) {
+	e, err := c.Regions.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Region{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Region).fixDates(), nil
+}
--- a/vendor/github.com/linode/linodego/resources.go
+++ b/vendor/github.com/linode/linodego/resources.go
@ -0,0 +1,162 @@
+package linodego
+
+import (
+	"bytes"
+	"context"
+	"fmt"
+	"text/template"
+
+	"gopkg.in/resty.v1"
+)
+
+const (
+	stackscriptsName          = "stackscripts"
+	imagesName                = "images"
+	instancesName             = "instances"
+	instanceDisksName         = "disks"
+	instanceConfigsName       = "configs"
+	instanceIPsName           = "ips"
+	instanceSnapshotsName     = "snapshots"
+	instanceVolumesName       = "instancevolumes"
+	ipaddressesName           = "ipaddresses"
+	ipv6poolsName             = "ipv6pools"
+	ipv6rangesName            = "ipv6ranges"
+	regionsName               = "regions"
+	volumesName               = "volumes"
+	kernelsName               = "kernels"
+	typesName                 = "types"
+	domainsName               = "domains"
+	domainRecordsName         = "records"
+	longviewName              = "longview"
+	longviewclientsName       = "longviewclients"
+	longviewsubscriptionsName = "longviewsubscriptions"
+	nodebalancersName         = "nodebalancers"
+	nodebalancerconfigsName   = "nodebalancerconfigs"
+	nodebalancernodesName     = "nodebalancernodes"
+	notificationsName         = "notifications"
+	sshkeysName               = "sshkeys"
+	ticketsName               = "tickets"
+	tokensName                = "tokens"
+	accountName               = "account"
+	eventsName                = "events"
+	invoicesName              = "invoices"
+	invoiceItemsName          = "invoiceitems"
+	profileName               = "profile"
+	managedName               = "managed"
+	tagsName                  = "tags"
+	usersName                 = "users"
+	// notificationsName = "notifications"
+
+	stackscriptsEndpoint          = "linode/stackscripts"
+	imagesEndpoint                = "images"
+	instancesEndpoint             = "linode/instances"
+	instanceConfigsEndpoint       = "linode/instances/{{ .ID }}/configs"
+	instanceDisksEndpoint         = "linode/instances/{{ .ID }}/disks"
+	instanceSnapshotsEndpoint     = "linode/instances/{{ .ID }}/backups"
+	instanceIPsEndpoint           = "linode/instances/{{ .ID }}/ips"
+	instanceVolumesEndpoint       = "linode/instances/{{ .ID }}/volumes"
+	ipaddressesEndpoint           = "networking/ips"
+	ipv6poolsEndpoint             = "networking/ipv6/pools"
+	ipv6rangesEndpoint            = "networking/ipv6/ranges"
+	regionsEndpoint               = "regions"
+	volumesEndpoint               = "volumes"
+	kernelsEndpoint               = "linode/kernels"
+	typesEndpoint                 = "linode/types"
+	domainsEndpoint               = "domains"
+	domainRecordsEndpoint         = "domains/{{ .ID }}/records"
+	longviewEndpoint              = "longview"
+	longviewclientsEndpoint       = "longview/clients"
+	longviewsubscriptionsEndpoint = "longview/subscriptions"
+	nodebalancersEndpoint         = "nodebalancers"
+	// @TODO we can't use these nodebalancer endpoints unless we include these templated fields
+	// The API seems inconsistent about including parent IDs in objects, (compare instance configs to nb configs)
+	// Parent IDs would be immutable for updates and are ignored in create requests ..
+	// Should we include these fields in CreateOpts and UpdateOpts?
+	nodebalancerconfigsEndpoint = "nodebalancers/{{ .ID }}/configs"
+	nodebalancernodesEndpoint   = "nodebalancers/{{ .ID }}/configs/{{ .SecondID }}/nodes"
+	sshkeysEndpoint             = "profile/sshkeys"
+	ticketsEndpoint             = "support/tickets"
+	tokensEndpoint              = "profile/tokens"
+	accountEndpoint             = "account"
+	eventsEndpoint              = "account/events"
+	invoicesEndpoint            = "account/invoices"
+	invoiceItemsEndpoint        = "account/invoices/{{ .ID }}/items"
+	profileEndpoint             = "profile"
+	managedEndpoint             = "managed"
+	tagsEndpoint                = "tags"
+	usersEndpoint               = "account/users"
+	notificationsEndpoint       = "account/notifications"
+)
+
+// Resource represents a linode API resource
+type Resource struct {
+	name             string
+	endpoint         string
+	isTemplate       bool
+	endpointTemplate *template.Template
+	R                func(ctx context.Context) *resty.Request
+	PR               func(ctx context.Context) *resty.Request
+}
+
+// NewResource is the factory to create a new Resource struct. If it has a template string the useTemplate bool must be set.
+func NewResource(client *Client, name string, endpoint string, useTemplate bool, singleType interface{}, pagedType interface{}) *Resource {
+	var tmpl *template.Template
+
+	if useTemplate {
+		tmpl = template.Must(template.New(name).Parse(endpoint))
+	}
+
+	r := func(ctx context.Context) *resty.Request {
+		return client.R(ctx).SetResult(singleType)
+	}
+
+	pr := func(ctx context.Context) *resty.Request {
+		return client.R(ctx).SetResult(pagedType)
+	}
+
+	return &Resource{name, endpoint, useTemplate, tmpl, r, pr}
+}
+
+func (r Resource) render(data ...interface{}) (string, error) {
+	if data == nil {
+		return "", NewError("Cannot template endpoint with <nil> data")
+	}
+	out := ""
+	buf := bytes.NewBufferString(out)
+
+	var substitutions interface{}
+	if len(data) == 1 {
+		substitutions = struct{ ID interface{} }{data[0]}
+	} else if len(data) == 2 {
+		substitutions = struct {
+			ID       interface{}
+			SecondID interface{}
+		}{data[0], data[1]}
+	} else {
+		return "", NewError("Too many arguments to render template (expected 1 or 2)")
+	}
+	if err := r.endpointTemplate.Execute(buf, substitutions); err != nil {
+		return "", NewError(err)
+	}
+	return buf.String(), nil
+}
+
+// endpointWithID will return the rendered endpoint string for the resource with provided id
+func (r Resource) endpointWithID(id ...int) (string, error) {
+	if !r.isTemplate {
+		return r.endpoint, nil
+	}
+	data := make([]interface{}, len(id))
+	for i, v := range id {
+		data[i] = v
+	}
+	return r.render(data...)
+}
+
+// Endpoint will return the non-templated endpoint string for resource
+func (r Resource) Endpoint() (string, error) {
+	if r.isTemplate {
+		return "", NewError(fmt.Sprintf("Tried to get endpoint for %s without providing data for template", r.name))
+	}
+	return r.endpoint, nil
+}
--- a/vendor/github.com/linode/linodego/stackscripts.go
+++ b/vendor/github.com/linode/linodego/stackscripts.go
@ -0,0 +1,208 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// Stackscript represents a Linode StackScript
+type Stackscript struct {
+	CreatedStr string `json:"created"`
+	UpdatedStr string `json:"updated"`
+
+	ID                int               `json:"id"`
+	Username          string            `json:"username"`
+	Label             string            `json:"label"`
+	Description       string            `json:"description"`
+	Images            []string          `json:"images"`
+	DeploymentsTotal  int               `json:"deployments_total"`
+	DeploymentsActive int               `json:"deployments_active"`
+	IsPublic          bool              `json:"is_public"`
+	Created           *time.Time        `json:"-"`
+	Updated           *time.Time        `json:"-"`
+	RevNote           string            `json:"rev_note"`
+	Script            string            `json:"script"`
+	UserDefinedFields *[]StackscriptUDF `json:"user_defined_fields"`
+	UserGravatarID    string            `json:"user_gravatar_id"`
+}
+
+// StackscriptUDF define a single variable that is accepted by a Stackscript
+type StackscriptUDF struct {
+	// A human-readable label for the field that will serve as the input prompt for entering the value during deployment.
+	Label string `json:"label"`
+
+	// The name of the field.
+	Name string `json:"name"`
+
+	// An example value for the field.
+	Example string `json:"example"`
+
+	// A list of acceptable single values for the field.
+	OneOf string `json:"oneOf,omitempty"`
+
+	// A list of acceptable values for the field in any quantity, combination or order.
+	ManyOf string `json:"manyOf,omitempty"`
+
+	// The default value. If not specified, this value will be used.
+	Default string `json:"default,omitempty"`
+}
+
+// StackscriptCreateOptions fields are those accepted by CreateStackscript
+type StackscriptCreateOptions struct {
+	Label       string   `json:"label"`
+	Description string   `json:"description"`
+	Images      []string `json:"images"`
+	IsPublic    bool     `json:"is_public"`
+	RevNote     string   `json:"rev_note"`
+	Script      string   `json:"script"`
+}
+
+// StackscriptUpdateOptions fields are those accepted by UpdateStackscript
+type StackscriptUpdateOptions StackscriptCreateOptions
+
+// GetCreateOptions converts a Stackscript to StackscriptCreateOptions for use in CreateStackscript
+func (i Stackscript) GetCreateOptions() StackscriptCreateOptions {
+	return StackscriptCreateOptions{
+		Label:       i.Label,
+		Description: i.Description,
+		Images:      i.Images,
+		IsPublic:    i.IsPublic,
+		RevNote:     i.RevNote,
+		Script:      i.Script,
+	}
+}
+
+// GetUpdateOptions converts a Stackscript to StackscriptUpdateOptions for use in UpdateStackscript
+func (i Stackscript) GetUpdateOptions() StackscriptUpdateOptions {
+	return StackscriptUpdateOptions{
+		Label:       i.Label,
+		Description: i.Description,
+		Images:      i.Images,
+		IsPublic:    i.IsPublic,
+		RevNote:     i.RevNote,
+		Script:      i.Script,
+	}
+}
+
+// StackscriptsPagedResponse represents a paginated Stackscript API response
+type StackscriptsPagedResponse struct {
+	*PageOptions
+	Data []Stackscript `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Stackscript
+func (StackscriptsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.StackScripts.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Stackscripts when processing paginated Stackscript responses
+func (resp *StackscriptsPagedResponse) appendData(r *StackscriptsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListStackscripts lists Stackscripts
+func (c *Client) ListStackscripts(ctx context.Context, opts *ListOptions) ([]Stackscript, error) {
+	response := StackscriptsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *Stackscript) fixDates() *Stackscript {
+	i.Created, _ = parseDates(i.CreatedStr)
+	i.Updated, _ = parseDates(i.UpdatedStr)
+	return i
+}
+
+// GetStackscript gets the Stackscript with the provided ID
+func (c *Client) GetStackscript(ctx context.Context, id int) (*Stackscript, error) {
+	e, err := c.StackScripts.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&Stackscript{}).
+		Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Stackscript).fixDates(), nil
+}
+
+// CreateStackscript creates a StackScript
+func (c *Client) CreateStackscript(ctx context.Context, createOpts StackscriptCreateOptions) (*Stackscript, error) {
+	var body string
+	e, err := c.StackScripts.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Stackscript{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Stackscript).fixDates(), nil
+}
+
+// UpdateStackscript updates the StackScript with the specified id
+func (c *Client) UpdateStackscript(ctx context.Context, id int, updateOpts StackscriptUpdateOptions) (*Stackscript, error) {
+	var body string
+	e, err := c.StackScripts.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&Stackscript{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Stackscript).fixDates(), nil
+}
+
+// DeleteStackscript deletes the StackScript with the specified id
+func (c *Client) DeleteStackscript(ctx context.Context, id int) error {
+	e, err := c.StackScripts.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
--- a/vendor/github.com/linode/linodego/support.go
+++ b/vendor/github.com/linode/linodego/support.go
@ -0,0 +1,88 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+// Ticket represents a support ticket object
+type Ticket struct {
+	ID          int           `json:"id"`
+	Attachments []string      `json:"attachments"`
+	Closed      *time.Time    `json:"-"`
+	Description string        `json:"description"`
+	Entity      *TicketEntity `json:"entity"`
+	GravatarID  string        `json:"gravatar_id"`
+	Opened      *time.Time    `json:"-"`
+	OpenedBy    string        `json:"opened_by"`
+	Status      TicketStatus  `json:"status"`
+	Summary     string        `json:"summary"`
+	Updated     *time.Time    `json:"-"`
+	UpdatedBy   string        `json:"updated_by"`
+}
+
+// TicketEntity refers a ticket to a specific entity
+type TicketEntity struct {
+	ID    int    `json:"id"`
+	Label string `json:"label"`
+	Type  string `json:"type"`
+	URL   string `json:"url"`
+}
+
+// TicketStatus constants start with Ticket and include Linode API Ticket Status values
+type TicketStatus string
+
+// TicketStatus constants reflect the current status of a Ticket
+const (
+	TicketNew    TicketStatus = "new"
+	TicketClosed TicketStatus = "closed"
+	TicketOpen   TicketStatus = "open"
+)
+
+// TicketsPagedResponse represents a paginated ticket API response
+type TicketsPagedResponse struct {
+	*PageOptions
+	Data []Ticket `json:"data"`
+}
+
+func (TicketsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Tickets.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+func (resp *TicketsPagedResponse) appendData(r *TicketsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListTickets returns a collection of Support Tickets on the Account. Support Tickets
+// can be both tickets opened with Linode for support, as well as tickets generated by
+// Linode regarding the Account. This collection includes all Support Tickets generated
+// on the Account, with open tickets returned first.
+func (c *Client) ListTickets(ctx context.Context, opts *ListOptions) ([]Ticket, error) {
+	response := TicketsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetTicket gets a Support Ticket on the Account with the specified ID
+func (c *Client) GetTicket(ctx context.Context, id int) (*Ticket, error) {
+	e, err := c.Tickets.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&Ticket{}).
+		Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Ticket), nil
+}
--- a/vendor/github.com/linode/linodego/tags.go
+++ b/vendor/github.com/linode/linodego/tags.go
@ -0,0 +1,219 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+)
+
+// Tag represents a Tag object
+type Tag struct {
+	Label string `json:"label"`
+}
+
+// TaggedObject represents a Tagged Object object
+type TaggedObject struct {
+	Type    string          `json:"type"`
+	RawData json.RawMessage `json:"data"`
+	Data    interface{}     `json:"-"`
+}
+
+// SortedObjects currently only includes Instances
+type SortedObjects struct {
+	Instances     []Instance
+	Domains       []Domain
+	Volumes       []Volume
+	NodeBalancers []NodeBalancer
+	/*
+		StackScripts  []Stackscript
+	*/
+}
+
+// TaggedObjectList are a list of TaggedObjects, as returning by ListTaggedObjects
+type TaggedObjectList []TaggedObject
+
+// TagCreateOptions fields are those accepted by CreateTag
+type TagCreateOptions struct {
+	Label         string `json:"label"`
+	Linodes       []int  `json:"linodes,omitempty"`
+	Domains       []int  `json:"domains,omitempty"`
+	Volumes       []int  `json:"volumes,omitempty"`
+	NodeBalancers []int  `json:"nodebalancers,omitempty"`
+}
+
+// GetCreateOptions converts a Tag to TagCreateOptions for use in CreateTag
+func (i Tag) GetCreateOptions() (o TagCreateOptions) {
+	o.Label = i.Label
+	return
+}
+
+// TaggedObjectsPagedResponse represents a paginated Tag API response
+type TaggedObjectsPagedResponse struct {
+	*PageOptions
+	Data []TaggedObject `json:"data"`
+}
+
+// TagsPagedResponse represents a paginated Tag API response
+type TagsPagedResponse struct {
+	*PageOptions
+	Data []Tag `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Tag
+func (TagsPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Tags.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// endpoint gets the endpoint URL for Tag
+func (TaggedObjectsPagedResponse) endpointWithID(c *Client, id string) string {
+	endpoint, err := c.Tags.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	endpoint = fmt.Sprintf("%s/%s", endpoint, id)
+	return endpoint
+}
+
+// appendData appends Tags when processing paginated Tag responses
+func (resp *TagsPagedResponse) appendData(r *TagsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// appendData appends TaggedObjects when processing paginated TaggedObjects responses
+func (resp *TaggedObjectsPagedResponse) appendData(r *TaggedObjectsPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListTags lists Tags
+func (c *Client) ListTags(ctx context.Context, opts *ListOptions) ([]Tag, error) {
+	response := TagsPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixData stores an object of the type defined by Type in Data using RawData
+func (i *TaggedObject) fixData() (*TaggedObject, error) {
+	switch i.Type {
+	case "linode":
+		obj := Instance{}
+		if err := json.Unmarshal(i.RawData, &obj); err != nil {
+			return nil, err
+		}
+		i.Data = obj
+	case "nodebalancer":
+		obj := NodeBalancer{}
+		if err := json.Unmarshal(i.RawData, &obj); err != nil {
+			return nil, err
+		}
+		i.Data = obj
+	case "domain":
+		obj := Domain{}
+		if err := json.Unmarshal(i.RawData, &obj); err != nil {
+			return nil, err
+		}
+		i.Data = obj
+	case "volume":
+		obj := Volume{}
+		if err := json.Unmarshal(i.RawData, &obj); err != nil {
+			return nil, err
+		}
+		i.Data = obj
+	}
+
+	return i, nil
+}
+
+// ListTaggedObjects lists Tagged Objects
+func (c *Client) ListTaggedObjects(ctx context.Context, label string, opts *ListOptions) (TaggedObjectList, error) {
+	response := TaggedObjectsPagedResponse{}
+	err := c.listHelperWithID(ctx, &response, label, opts)
+	if err != nil {
+		return nil, err
+	}
+	for i := range response.Data {
+		if _, err := response.Data[i].fixData(); err != nil {
+			return nil, err
+		}
+	}
+	return response.Data, nil
+}
+
+// SortedObjects converts a list of TaggedObjects into a Sorted Objects struct, for easier access
+func (t TaggedObjectList) SortedObjects() (SortedObjects, error) {
+	so := SortedObjects{}
+	for _, o := range t {
+		switch o.Type {
+		case "linode":
+			if instance, ok := o.Data.(Instance); ok {
+				so.Instances = append(so.Instances, instance)
+			} else {
+				return so, errors.New("Expected an Instance when Type was \"linode\"")
+			}
+		case "domain":
+			if domain, ok := o.Data.(Domain); ok {
+				so.Domains = append(so.Domains, domain)
+			} else {
+				return so, errors.New("Expected a Domain when Type was \"domain\"")
+			}
+		case "volume":
+			if volume, ok := o.Data.(Volume); ok {
+				so.Volumes = append(so.Volumes, volume)
+			} else {
+				return so, errors.New("Expected an Volume when Type was \"volume\"")
+			}
+		case "nodebalancer":
+			if nodebalancer, ok := o.Data.(NodeBalancer); ok {
+				so.NodeBalancers = append(so.NodeBalancers, nodebalancer)
+			} else {
+				return so, errors.New("Expected an NodeBalancer when Type was \"nodebalancer\"")
+			}
+		}
+	}
+	return so, nil
+}
+
+// CreateTag creates a Tag
+func (c *Client) CreateTag(ctx context.Context, createOpts TagCreateOptions) (*Tag, error) {
+	var body string
+	e, err := c.Tags.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Tag{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Tag), nil
+}
+
+// DeleteTag deletes the Tag with the specified id
+func (c *Client) DeleteTag(ctx context.Context, label string) error {
+	e, err := c.Tags.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%s", e, label)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
--- a/vendor/github.com/linode/linodego/template.go
+++ b/vendor/github.com/linode/linodego/template.go
@ -0,0 +1,167 @@
+// +build ignore
+
+package linodego
+
+/*
+ - replace "Template" with "NameOfResource"
+ - replace "template" with "nameOfResource"
+ - copy template_test.go and do the same
+ - When updating Template structs,
+   - use pointers where ever null'able would have a different meaning if the wrapper
+	 supplied "" or 0 instead
+ - Add "NameOfResource" to client.go, resources.go, pagination.go
+*/
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+)
+
+// Template represents a Template object
+type Template struct {
+	ID int `json:"id"`
+	// UpdatedStr string `json:"updated"`
+	// Updated *time.Time `json:"-"`
+}
+
+// TemplateCreateOptions fields are those accepted by CreateTemplate
+type TemplateCreateOptions struct {
+}
+
+// TemplateUpdateOptions fields are those accepted by UpdateTemplate
+type TemplateUpdateOptions struct {
+}
+
+// GetCreateOptions converts a Template to TemplateCreateOptions for use in CreateTemplate
+func (i Template) GetCreateOptions() (o TemplateCreateOptions) {
+	// o.Label = i.Label
+	// o.Description = copyString(i.Description)
+	return
+}
+
+// GetUpdateOptions converts a Template to TemplateUpdateOptions for use in UpdateTemplate
+func (i Template) GetUpdateOptions() (o TemplateUpdateOptions) {
+	// o.Label = i.Label
+	// o.Description = copyString(i.Description)
+	return
+}
+
+// TemplatesPagedResponse represents a paginated Template API response
+type TemplatesPagedResponse struct {
+	*PageOptions
+	Data []Template `json:"data"`
+}
+
+// endpoint gets the endpoint URL for Template
+func (TemplatesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Templates.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Templates when processing paginated Template responses
+func (resp *TemplatesPagedResponse) appendData(r *TemplatesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListTemplates lists Templates
+func (c *Client) ListTemplates(ctx context.Context, opts *ListOptions) ([]Template, error) {
+	response := TemplatesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (i *Template) fixDates() *Template {
+	// i.Created, _ = parseDates(i.CreatedStr)
+	// i.Updated, _ = parseDates(i.UpdatedStr)
+	return i
+}
+
+// GetTemplate gets the template with the provided ID
+func (c *Client) GetTemplate(ctx context.Context, id int) (*Template, error) {
+	e, err := c.Templates.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Template{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Template).fixDates(), nil
+}
+
+// CreateTemplate creates a Template
+func (c *Client) CreateTemplate(ctx context.Context, createOpts TemplateCreateOptions) (*Template, error) {
+	var body string
+	e, err := c.Templates.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+
+	req := c.R(ctx).SetResult(&Template{})
+
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Template).fixDates(), nil
+}
+
+// UpdateTemplate updates the Template with the specified id
+func (c *Client) UpdateTemplate(ctx context.Context, id int, updateOpts TemplateUpdateOptions) (*Template, error) {
+	var body string
+	e, err := c.Templates.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&Template{})
+
+	if bodyData, err := json.Marshal(updateOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Template).fixDates(), nil
+}
+
+// DeleteTemplate deletes the Template with the specified id
+func (c *Client) DeleteTemplate(ctx context.Context, id int) error {
+	e, err := c.Templates.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
--- a/vendor/github.com/linode/linodego/types.go
+++ b/vendor/github.com/linode/linodego/types.go
@ -0,0 +1,90 @@
+package linodego
+
+import (
+	"context"
+	"fmt"
+)
+
+// LinodeType represents a linode type object
+type LinodeType struct {
+	ID         string          `json:"id"`
+	Disk       int             `json:"disk"`
+	Class      LinodeTypeClass `json:"class"` // enum: nanode, standard, highmem, dedicated
+	Price      *LinodePrice    `json:"price"`
+	Label      string          `json:"label"`
+	Addons     *LinodeAddons   `json:"addons"`
+	NetworkOut int             `json:"network_out"`
+	Memory     int             `json:"memory"`
+	Transfer   int             `json:"transfer"`
+	VCPUs      int             `json:"vcpus"`
+}
+
+// LinodePrice represents a linode type price object
+type LinodePrice struct {
+	Hourly  float32 `json:"hourly"`
+	Monthly float32 `json:"monthly"`
+}
+
+// LinodeBackupsAddon represents a linode backups addon object
+type LinodeBackupsAddon struct {
+	Price *LinodePrice `json:"price"`
+}
+
+// LinodeAddons represent the linode addons object
+type LinodeAddons struct {
+	Backups *LinodeBackupsAddon `json:"backups"`
+}
+
+// LinodeTypeClass constants start with Class and include Linode API Instance Type Classes
+type LinodeTypeClass string
+
+// LinodeTypeClass contants are the Instance Type Classes that an Instance Type can be assigned
+const (
+	ClassNanode    LinodeTypeClass = "nanode"
+	ClassStandard  LinodeTypeClass = "standard"
+	ClassHighmem   LinodeTypeClass = "highmem"
+	ClassDedicated LinodeTypeClass = "dedicated"
+)
+
+// LinodeTypesPagedResponse represents a linode types API response for listing
+type LinodeTypesPagedResponse struct {
+	*PageOptions
+	Data []LinodeType `json:"data"`
+}
+
+func (LinodeTypesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Types.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+func (resp *LinodeTypesPagedResponse) appendData(r *LinodeTypesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListTypes lists linode types
+func (c *Client) ListTypes(ctx context.Context, opts *ListOptions) ([]LinodeType, error) {
+	response := LinodeTypesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// GetType gets the type with the provided ID
+func (c *Client) GetType(ctx context.Context, typeID string) (*LinodeType, error) {
+	e, err := c.Types.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%s", e, typeID)
+
+	r, err := coupleAPIErrors(c.Types.R(ctx).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*LinodeType), nil
+}
--- a/vendor/github.com/linode/linodego/util.go
+++ b/vendor/github.com/linode/linodego/util.go
@ -0,0 +1,15 @@
+package linodego
+
+import "time"
+
+const (
+	dateLayout = "2006-01-02T15:04:05"
+)
+
+func parseDates(dateStr string) (*time.Time, error) {
+	d, err := time.Parse(dateLayout, dateStr)
+	if err != nil {
+		return nil, err
+	}
+	return &d, nil
+}
--- a/vendor/github.com/linode/linodego/volumes.go
+++ b/vendor/github.com/linode/linodego/volumes.go
@ -0,0 +1,299 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// VolumeStatus indicates the status of the Volume
+type VolumeStatus string
+
+const (
+	// VolumeCreating indicates the Volume is being created and is not yet available for use
+	VolumeCreating VolumeStatus = "creating"
+
+	// VolumeActive indicates the Volume is online and available for use
+	VolumeActive VolumeStatus = "active"
+
+	// VolumeResizing indicates the Volume is in the process of upgrading its current capacity
+	VolumeResizing VolumeStatus = "resizing"
+
+	// VolumeContactSupport indicates there is a problem with the Volume. A support ticket must be opened to resolve the issue
+	VolumeContactSupport VolumeStatus = "contact_support"
+)
+
+// Volume represents a linode volume object
+type Volume struct {
+	CreatedStr string `json:"created"`
+	UpdatedStr string `json:"updated"`
+
+	ID             int          `json:"id"`
+	Label          string       `json:"label"`
+	Status         VolumeStatus `json:"status"`
+	Region         string       `json:"region"`
+	Size           int          `json:"size"`
+	LinodeID       *int         `json:"linode_id"`
+	FilesystemPath string       `json:"filesystem_path"`
+	Tags           []string     `json:"tags"`
+	Created        time.Time    `json:"-"`
+	Updated        time.Time    `json:"-"`
+}
+
+// VolumeCreateOptions fields are those accepted by CreateVolume
+type VolumeCreateOptions struct {
+	Label    string `json:"label,omitempty"`
+	Region   string `json:"region,omitempty"`
+	LinodeID int    `json:"linode_id,omitempty"`
+	ConfigID int    `json:"config_id,omitempty"`
+	// The Volume's size, in GiB. Minimum size is 10GiB, maximum size is 10240GiB. A "0" value will result in the default size.
+	Size int `json:"size,omitempty"`
+	// An array of tags applied to this object. Tags are for organizational purposes only.
+	Tags []string `json:"tags"`
+}
+
+// VolumeUpdateOptions fields are those accepted by UpdateVolume
+type VolumeUpdateOptions struct {
+	Label string    `json:"label,omitempty"`
+	Tags  *[]string `json:"tags,omitempty"`
+}
+
+// VolumeAttachOptions fields are those accepted by AttachVolume
+type VolumeAttachOptions struct {
+	LinodeID int `json:"linode_id"`
+	ConfigID int `json:"config_id,omitempty"`
+}
+
+// VolumesPagedResponse represents a linode API response for listing of volumes
+type VolumesPagedResponse struct {
+	*PageOptions
+	Data []Volume `json:"data"`
+}
+
+// GetUpdateOptions converts a Volume to VolumeUpdateOptions for use in UpdateVolume
+func (v Volume) GetUpdateOptions() (updateOpts VolumeUpdateOptions) {
+	updateOpts.Label = v.Label
+	updateOpts.Tags = &v.Tags
+	return
+}
+
+// GetCreateOptions converts a Volume to VolumeCreateOptions for use in CreateVolume
+func (v Volume) GetCreateOptions() (createOpts VolumeCreateOptions) {
+	createOpts.Label = v.Label
+	createOpts.Tags = v.Tags
+	createOpts.Region = v.Region
+	createOpts.Size = v.Size
+	if v.LinodeID != nil && *v.LinodeID > 0 {
+		createOpts.LinodeID = *v.LinodeID
+	}
+	return
+}
+
+// endpoint gets the endpoint URL for Volume
+func (VolumesPagedResponse) endpoint(c *Client) string {
+	endpoint, err := c.Volumes.Endpoint()
+	if err != nil {
+		panic(err)
+	}
+	return endpoint
+}
+
+// appendData appends Volumes when processing paginated Volume responses
+func (resp *VolumesPagedResponse) appendData(r *VolumesPagedResponse) {
+	resp.Data = append(resp.Data, r.Data...)
+}
+
+// ListVolumes lists Volumes
+func (c *Client) ListVolumes(ctx context.Context, opts *ListOptions) ([]Volume, error) {
+	response := VolumesPagedResponse{}
+	err := c.listHelper(ctx, &response, opts)
+	for i := range response.Data {
+		response.Data[i].fixDates()
+	}
+	if err != nil {
+		return nil, err
+	}
+	return response.Data, nil
+}
+
+// fixDates converts JSON timestamps to Go time.Time values
+func (v *Volume) fixDates() *Volume {
+	if parsed, err := parseDates(v.CreatedStr); err != nil {
+		v.Created = *parsed
+	}
+	if parsed, err := parseDates(v.UpdatedStr); err != nil {
+		v.Updated = *parsed
+	}
+	return v
+}
+
+// GetVolume gets the template with the provided ID
+func (c *Client) GetVolume(ctx context.Context, id int) (*Volume, error) {
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+	r, err := coupleAPIErrors(c.R(ctx).SetResult(&Volume{}).Get(e))
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Volume).fixDates(), nil
+}
+
+// AttachVolume attaches a volume to a Linode instance
+func (c *Client) AttachVolume(ctx context.Context, id int, options *VolumeAttachOptions) (*Volume, error) {
+	body := ""
+	if bodyData, err := json.Marshal(options); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return nil, NewError(err)
+	}
+
+	e = fmt.Sprintf("%s/%d/attach", e, id)
+	resp, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&Volume{}).
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return resp.Result().(*Volume).fixDates(), nil
+}
+
+// CreateVolume creates a Linode Volume
+func (c *Client) CreateVolume(ctx context.Context, createOpts VolumeCreateOptions) (*Volume, error) {
+	body := ""
+	if bodyData, err := json.Marshal(createOpts); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return nil, NewError(err)
+	}
+
+	resp, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&Volume{}).
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return resp.Result().(*Volume).fixDates(), nil
+}
+
+// RenameVolume renames the label of a Linode volume
+// DEPRECATED: use UpdateVolume
+func (c *Client) RenameVolume(ctx context.Context, id int, label string) (*Volume, error) {
+	updateOpts := VolumeUpdateOptions{Label: label}
+	return c.UpdateVolume(ctx, id, updateOpts)
+}
+
+// UpdateVolume updates the Volume with the specified id
+func (c *Client) UpdateVolume(ctx context.Context, id int, volume VolumeUpdateOptions) (*Volume, error) {
+	var body string
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return nil, err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	req := c.R(ctx).SetResult(&Volume{})
+
+	if bodyData, err := json.Marshal(volume); err == nil {
+		body = string(bodyData)
+	} else {
+		return nil, NewError(err)
+	}
+
+	r, err := coupleAPIErrors(req.
+		SetBody(body).
+		Put(e))
+
+	if err != nil {
+		return nil, err
+	}
+	return r.Result().(*Volume).fixDates(), nil
+}
+
+// CloneVolume clones a Linode volume
+func (c *Client) CloneVolume(ctx context.Context, id int, label string) (*Volume, error) {
+	body := fmt.Sprintf("{\"label\":\"%s\"}", label)
+
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return nil, NewError(err)
+	}
+	e = fmt.Sprintf("%s/%d/clone", e, id)
+
+	resp, err := coupleAPIErrors(c.R(ctx).
+		SetResult(&Volume{}).
+		SetBody(body).
+		Post(e))
+
+	if err != nil {
+		return nil, err
+	}
+
+	return resp.Result().(*Volume).fixDates(), nil
+}
+
+// DetachVolume detaches a Linode volume
+func (c *Client) DetachVolume(ctx context.Context, id int) error {
+	body := ""
+
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return NewError(err)
+	}
+
+	e = fmt.Sprintf("%s/%d/detach", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).
+		SetBody(body).
+		Post(e))
+
+	return err
+}
+
+// ResizeVolume resizes an instance to new Linode type
+func (c *Client) ResizeVolume(ctx context.Context, id int, size int) error {
+	body := fmt.Sprintf("{\"size\": %d}", size)
+
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return NewError(err)
+	}
+	e = fmt.Sprintf("%s/%d/resize", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).
+		SetBody(body).
+		Post(e))
+
+	return err
+}
+
+// DeleteVolume deletes the Volume with the specified id
+func (c *Client) DeleteVolume(ctx context.Context, id int) error {
+	e, err := c.Volumes.Endpoint()
+	if err != nil {
+		return err
+	}
+	e = fmt.Sprintf("%s/%d", e, id)
+
+	_, err = coupleAPIErrors(c.R(ctx).Delete(e))
+	return err
+}
--- a/vendor/github.com/linode/linodego/waitfor.go
+++ b/vendor/github.com/linode/linodego/waitfor.go
@ -0,0 +1,273 @@
+package linodego
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"log"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// WaitForInstanceStatus waits for the Linode instance to reach the desired state
+// before returning. It will timeout with an error after timeoutSeconds.
+func (client Client) WaitForInstanceStatus(ctx context.Context, instanceID int, status InstanceStatus, timeoutSeconds int) (*Instance, error) {
+	ctx, cancel := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
+	defer cancel()
+
+	ticker := time.NewTicker(client.millisecondsPerPoll * time.Millisecond)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ticker.C:
+			instance, err := client.GetInstance(ctx, instanceID)
+			if err != nil {
+				return instance, err
+			}
+			complete := (instance.Status == status)
+
+			if complete {
+				return instance, nil
+			}
+		case <-ctx.Done():
+			return nil, fmt.Errorf("Error waiting for Instance %d status %s: %s", instanceID, status, ctx.Err())
+		}
+	}
+}
+
+// WaitForInstanceDiskStatus waits for the Linode instance disk to reach the desired state
+// before returning. It will timeout with an error after timeoutSeconds.
+func (client Client) WaitForInstanceDiskStatus(ctx context.Context, instanceID int, diskID int, status DiskStatus, timeoutSeconds int) (*InstanceDisk, error) {
+	ctx, cancel := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
+	defer cancel()
+
+	ticker := time.NewTicker(client.millisecondsPerPoll * time.Millisecond)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ticker.C:
+			// GetInstanceDisk will 404 on newly created disks. use List instead.
+			// disk, err := client.GetInstanceDisk(ctx, instanceID, diskID)
+			disks, err := client.ListInstanceDisks(ctx, instanceID, nil)
+			if err != nil {
+				return nil, err
+			}
+			for _, disk := range disks {
+				if disk.ID == diskID {
+					complete := (disk.Status == status)
+					if complete {
+						return &disk, nil
+					}
+					break
+				}
+			}
+
+		case <-ctx.Done():
+			return nil, fmt.Errorf("Error waiting for Instance %d Disk %d status %s: %s", instanceID, diskID, status, ctx.Err())
+		}
+	}
+}
+
+// WaitForVolumeStatus waits for the Volume to reach the desired state
+// before returning. It will timeout with an error after timeoutSeconds.
+func (client Client) WaitForVolumeStatus(ctx context.Context, volumeID int, status VolumeStatus, timeoutSeconds int) (*Volume, error) {
+	ctx, cancel := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
+	defer cancel()
+
+	ticker := time.NewTicker(client.millisecondsPerPoll * time.Millisecond)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ticker.C:
+			volume, err := client.GetVolume(ctx, volumeID)
+			if err != nil {
+				return volume, err
+			}
+			complete := (volume.Status == status)
+
+			if complete {
+				return volume, nil
+			}
+		case <-ctx.Done():
+			return nil, fmt.Errorf("Error waiting for Volume %d status %s: %s", volumeID, status, ctx.Err())
+		}
+	}
+}
+
+// WaitForSnapshotStatus waits for the Snapshot to reach the desired state
+// before returning. It will timeout with an error after timeoutSeconds.
+func (client Client) WaitForSnapshotStatus(ctx context.Context, instanceID int, snapshotID int, status InstanceSnapshotStatus, timeoutSeconds int) (*InstanceSnapshot, error) {
+	ctx, cancel := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
+	defer cancel()
+
+	ticker := time.NewTicker(client.millisecondsPerPoll * time.Millisecond)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ticker.C:
+			snapshot, err := client.GetInstanceSnapshot(ctx, instanceID, snapshotID)
+			if err != nil {
+				return snapshot, err
+			}
+			complete := (snapshot.Status == status)
+
+			if complete {
+				return snapshot, nil
+			}
+		case <-ctx.Done():
+			return nil, fmt.Errorf("Error waiting for Instance %d Snapshot %d status %s: %s", instanceID, snapshotID, status, ctx.Err())
+		}
+	}
+}
+
+// WaitForVolumeLinodeID waits for the Volume to match the desired LinodeID
+// before returning. An active Instance will not immediately attach or detach a volume, so the
+// the LinodeID must be polled to determine volume readiness from the API.
+// WaitForVolumeLinodeID will timeout with an error after timeoutSeconds.
+func (client Client) WaitForVolumeLinodeID(ctx context.Context, volumeID int, linodeID *int, timeoutSeconds int) (*Volume, error) {
+	ctx, cancel := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
+	defer cancel()
+
+	ticker := time.NewTicker(client.millisecondsPerPoll * time.Millisecond)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ticker.C:
+			volume, err := client.GetVolume(ctx, volumeID)
+			if err != nil {
+				return volume, err
+			}
+
+			if linodeID == nil && volume.LinodeID == nil {
+				return volume, nil
+			} else if linodeID == nil || volume.LinodeID == nil {
+				// continue waiting
+			} else if *volume.LinodeID == *linodeID {
+				return volume, nil
+			}
+
+		case <-ctx.Done():
+			return nil, fmt.Errorf("Error waiting for Volume %d to have Instance %v: %s", volumeID, linodeID, ctx.Err())
+		}
+	}
+}
+
+// WaitForEventFinished waits for an entity action to reach the 'finished' state
+// before returning. It will timeout with an error after timeoutSeconds.
+// If the event indicates a failure both the failed event and the error will be returned.
+func (client Client) WaitForEventFinished(ctx context.Context, id interface{}, entityType EntityType, action EventAction, minStart time.Time, timeoutSeconds int) (*Event, error) {
+	titledEntityType := strings.Title(string(entityType))
+	filter, _ := json.Marshal(map[string]interface{}{
+		// Entity is not filtered by the API
+		// Perhaps one day they will permit Entity ID/Type filtering.
+		// We'll have to verify these values manually, for now.
+		//"entity": map[string]interface{}{
+		//	"id":   fmt.Sprintf("%v", id),
+		//	"type": entityType,
+		//},
+
+		// Nor is action
+		//"action": action,
+
+		// Created is not correctly filtered by the API
+		// We'll have to verify these values manually, for now.
+		//"created": map[string]interface{}{
+		//	"+gte": minStart.Format(time.RFC3339),
+		//},
+
+		// With potentially 1000+ events coming back, we should filter on something
+		"seen": false,
+
+		// Float the latest events to page 1
+		"+order_by": "created",
+		"+order":    "desc",
+	})
+
+	// Optimistically restrict results to page 1.  We should remove this when more
+	// precise filtering options exist.
+	listOptions := NewListOptions(1, string(filter))
+
+	ctx, cancel := context.WithTimeout(ctx, time.Duration(timeoutSeconds)*time.Second)
+	defer cancel()
+
+	if deadline, ok := ctx.Deadline(); ok {
+		duration := time.Until(deadline)
+		log.Printf("[INFO] Waiting %d seconds for %s events since %v for %s %v", int(duration.Seconds()), action, minStart, titledEntityType, id)
+	}
+
+	ticker := time.NewTicker(client.millisecondsPerPoll * time.Millisecond)
+	defer ticker.Stop()
+	for {
+		select {
+		case <-ticker.C:
+
+			events, err := client.ListEvents(ctx, listOptions)
+			if err != nil {
+				return nil, err
+			}
+
+			// If there are events for this instance + action, inspect them
+			for _, event := range events {
+				if event.Action != action {
+					// log.Println("action mismatch", event.Action, action)
+					continue
+				}
+				if event.Entity == nil || event.Entity.Type != entityType {
+					// log.Println("type mismatch", event.Entity.Type, entityType)
+					continue
+				}
+
+				var entID string
+
+				switch event.Entity.ID.(type) {
+				case float64, float32:
+					entID = fmt.Sprintf("%.f", event.Entity.ID)
+				case int:
+					entID = strconv.Itoa(event.Entity.ID.(int))
+				default:
+					entID = fmt.Sprintf("%v", event.Entity.ID)
+				}
+
+				var findID string
+				switch id.(type) {
+				case float64, float32:
+					findID = fmt.Sprintf("%.f", id)
+				case int:
+					findID = strconv.Itoa(id.(int))
+				default:
+					findID = fmt.Sprintf("%v", id)
+				}
+
+				if entID != findID {
+					// log.Println("id mismatch", entID, findID)
+					continue
+				}
+
+				// @TODO(displague) This event.Created check shouldn't be needed, but it appears
+				// that the ListEvents method is not populating it correctly
+				if event.Created == nil {
+					log.Printf("[WARN] event.Created is nil when API returned: %#+v", event.CreatedStr)
+				} else if *event.Created != minStart && !event.Created.After(minStart) {
+					// Not the event we were looking for
+					// log.Println(event.Created, "is not >=", minStart)
+					continue
+
+				}
+
+				if event.Status == EventFailed {
+					return &event, fmt.Errorf("%s %v action %s failed", titledEntityType, id, action)
+				} else if event.Status == EventScheduled {
+					log.Printf("[INFO] %s %v action %s is scheduled", titledEntityType, id, action)
+				} else if event.Status == EventFinished {
+					log.Printf("[INFO] %s %v action %s is finished", titledEntityType, id, action)
+					return &event, nil
+				}
+				// TODO(displague) can we bump the ticker to TimeRemaining/2 (>=1) when non-nil?
+				log.Printf("[INFO] %s %v action %s is %s", titledEntityType, id, action, event.Status)
+			}
+		case <-ctx.Done():
+			return nil, fmt.Errorf("Error waiting for Event Status '%s' of %s %v action '%s': %s", EventFinished, titledEntityType, id, action, ctx.Err())
+		}
+	}
+}
--- a/vendor/golang.org/x/net/publicsuffix/gen.go
+++ b/vendor/golang.org/x/net/publicsuffix/gen.go
@ -0,0 +1,717 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// +build ignore
+
+package main
+
+// This program generates table.go and table_test.go based on the authoritative
+// public suffix list at https://publicsuffix.org/list/effective_tld_names.dat
+//
+// The version is derived from
+// https://api.github.com/repos/publicsuffix/list/commits?path=public_suffix_list.dat
+// and a human-readable form is at
+// https://github.com/publicsuffix/list/commits/master/public_suffix_list.dat
+//
+// To fetch a particular git revision, such as 5c70ccd250, pass
+// -url "https://raw.githubusercontent.com/publicsuffix/list/5c70ccd250/public_suffix_list.dat"
+// and -version "an explicit version string".
+
+import (
+	"bufio"
+	"bytes"
+	"flag"
+	"fmt"
+	"go/format"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"regexp"
+	"sort"
+	"strings"
+
+	"golang.org/x/net/idna"
+)
+
+const (
+	// These sum of these four values must be no greater than 32.
+	nodesBitsChildren   = 10
+	nodesBitsICANN      = 1
+	nodesBitsTextOffset = 15
+	nodesBitsTextLength = 6
+
+	// These sum of these four values must be no greater than 32.
+	childrenBitsWildcard = 1
+	childrenBitsNodeType = 2
+	childrenBitsHi       = 14
+	childrenBitsLo       = 14
+)
+
+var (
+	maxChildren   int
+	maxTextOffset int
+	maxTextLength int
+	maxHi         uint32
+	maxLo         uint32
+)
+
+func max(a, b int) int {
+	if a < b {
+		return b
+	}
+	return a
+}
+
+func u32max(a, b uint32) uint32 {
+	if a < b {
+		return b
+	}
+	return a
+}
+
+const (
+	nodeTypeNormal     = 0
+	nodeTypeException  = 1
+	nodeTypeParentOnly = 2
+	numNodeType        = 3
+)
+
+func nodeTypeStr(n int) string {
+	switch n {
+	case nodeTypeNormal:
+		return "+"
+	case nodeTypeException:
+		return "!"
+	case nodeTypeParentOnly:
+		return "o"
+	}
+	panic("unreachable")
+}
+
+const (
+	defaultURL   = "https://publicsuffix.org/list/effective_tld_names.dat"
+	gitCommitURL = "https://api.github.com/repos/publicsuffix/list/commits?path=public_suffix_list.dat"
+)
+
+var (
+	labelEncoding = map[string]uint32{}
+	labelsList    = []string{}
+	labelsMap     = map[string]bool{}
+	rules         = []string{}
+	numICANNRules = 0
+
+	// validSuffixRE is used to check that the entries in the public suffix
+	// list are in canonical form (after Punycode encoding). Specifically,
+	// capital letters are not allowed.
+	validSuffixRE = regexp.MustCompile(`^[a-z0-9_\!\*\-\.]+$`)
+
+	shaRE  = regexp.MustCompile(`"sha":"([^"]+)"`)
+	dateRE = regexp.MustCompile(`"committer":{[^{]+"date":"([^"]+)"`)
+
+	comments = flag.Bool("comments", false, "generate table.go comments, for debugging")
+	subset   = flag.Bool("subset", false, "generate only a subset of the full table, for debugging")
+	url      = flag.String("url", defaultURL, "URL of the publicsuffix.org list. If empty, stdin is read instead")
+	v        = flag.Bool("v", false, "verbose output (to stderr)")
+	version  = flag.String("version", "", "the effective_tld_names.dat version")
+)
+
+func main() {
+	if err := main1(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+
+func main1() error {
+	flag.Parse()
+	if nodesBitsTextLength+nodesBitsTextOffset+nodesBitsICANN+nodesBitsChildren > 32 {
+		return fmt.Errorf("not enough bits to encode the nodes table")
+	}
+	if childrenBitsLo+childrenBitsHi+childrenBitsNodeType+childrenBitsWildcard > 32 {
+		return fmt.Errorf("not enough bits to encode the children table")
+	}
+	if *version == "" {
+		if *url != defaultURL {
+			return fmt.Errorf("-version was not specified, and the -url is not the default one")
+		}
+		sha, date, err := gitCommit()
+		if err != nil {
+			return err
+		}
+		*version = fmt.Sprintf("publicsuffix.org's public_suffix_list.dat, git revision %s (%s)", sha, date)
+	}
+	var r io.Reader = os.Stdin
+	if *url != "" {
+		res, err := http.Get(*url)
+		if err != nil {
+			return err
+		}
+		if res.StatusCode != http.StatusOK {
+			return fmt.Errorf("bad GET status for %s: %d", *url, res.Status)
+		}
+		r = res.Body
+		defer res.Body.Close()
+	}
+
+	var root node
+	icann := false
+	br := bufio.NewReader(r)
+	for {
+		s, err := br.ReadString('\n')
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			return err
+		}
+		s = strings.TrimSpace(s)
+		if strings.Contains(s, "BEGIN ICANN DOMAINS") {
+			if len(rules) != 0 {
+				return fmt.Errorf(`expected no rules before "BEGIN ICANN DOMAINS"`)
+			}
+			icann = true
+			continue
+		}
+		if strings.Contains(s, "END ICANN DOMAINS") {
+			icann, numICANNRules = false, len(rules)
+			continue
+		}
+		if s == "" || strings.HasPrefix(s, "//") {
+			continue
+		}
+		s, err = idna.ToASCII(s)
+		if err != nil {
+			return err
+		}
+		if !validSuffixRE.MatchString(s) {
+			return fmt.Errorf("bad publicsuffix.org list data: %q", s)
+		}
+
+		if *subset {
+			switch {
+			case s == "ac.jp" || strings.HasSuffix(s, ".ac.jp"):
+			case s == "ak.us" || strings.HasSuffix(s, ".ak.us"):
+			case s == "ao" || strings.HasSuffix(s, ".ao"):
+			case s == "ar" || strings.HasSuffix(s, ".ar"):
+			case s == "arpa" || strings.HasSuffix(s, ".arpa"):
+			case s == "cy" || strings.HasSuffix(s, ".cy"):
+			case s == "dyndns.org" || strings.HasSuffix(s, ".dyndns.org"):
+			case s == "jp":
+			case s == "kobe.jp" || strings.HasSuffix(s, ".kobe.jp"):
+			case s == "kyoto.jp" || strings.HasSuffix(s, ".kyoto.jp"):
+			case s == "om" || strings.HasSuffix(s, ".om"):
+			case s == "uk" || strings.HasSuffix(s, ".uk"):
+			case s == "uk.com" || strings.HasSuffix(s, ".uk.com"):
+			case s == "tw" || strings.HasSuffix(s, ".tw"):
+			case s == "zw" || strings.HasSuffix(s, ".zw"):
+			case s == "xn--p1ai" || strings.HasSuffix(s, ".xn--p1ai"):
+				// xn--p1ai is Russian-Cyrillic "рф".
+			default:
+				continue
+			}
+		}
+
+		rules = append(rules, s)
+
+		nt, wildcard := nodeTypeNormal, false
+		switch {
+		case strings.HasPrefix(s, "*."):
+			s, nt = s[2:], nodeTypeParentOnly
+			wildcard = true
+		case strings.HasPrefix(s, "!"):
+			s, nt = s[1:], nodeTypeException
+		}
+		labels := strings.Split(s, ".")
+		for n, i := &root, len(labels)-1; i >= 0; i-- {
+			label := labels[i]
+			n = n.child(label)
+			if i == 0 {
+				if nt != nodeTypeParentOnly && n.nodeType == nodeTypeParentOnly {
+					n.nodeType = nt
+				}
+				n.icann = n.icann && icann
+				n.wildcard = n.wildcard || wildcard
+			}
+			labelsMap[label] = true
+		}
+	}
+	labelsList = make([]string, 0, len(labelsMap))
+	for label := range labelsMap {
+		labelsList = append(labelsList, label)
+	}
+	sort.Strings(labelsList)
+
+	if err := generate(printReal, &root, "table.go"); err != nil {
+		return err
+	}
+	if err := generate(printTest, &root, "table_test.go"); err != nil {
+		return err
+	}
+	return nil
+}
+
+func generate(p func(io.Writer, *node) error, root *node, filename string) error {
+	buf := new(bytes.Buffer)
+	if err := p(buf, root); err != nil {
+		return err
+	}
+	b, err := format.Source(buf.Bytes())
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(filename, b, 0644)
+}
+
+func gitCommit() (sha, date string, retErr error) {
+	res, err := http.Get(gitCommitURL)
+	if err != nil {
+		return "", "", err
+	}
+	if res.StatusCode != http.StatusOK {
+		return "", "", fmt.Errorf("bad GET status for %s: %d", gitCommitURL, res.Status)
+	}
+	defer res.Body.Close()
+	b, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return "", "", err
+	}
+	if m := shaRE.FindSubmatch(b); m != nil {
+		sha = string(m[1])
+	}
+	if m := dateRE.FindSubmatch(b); m != nil {
+		date = string(m[1])
+	}
+	if sha == "" || date == "" {
+		retErr = fmt.Errorf("could not find commit SHA and date in %s", gitCommitURL)
+	}
+	return sha, date, retErr
+}
+
+func printTest(w io.Writer, n *node) error {
+	fmt.Fprintf(w, "// generated by go run gen.go; DO NOT EDIT\n\n")
+	fmt.Fprintf(w, "package publicsuffix\n\nconst numICANNRules = %d\n\nvar rules = [...]string{\n", numICANNRules)
+	for _, rule := range rules {
+		fmt.Fprintf(w, "%q,\n", rule)
+	}
+	fmt.Fprintf(w, "}\n\nvar nodeLabels = [...]string{\n")
+	if err := n.walk(w, printNodeLabel); err != nil {
+		return err
+	}
+	fmt.Fprintf(w, "}\n")
+	return nil
+}
+
+func printReal(w io.Writer, n *node) error {
+	const header = `// generated by go run gen.go; DO NOT EDIT
+
+package publicsuffix
+
+const version = %q
+
+const (
+	nodesBitsChildren   = %d
+	nodesBitsICANN      = %d
+	nodesBitsTextOffset = %d
+	nodesBitsTextLength = %d
+
+	childrenBitsWildcard = %d
+	childrenBitsNodeType = %d
+	childrenBitsHi       = %d
+	childrenBitsLo       = %d
+)
+
+const (
+	nodeTypeNormal     = %d
+	nodeTypeException  = %d
+	nodeTypeParentOnly = %d
+)
+
+// numTLD is the number of top level domains.
+const numTLD = %d
+
+`
+	fmt.Fprintf(w, header, *version,
+		nodesBitsChildren, nodesBitsICANN, nodesBitsTextOffset, nodesBitsTextLength,
+		childrenBitsWildcard, childrenBitsNodeType, childrenBitsHi, childrenBitsLo,
+		nodeTypeNormal, nodeTypeException, nodeTypeParentOnly, len(n.children))
+
+	text := combineText(labelsList)
+	if text == "" {
+		return fmt.Errorf("internal error: makeText returned no text")
+	}
+	for _, label := range labelsList {
+		offset, length := strings.Index(text, label), len(label)
+		if offset < 0 {
+			return fmt.Errorf("internal error: could not find %q in text %q", label, text)
+		}
+		maxTextOffset, maxTextLength = max(maxTextOffset, offset), max(maxTextLength, length)
+		if offset >= 1<<nodesBitsTextOffset {
+			return fmt.Errorf("text offset %d is too large, or nodeBitsTextOffset is too small", offset)
+		}
+		if length >= 1<<nodesBitsTextLength {
+			return fmt.Errorf("text length %d is too large, or nodeBitsTextLength is too small", length)
+		}
+		labelEncoding[label] = uint32(offset)<<nodesBitsTextLength | uint32(length)
+	}
+	fmt.Fprintf(w, "// Text is the combined text of all labels.\nconst text = ")
+	for len(text) > 0 {
+		n, plus := len(text), ""
+		if n > 64 {
+			n, plus = 64, " +"
+		}
+		fmt.Fprintf(w, "%q%s\n", text[:n], plus)
+		text = text[n:]
+	}
+
+	if err := n.walk(w, assignIndexes); err != nil {
+		return err
+	}
+
+	fmt.Fprintf(w, `
+
+// nodes is the list of nodes. Each node is represented as a uint32, which
+// encodes the node's children, wildcard bit and node type (as an index into
+// the children array), ICANN bit and text.
+//
+// If the table was generated with the -comments flag, there is a //-comment
+// after each node's data. In it is the nodes-array indexes of the children,
+// formatted as (n0x1234-n0x1256), with * denoting the wildcard bit. The
+// nodeType is printed as + for normal, ! for exception, and o for parent-only
+// nodes that have children but don't match a domain label in their own right.
+// An I denotes an ICANN domain.
+//
+// The layout within the uint32, from MSB to LSB, is:
+//	[%2d bits] unused
+//	[%2d bits] children index
+//	[%2d bits] ICANN bit
+//	[%2d bits] text index
+//	[%2d bits] text length
+var nodes = [...]uint32{
+`,
+		32-nodesBitsChildren-nodesBitsICANN-nodesBitsTextOffset-nodesBitsTextLength,
+		nodesBitsChildren, nodesBitsICANN, nodesBitsTextOffset, nodesBitsTextLength)
+	if err := n.walk(w, printNode); err != nil {
+		return err
+	}
+	fmt.Fprintf(w, `}
+
+// children is the list of nodes' children, the parent's wildcard bit and the
+// parent's node type. If a node has no children then their children index
+// will be in the range [0, 6), depending on the wildcard bit and node type.
+//
+// The layout within the uint32, from MSB to LSB, is:
+//	[%2d bits] unused
+//	[%2d bits] wildcard bit
+//	[%2d bits] node type
+//	[%2d bits] high nodes index (exclusive) of children
+//	[%2d bits] low nodes index (inclusive) of children
+var children=[...]uint32{
+`,
+		32-childrenBitsWildcard-childrenBitsNodeType-childrenBitsHi-childrenBitsLo,
+		childrenBitsWildcard, childrenBitsNodeType, childrenBitsHi, childrenBitsLo)
+	for i, c := range childrenEncoding {
+		s := "---------------"
+		lo := c & (1<<childrenBitsLo - 1)
+		hi := (c >> childrenBitsLo) & (1<<childrenBitsHi - 1)
+		if lo != hi {
+			s = fmt.Sprintf("n0x%04x-n0x%04x", lo, hi)
+		}
+		nodeType := int(c>>(childrenBitsLo+childrenBitsHi)) & (1<<childrenBitsNodeType - 1)
+		wildcard := c>>(childrenBitsLo+childrenBitsHi+childrenBitsNodeType) != 0
+		if *comments {
+			fmt.Fprintf(w, "0x%08x, // c0x%04x (%s)%s %s\n",
+				c, i, s, wildcardStr(wildcard), nodeTypeStr(nodeType))
+		} else {
+			fmt.Fprintf(w, "0x%x,\n", c)
+		}
+	}
+	fmt.Fprintf(w, "}\n\n")
+	fmt.Fprintf(w, "// max children %d (capacity %d)\n", maxChildren, 1<<nodesBitsChildren-1)
+	fmt.Fprintf(w, "// max text offset %d (capacity %d)\n", maxTextOffset, 1<<nodesBitsTextOffset-1)
+	fmt.Fprintf(w, "// max text length %d (capacity %d)\n", maxTextLength, 1<<nodesBitsTextLength-1)
+	fmt.Fprintf(w, "// max hi %d (capacity %d)\n", maxHi, 1<<childrenBitsHi-1)
+	fmt.Fprintf(w, "// max lo %d (capacity %d)\n", maxLo, 1<<childrenBitsLo-1)
+	return nil
+}
+
+type node struct {
+	label    string
+	nodeType int
+	icann    bool
+	wildcard bool
+	// nodesIndex and childrenIndex are the index of this node in the nodes
+	// and the index of its children offset/length in the children arrays.
+	nodesIndex, childrenIndex int
+	// firstChild is the index of this node's first child, or zero if this
+	// node has no children.
+	firstChild int
+	// children are the node's children, in strictly increasing node label order.
+	children []*node
+}
+
+func (n *node) walk(w io.Writer, f func(w1 io.Writer, n1 *node) error) error {
+	if err := f(w, n); err != nil {
+		return err
+	}
+	for _, c := range n.children {
+		if err := c.walk(w, f); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// child returns the child of n with the given label. The child is created if
+// it did not exist beforehand.
+func (n *node) child(label string) *node {
+	for _, c := range n.children {
+		if c.label == label {
+			return c
+		}
+	}
+	c := &node{
+		label:    label,
+		nodeType: nodeTypeParentOnly,
+		icann:    true,
+	}
+	n.children = append(n.children, c)
+	sort.Sort(byLabel(n.children))
+	return c
+}
+
+type byLabel []*node
+
+func (b byLabel) Len() int           { return len(b) }
+func (b byLabel) Swap(i, j int)      { b[i], b[j] = b[j], b[i] }
+func (b byLabel) Less(i, j int) bool { return b[i].label < b[j].label }
+
+var nextNodesIndex int
+
+// childrenEncoding are the encoded entries in the generated children array.
+// All these pre-defined entries have no children.
+var childrenEncoding = []uint32{
+	0 << (childrenBitsLo + childrenBitsHi), // Without wildcard bit, nodeTypeNormal.
+	1 << (childrenBitsLo + childrenBitsHi), // Without wildcard bit, nodeTypeException.
+	2 << (childrenBitsLo + childrenBitsHi), // Without wildcard bit, nodeTypeParentOnly.
+	4 << (childrenBitsLo + childrenBitsHi), // With wildcard bit, nodeTypeNormal.
+	5 << (childrenBitsLo + childrenBitsHi), // With wildcard bit, nodeTypeException.
+	6 << (childrenBitsLo + childrenBitsHi), // With wildcard bit, nodeTypeParentOnly.
+}
+
+var firstCallToAssignIndexes = true
+
+func assignIndexes(w io.Writer, n *node) error {
+	if len(n.children) != 0 {
+		// Assign nodesIndex.
+		n.firstChild = nextNodesIndex
+		for _, c := range n.children {
+			c.nodesIndex = nextNodesIndex
+			nextNodesIndex++
+		}
+
+		// The root node's children is implicit.
+		if firstCallToAssignIndexes {
+			firstCallToAssignIndexes = false
+			return nil
+		}
+
+		// Assign childrenIndex.
+		maxChildren = max(maxChildren, len(childrenEncoding))
+		if len(childrenEncoding) >= 1<<nodesBitsChildren {
+			return fmt.Errorf("children table size %d is too large, or nodeBitsChildren is too small", len(childrenEncoding))
+		}
+		n.childrenIndex = len(childrenEncoding)
+		lo := uint32(n.firstChild)
+		hi := lo + uint32(len(n.children))
+		maxLo, maxHi = u32max(maxLo, lo), u32max(maxHi, hi)
+		if lo >= 1<<childrenBitsLo {
+			return fmt.Errorf("children lo %d is too large, or childrenBitsLo is too small", lo)
+		}
+		if hi >= 1<<childrenBitsHi {
+			return fmt.Errorf("children hi %d is too large, or childrenBitsHi is too small", hi)
+		}
+		enc := hi<<childrenBitsLo | lo
+		enc |= uint32(n.nodeType) << (childrenBitsLo + childrenBitsHi)
+		if n.wildcard {
+			enc |= 1 << (childrenBitsLo + childrenBitsHi + childrenBitsNodeType)
+		}
+		childrenEncoding = append(childrenEncoding, enc)
+	} else {
+		n.childrenIndex = n.nodeType
+		if n.wildcard {
+			n.childrenIndex += numNodeType
+		}
+	}
+	return nil
+}
+
+func printNode(w io.Writer, n *node) error {
+	for _, c := range n.children {
+		s := "---------------"
+		if len(c.children) != 0 {
+			s = fmt.Sprintf("n0x%04x-n0x%04x", c.firstChild, c.firstChild+len(c.children))
+		}
+		encoding := labelEncoding[c.label]
+		if c.icann {
+			encoding |= 1 << (nodesBitsTextLength + nodesBitsTextOffset)
+		}
+		encoding |= uint32(c.childrenIndex) << (nodesBitsTextLength + nodesBitsTextOffset + nodesBitsICANN)
+		if *comments {
+			fmt.Fprintf(w, "0x%08x, // n0x%04x c0x%04x (%s)%s %s %s %s\n",
+				encoding, c.nodesIndex, c.childrenIndex, s, wildcardStr(c.wildcard),
+				nodeTypeStr(c.nodeType), icannStr(c.icann), c.label,
+			)
+		} else {
+			fmt.Fprintf(w, "0x%x,\n", encoding)
+		}
+	}
+	return nil
+}
+
+func printNodeLabel(w io.Writer, n *node) error {
+	for _, c := range n.children {
+		fmt.Fprintf(w, "%q,\n", c.label)
+	}
+	return nil
+}
+
+func icannStr(icann bool) string {
+	if icann {
+		return "I"
+	}
+	return " "
+}
+
+func wildcardStr(wildcard bool) string {
+	if wildcard {
+		return "*"
+	}
+	return " "
+}
+
+// combineText combines all the strings in labelsList to form one giant string.
+// Overlapping strings will be merged: "arpa" and "parliament" could yield
+// "arparliament".
+func combineText(labelsList []string) string {
+	beforeLength := 0
+	for _, s := range labelsList {
+		beforeLength += len(s)
+	}
+
+	text := crush(removeSubstrings(labelsList))
+	if *v {
+		fmt.Fprintf(os.Stderr, "crushed %d bytes to become %d bytes\n", beforeLength, len(text))
+	}
+	return text
+}
+
+type byLength []string
+
+func (s byLength) Len() int           { return len(s) }
+func (s byLength) Swap(i, j int)      { s[i], s[j] = s[j], s[i] }
+func (s byLength) Less(i, j int) bool { return len(s[i]) < len(s[j]) }
+
+// removeSubstrings returns a copy of its input with any strings removed
+// that are substrings of other provided strings.
+func removeSubstrings(input []string) []string {
+	// Make a copy of input.
+	ss := append(make([]string, 0, len(input)), input...)
+	sort.Sort(byLength(ss))
+
+	for i, shortString := range ss {
+		// For each string, only consider strings higher than it in sort order, i.e.
+		// of equal length or greater.
+		for _, longString := range ss[i+1:] {
+			if strings.Contains(longString, shortString) {
+				ss[i] = ""
+				break
+			}
+		}
+	}
+
+	// Remove the empty strings.
+	sort.Strings(ss)
+	for len(ss) > 0 && ss[0] == "" {
+		ss = ss[1:]
+	}
+	return ss
+}
+
+// crush combines a list of strings, taking advantage of overlaps. It returns a
+// single string that contains each input string as a substring.
+func crush(ss []string) string {
+	maxLabelLen := 0
+	for _, s := range ss {
+		if maxLabelLen < len(s) {
+			maxLabelLen = len(s)
+		}
+	}
+
+	for prefixLen := maxLabelLen; prefixLen > 0; prefixLen-- {
+		prefixes := makePrefixMap(ss, prefixLen)
+		for i, s := range ss {
+			if len(s) <= prefixLen {
+				continue
+			}
+			mergeLabel(ss, i, prefixLen, prefixes)
+		}
+	}
+
+	return strings.Join(ss, "")
+}
+
+// mergeLabel merges the label at ss[i] with the first available matching label
+// in prefixMap, where the last "prefixLen" characters in ss[i] match the first
+// "prefixLen" characters in the matching label.
+// It will merge ss[i] repeatedly until no more matches are available.
+// All matching labels merged into ss[i] are replaced by "".
+func mergeLabel(ss []string, i, prefixLen int, prefixes prefixMap) {
+	s := ss[i]
+	suffix := s[len(s)-prefixLen:]
+	for _, j := range prefixes[suffix] {
+		// Empty strings mean "already used." Also avoid merging with self.
+		if ss[j] == "" || i == j {
+			continue
+		}
+		if *v {
+			fmt.Fprintf(os.Stderr, "%d-length overlap at (%4d,%4d): %q and %q share %q\n",
+				prefixLen, i, j, ss[i], ss[j], suffix)
+		}
+		ss[i] += ss[j][prefixLen:]
+		ss[j] = ""
+		// ss[i] has a new suffix, so merge again if possible.
+		// Note: we only have to merge again at the same prefix length. Shorter
+		// prefix lengths will be handled in the next iteration of crush's for loop.
+		// Can there be matches for longer prefix lengths, introduced by the merge?
+		// I believe that any such matches would by necessity have been eliminated
+		// during substring removal or merged at a higher prefix length. For
+		// instance, in crush("abc", "cde", "bcdef"), combining "abc" and "cde"
+		// would yield "abcde", which could be merged with "bcdef." However, in
+		// practice "cde" would already have been elimintated by removeSubstrings.
+		mergeLabel(ss, i, prefixLen, prefixes)
+		return
+	}
+}
+
+// prefixMap maps from a prefix to a list of strings containing that prefix. The
+// list of strings is represented as indexes into a slice of strings stored
+// elsewhere.
+type prefixMap map[string][]int
+
+// makePrefixMap constructs a prefixMap from a slice of strings.
+func makePrefixMap(ss []string, prefixLen int) prefixMap {
+	prefixes := make(prefixMap)
+	for i, s := range ss {
+		// We use < rather than <= because if a label matches on a prefix equal to
+		// its full length, that's actually a substring match handled by
+		// removeSubstrings.
+		if prefixLen < len(s) {
+			prefix := s[:prefixLen]
+			prefixes[prefix] = append(prefixes[prefix], i)
+		}
+	}
+
+	return prefixes
+}
--- a/vendor/golang.org/x/net/publicsuffix/list.go
+++ b/vendor/golang.org/x/net/publicsuffix/list.go
@ -0,0 +1,177 @@
+// Copyright 2012 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+//go:generate go run gen.go
+
+// Package publicsuffix provides a public suffix list based on data from
+// https://publicsuffix.org/
+//
+// A public suffix is one under which Internet users can directly register
+// names. It is related to, but different from, a TLD (top level domain).
+//
+// "com" is a TLD (top level domain). Top level means it has no dots.
+//
+// "com" is also a public suffix. Amazon and Google have registered different
+// siblings under that domain: "amazon.com" and "google.com".
+//
+// "au" is another TLD, again because it has no dots. But it's not "amazon.au".
+// Instead, it's "amazon.com.au".
+//
+// "com.au" isn't an actual TLD, because it's not at the top level (it has
+// dots). But it is an eTLD (effective TLD), because that's the branching point
+// for domain name registrars.
+//
+// Another name for "an eTLD" is "a public suffix". Often, what's more of
+// interest is the eTLD+1, or one more label than the public suffix. For
+// example, browsers partition read/write access to HTTP cookies according to
+// the eTLD+1. Web pages served from "amazon.com.au" can't read cookies from
+// "google.com.au", but web pages served from "maps.google.com" can share
+// cookies from "www.google.com", so you don't have to sign into Google Maps
+// separately from signing into Google Web Search. Note that all four of those
+// domains have 3 labels and 2 dots. The first two domains are each an eTLD+1,
+// the last two are not (but share the same eTLD+1: "google.com").
+//
+// All of these domains have the same eTLD+1:
+//  - "www.books.amazon.co.uk"
+//  - "books.amazon.co.uk"
+//  - "amazon.co.uk"
+// Specifically, the eTLD+1 is "amazon.co.uk", because the eTLD is "co.uk".
+//
+// There is no closed form algorithm to calculate the eTLD of a domain.
+// Instead, the calculation is data driven. This package provides a
+// pre-compiled snapshot of Mozilla's PSL (Public Suffix List) data at
+// https://publicsuffix.org/
+package publicsuffix // import "golang.org/x/net/publicsuffix"
+
+// TODO: specify case sensitivity and leading/trailing dot behavior for
+// func PublicSuffix and func EffectiveTLDPlusOne.
+
+import (
+	"fmt"
+	"net/http/cookiejar"
+	"strings"
+)
+
+// List implements the cookiejar.PublicSuffixList interface by calling the
+// PublicSuffix function.
+var List cookiejar.PublicSuffixList = list{}
+
+type list struct{}
+
+func (list) PublicSuffix(domain string) string {
+	ps, _ := PublicSuffix(domain)
+	return ps
+}
+
+func (list) String() string {
+	return version
+}
+
+// PublicSuffix returns the public suffix of the domain using a copy of the
+// publicsuffix.org database compiled into the library.
+//
+// icann is whether the public suffix is managed by the Internet Corporation
+// for Assigned Names and Numbers. If not, the public suffix is either a
+// privately managed domain (and in practice, not a top level domain) or an
+// unmanaged top level domain (and not explicitly mentioned in the
+// publicsuffix.org list). For example, "foo.org" and "foo.co.uk" are ICANN
+// domains, "foo.dyndns.org" and "foo.blogspot.co.uk" are private domains and
+// "cromulent" is an unmanaged top level domain.
+//
+// Use cases for distinguishing ICANN domains like "foo.com" from private
+// domains like "foo.appspot.com" can be found at
+// https://wiki.mozilla.org/Public_Suffix_List/Use_Cases
+func PublicSuffix(domain string) (publicSuffix string, icann bool) {
+	lo, hi := uint32(0), uint32(numTLD)
+	s, suffix, icannNode, wildcard := domain, len(domain), false, false
+loop:
+	for {
+		dot := strings.LastIndex(s, ".")
+		if wildcard {
+			icann = icannNode
+			suffix = 1 + dot
+		}
+		if lo == hi {
+			break
+		}
+		f := find(s[1+dot:], lo, hi)
+		if f == notFound {
+			break
+		}
+
+		u := nodes[f] >> (nodesBitsTextOffset + nodesBitsTextLength)
+		icannNode = u&(1<<nodesBitsICANN-1) != 0
+		u >>= nodesBitsICANN
+		u = children[u&(1<<nodesBitsChildren-1)]
+		lo = u & (1<<childrenBitsLo - 1)
+		u >>= childrenBitsLo
+		hi = u & (1<<childrenBitsHi - 1)
+		u >>= childrenBitsHi
+		switch u & (1<<childrenBitsNodeType - 1) {
+		case nodeTypeNormal:
+			suffix = 1 + dot
+		case nodeTypeException:
+			suffix = 1 + len(s)
+			break loop
+		}
+		u >>= childrenBitsNodeType
+		wildcard = u&(1<<childrenBitsWildcard-1) != 0
+		if !wildcard {
+			icann = icannNode
+		}
+
+		if dot == -1 {
+			break
+		}
+		s = s[:dot]
+	}
+	if suffix == len(domain) {
+		// If no rules match, the prevailing rule is "*".
+		return domain[1+strings.LastIndex(domain, "."):], icann
+	}
+	return domain[suffix:], icann
+}
+
+const notFound uint32 = 1<<32 - 1
+
+// find returns the index of the node in the range [lo, hi) whose label equals
+// label, or notFound if there is no such node. The range is assumed to be in
+// strictly increasing node label order.
+func find(label string, lo, hi uint32) uint32 {
+	for lo < hi {
+		mid := lo + (hi-lo)/2
+		s := nodeLabel(mid)
+		if s < label {
+			lo = mid + 1
+		} else if s == label {
+			return mid
+		} else {
+			hi = mid
+		}
+	}
+	return notFound
+}
+
+// nodeLabel returns the label for the i'th node.
+func nodeLabel(i uint32) string {
+	x := nodes[i]
+	length := x & (1<<nodesBitsTextLength - 1)
+	x >>= nodesBitsTextLength
+	offset := x & (1<<nodesBitsTextOffset - 1)
+	return text[offset : offset+length]
+}
+
+// EffectiveTLDPlusOne returns the effective top level domain plus one more
+// label. For example, the eTLD+1 for "foo.bar.golang.org" is "golang.org".
+func EffectiveTLDPlusOne(domain string) (string, error) {
+	suffix, _ := PublicSuffix(domain)
+	if len(domain) <= len(suffix) {
+		return "", fmt.Errorf("publicsuffix: cannot derive eTLD+1 for domain %q", domain)
+	}
+	i := len(domain) - len(suffix) - 1
+	if domain[i] != '.' {
+		return "", fmt.Errorf("publicsuffix: invalid public suffix %q for domain %q", suffix, domain)
+	}
+	return domain[1+strings.LastIndex(domain[:i], "."):], nil
+}
--- a/vendor/golang.org/x/net/publicsuffix/table.go
+++ b/vendor/golang.org/x/net/publicsuffix/table.go
--- a/vendor/gopkg.in/resty.v1/.gitignore
+++ b/vendor/gopkg.in/resty.v1/.gitignore
@ -0,0 +1,28 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
+*.test
+*.prof
+
+coverage.out
+coverage.txt
+go.sum
--- a/vendor/gopkg.in/resty.v1/.travis.yml
+++ b/vendor/gopkg.in/resty.v1/.travis.yml
@ -0,0 +1,28 @@
+language: go
+
+sudo: false
+
+go:
+#  - 1.3
+#  - 1.4
+#  - 1.5
+#  - 1.6
+#  - 1.7
+#  - 1.8.x
+#  - 1.9.x
+  - 1.10.x
+  - 1.11.x
+  - tip
+
+install:
+  - go get -v -t ./...
+
+script:
+  - go test ./... -coverprofile=coverage.txt -covermode=atomic
+
+after_success:
+  - bash <(curl -s https://codecov.io/bash)
+
+matrix:
+  allow_failures:
+    - go: tip
--- a/vendor/gopkg.in/resty.v1/BUILD.bazel
+++ b/vendor/gopkg.in/resty.v1/BUILD.bazel
@ -0,0 +1,36 @@
+package(default_visibility = ["//visibility:private"])
+
+load("@bazel_gazelle//:def.bzl", "gazelle")
+load("@io_bazel_rules_go//go:def.bzl", "go_library", "go_test")
+
+gazelle(
+    name = "gazelle",
+    command = "fix",
+    prefix = "gopkg.in/resty.v1",
+)
+
+go_library(
+    name = "go_default_library",
+    srcs = glob(
+        ["*.go"],
+        exclude = ["*_test.go"],
+    ),
+    importpath = "gopkg.in/resty.v1",
+    visibility = ["//visibility:public"],
+    deps = ["@org_golang_x_net//publicsuffix:go_default_library"],
+)
+
+go_test(
+    name = "go_default_test",
+    srcs =
+        glob(
+            ["*_test.go"],
+            exclude = ["example_test.go"],
+        ),
+    data = glob([".testdata/*"]),
+    embed = [":go_default_library"],
+    importpath = "gopkg.in/resty.v1",
+    deps = [
+        "@org_golang_x_net//proxy:go_default_library",
+    ],
+)
--- a/vendor/gopkg.in/resty.v1/LICENSE
+++ b/vendor/gopkg.in/resty.v1/LICENSE
@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015-2019 Jeevanandam M., https://myjeeva.com <jeeva@myjeeva.com>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
--- a/vendor/gopkg.in/resty.v1/README.md
+++ b/vendor/gopkg.in/resty.v1/README.md
@ -0,0 +1,741 @@
+<p align="center">
+<h1 align="center">Resty</h1>
+<p align="center">Simple HTTP and REST client library for Go (inspired by Ruby rest-client)</p>
+<p align="center"><a href="#features">Features</a> section describes in detail about Resty capabilities</p>
+</p>
+<p align="center">
+<p align="center"><a href="https://travis-ci.org/go-resty/resty"><img src="https://travis-ci.org/go-resty/resty.svg?branch=master" alt="Build Status"></a> <a href="https://codecov.io/gh/go-resty/resty/branch/master"><img src="https://codecov.io/gh/go-resty/resty/branch/master/graph/badge.svg" alt="Code Coverage"></a> <a href="https://goreportcard.com/report/go-resty/resty"><img src="https://goreportcard.com/badge/go-resty/resty" alt="Go Report Card"></a> <a href="https://github.com/go-resty/resty/releases/latest"><img src="https://img.shields.io/badge/version-1.12.0-blue.svg" alt="Release Version"></a> <a href="https://godoc.org/gopkg.in/resty.v1"><img src="https://godoc.org/gopkg.in/resty.v1?status.svg" alt="GoDoc"></a> <a href="LICENSE"><img src="https://img.shields.io/github/license/go-resty/resty.svg" alt="License"></a></p>
+</p>
+<p align="center">
+<h4 align="center">Resty Communication Channels</h4>
+<p align="center"><a href="https://gitter.im/go_resty/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge"><img src="https://badges.gitter.im/go_resty/community.svg" alt="Chat on Gitter - Resty Community"></a> <a href="https://twitter.com/go_resty"><img src="https://img.shields.io/badge/twitter-@go_resty-55acee.svg" alt="Twitter @go_resty"></a></p>
+</p>
+
+## News
+
+  * Resty `v2` development is in-progress :smile:
+  * v1.12.0 [released](https://github.com/go-resty/resty/releases/tag/v1.12.0) and tagged on Feb 27, 2019.
+  * v1.11.0 [released](https://github.com/go-resty/resty/releases/tag/v1.11.0) and tagged on Jan 06, 2019.
+  * v1.10.3 [released](https://github.com/go-resty/resty/releases/tag/v1.10.3) and tagged on Dec 04, 2018.
+  * v1.0 released and tagged on Sep 25, 2017. - Resty's first version was released on Sep 15, 2015 then it grew gradually as a very handy and helpful library. Its been a two years since first release. I'm very thankful to Resty users and its [contributors](https://github.com/go-resty/resty/graphs/contributors).
+
+## Features
+
+  * GET, POST, PUT, DELETE, HEAD, PATCH, OPTIONS, etc.
+  * Simple and chainable methods for settings and request
+  * Request Body can be `string`, `[]byte`, `struct`, `map`, `slice` and `io.Reader` too
+    * Auto detects `Content-Type`
+    * Buffer less processing for `io.Reader`
+  * [Response](https://godoc.org/gopkg.in/resty.v1#Response) object gives you more possibility
+    * Access as `[]byte` array - `response.Body()` OR Access as `string` - `response.String()`
+    * Know your `response.Time()` and when we `response.ReceivedAt()`
+  * Automatic marshal and unmarshal for `JSON` and `XML` content type
+    * Default is `JSON`, if you supply `struct/map` without header `Content-Type`
+    * For auto-unmarshal, refer to -
+        - Success scenario [Request.SetResult()](https://godoc.org/gopkg.in/resty.v1#Request.SetResult) and [Response.Result()](https://godoc.org/gopkg.in/resty.v1#Response.Result).
+        - Error scenario [Request.SetError()](https://godoc.org/gopkg.in/resty.v1#Request.SetError) and [Response.Error()](https://godoc.org/gopkg.in/resty.v1#Response.Error).
+        - Supports [RFC7807](https://tools.ietf.org/html/rfc7807) - `application/problem+json` & `application/problem+xml`
+  * Easy to upload one or more file(s) via `multipart/form-data`
+    * Auto detects file content type
+  * Request URL [Path Params (aka URI Params)](https://godoc.org/gopkg.in/resty.v1#Request.SetPathParams)
+  * Backoff Retry Mechanism with retry condition function [reference](retry_test.go)
+  * resty client HTTP & REST [Request](https://godoc.org/gopkg.in/resty.v1#Client.OnBeforeRequest) and [Response](https://godoc.org/gopkg.in/resty.v1#Client.OnAfterResponse) middlewares
+  * `Request.SetContext` supported `go1.7` and above
+  * Authorization option of `BasicAuth` and `Bearer` token
+  * Set request `ContentLength` value for all request or particular request
+  * Choose between HTTP and REST mode. Default is `REST`
+    * `HTTP` - default up to 10 redirects and no automatic response unmarshal
+    * `REST` - defaults to no redirects and automatic response marshal/unmarshal for `JSON` & `XML`
+  * Custom [Root Certificates](https://godoc.org/gopkg.in/resty.v1#Client.SetRootCertificate) and Client [Certificates](https://godoc.org/gopkg.in/resty.v1#Client.SetCertificates)
+  * Download/Save HTTP response directly into File, like `curl -o` flag. See [SetOutputDirectory](https://godoc.org/gopkg.in/resty.v1#Client.SetOutputDirectory) & [SetOutput](https://godoc.org/gopkg.in/resty.v1#Request.SetOutput).
+  * Cookies for your request and CookieJar support
+  * SRV Record based request instead of Host URL
+  * Client settings like `Timeout`, `RedirectPolicy`, `Proxy`, `TLSClientConfig`, `Transport`, etc.
+  * Optionally allows GET request with payload, see [SetAllowGetMethodPayload](https://godoc.org/gopkg.in/resty.v1#Client.SetAllowGetMethodPayload)
+  * Supports registering external JSON library into resty, see [how to use](https://github.com/go-resty/resty/issues/76#issuecomment-314015250)
+  * Exposes Response reader without reading response (no auto-unmarshaling) if need be, see [how to use](https://github.com/go-resty/resty/issues/87#issuecomment-322100604)
+  * Option to specify expected `Content-Type` when response `Content-Type` header missing. Refer to [#92](https://github.com/go-resty/resty/issues/92)
+  * Resty design
+    * Have client level settings & options and also override at Request level if you want to
+    * Request and Response middlewares
+    * Create Multiple clients if you want to `resty.New()`
+    * Supports `http.RoundTripper` implementation, see [SetTransport](https://godoc.org/gopkg.in/resty.v1#Client.SetTransport)
+    * goroutine concurrent safe
+    * REST and HTTP modes
+    * Debug mode - clean and informative logging presentation
+    * Gzip - Go does it automatically also resty has fallback handling too
+    * Works fine with `HTTP/2` and `HTTP/1.1`
+  * [Bazel support](#bazel-support)
+  * Easily mock resty for testing, [for e.g.](#mocking-http-requests-using-httpmock-library)
+  * Well tested client library
+
+Resty works with `go1.3` and above.
+
+### Included Batteries
+
+  * Redirect Policies - see [how to use](#redirect-policy)
+    * NoRedirectPolicy
+    * FlexibleRedirectPolicy
+    * DomainCheckRedirectPolicy
+    * etc. [more info](redirect.go)
+  * Retry Mechanism [how to use](#retries)
+    * Backoff Retry
+    * Conditional Retry
+  * SRV Record based request instead of Host URL [how to use](resty_test.go#L1412)
+  * etc (upcoming - throw your idea's [here](https://github.com/go-resty/resty/issues)).
+
+## Installation
+
+#### Stable Version - Production Ready
+
+Please refer section [Versioning](#versioning) for detailed info.
+
+##### go.mod
+
+```bash
+require gopkg.in/resty.v1 v1.12.0
+```
+
+##### go get
+```bash
+go get -u gopkg.in/resty.v1
+```
+
+#### Heads up for upcoming Resty v2 
+
+Resty v2 release will be moving away from `gopkg.in` proxy versioning. It will completely follow and adpating Go Mod versioning recommendation. For e.g.: module definition would be `module github.com/go-resty/resty/v2`.
+
+
+## It might be beneficial for your project :smile:
+
+Resty author also published following projects for Go Community.
+
+  * [aah framework](https://aahframework.org) - A secure, flexible, rapid Go web framework.
+  * [THUMBAI](https://thumbai.app), [Source Code](https://github.com/thumbai/thumbai) - Go Mod Repository, Go Vanity Service and Simple Proxy Server.
+  * [go-model](https://github.com/jeevatkm/go-model) - Robust & Easy to use model mapper and utility methods for Go `struct`.
+
+## Usage
+
+The following samples will assist you to become as comfortable as possible with resty library. Resty comes with ready to use DefaultClient.
+
+Import resty into your code and refer it as `resty`.
+
+```go
+import "gopkg.in/resty.v1"
+```
+
+#### Simple GET
+
+```go
+// GET request
+resp, err := resty.R().Get("http://httpbin.org/get")
+
+// explore response object
+fmt.Printf("\nError: %v", err)
+fmt.Printf("\nResponse Status Code: %v", resp.StatusCode())
+fmt.Printf("\nResponse Status: %v", resp.Status())
+fmt.Printf("\nResponse Time: %v", resp.Time())
+fmt.Printf("\nResponse Received At: %v", resp.ReceivedAt())
+fmt.Printf("\nResponse Body: %v", resp)     // or resp.String() or string(resp.Body())
+// more...
+
+/* Output
+Error: <nil>
+Response Status Code: 200
+Response Status: 200 OK
+Response Time: 160.1151ms
+Response Received At: 2018-10-16 16:28:34.8595663 -0700 PDT m=+0.166119401
+Response Body: {
+  "args": {},
+  "headers": {
+    "Accept-Encoding": "gzip",
+    "Connection": "close",
+    "Host": "httpbin.org",
+    "User-Agent": "go-resty/1.10.0 (https://github.com/go-resty/resty)"
+  },
+  "origin": "0.0.0.0",
+  "url": "http://httpbin.org/get"
+}
+*/
+```
+
+#### Enhanced GET
+
+```go
+resp, err := resty.R().
+      SetQueryParams(map[string]string{
+          "page_no": "1",
+          "limit": "20",
+          "sort":"name",
+          "order": "asc",
+          "random":strconv.FormatInt(time.Now().Unix(), 10),
+      }).
+      SetHeader("Accept", "application/json").
+      SetAuthToken("BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F").
+      Get("/search_result")
+
+
+// Sample of using Request.SetQueryString method
+resp, err := resty.R().
+      SetQueryString("productId=232&template=fresh-sample&cat=resty&source=google&kw=buy a lot more").
+      SetHeader("Accept", "application/json").
+      SetAuthToken("BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F").
+      Get("/show_product")
+```
+
+#### Various POST method combinations
+
+```go
+// POST JSON string
+// No need to set content type, if you have client level setting
+resp, err := resty.R().
+      SetHeader("Content-Type", "application/json").
+      SetBody(`{"username":"testuser", "password":"testpass"}`).
+      SetResult(&AuthSuccess{}).    // or SetResult(AuthSuccess{}).
+      Post("https://myapp.com/login")
+
+// POST []byte array
+// No need to set content type, if you have client level setting
+resp, err := resty.R().
+      SetHeader("Content-Type", "application/json").
+      SetBody([]byte(`{"username":"testuser", "password":"testpass"}`)).
+      SetResult(&AuthSuccess{}).    // or SetResult(AuthSuccess{}).
+      Post("https://myapp.com/login")
+
+// POST Struct, default is JSON content type. No need to set one
+resp, err := resty.R().
+      SetBody(User{Username: "testuser", Password: "testpass"}).
+      SetResult(&AuthSuccess{}).    // or SetResult(AuthSuccess{}).
+      SetError(&AuthError{}).       // or SetError(AuthError{}).
+      Post("https://myapp.com/login")
+
+// POST Map, default is JSON content type. No need to set one
+resp, err := resty.R().
+      SetBody(map[string]interface{}{"username": "testuser", "password": "testpass"}).
+      SetResult(&AuthSuccess{}).    // or SetResult(AuthSuccess{}).
+      SetError(&AuthError{}).       // or SetError(AuthError{}).
+      Post("https://myapp.com/login")
+
+// POST of raw bytes for file upload. For example: upload file to Dropbox
+fileBytes, _ := ioutil.ReadFile("/Users/jeeva/mydocument.pdf")
+
+// See we are not setting content-type header, since go-resty automatically detects Content-Type for you
+resp, err := resty.R().
+      SetBody(fileBytes).
+      SetContentLength(true).          // Dropbox expects this value
+      SetAuthToken("<your-auth-token>").
+      SetError(&DropboxError{}).       // or SetError(DropboxError{}).
+      Post("https://content.dropboxapi.com/1/files_put/auto/resty/mydocument.pdf") // for upload Dropbox supports PUT too
+
+// Note: resty detects Content-Type for request body/payload if content type header is not set.
+//   * For struct and map data type defaults to 'application/json'
+//   * Fallback is plain text content type
+```
+
+#### Sample PUT
+
+You can use various combinations of `PUT` method call like demonstrated for `POST`.
+
+```go
+// Note: This is one sample of PUT method usage, refer POST for more combination
+
+// Request goes as JSON content type
+// No need to set auth token, error, if you have client level settings
+resp, err := resty.R().
+      SetBody(Article{
+        Title: "go-resty",
+        Content: "This is my article content, oh ya!",
+        Author: "Jeevanandam M",
+        Tags: []string{"article", "sample", "resty"},
+      }).
+      SetAuthToken("C6A79608-782F-4ED0-A11D-BD82FAD829CD").
+      SetError(&Error{}).       // or SetError(Error{}).
+      Put("https://myapp.com/article/1234")
+```
+
+#### Sample PATCH
+
+You can use various combinations of `PATCH` method call like demonstrated for `POST`.
+
+```go
+// Note: This is one sample of PUT method usage, refer POST for more combination
+
+// Request goes as JSON content type
+// No need to set auth token, error, if you have client level settings
+resp, err := resty.R().
+      SetBody(Article{
+        Tags: []string{"new tag1", "new tag2"},
+      }).
+      SetAuthToken("C6A79608-782F-4ED0-A11D-BD82FAD829CD").
+      SetError(&Error{}).       // or SetError(Error{}).
+      Patch("https://myapp.com/articles/1234")
+```
+
+#### Sample DELETE, HEAD, OPTIONS
+
+```go
+// DELETE a article
+// No need to set auth token, error, if you have client level settings
+resp, err := resty.R().
+      SetAuthToken("C6A79608-782F-4ED0-A11D-BD82FAD829CD").
+      SetError(&Error{}).       // or SetError(Error{}).
+      Delete("https://myapp.com/articles/1234")
+
+// DELETE a articles with payload/body as a JSON string
+// No need to set auth token, error, if you have client level settings
+resp, err := resty.R().
+      SetAuthToken("C6A79608-782F-4ED0-A11D-BD82FAD829CD").
+      SetError(&Error{}).       // or SetError(Error{}).
+      SetHeader("Content-Type", "application/json").
+      SetBody(`{article_ids: [1002, 1006, 1007, 87683, 45432] }`).
+      Delete("https://myapp.com/articles")
+
+// HEAD of resource
+// No need to set auth token, if you have client level settings
+resp, err := resty.R().
+      SetAuthToken("C6A79608-782F-4ED0-A11D-BD82FAD829CD").
+      Head("https://myapp.com/videos/hi-res-video")
+
+// OPTIONS of resource
+// No need to set auth token, if you have client level settings
+resp, err := resty.R().
+      SetAuthToken("C6A79608-782F-4ED0-A11D-BD82FAD829CD").
+      Options("https://myapp.com/servers/nyc-dc-01")
+```
+
+### Multipart File(s) upload
+
+#### Using io.Reader
+
+```go
+profileImgBytes, _ := ioutil.ReadFile("/Users/jeeva/test-img.png")
+notesBytes, _ := ioutil.ReadFile("/Users/jeeva/text-file.txt")
+
+resp, err := resty.R().
+      SetFileReader("profile_img", "test-img.png", bytes.NewReader(profileImgBytes)).
+      SetFileReader("notes", "text-file.txt", bytes.NewReader(notesBytes)).
+      SetFormData(map[string]string{
+          "first_name": "Jeevanandam",
+          "last_name": "M",
+      }).
+      Post("http://myapp.com/upload")
+```
+
+#### Using File directly from Path
+
+```go
+// Single file scenario
+resp, err := resty.R().
+      SetFile("profile_img", "/Users/jeeva/test-img.png").
+      Post("http://myapp.com/upload")
+
+// Multiple files scenario
+resp, err := resty.R().
+      SetFiles(map[string]string{
+        "profile_img": "/Users/jeeva/test-img.png",
+        "notes": "/Users/jeeva/text-file.txt",
+      }).
+      Post("http://myapp.com/upload")
+
+// Multipart of form fields and files
+resp, err := resty.R().
+      SetFiles(map[string]string{
+        "profile_img": "/Users/jeeva/test-img.png",
+        "notes": "/Users/jeeva/text-file.txt",
+      }).
+      SetFormData(map[string]string{
+        "first_name": "Jeevanandam",
+        "last_name": "M",
+        "zip_code": "00001",
+        "city": "my city",
+        "access_token": "C6A79608-782F-4ED0-A11D-BD82FAD829CD",
+      }).
+      Post("http://myapp.com/profile")
+```
+
+#### Sample Form submission
+
+```go
+// just mentioning about POST as an example with simple flow
+// User Login
+resp, err := resty.R().
+      SetFormData(map[string]string{
+        "username": "jeeva",
+        "password": "mypass",
+      }).
+      Post("http://myapp.com/login")
+
+// Followed by profile update
+resp, err := resty.R().
+      SetFormData(map[string]string{
+        "first_name": "Jeevanandam",
+        "last_name": "M",
+        "zip_code": "00001",
+        "city": "new city update",
+      }).
+      Post("http://myapp.com/profile")
+
+// Multi value form data
+criteria := url.Values{
+  "search_criteria": []string{"book", "glass", "pencil"},
+}
+resp, err := resty.R().
+      SetMultiValueFormData(criteria).
+      Post("http://myapp.com/search")
+```
+
+#### Save HTTP Response into File
+
+```go
+// Setting output directory path, If directory not exists then resty creates one!
+// This is optional one, if you're planning using absoule path in
+// `Request.SetOutput` and can used together.
+resty.SetOutputDirectory("/Users/jeeva/Downloads")
+
+// HTTP response gets saved into file, similar to curl -o flag
+_, err := resty.R().
+          SetOutput("plugin/ReplyWithHeader-v5.1-beta.zip").
+          Get("http://bit.ly/1LouEKr")
+
+// OR using absolute path
+// Note: output directory path is not used for absoulte path
+_, err := resty.R().
+          SetOutput("/MyDownloads/plugin/ReplyWithHeader-v5.1-beta.zip").
+          Get("http://bit.ly/1LouEKr")
+```
+
+#### Request URL Path Params
+
+Resty provides easy to use dynamic request URL path params. Params can be set at client and request level. Client level params value can be overridden at request level.
+
+```go
+resty.R().SetPathParams(map[string]string{
+   "userId": "sample@sample.com",
+   "subAccountId": "100002",
+}).
+Get("/v1/users/{userId}/{subAccountId}/details")
+
+// Result:
+//   Composed URL - /v1/users/sample@sample.com/100002/details
+```
+
+#### Request and Response Middleware
+
+Resty provides middleware ability to manipulate for Request and Response. It is more flexible than callback approach.
+
+```go
+// Registering Request Middleware
+resty.OnBeforeRequest(func(c *resty.Client, req *resty.Request) error {
+    // Now you have access to Client and current Request object
+    // manipulate it as per your need
+
+    return nil  // if its success otherwise return error
+  })
+
+// Registering Response Middleware
+resty.OnAfterResponse(func(c *resty.Client, resp *resty.Response) error {
+    // Now you have access to Client and current Response object
+    // manipulate it as per your need
+
+    return nil  // if its success otherwise return error
+  })
+```
+
+#### Redirect Policy
+
+Resty provides few ready to use redirect policy(s) also it supports multiple policies together.
+
+```go
+// Assign Client Redirect Policy. Create one as per you need
+resty.SetRedirectPolicy(resty.FlexibleRedirectPolicy(15))
+
+// Wanna multiple policies such as redirect count, domain name check, etc
+resty.SetRedirectPolicy(resty.FlexibleRedirectPolicy(20),
+                        resty.DomainCheckRedirectPolicy("host1.com", "host2.org", "host3.net"))
+```
+
+##### Custom Redirect Policy
+
+Implement [RedirectPolicy](redirect.go#L20) interface and register it with resty client. Have a look [redirect.go](redirect.go) for more information.
+
+```go
+// Using raw func into resty.SetRedirectPolicy
+resty.SetRedirectPolicy(resty.RedirectPolicyFunc(func(req *http.Request, via []*http.Request) error {
+  // Implement your logic here
+
+  // return nil for continue redirect otherwise return error to stop/prevent redirect
+  return nil
+}))
+
+//---------------------------------------------------
+
+// Using struct create more flexible redirect policy
+type CustomRedirectPolicy struct {
+  // variables goes here
+}
+
+func (c *CustomRedirectPolicy) Apply(req *http.Request, via []*http.Request) error {
+  // Implement your logic here
+
+  // return nil for continue redirect otherwise return error to stop/prevent redirect
+  return nil
+}
+
+// Registering in resty
+resty.SetRedirectPolicy(CustomRedirectPolicy{/* initialize variables */})
+```
+
+#### Custom Root Certificates and Client Certificates
+
+```go
+// Custom Root certificates, just supply .pem file.
+// you can add one or more root certificates, its get appended
+resty.SetRootCertificate("/path/to/root/pemFile1.pem")
+resty.SetRootCertificate("/path/to/root/pemFile2.pem")
+// ... and so on!
+
+// Adding Client Certificates, you add one or more certificates
+// Sample for creating certificate object
+// Parsing public/private key pair from a pair of files. The files must contain PEM encoded data.
+cert1, err := tls.LoadX509KeyPair("certs/client.pem", "certs/client.key")
+if err != nil {
+  log.Fatalf("ERROR client certificate: %s", err)
+}
+// ...
+
+// You add one or more certificates
+resty.SetCertificates(cert1, cert2, cert3)
+```
+
+#### Proxy Settings - Client as well as at Request Level
+
+Default `Go` supports Proxy via environment variable `HTTP_PROXY`. Resty provides support via `SetProxy` & `RemoveProxy`.
+Choose as per your need.
+
+**Client Level Proxy** settings applied to all the request
+
+```go
+// Setting a Proxy URL and Port
+resty.SetProxy("http://proxyserver:8888")
+
+// Want to remove proxy setting
+resty.RemoveProxy()
+```
+
+#### Retries
+
+Resty uses [backoff](http://www.awsarchitectureblog.com/2015/03/backoff.html)
+to increase retry intervals after each attempt.
+
+Usage example:
+
+```go
+// Retries are configured per client
+resty.
+    // Set retry count to non zero to enable retries
+    SetRetryCount(3).
+    // You can override initial retry wait time.
+    // Default is 100 milliseconds.
+    SetRetryWaitTime(5 * time.Second).
+    // MaxWaitTime can be overridden as well.
+    // Default is 2 seconds.
+    SetRetryMaxWaitTime(20 * time.Second)
+```
+
+Above setup will result in resty retrying requests returned non nil error up to
+3 times with delay increased after each attempt.
+
+You can optionally provide client with custom retry conditions:
+
+```go
+resty.AddRetryCondition(
+    // Condition function will be provided with *resty.Response as a
+    // parameter. It is expected to return (bool, error) pair. Resty will retry
+    // in case condition returns true or non nil error.
+    func(r *resty.Response) (bool, error) {
+        return r.StatusCode() == http.StatusTooManyRequests, nil
+    },
+)
+```
+
+Above example will make resty retry requests ended with `429 Too Many Requests`
+status code.
+
+Multiple retry conditions can be added.
+
+It is also possible to use `resty.Backoff(...)` to get arbitrary retry scenarios
+implemented. [Reference](retry_test.go).
+
+#### Choose REST or HTTP mode
+
+```go
+// REST mode. This is Default.
+resty.SetRESTMode()
+
+// HTTP mode
+resty.SetHTTPMode()
+```
+
+#### Allow GET request with Payload
+
+```go
+// Allow GET request with Payload. This is disabled by default.
+resty.SetAllowGetMethodPayload(true)
+```
+
+#### Wanna Multiple Clients
+
+```go
+// Here you go!
+// Client 1
+client1 := resty.New()
+client1.R().Get("http://httpbin.org")
+// ...
+
+// Client 2
+client2 := resty.New()
+client2.R().Head("http://httpbin.org")
+// ...
+
+// Bend it as per your need!!!
+```
+
+#### Remaining Client Settings & its Options
+
+```go
+// Unique settings at Client level
+//--------------------------------
+// Enable debug mode
+resty.SetDebug(true)
+
+// Using you custom log writer
+logFile, _ := os.OpenFile("/Users/jeeva/go-resty.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+resty.SetLogger(logFile)
+
+// Assign Client TLSClientConfig
+// One can set custom root-certificate. Refer: http://golang.org/pkg/crypto/tls/#example_Dial
+resty.SetTLSClientConfig(&tls.Config{ RootCAs: roots })
+
+// or One can disable security check (https)
+resty.SetTLSClientConfig(&tls.Config{ InsecureSkipVerify: true })
+
+// Set client timeout as per your need
+resty.SetTimeout(1 * time.Minute)
+
+
+// You can override all below settings and options at request level if you want to
+//--------------------------------------------------------------------------------
+// Host URL for all request. So you can use relative URL in the request
+resty.SetHostURL("http://httpbin.org")
+
+// Headers for all request
+resty.SetHeader("Accept", "application/json")
+resty.SetHeaders(map[string]string{
+        "Content-Type": "application/json",
+        "User-Agent": "My custom User Agent String",
+      })
+
+// Cookies for all request
+resty.SetCookie(&http.Cookie{
+      Name:"go-resty",
+      Value:"This is cookie value",
+      Path: "/",
+      Domain: "sample.com",
+      MaxAge: 36000,
+      HttpOnly: true,
+      Secure: false,
+    })
+resty.SetCookies(cookies)
+
+// URL query parameters for all request
+resty.SetQueryParam("user_id", "00001")
+resty.SetQueryParams(map[string]string{ // sample of those who use this manner
+      "api_key": "api-key-here",
+      "api_secert": "api-secert",
+    })
+resty.R().SetQueryString("productId=232&template=fresh-sample&cat=resty&source=google&kw=buy a lot more")
+
+// Form data for all request. Typically used with POST and PUT
+resty.SetFormData(map[string]string{
+    "access_token": "BC594900-518B-4F7E-AC75-BD37F019E08F",
+  })
+
+// Basic Auth for all request
+resty.SetBasicAuth("myuser", "mypass")
+
+// Bearer Auth Token for all request
+resty.SetAuthToken("BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F")
+
+// Enabling Content length value for all request
+resty.SetContentLength(true)
+
+// Registering global Error object structure for JSON/XML request
+resty.SetError(&Error{})    // or resty.SetError(Error{})
+```
+
+#### Unix Socket
+
+```go
+unixSocket := "/var/run/my_socket.sock"
+
+// Create a Go's http.Transport so we can set it in resty.
+transport := http.Transport{
+	Dial: func(_, _ string) (net.Conn, error) {
+		return net.Dial("unix", unixSocket)
+	},
+}
+
+// Set the previous transport that we created, set the scheme of the communication to the
+// socket and set the unixSocket as the HostURL.
+r := resty.New().SetTransport(&transport).SetScheme("http").SetHostURL(unixSocket)
+
+// No need to write the host's URL on the request, just the path.
+r.R().Get("/index.html")
+```
+
+#### Bazel support
+
+Resty can be built, tested and depended upon via [Bazel](https://bazel.build).
+For example, to run all tests:
+
+```shell
+bazel test :go_default_test
+```
+
+#### Mocking http requests using [httpmock](https://github.com/jarcoal/httpmock) library
+
+In order to mock the http requests when testing your application you
+could use the `httpmock` library.
+
+When using the default resty client, you should pass the client to the library as follow:
+
+```go
+httpmock.ActivateNonDefault(resty.DefaultClient.GetClient())
+```
+
+More detailed example of mocking resty http requests using ginko could be found [here](https://github.com/jarcoal/httpmock#ginkgo--resty-example).
+
+## Versioning
+
+resty releases versions according to [Semantic Versioning](http://semver.org)
+
+  * `gopkg.in/resty.vX` points to appropriate tagged versions; `X` denotes version series number and it's a stable release for production use. For e.g. `gopkg.in/resty.v0`.
+  * Development takes place at the master branch. Although the code in master should always compile and test successfully, it might break API's. I aim to maintain backwards compatibility, but sometimes API's and behavior might be changed to fix a bug.
+
+## Contribution
+
+I would welcome your contribution! If you find any improvement or issue you want to fix, feel free to send a pull request, I like pull requests that include test cases for fix/enhancement. I have done my best to bring pretty good code coverage. Feel free to write tests.
+
+BTW, I'd like to know what you think about `Resty`. Kindly open an issue or send me an email; it'd mean a lot to me.
+
+## Creator
+
+[Jeevanandam M.](https://github.com/jeevatkm) (jeeva@myjeeva.com)
+
+## Contributors
+
+Have a look on [Contributors](https://github.com/go-resty/resty/graphs/contributors) page.
+
+## License
+
+Resty released under MIT license, refer [LICENSE](LICENSE) file.
--- a/vendor/gopkg.in/resty.v1/WORKSPACE
+++ b/vendor/gopkg.in/resty.v1/WORKSPACE
@ -0,0 +1,27 @@
+workspace(name = "resty")
+
+git_repository(
+    name = "io_bazel_rules_go",
+    remote = "https://github.com/bazelbuild/rules_go.git",
+    tag = "0.13.0",
+)
+
+git_repository(
+    name = "bazel_gazelle",
+    remote = "https://github.com/bazelbuild/bazel-gazelle.git",
+    tag = "0.13.0",
+)
+
+load(
+    "@io_bazel_rules_go//go:def.bzl",
+    "go_rules_dependencies",
+    "go_register_toolchains",
+)
+
+go_rules_dependencies()
+
+go_register_toolchains()
+
+load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies")
+
+gazelle_dependencies()
--- a/vendor/gopkg.in/resty.v1/client.go
+++ b/vendor/gopkg.in/resty.v1/client.go
@ -0,0 +1,926 @@
+// Copyright (c) 2015-2019 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"bytes"
+	"compress/gzip"
+	"crypto/tls"
+	"crypto/x509"
+	"errors"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"net/url"
+	"reflect"
+	"regexp"
+	"strings"
+	"sync"
+	"time"
+)
+
+const (
+	// MethodGet HTTP method
+	MethodGet = "GET"
+
+	// MethodPost HTTP method
+	MethodPost = "POST"
+
+	// MethodPut HTTP method
+	MethodPut = "PUT"
+
+	// MethodDelete HTTP method
+	MethodDelete = "DELETE"
+
+	// MethodPatch HTTP method
+	MethodPatch = "PATCH"
+
+	// MethodHead HTTP method
+	MethodHead = "HEAD"
+
+	// MethodOptions HTTP method
+	MethodOptions = "OPTIONS"
+)
+
+var (
+	hdrUserAgentKey       = http.CanonicalHeaderKey("User-Agent")
+	hdrAcceptKey          = http.CanonicalHeaderKey("Accept")
+	hdrContentTypeKey     = http.CanonicalHeaderKey("Content-Type")
+	hdrContentLengthKey   = http.CanonicalHeaderKey("Content-Length")
+	hdrContentEncodingKey = http.CanonicalHeaderKey("Content-Encoding")
+	hdrAuthorizationKey   = http.CanonicalHeaderKey("Authorization")
+
+	plainTextType   = "text/plain; charset=utf-8"
+	jsonContentType = "application/json; charset=utf-8"
+	formContentType = "application/x-www-form-urlencoded"
+
+	jsonCheck = regexp.MustCompile(`(?i:(application|text)/(json|.*\+json|json\-.*)(;|$))`)
+	xmlCheck  = regexp.MustCompile(`(?i:(application|text)/(xml|.*\+xml)(;|$))`)
+
+	hdrUserAgentValue = "go-resty/%s (https://github.com/go-resty/resty)"
+	bufPool           = &sync.Pool{New: func() interface{} { return &bytes.Buffer{} }}
+)
+
+// Client type is used for HTTP/RESTful global values
+// for all request raised from the client
+type Client struct {
+	HostURL               string
+	QueryParam            url.Values
+	FormData              url.Values
+	Header                http.Header
+	UserInfo              *User
+	Token                 string
+	Cookies               []*http.Cookie
+	Error                 reflect.Type
+	Debug                 bool
+	DisableWarn           bool
+	AllowGetMethodPayload bool
+	Log                   *log.Logger
+	RetryCount            int
+	RetryWaitTime         time.Duration
+	RetryMaxWaitTime      time.Duration
+	RetryConditions       []RetryConditionFunc
+	JSONMarshal           func(v interface{}) ([]byte, error)
+	JSONUnmarshal         func(data []byte, v interface{}) error
+
+	jsonEscapeHTML     bool
+	httpClient         *http.Client
+	setContentLength   bool
+	isHTTPMode         bool
+	outputDirectory    string
+	scheme             string
+	proxyURL           *url.URL
+	closeConnection    bool
+	notParseResponse   bool
+	debugBodySizeLimit int64
+	logPrefix          string
+	pathParams         map[string]string
+	beforeRequest      []func(*Client, *Request) error
+	udBeforeRequest    []func(*Client, *Request) error
+	preReqHook         func(*Client, *Request) error
+	afterResponse      []func(*Client, *Response) error
+	requestLog         func(*RequestLog) error
+	responseLog        func(*ResponseLog) error
+}
+
+// User type is to hold an username and password information
+type User struct {
+	Username, Password string
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Client methods
+//___________________________________
+
+// SetHostURL method is to set Host URL in the client instance. It will be used with request
+// raised from this client with relative URL
+//		// Setting HTTP address
+//		resty.SetHostURL("http://myjeeva.com")
+//
+//		// Setting HTTPS address
+//		resty.SetHostURL("https://myjeeva.com")
+//
+func (c *Client) SetHostURL(url string) *Client {
+	c.HostURL = strings.TrimRight(url, "/")
+	return c
+}
+
+// SetHeader method sets a single header field and its value in the client instance.
+// These headers will be applied to all requests raised from this client instance.
+// Also it can be overridden at request level header options, see `resty.R().SetHeader`
+// or `resty.R().SetHeaders`.
+//
+// Example: To set `Content-Type` and `Accept` as `application/json`
+//
+// 		resty.
+// 			SetHeader("Content-Type", "application/json").
+// 			SetHeader("Accept", "application/json")
+//
+func (c *Client) SetHeader(header, value string) *Client {
+	c.Header.Set(header, value)
+	return c
+}
+
+// SetHeaders method sets multiple headers field and its values at one go in the client instance.
+// These headers will be applied to all requests raised from this client instance. Also it can be
+// overridden at request level headers options, see `resty.R().SetHeaders` or `resty.R().SetHeader`.
+//
+// Example: To set `Content-Type` and `Accept` as `application/json`
+//
+// 		resty.SetHeaders(map[string]string{
+//				"Content-Type": "application/json",
+//				"Accept": "application/json",
+//			})
+//
+func (c *Client) SetHeaders(headers map[string]string) *Client {
+	for h, v := range headers {
+		c.Header.Set(h, v)
+	}
+
+	return c
+}
+
+// SetCookieJar method sets custom http.CookieJar in the resty client. Its way to override default.
+// Example: sometimes we don't want to save cookies in api contacting, we can remove the default
+// CookieJar in resty client.
+//
+//		resty.SetCookieJar(nil)
+//
+func (c *Client) SetCookieJar(jar http.CookieJar) *Client {
+	c.httpClient.Jar = jar
+	return c
+}
+
+// SetCookie method appends a single cookie in the client instance.
+// These cookies will be added to all the request raised from this client instance.
+// 		resty.SetCookie(&http.Cookie{
+// 					Name:"go-resty",
+//					Value:"This is cookie value",
+//					Path: "/",
+// 					Domain: "sample.com",
+// 					MaxAge: 36000,
+// 					HttpOnly: true,
+//					Secure: false,
+// 				})
+//
+func (c *Client) SetCookie(hc *http.Cookie) *Client {
+	c.Cookies = append(c.Cookies, hc)
+	return c
+}
+
+// SetCookies method sets an array of cookies in the client instance.
+// These cookies will be added to all the request raised from this client instance.
+// 		cookies := make([]*http.Cookie, 0)
+//
+//		cookies = append(cookies, &http.Cookie{
+// 					Name:"go-resty-1",
+//					Value:"This is cookie 1 value",
+//					Path: "/",
+// 					Domain: "sample.com",
+// 					MaxAge: 36000,
+// 					HttpOnly: true,
+//					Secure: false,
+// 				})
+//
+//		cookies = append(cookies, &http.Cookie{
+// 					Name:"go-resty-2",
+//					Value:"This is cookie 2 value",
+//					Path: "/",
+// 					Domain: "sample.com",
+// 					MaxAge: 36000,
+// 					HttpOnly: true,
+//					Secure: false,
+// 				})
+//
+//		// Setting a cookies into resty
+// 		resty.SetCookies(cookies)
+//
+func (c *Client) SetCookies(cs []*http.Cookie) *Client {
+	c.Cookies = append(c.Cookies, cs...)
+	return c
+}
+
+// SetQueryParam method sets single parameter and its value in the client instance.
+// It will be formed as query string for the request. For example: `search=kitchen%20papers&size=large`
+// in the URL after `?` mark. These query params will be added to all the request raised from
+// this client instance. Also it can be overridden at request level Query Param options,
+// see `resty.R().SetQueryParam` or `resty.R().SetQueryParams`.
+// 		resty.
+//			SetQueryParam("search", "kitchen papers").
+//			SetQueryParam("size", "large")
+//
+func (c *Client) SetQueryParam(param, value string) *Client {
+	c.QueryParam.Set(param, value)
+	return c
+}
+
+// SetQueryParams method sets multiple parameters and their values at one go in the client instance.
+// It will be formed as query string for the request. For example: `search=kitchen%20papers&size=large`
+// in the URL after `?` mark. These query params will be added to all the request raised from this
+// client instance. Also it can be overridden at request level Query Param options,
+// see `resty.R().SetQueryParams` or `resty.R().SetQueryParam`.
+// 		resty.SetQueryParams(map[string]string{
+//				"search": "kitchen papers",
+//				"size": "large",
+//			})
+//
+func (c *Client) SetQueryParams(params map[string]string) *Client {
+	for p, v := range params {
+		c.SetQueryParam(p, v)
+	}
+
+	return c
+}
+
+// SetFormData method sets Form parameters and their values in the client instance.
+// It's applicable only HTTP method `POST` and `PUT` and requets content type would be set as
+// `application/x-www-form-urlencoded`. These form data will be added to all the request raised from
+// this client instance. Also it can be overridden at request level form data, see `resty.R().SetFormData`.
+// 		resty.SetFormData(map[string]string{
+//				"access_token": "BC594900-518B-4F7E-AC75-BD37F019E08F",
+//				"user_id": "3455454545",
+//			})
+//
+func (c *Client) SetFormData(data map[string]string) *Client {
+	for k, v := range data {
+		c.FormData.Set(k, v)
+	}
+
+	return c
+}
+
+// SetBasicAuth method sets the basic authentication header in the HTTP request. Example:
+//		Authorization: Basic <base64-encoded-value>
+//
+// Example: To set the header for username "go-resty" and password "welcome"
+// 		resty.SetBasicAuth("go-resty", "welcome")
+//
+// This basic auth information gets added to all the request rasied from this client instance.
+// Also it can be overridden or set one at the request level is supported, see `resty.R().SetBasicAuth`.
+//
+func (c *Client) SetBasicAuth(username, password string) *Client {
+	c.UserInfo = &User{Username: username, Password: password}
+	return c
+}
+
+// SetAuthToken method sets bearer auth token header in the HTTP request. Example:
+// 		Authorization: Bearer <auth-token-value-comes-here>
+//
+// Example: To set auth token BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F
+//
+// 		resty.SetAuthToken("BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F")
+//
+// This bearer auth token gets added to all the request rasied from this client instance.
+// Also it can be overridden or set one at the request level is supported, see `resty.R().SetAuthToken`.
+//
+func (c *Client) SetAuthToken(token string) *Client {
+	c.Token = token
+	return c
+}
+
+// R method creates a request instance, its used for Get, Post, Put, Delete, Patch, Head and Options.
+func (c *Client) R() *Request {
+	r := &Request{
+		QueryParam: url.Values{},
+		FormData:   url.Values{},
+		Header:     http.Header{},
+
+		client:          c,
+		multipartFiles:  []*File{},
+		multipartFields: []*MultipartField{},
+		pathParams:      map[string]string{},
+		jsonEscapeHTML:  true,
+	}
+
+	return r
+}
+
+// NewRequest is an alias for R(). Creates a request instance, its used for
+// Get, Post, Put, Delete, Patch, Head and Options.
+func (c *Client) NewRequest() *Request {
+	return c.R()
+}
+
+// OnBeforeRequest method appends request middleware into the before request chain.
+// Its gets applied after default `go-resty` request middlewares and before request
+// been sent from `go-resty` to host server.
+// 		resty.OnBeforeRequest(func(c *resty.Client, r *resty.Request) error {
+//				// Now you have access to Client and Request instance
+//				// manipulate it as per your need
+//
+//				return nil 	// if its success otherwise return error
+//			})
+//
+func (c *Client) OnBeforeRequest(m func(*Client, *Request) error) *Client {
+	c.udBeforeRequest = append(c.udBeforeRequest, m)
+	return c
+}
+
+// OnAfterResponse method appends response middleware into the after response chain.
+// Once we receive response from host server, default `go-resty` response middleware
+// gets applied and then user assigened response middlewares applied.
+// 		resty.OnAfterResponse(func(c *resty.Client, r *resty.Response) error {
+//				// Now you have access to Client and Response instance
+//				// manipulate it as per your need
+//
+//				return nil 	// if its success otherwise return error
+//			})
+//
+func (c *Client) OnAfterResponse(m func(*Client, *Response) error) *Client {
+	c.afterResponse = append(c.afterResponse, m)
+	return c
+}
+
+// SetPreRequestHook method sets the given pre-request function into resty client.
+// It is called right before the request is fired.
+//
+// Note: Only one pre-request hook can be registered. Use `resty.OnBeforeRequest` for mutilple.
+func (c *Client) SetPreRequestHook(h func(*Client, *Request) error) *Client {
+	if c.preReqHook != nil {
+		c.Log.Printf("Overwriting an existing pre-request hook: %s", functionName(h))
+	}
+	c.preReqHook = h
+	return c
+}
+
+// SetDebug method enables the debug mode on `go-resty` client. Client logs details of every request and response.
+// For `Request` it logs information such as HTTP verb, Relative URL path, Host, Headers, Body if it has one.
+// For `Response` it logs information such as Status, Response Time, Headers, Body if it has one.
+//		resty.SetDebug(true)
+//
+func (c *Client) SetDebug(d bool) *Client {
+	c.Debug = d
+	return c
+}
+
+// SetDebugBodyLimit sets the maximum size for which the response body will be logged in debug mode.
+//		resty.SetDebugBodyLimit(1000000)
+//
+func (c *Client) SetDebugBodyLimit(sl int64) *Client {
+	c.debugBodySizeLimit = sl
+	return c
+}
+
+// OnRequestLog method used to set request log callback into resty. Registered callback gets
+// called before the resty actually logs the information.
+func (c *Client) OnRequestLog(rl func(*RequestLog) error) *Client {
+	if c.requestLog != nil {
+		c.Log.Printf("Overwriting an existing on-request-log callback from=%s to=%s", functionName(c.requestLog), functionName(rl))
+	}
+	c.requestLog = rl
+	return c
+}
+
+// OnResponseLog method used to set response log callback into resty. Registered callback gets
+// called before the resty actually logs the information.
+func (c *Client) OnResponseLog(rl func(*ResponseLog) error) *Client {
+	if c.responseLog != nil {
+		c.Log.Printf("Overwriting an existing on-response-log callback from=%s to=%s", functionName(c.responseLog), functionName(rl))
+	}
+	c.responseLog = rl
+	return c
+}
+
+// SetDisableWarn method disables the warning message on `go-resty` client.
+// For example: go-resty warns the user when BasicAuth used on HTTP mode.
+//		resty.SetDisableWarn(true)
+//
+func (c *Client) SetDisableWarn(d bool) *Client {
+	c.DisableWarn = d
+	return c
+}
+
+// SetAllowGetMethodPayload method allows the GET method with payload on `go-resty` client.
+// For example: go-resty allows the user sends request with a payload on HTTP GET method.
+//		resty.SetAllowGetMethodPayload(true)
+//
+func (c *Client) SetAllowGetMethodPayload(a bool) *Client {
+	c.AllowGetMethodPayload = a
+	return c
+}
+
+// SetLogger method sets given writer for logging go-resty request and response details.
+// Default is os.Stderr
+// 		file, _ := os.OpenFile("/Users/jeeva/go-resty.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+//
+//		resty.SetLogger(file)
+//
+func (c *Client) SetLogger(w io.Writer) *Client {
+	c.Log = getLogger(w)
+	return c
+}
+
+// SetContentLength method enables the HTTP header `Content-Length` value for every request.
+// By default go-resty won't set `Content-Length`.
+// 		resty.SetContentLength(true)
+//
+// Also you have an option to enable for particular request. See `resty.R().SetContentLength`
+//
+func (c *Client) SetContentLength(l bool) *Client {
+	c.setContentLength = l
+	return c
+}
+
+// SetTimeout method sets timeout for request raised from client.
+//		resty.SetTimeout(time.Duration(1 * time.Minute))
+//
+func (c *Client) SetTimeout(timeout time.Duration) *Client {
+	c.httpClient.Timeout = timeout
+	return c
+}
+
+// SetError method is to register the global or client common `Error` object into go-resty.
+// It is used for automatic unmarshalling if response status code is greater than 399 and
+// content type either JSON or XML. Can be pointer or non-pointer.
+// 		resty.SetError(&Error{})
+//		// OR
+//		resty.SetError(Error{})
+//
+func (c *Client) SetError(err interface{}) *Client {
+	c.Error = typeOf(err)
+	return c
+}
+
+// SetRedirectPolicy method sets the client redirect poilicy. go-resty provides ready to use
+// redirect policies. Wanna create one for yourself refer `redirect.go`.
+//
+//		resty.SetRedirectPolicy(FlexibleRedirectPolicy(20))
+//
+// 		// Need multiple redirect policies together
+//		resty.SetRedirectPolicy(FlexibleRedirectPolicy(20), DomainCheckRedirectPolicy("host1.com", "host2.net"))
+//
+func (c *Client) SetRedirectPolicy(policies ...interface{}) *Client {
+	for _, p := range policies {
+		if _, ok := p.(RedirectPolicy); !ok {
+			c.Log.Printf("ERORR: %v does not implement resty.RedirectPolicy (missing Apply method)",
+				functionName(p))
+		}
+	}
+
+	c.httpClient.CheckRedirect = func(req *http.Request, via []*http.Request) error {
+		for _, p := range policies {
+			if err := p.(RedirectPolicy).Apply(req, via); err != nil {
+				return err
+			}
+		}
+		return nil // looks good, go ahead
+	}
+
+	return c
+}
+
+// SetRetryCount method enables retry on `go-resty` client and allows you
+// to set no. of retry count. Resty uses a Backoff mechanism.
+func (c *Client) SetRetryCount(count int) *Client {
+	c.RetryCount = count
+	return c
+}
+
+// SetRetryWaitTime method sets default wait time to sleep before retrying
+// request.
+// Default is 100 milliseconds.
+func (c *Client) SetRetryWaitTime(waitTime time.Duration) *Client {
+	c.RetryWaitTime = waitTime
+	return c
+}
+
+// SetRetryMaxWaitTime method sets max wait time to sleep before retrying
+// request.
+// Default is 2 seconds.
+func (c *Client) SetRetryMaxWaitTime(maxWaitTime time.Duration) *Client {
+	c.RetryMaxWaitTime = maxWaitTime
+	return c
+}
+
+// AddRetryCondition method adds a retry condition function to array of functions
+// that are checked to determine if the request is retried. The request will
+// retry if any of the functions return true and error is nil.
+func (c *Client) AddRetryCondition(condition RetryConditionFunc) *Client {
+	c.RetryConditions = append(c.RetryConditions, condition)
+	return c
+}
+
+// SetHTTPMode method sets go-resty mode to 'http'
+func (c *Client) SetHTTPMode() *Client {
+	return c.SetMode("http")
+}
+
+// SetRESTMode method sets go-resty mode to 'rest'
+func (c *Client) SetRESTMode() *Client {
+	return c.SetMode("rest")
+}
+
+// SetMode method sets go-resty client mode to given value such as 'http' & 'rest'.
+//	'rest':
+//		- No Redirect
+//		- Automatic response unmarshal if it is JSON or XML
+//	'http':
+//		- Up to 10 Redirects
+//		- No automatic unmarshall. Response will be treated as `response.String()`
+//
+// If you want more redirects, use FlexibleRedirectPolicy
+//		resty.SetRedirectPolicy(FlexibleRedirectPolicy(20))
+//
+func (c *Client) SetMode(mode string) *Client {
+	// HTTP
+	if mode == "http" {
+		c.isHTTPMode = true
+		c.SetRedirectPolicy(FlexibleRedirectPolicy(10))
+		c.afterResponse = []func(*Client, *Response) error{
+			responseLogger,
+			saveResponseIntoFile,
+		}
+		return c
+	}
+
+	// RESTful
+	c.isHTTPMode = false
+	c.SetRedirectPolicy(NoRedirectPolicy())
+	c.afterResponse = []func(*Client, *Response) error{
+		responseLogger,
+		parseResponseBody,
+		saveResponseIntoFile,
+	}
+	return c
+}
+
+// Mode method returns the current client mode. Typically its a "http" or "rest".
+// Default is "rest"
+func (c *Client) Mode() string {
+	if c.isHTTPMode {
+		return "http"
+	}
+	return "rest"
+}
+
+// SetTLSClientConfig method sets TLSClientConfig for underling client Transport.
+//
+// Example:
+// 		// One can set custom root-certificate. Refer: http://golang.org/pkg/crypto/tls/#example_Dial
+//		resty.SetTLSClientConfig(&tls.Config{ RootCAs: roots })
+//
+// 		// or One can disable security check (https)
+//		resty.SetTLSClientConfig(&tls.Config{ InsecureSkipVerify: true })
+// Note: This method overwrites existing `TLSClientConfig`.
+//
+func (c *Client) SetTLSClientConfig(config *tls.Config) *Client {
+	transport, err := c.getTransport()
+	if err != nil {
+		c.Log.Printf("ERROR %v", err)
+		return c
+	}
+	transport.TLSClientConfig = config
+	return c
+}
+
+// SetProxy method sets the Proxy URL and Port for resty client.
+//		resty.SetProxy("http://proxyserver:8888")
+//
+// Alternatives: At request level proxy, see `Request.SetProxy`.  OR Without this `SetProxy` method,
+// you can also set Proxy via environment variable. By default `Go` uses setting from `HTTP_PROXY`.
+//
+func (c *Client) SetProxy(proxyURL string) *Client {
+	transport, err := c.getTransport()
+	if err != nil {
+		c.Log.Printf("ERROR %v", err)
+		return c
+	}
+
+	if pURL, err := url.Parse(proxyURL); err == nil {
+		c.proxyURL = pURL
+		transport.Proxy = http.ProxyURL(c.proxyURL)
+	} else {
+		c.Log.Printf("ERROR %v", err)
+		c.RemoveProxy()
+	}
+	return c
+}
+
+// RemoveProxy method removes the proxy configuration from resty client
+//		resty.RemoveProxy()
+//
+func (c *Client) RemoveProxy() *Client {
+	transport, err := c.getTransport()
+	if err != nil {
+		c.Log.Printf("ERROR %v", err)
+		return c
+	}
+	c.proxyURL = nil
+	transport.Proxy = nil
+	return c
+}
+
+// SetCertificates method helps to set client certificates into resty conveniently.
+//
+func (c *Client) SetCertificates(certs ...tls.Certificate) *Client {
+	config, err := c.getTLSConfig()
+	if err != nil {
+		c.Log.Printf("ERROR %v", err)
+		return c
+	}
+	config.Certificates = append(config.Certificates, certs...)
+	return c
+}
+
+// SetRootCertificate method helps to add one or more root certificates into resty client
+// 		resty.SetRootCertificate("/path/to/root/pemFile.pem")
+//
+func (c *Client) SetRootCertificate(pemFilePath string) *Client {
+	rootPemData, err := ioutil.ReadFile(pemFilePath)
+	if err != nil {
+		c.Log.Printf("ERROR %v", err)
+		return c
+	}
+
+	config, err := c.getTLSConfig()
+	if err != nil {
+		c.Log.Printf("ERROR %v", err)
+		return c
+	}
+	if config.RootCAs == nil {
+		config.RootCAs = x509.NewCertPool()
+	}
+
+	config.RootCAs.AppendCertsFromPEM(rootPemData)
+
+	return c
+}
+
+// SetOutputDirectory method sets output directory for saving HTTP response into file.
+// If the output directory not exists then resty creates one. This setting is optional one,
+// if you're planning using absoule path in `Request.SetOutput` and can used together.
+// 		resty.SetOutputDirectory("/save/http/response/here")
+//
+func (c *Client) SetOutputDirectory(dirPath string) *Client {
+	c.outputDirectory = dirPath
+	return c
+}
+
+// SetTransport method sets custom `*http.Transport` or any `http.RoundTripper`
+// compatible interface implementation in the resty client.
+//
+// NOTE:
+//
+// - If transport is not type of `*http.Transport` then you may not be able to
+// take advantage of some of the `resty` client settings.
+//
+// - It overwrites the resty client transport instance and it's configurations.
+//
+//		transport := &http.Transport{
+//			// somthing like Proxying to httptest.Server, etc...
+//			Proxy: func(req *http.Request) (*url.URL, error) {
+//				return url.Parse(server.URL)
+//			},
+//		}
+//
+//		resty.SetTransport(transport)
+//
+func (c *Client) SetTransport(transport http.RoundTripper) *Client {
+	if transport != nil {
+		c.httpClient.Transport = transport
+	}
+	return c
+}
+
+// SetScheme method sets custom scheme in the resty client. It's way to override default.
+// 		resty.SetScheme("http")
+//
+func (c *Client) SetScheme(scheme string) *Client {
+	if !IsStringEmpty(scheme) {
+		c.scheme = scheme
+	}
+
+	return c
+}
+
+// SetCloseConnection method sets variable `Close` in http request struct with the given
+// value. More info: https://golang.org/src/net/http/request.go
+func (c *Client) SetCloseConnection(close bool) *Client {
+	c.closeConnection = close
+	return c
+}
+
+// SetDoNotParseResponse method instructs `Resty` not to parse the response body automatically.
+// Resty exposes the raw response body as `io.ReadCloser`. Also do not forget to close the body,
+// otherwise you might get into connection leaks, no connection reuse.
+//
+// Please Note: Response middlewares are not applicable, if you use this option. Basically you have
+// taken over the control of response parsing from `Resty`.
+func (c *Client) SetDoNotParseResponse(parse bool) *Client {
+	c.notParseResponse = parse
+	return c
+}
+
+// SetLogPrefix method sets the Resty logger prefix value.
+func (c *Client) SetLogPrefix(prefix string) *Client {
+	c.logPrefix = prefix
+	c.Log.SetPrefix(prefix)
+	return c
+}
+
+// SetPathParams method sets multiple URL path key-value pairs at one go in the
+// resty client instance.
+// 		resty.SetPathParams(map[string]string{
+// 		   "userId": "sample@sample.com",
+// 		   "subAccountId": "100002",
+// 		})
+//
+// 		Result:
+// 		   URL - /v1/users/{userId}/{subAccountId}/details
+// 		   Composed URL - /v1/users/sample@sample.com/100002/details
+// It replace the value of the key while composing request URL. Also it can be
+// overridden at request level Path Params options, see `Request.SetPathParams`.
+func (c *Client) SetPathParams(params map[string]string) *Client {
+	for p, v := range params {
+		c.pathParams[p] = v
+	}
+	return c
+}
+
+// SetJSONEscapeHTML method is to enable/disable the HTML escape on JSON marshal.
+//
+// NOTE: This option only applicable to standard JSON Marshaller.
+func (c *Client) SetJSONEscapeHTML(b bool) *Client {
+	c.jsonEscapeHTML = b
+	return c
+}
+
+// IsProxySet method returns the true if proxy is set on client otherwise false.
+func (c *Client) IsProxySet() bool {
+	return c.proxyURL != nil
+}
+
+// GetClient method returns the current http.Client used by the resty client.
+func (c *Client) GetClient() *http.Client {
+	return c.httpClient
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Client Unexported methods
+//___________________________________
+
+// executes the given `Request` object and returns response
+func (c *Client) execute(req *Request) (*Response, error) {
+	defer releaseBuffer(req.bodyBuf)
+	// Apply Request middleware
+	var err error
+
+	// user defined on before request methods
+	// to modify the *resty.Request object
+	for _, f := range c.udBeforeRequest {
+		if err = f(c, req); err != nil {
+			return nil, err
+		}
+	}
+
+	// resty middlewares
+	for _, f := range c.beforeRequest {
+		if err = f(c, req); err != nil {
+			return nil, err
+		}
+	}
+
+	// call pre-request if defined
+	if c.preReqHook != nil {
+		if err = c.preReqHook(c, req); err != nil {
+			return nil, err
+		}
+	}
+
+	if hostHeader := req.Header.Get("Host"); hostHeader != "" {
+		req.RawRequest.Host = hostHeader
+	}
+
+	if err = requestLogger(c, req); err != nil {
+		return nil, err
+	}
+
+	req.Time = time.Now()
+	resp, err := c.httpClient.Do(req.RawRequest)
+
+	response := &Response{
+		Request:     req,
+		RawResponse: resp,
+		receivedAt:  time.Now(),
+	}
+
+	if err != nil || req.notParseResponse || c.notParseResponse {
+		return response, err
+	}
+
+	if !req.isSaveResponse {
+		defer closeq(resp.Body)
+		body := resp.Body
+
+		// GitHub #142 & #187
+		if strings.EqualFold(resp.Header.Get(hdrContentEncodingKey), "gzip") && resp.ContentLength != 0 {
+			if _, ok := body.(*gzip.Reader); !ok {
+				body, err = gzip.NewReader(body)
+				if err != nil {
+					return response, err
+				}
+				defer closeq(body)
+			}
+		}
+
+		if response.body, err = ioutil.ReadAll(body); err != nil {
+			return response, err
+		}
+
+		response.size = int64(len(response.body))
+	}
+
+	// Apply Response middleware
+	for _, f := range c.afterResponse {
+		if err = f(c, response); err != nil {
+			break
+		}
+	}
+
+	return response, err
+}
+
+// enables a log prefix
+func (c *Client) enableLogPrefix() {
+	c.Log.SetFlags(log.LstdFlags)
+	c.Log.SetPrefix(c.logPrefix)
+}
+
+// disables a log prefix
+func (c *Client) disableLogPrefix() {
+	c.Log.SetFlags(0)
+	c.Log.SetPrefix("")
+}
+
+// getting TLS client config if not exists then create one
+func (c *Client) getTLSConfig() (*tls.Config, error) {
+	transport, err := c.getTransport()
+	if err != nil {
+		return nil, err
+	}
+	if transport.TLSClientConfig == nil {
+		transport.TLSClientConfig = &tls.Config{}
+	}
+	return transport.TLSClientConfig, nil
+}
+
+// returns `*http.Transport` currently in use or error
+// in case currently used `transport` is not an `*http.Transport`
+func (c *Client) getTransport() (*http.Transport, error) {
+	if c.httpClient.Transport == nil {
+		c.SetTransport(new(http.Transport))
+	}
+
+	if transport, ok := c.httpClient.Transport.(*http.Transport); ok {
+		return transport, nil
+	}
+	return nil, errors.New("current transport is not an *http.Transport instance")
+}
+
+//
+// File
+//
+
+// File represent file information for multipart request
+type File struct {
+	Name      string
+	ParamName string
+	io.Reader
+}
+
+// String returns string value of current file details
+func (f *File) String() string {
+	return fmt.Sprintf("ParamName: %v; FileName: %v", f.ParamName, f.Name)
+}
+
+// MultipartField represent custom data part for multipart request
+type MultipartField struct {
+	Param       string
+	FileName    string
+	ContentType string
+	io.Reader
+}
--- a/vendor/gopkg.in/resty.v1/default.go
+++ b/vendor/gopkg.in/resty.v1/default.go
@ -0,0 +1,327 @@
+// Copyright (c) 2015-2019 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"crypto/tls"
+	"encoding/json"
+	"io"
+	"math"
+	"net/http"
+	"net/http/cookiejar"
+	"net/url"
+	"os"
+	"time"
+
+	"golang.org/x/net/publicsuffix"
+)
+
+// DefaultClient of resty
+var DefaultClient *Client
+
+// New method creates a new go-resty client.
+func New() *Client {
+	cookieJar, _ := cookiejar.New(&cookiejar.Options{PublicSuffixList: publicsuffix.List})
+	return createClient(&http.Client{Jar: cookieJar})
+}
+
+// NewWithClient method create a new go-resty client with given `http.Client`.
+func NewWithClient(hc *http.Client) *Client {
+	return createClient(hc)
+}
+
+// R creates a new resty request object, it is used form a HTTP/RESTful request
+// such as GET, POST, PUT, DELETE, HEAD, PATCH and OPTIONS.
+func R() *Request {
+	return DefaultClient.R()
+}
+
+// NewRequest is an alias for R(). Creates a new resty request object, it is used form a HTTP/RESTful request
+// such as GET, POST, PUT, DELETE, HEAD, PATCH and OPTIONS.
+func NewRequest() *Request {
+	return R()
+}
+
+// SetHostURL sets Host URL. See `Client.SetHostURL for more information.
+func SetHostURL(url string) *Client {
+	return DefaultClient.SetHostURL(url)
+}
+
+// SetHeader sets single header. See `Client.SetHeader` for more information.
+func SetHeader(header, value string) *Client {
+	return DefaultClient.SetHeader(header, value)
+}
+
+// SetHeaders sets multiple headers. See `Client.SetHeaders` for more information.
+func SetHeaders(headers map[string]string) *Client {
+	return DefaultClient.SetHeaders(headers)
+}
+
+// SetCookieJar sets custom http.CookieJar. See `Client.SetCookieJar` for more information.
+func SetCookieJar(jar http.CookieJar) *Client {
+	return DefaultClient.SetCookieJar(jar)
+}
+
+// SetCookie sets single cookie object. See `Client.SetCookie` for more information.
+func SetCookie(hc *http.Cookie) *Client {
+	return DefaultClient.SetCookie(hc)
+}
+
+// SetCookies sets multiple cookie object. See `Client.SetCookies` for more information.
+func SetCookies(cs []*http.Cookie) *Client {
+	return DefaultClient.SetCookies(cs)
+}
+
+// SetQueryParam method sets single parameter and its value. See `Client.SetQueryParam` for more information.
+func SetQueryParam(param, value string) *Client {
+	return DefaultClient.SetQueryParam(param, value)
+}
+
+// SetQueryParams method sets multiple parameters and its value. See `Client.SetQueryParams` for more information.
+func SetQueryParams(params map[string]string) *Client {
+	return DefaultClient.SetQueryParams(params)
+}
+
+// SetFormData method sets Form parameters and its values. See `Client.SetFormData` for more information.
+func SetFormData(data map[string]string) *Client {
+	return DefaultClient.SetFormData(data)
+}
+
+// SetBasicAuth method sets the basic authentication header. See `Client.SetBasicAuth` for more information.
+func SetBasicAuth(username, password string) *Client {
+	return DefaultClient.SetBasicAuth(username, password)
+}
+
+// SetAuthToken method sets bearer auth token header. See `Client.SetAuthToken` for more information.
+func SetAuthToken(token string) *Client {
+	return DefaultClient.SetAuthToken(token)
+}
+
+// OnBeforeRequest method sets request middleware. See `Client.OnBeforeRequest` for more information.
+func OnBeforeRequest(m func(*Client, *Request) error) *Client {
+	return DefaultClient.OnBeforeRequest(m)
+}
+
+// OnAfterResponse method sets response middleware. See `Client.OnAfterResponse` for more information.
+func OnAfterResponse(m func(*Client, *Response) error) *Client {
+	return DefaultClient.OnAfterResponse(m)
+}
+
+// SetPreRequestHook method sets the pre-request hook. See `Client.SetPreRequestHook` for more information.
+func SetPreRequestHook(h func(*Client, *Request) error) *Client {
+	return DefaultClient.SetPreRequestHook(h)
+}
+
+// SetDebug method enables the debug mode. See `Client.SetDebug` for more information.
+func SetDebug(d bool) *Client {
+	return DefaultClient.SetDebug(d)
+}
+
+// SetDebugBodyLimit method sets the response body limit for debug mode. See `Client.SetDebugBodyLimit` for more information.
+func SetDebugBodyLimit(sl int64) *Client {
+	return DefaultClient.SetDebugBodyLimit(sl)
+}
+
+// SetAllowGetMethodPayload method allows the GET method with payload. See `Client.SetAllowGetMethodPayload` for more information.
+func SetAllowGetMethodPayload(a bool) *Client {
+	return DefaultClient.SetAllowGetMethodPayload(a)
+}
+
+// SetRetryCount method sets the retry count. See `Client.SetRetryCount` for more information.
+func SetRetryCount(count int) *Client {
+	return DefaultClient.SetRetryCount(count)
+}
+
+// SetRetryWaitTime method sets the retry wait time. See `Client.SetRetryWaitTime` for more information.
+func SetRetryWaitTime(waitTime time.Duration) *Client {
+	return DefaultClient.SetRetryWaitTime(waitTime)
+}
+
+// SetRetryMaxWaitTime method sets the retry max wait time. See `Client.SetRetryMaxWaitTime` for more information.
+func SetRetryMaxWaitTime(maxWaitTime time.Duration) *Client {
+	return DefaultClient.SetRetryMaxWaitTime(maxWaitTime)
+}
+
+// AddRetryCondition method appends check function for retry. See `Client.AddRetryCondition` for more information.
+func AddRetryCondition(condition RetryConditionFunc) *Client {
+	return DefaultClient.AddRetryCondition(condition)
+}
+
+// SetDisableWarn method disables warning comes from `go-resty` client. See `Client.SetDisableWarn` for more information.
+func SetDisableWarn(d bool) *Client {
+	return DefaultClient.SetDisableWarn(d)
+}
+
+// SetLogger method sets given writer for logging. See `Client.SetLogger` for more information.
+func SetLogger(w io.Writer) *Client {
+	return DefaultClient.SetLogger(w)
+}
+
+// SetContentLength method enables `Content-Length` value. See `Client.SetContentLength` for more information.
+func SetContentLength(l bool) *Client {
+	return DefaultClient.SetContentLength(l)
+}
+
+// SetError method is to register the global or client common `Error` object. See `Client.SetError` for more information.
+func SetError(err interface{}) *Client {
+	return DefaultClient.SetError(err)
+}
+
+// SetRedirectPolicy method sets the client redirect poilicy. See `Client.SetRedirectPolicy` for more information.
+func SetRedirectPolicy(policies ...interface{}) *Client {
+	return DefaultClient.SetRedirectPolicy(policies...)
+}
+
+// SetHTTPMode method sets go-resty mode into HTTP. See `Client.SetMode` for more information.
+func SetHTTPMode() *Client {
+	return DefaultClient.SetHTTPMode()
+}
+
+// SetRESTMode method sets go-resty mode into RESTful. See `Client.SetMode` for more information.
+func SetRESTMode() *Client {
+	return DefaultClient.SetRESTMode()
+}
+
+// Mode method returns the current client mode. See `Client.Mode` for more information.
+func Mode() string {
+	return DefaultClient.Mode()
+}
+
+// SetTLSClientConfig method sets TLSClientConfig for underling client Transport. See `Client.SetTLSClientConfig` for more information.
+func SetTLSClientConfig(config *tls.Config) *Client {
+	return DefaultClient.SetTLSClientConfig(config)
+}
+
+// SetTimeout method sets timeout for request. See `Client.SetTimeout` for more information.
+func SetTimeout(timeout time.Duration) *Client {
+	return DefaultClient.SetTimeout(timeout)
+}
+
+// SetProxy method sets Proxy for request. See `Client.SetProxy` for more information.
+func SetProxy(proxyURL string) *Client {
+	return DefaultClient.SetProxy(proxyURL)
+}
+
+// RemoveProxy method removes the proxy configuration. See `Client.RemoveProxy` for more information.
+func RemoveProxy() *Client {
+	return DefaultClient.RemoveProxy()
+}
+
+// SetCertificates method helps to set client certificates into resty conveniently.
+// See `Client.SetCertificates` for more information and example.
+func SetCertificates(certs ...tls.Certificate) *Client {
+	return DefaultClient.SetCertificates(certs...)
+}
+
+// SetRootCertificate method helps to add one or more root certificates into resty client.
+// See `Client.SetRootCertificate` for more information.
+func SetRootCertificate(pemFilePath string) *Client {
+	return DefaultClient.SetRootCertificate(pemFilePath)
+}
+
+// SetOutputDirectory method sets output directory. See `Client.SetOutputDirectory` for more information.
+func SetOutputDirectory(dirPath string) *Client {
+	return DefaultClient.SetOutputDirectory(dirPath)
+}
+
+// SetTransport method sets custom `*http.Transport` or any `http.RoundTripper`
+// compatible interface implementation in the resty client.
+// See `Client.SetTransport` for more information.
+func SetTransport(transport http.RoundTripper) *Client {
+	return DefaultClient.SetTransport(transport)
+}
+
+// SetScheme method sets custom scheme in the resty client.
+// See `Client.SetScheme` for more information.
+func SetScheme(scheme string) *Client {
+	return DefaultClient.SetScheme(scheme)
+}
+
+// SetCloseConnection method sets close connection value in the resty client.
+// See `Client.SetCloseConnection` for more information.
+func SetCloseConnection(close bool) *Client {
+	return DefaultClient.SetCloseConnection(close)
+}
+
+// SetDoNotParseResponse method instructs `Resty` not to parse the response body automatically.
+// See `Client.SetDoNotParseResponse` for more information.
+func SetDoNotParseResponse(parse bool) *Client {
+	return DefaultClient.SetDoNotParseResponse(parse)
+}
+
+// SetPathParams method sets the Request path parameter key-value pairs. See
+// `Client.SetPathParams` for more information.
+func SetPathParams(params map[string]string) *Client {
+	return DefaultClient.SetPathParams(params)
+}
+
+// IsProxySet method returns the true if proxy is set on client otherwise false.
+// See `Client.IsProxySet` for more information.
+func IsProxySet() bool {
+	return DefaultClient.IsProxySet()
+}
+
+// GetClient method returns the current `http.Client` used by the default resty client.
+func GetClient() *http.Client {
+	return DefaultClient.httpClient
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Unexported methods
+//___________________________________
+
+func createClient(hc *http.Client) *Client {
+	c := &Client{
+		HostURL:            "",
+		QueryParam:         url.Values{},
+		FormData:           url.Values{},
+		Header:             http.Header{},
+		UserInfo:           nil,
+		Token:              "",
+		Cookies:            make([]*http.Cookie, 0),
+		Debug:              false,
+		Log:                getLogger(os.Stderr),
+		RetryCount:         0,
+		RetryWaitTime:      defaultWaitTime,
+		RetryMaxWaitTime:   defaultMaxWaitTime,
+		JSONMarshal:        json.Marshal,
+		JSONUnmarshal:      json.Unmarshal,
+		jsonEscapeHTML:     true,
+		httpClient:         hc,
+		debugBodySizeLimit: math.MaxInt32,
+		pathParams:         make(map[string]string),
+	}
+
+	// Log Prefix
+	c.SetLogPrefix("RESTY ")
+
+	// Default redirect policy
+	c.SetRedirectPolicy(NoRedirectPolicy())
+
+	// default before request middlewares
+	c.beforeRequest = []func(*Client, *Request) error{
+		parseRequestURL,
+		parseRequestHeader,
+		parseRequestBody,
+		createHTTPRequest,
+		addCredentials,
+	}
+
+	// user defined request middlewares
+	c.udBeforeRequest = []func(*Client, *Request) error{}
+
+	// default after response middlewares
+	c.afterResponse = []func(*Client, *Response) error{
+		responseLogger,
+		parseResponseBody,
+		saveResponseIntoFile,
+	}
+
+	return c
+}
+
+func init() {
+	DefaultClient = New()
+}
--- a/vendor/gopkg.in/resty.v1/go.mod
+++ b/vendor/gopkg.in/resty.v1/go.mod
@ -0,0 +1,3 @@
+module gopkg.in/resty.v1
+
+require golang.org/x/net v0.0.0-20181220203305-927f97764cc3
--- a/vendor/gopkg.in/resty.v1/middleware.go
+++ b/vendor/gopkg.in/resty.v1/middleware.go
@ -0,0 +1,469 @@
+// Copyright (c) 2015-2019 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"bytes"
+	"encoding/xml"
+	"errors"
+	"fmt"
+	"io"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"reflect"
+	"strings"
+	"time"
+)
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Request Middleware(s)
+//___________________________________
+
+func parseRequestURL(c *Client, r *Request) error {
+	// GitHub #103 Path Params
+	if len(r.pathParams) > 0 {
+		for p, v := range r.pathParams {
+			r.URL = strings.Replace(r.URL, "{"+p+"}", url.PathEscape(v), -1)
+		}
+	}
+	if len(c.pathParams) > 0 {
+		for p, v := range c.pathParams {
+			r.URL = strings.Replace(r.URL, "{"+p+"}", url.PathEscape(v), -1)
+		}
+	}
+
+	// Parsing request URL
+	reqURL, err := url.Parse(r.URL)
+	if err != nil {
+		return err
+	}
+
+	// If Request.URL is relative path then added c.HostURL into
+	// the request URL otherwise Request.URL will be used as-is
+	if !reqURL.IsAbs() {
+		r.URL = reqURL.String()
+		if len(r.URL) > 0 && r.URL[0] != '/' {
+			r.URL = "/" + r.URL
+		}
+
+		reqURL, err = url.Parse(c.HostURL + r.URL)
+		if err != nil {
+			return err
+		}
+	}
+
+	// Adding Query Param
+	query := make(url.Values)
+	for k, v := range c.QueryParam {
+		for _, iv := range v {
+			query.Add(k, iv)
+		}
+	}
+
+	for k, v := range r.QueryParam {
+		// remove query param from client level by key
+		// since overrides happens for that key in the request
+		query.Del(k)
+
+		for _, iv := range v {
+			query.Add(k, iv)
+		}
+	}
+
+	// GitHub #123 Preserve query string order partially.
+	// Since not feasible in `SetQuery*` resty methods, because
+	// standard package `url.Encode(...)` sorts the query params
+	// alphabetically
+	if len(query) > 0 {
+		if IsStringEmpty(reqURL.RawQuery) {
+			reqURL.RawQuery = query.Encode()
+		} else {
+			reqURL.RawQuery = reqURL.RawQuery + "&" + query.Encode()
+		}
+	}
+
+	r.URL = reqURL.String()
+
+	return nil
+}
+
+func parseRequestHeader(c *Client, r *Request) error {
+	hdr := make(http.Header)
+	for k := range c.Header {
+		hdr[k] = append(hdr[k], c.Header[k]...)
+	}
+
+	for k := range r.Header {
+		hdr.Del(k)
+		hdr[k] = append(hdr[k], r.Header[k]...)
+	}
+
+	if IsStringEmpty(hdr.Get(hdrUserAgentKey)) {
+		hdr.Set(hdrUserAgentKey, fmt.Sprintf(hdrUserAgentValue, Version))
+	}
+
+	ct := hdr.Get(hdrContentTypeKey)
+	if IsStringEmpty(hdr.Get(hdrAcceptKey)) && !IsStringEmpty(ct) &&
+		(IsJSONType(ct) || IsXMLType(ct)) {
+		hdr.Set(hdrAcceptKey, hdr.Get(hdrContentTypeKey))
+	}
+
+	r.Header = hdr
+
+	return nil
+}
+
+func parseRequestBody(c *Client, r *Request) (err error) {
+	if isPayloadSupported(r.Method, c.AllowGetMethodPayload) {
+		// Handling Multipart
+		if r.isMultiPart && !(r.Method == MethodPatch) {
+			if err = handleMultipart(c, r); err != nil {
+				return
+			}
+
+			goto CL
+		}
+
+		// Handling Form Data
+		if len(c.FormData) > 0 || len(r.FormData) > 0 {
+			handleFormData(c, r)
+
+			goto CL
+		}
+
+		// Handling Request body
+		if r.Body != nil {
+			handleContentType(c, r)
+
+			if err = handleRequestBody(c, r); err != nil {
+				return
+			}
+		}
+	}
+
+CL:
+	// by default resty won't set content length, you can if you want to :)
+	if (c.setContentLength || r.setContentLength) && r.bodyBuf != nil {
+		r.Header.Set(hdrContentLengthKey, fmt.Sprintf("%d", r.bodyBuf.Len()))
+	}
+
+	return
+}
+
+func createHTTPRequest(c *Client, r *Request) (err error) {
+	if r.bodyBuf == nil {
+		if reader, ok := r.Body.(io.Reader); ok {
+			r.RawRequest, err = http.NewRequest(r.Method, r.URL, reader)
+		} else {
+			r.RawRequest, err = http.NewRequest(r.Method, r.URL, nil)
+		}
+	} else {
+		r.RawRequest, err = http.NewRequest(r.Method, r.URL, r.bodyBuf)
+	}
+
+	if err != nil {
+		return
+	}
+
+	// Assign close connection option
+	r.RawRequest.Close = c.closeConnection
+
+	// Add headers into http request
+	r.RawRequest.Header = r.Header
+
+	// Add cookies into http request
+	for _, cookie := range c.Cookies {
+		r.RawRequest.AddCookie(cookie)
+	}
+
+	// it's for non-http scheme option
+	if r.RawRequest.URL != nil && r.RawRequest.URL.Scheme == "" {
+		r.RawRequest.URL.Scheme = c.scheme
+		r.RawRequest.URL.Host = r.URL
+	}
+
+	// Use context if it was specified
+	r.addContextIfAvailable()
+
+	return
+}
+
+func addCredentials(c *Client, r *Request) error {
+	var isBasicAuth bool
+	// Basic Auth
+	if r.UserInfo != nil { // takes precedence
+		r.RawRequest.SetBasicAuth(r.UserInfo.Username, r.UserInfo.Password)
+		isBasicAuth = true
+	} else if c.UserInfo != nil {
+		r.RawRequest.SetBasicAuth(c.UserInfo.Username, c.UserInfo.Password)
+		isBasicAuth = true
+	}
+
+	if !c.DisableWarn {
+		if isBasicAuth && !strings.HasPrefix(r.URL, "https") {
+			c.Log.Println("WARNING - Using Basic Auth in HTTP mode is not secure.")
+		}
+	}
+
+	// Token Auth
+	if !IsStringEmpty(r.Token) { // takes precedence
+		r.RawRequest.Header.Set(hdrAuthorizationKey, "Bearer "+r.Token)
+	} else if !IsStringEmpty(c.Token) {
+		r.RawRequest.Header.Set(hdrAuthorizationKey, "Bearer "+c.Token)
+	}
+
+	return nil
+}
+
+func requestLogger(c *Client, r *Request) error {
+	if c.Debug {
+		rr := r.RawRequest
+		rl := &RequestLog{Header: copyHeaders(rr.Header), Body: r.fmtBodyString()}
+		if c.requestLog != nil {
+			if err := c.requestLog(rl); err != nil {
+				return err
+			}
+		}
+
+		reqLog := "\n---------------------- REQUEST LOG -----------------------\n" +
+			fmt.Sprintf("%s  %s  %s\n", r.Method, rr.URL.RequestURI(), rr.Proto) +
+			fmt.Sprintf("HOST   : %s\n", rr.URL.Host) +
+			fmt.Sprintf("HEADERS:\n") +
+			composeHeaders(rl.Header) + "\n" +
+			fmt.Sprintf("BODY   :\n%v\n", rl.Body) +
+			"----------------------------------------------------------\n"
+
+		c.Log.Print(reqLog)
+	}
+
+	return nil
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Response Middleware(s)
+//___________________________________
+
+func responseLogger(c *Client, res *Response) error {
+	if c.Debug {
+		rl := &ResponseLog{Header: copyHeaders(res.Header()), Body: res.fmtBodyString(c.debugBodySizeLimit)}
+		if c.responseLog != nil {
+			if err := c.responseLog(rl); err != nil {
+				return err
+			}
+		}
+
+		resLog := "\n---------------------- RESPONSE LOG -----------------------\n" +
+			fmt.Sprintf("STATUS 		: %s\n", res.Status()) +
+			fmt.Sprintf("RECEIVED AT	: %v\n", res.ReceivedAt().Format(time.RFC3339Nano)) +
+			fmt.Sprintf("RESPONSE TIME	: %v\n", res.Time()) +
+			"HEADERS:\n" +
+			composeHeaders(rl.Header) + "\n"
+		if res.Request.isSaveResponse {
+			resLog += fmt.Sprintf("BODY   :\n***** RESPONSE WRITTEN INTO FILE *****\n")
+		} else {
+			resLog += fmt.Sprintf("BODY   :\n%v\n", rl.Body)
+		}
+		resLog += "----------------------------------------------------------\n"
+
+		c.Log.Print(resLog)
+	}
+
+	return nil
+}
+
+func parseResponseBody(c *Client, res *Response) (err error) {
+	if res.StatusCode() == http.StatusNoContent {
+		return
+	}
+	// Handles only JSON or XML content type
+	ct := firstNonEmpty(res.Header().Get(hdrContentTypeKey), res.Request.fallbackContentType)
+	if IsJSONType(ct) || IsXMLType(ct) {
+		// HTTP status code > 199 and < 300, considered as Result
+		if res.IsSuccess() {
+			if res.Request.Result != nil {
+				err = Unmarshalc(c, ct, res.body, res.Request.Result)
+				return
+			}
+		}
+
+		// HTTP status code > 399, considered as Error
+		if res.IsError() {
+			// global error interface
+			if res.Request.Error == nil && c.Error != nil {
+				res.Request.Error = reflect.New(c.Error).Interface()
+			}
+
+			if res.Request.Error != nil {
+				err = Unmarshalc(c, ct, res.body, res.Request.Error)
+			}
+		}
+	}
+
+	return
+}
+
+func handleMultipart(c *Client, r *Request) (err error) {
+	r.bodyBuf = acquireBuffer()
+	w := multipart.NewWriter(r.bodyBuf)
+
+	for k, v := range c.FormData {
+		for _, iv := range v {
+			if err = w.WriteField(k, iv); err != nil {
+				return err
+			}
+		}
+	}
+
+	for k, v := range r.FormData {
+		for _, iv := range v {
+			if strings.HasPrefix(k, "@") { // file
+				err = addFile(w, k[1:], iv)
+				if err != nil {
+					return
+				}
+			} else { // form value
+				if err = w.WriteField(k, iv); err != nil {
+					return err
+				}
+			}
+		}
+	}
+
+	// #21 - adding io.Reader support
+	if len(r.multipartFiles) > 0 {
+		for _, f := range r.multipartFiles {
+			err = addFileReader(w, f)
+			if err != nil {
+				return
+			}
+		}
+	}
+
+	// GitHub #130 adding multipart field support with content type
+	if len(r.multipartFields) > 0 {
+		for _, mf := range r.multipartFields {
+			if err = addMultipartFormField(w, mf); err != nil {
+				return
+			}
+		}
+	}
+
+	r.Header.Set(hdrContentTypeKey, w.FormDataContentType())
+	err = w.Close()
+
+	return
+}
+
+func handleFormData(c *Client, r *Request) {
+	formData := url.Values{}
+
+	for k, v := range c.FormData {
+		for _, iv := range v {
+			formData.Add(k, iv)
+		}
+	}
+
+	for k, v := range r.FormData {
+		// remove form data field from client level by key
+		// since overrides happens for that key in the request
+		formData.Del(k)
+
+		for _, iv := range v {
+			formData.Add(k, iv)
+		}
+	}
+
+	r.bodyBuf = bytes.NewBuffer([]byte(formData.Encode()))
+	r.Header.Set(hdrContentTypeKey, formContentType)
+	r.isFormData = true
+}
+
+func handleContentType(c *Client, r *Request) {
+	contentType := r.Header.Get(hdrContentTypeKey)
+	if IsStringEmpty(contentType) {
+		contentType = DetectContentType(r.Body)
+		r.Header.Set(hdrContentTypeKey, contentType)
+	}
+}
+
+func handleRequestBody(c *Client, r *Request) (err error) {
+	var bodyBytes []byte
+	contentType := r.Header.Get(hdrContentTypeKey)
+	kind := kindOf(r.Body)
+	r.bodyBuf = nil
+
+	if reader, ok := r.Body.(io.Reader); ok {
+		if c.setContentLength || r.setContentLength { // keep backward compability
+			r.bodyBuf = acquireBuffer()
+			_, err = r.bodyBuf.ReadFrom(reader)
+			r.Body = nil
+		} else {
+			// Otherwise buffer less processing for `io.Reader`, sounds good.
+			return
+		}
+	} else if b, ok := r.Body.([]byte); ok {
+		bodyBytes = b
+	} else if s, ok := r.Body.(string); ok {
+		bodyBytes = []byte(s)
+	} else if IsJSONType(contentType) &&
+		(kind == reflect.Struct || kind == reflect.Map || kind == reflect.Slice) {
+		bodyBytes, err = jsonMarshal(c, r, r.Body)
+	} else if IsXMLType(contentType) && (kind == reflect.Struct) {
+		bodyBytes, err = xml.Marshal(r.Body)
+	}
+
+	if bodyBytes == nil && r.bodyBuf == nil {
+		err = errors.New("unsupported 'Body' type/value")
+	}
+
+	// if any errors during body bytes handling, return it
+	if err != nil {
+		return
+	}
+
+	// []byte into Buffer
+	if bodyBytes != nil && r.bodyBuf == nil {
+		r.bodyBuf = acquireBuffer()
+		_, _ = r.bodyBuf.Write(bodyBytes)
+	}
+
+	return
+}
+
+func saveResponseIntoFile(c *Client, res *Response) error {
+	if res.Request.isSaveResponse {
+		file := ""
+
+		if len(c.outputDirectory) > 0 && !filepath.IsAbs(res.Request.outputFile) {
+			file += c.outputDirectory + string(filepath.Separator)
+		}
+
+		file = filepath.Clean(file + res.Request.outputFile)
+		if err := createDirectory(filepath.Dir(file)); err != nil {
+			return err
+		}
+
+		outFile, err := os.Create(file)
+		if err != nil {
+			return err
+		}
+		defer closeq(outFile)
+
+		// io.Copy reads maximum 32kb size, it is perfect for large file download too
+		defer closeq(res.RawResponse.Body)
+
+		written, err := io.Copy(outFile, res.RawResponse.Body)
+		if err != nil {
+			return err
+		}
+
+		res.size = written
+	}
+
+	return nil
+}
--- a/vendor/gopkg.in/resty.v1/redirect.go
+++ b/vendor/gopkg.in/resty.v1/redirect.go
@ -0,0 +1,99 @@
+// Copyright (c) 2015-2019 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"errors"
+	"fmt"
+	"net"
+	"net/http"
+	"strings"
+)
+
+type (
+	// RedirectPolicy to regulate the redirects in the resty client.
+	// Objects implementing the RedirectPolicy interface can be registered as
+	//
+	// Apply function should return nil to continue the redirect jounery, otherwise
+	// return error to stop the redirect.
+	RedirectPolicy interface {
+		Apply(req *http.Request, via []*http.Request) error
+	}
+
+	// The RedirectPolicyFunc type is an adapter to allow the use of ordinary functions as RedirectPolicy.
+	// If f is a function with the appropriate signature, RedirectPolicyFunc(f) is a RedirectPolicy object that calls f.
+	RedirectPolicyFunc func(*http.Request, []*http.Request) error
+)
+
+// Apply calls f(req, via).
+func (f RedirectPolicyFunc) Apply(req *http.Request, via []*http.Request) error {
+	return f(req, via)
+}
+
+// NoRedirectPolicy is used to disable redirects in the HTTP client
+// 		resty.SetRedirectPolicy(NoRedirectPolicy())
+func NoRedirectPolicy() RedirectPolicy {
+	return RedirectPolicyFunc(func(req *http.Request, via []*http.Request) error {
+		return errors.New("auto redirect is disabled")
+	})
+}
+
+// FlexibleRedirectPolicy is convenient method to create No of redirect policy for HTTP client.
+// 		resty.SetRedirectPolicy(FlexibleRedirectPolicy(20))
+func FlexibleRedirectPolicy(noOfRedirect int) RedirectPolicy {
+	return RedirectPolicyFunc(func(req *http.Request, via []*http.Request) error {
+		if len(via) >= noOfRedirect {
+			return fmt.Errorf("stopped after %d redirects", noOfRedirect)
+		}
+
+		checkHostAndAddHeaders(req, via[0])
+
+		return nil
+	})
+}
+
+// DomainCheckRedirectPolicy is convenient method to define domain name redirect rule in resty client.
+// Redirect is allowed for only mentioned host in the policy.
+// 		resty.SetRedirectPolicy(DomainCheckRedirectPolicy("host1.com", "host2.org", "host3.net"))
+func DomainCheckRedirectPolicy(hostnames ...string) RedirectPolicy {
+	hosts := make(map[string]bool)
+	for _, h := range hostnames {
+		hosts[strings.ToLower(h)] = true
+	}
+
+	fn := RedirectPolicyFunc(func(req *http.Request, via []*http.Request) error {
+		if ok := hosts[getHostname(req.URL.Host)]; !ok {
+			return errors.New("redirect is not allowed as per DomainCheckRedirectPolicy")
+		}
+
+		return nil
+	})
+
+	return fn
+}
+
+func getHostname(host string) (hostname string) {
+	if strings.Index(host, ":") > 0 {
+		host, _, _ = net.SplitHostPort(host)
+	}
+	hostname = strings.ToLower(host)
+	return
+}
+
+// By default Golang will not redirect request headers
+// after go throughing various discussion comments from thread
+// https://github.com/golang/go/issues/4800
+// go-resty will add all the headers during a redirect for the same host
+func checkHostAndAddHeaders(cur *http.Request, pre *http.Request) {
+	curHostname := getHostname(cur.URL.Host)
+	preHostname := getHostname(pre.URL.Host)
+	if strings.EqualFold(curHostname, preHostname) {
+		for key, val := range pre.Header {
+			cur.Header[key] = val
+		}
+	} else { // only library User-Agent header is added
+		cur.Header.Set(hdrUserAgentKey, fmt.Sprintf(hdrUserAgentValue, Version))
+	}
+}
--- a/vendor/gopkg.in/resty.v1/request.go
+++ b/vendor/gopkg.in/resty.v1/request.go
@ -0,0 +1,586 @@
+// Copyright (c) 2015-2019 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"encoding/base64"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"net"
+	"net/url"
+	"reflect"
+	"strings"
+)
+
+// SRVRecord holds the data to query the SRV record for the following service
+type SRVRecord struct {
+	Service string
+	Domain  string
+}
+
+// SetHeader method is to set a single header field and its value in the current request.
+// Example: To set `Content-Type` and `Accept` as `application/json`.
+// 		resty.R().
+//			SetHeader("Content-Type", "application/json").
+//			SetHeader("Accept", "application/json")
+//
+// Also you can override header value, which was set at client instance level.
+//
+func (r *Request) SetHeader(header, value string) *Request {
+	r.Header.Set(header, value)
+	return r
+}
+
+// SetHeaders method sets multiple headers field and its values at one go in the current request.
+// Example: To set `Content-Type` and `Accept` as `application/json`
+//
+// 		resty.R().
+//			SetHeaders(map[string]string{
+//				"Content-Type": "application/json",
+//				"Accept": "application/json",
+//			})
+// Also you can override header value, which was set at client instance level.
+//
+func (r *Request) SetHeaders(headers map[string]string) *Request {
+	for h, v := range headers {
+		r.SetHeader(h, v)
+	}
+
+	return r
+}
+
+// SetQueryParam method sets single parameter and its value in the current request.
+// It will be formed as query string for the request.
+// Example: `search=kitchen%20papers&size=large` in the URL after `?` mark.
+// 		resty.R().
+//			SetQueryParam("search", "kitchen papers").
+//			SetQueryParam("size", "large")
+// Also you can override query params value, which was set at client instance level
+//
+func (r *Request) SetQueryParam(param, value string) *Request {
+	r.QueryParam.Set(param, value)
+	return r
+}
+
+// SetQueryParams method sets multiple parameters and its values at one go in the current request.
+// It will be formed as query string for the request.
+// Example: `search=kitchen%20papers&size=large` in the URL after `?` mark.
+// 		resty.R().
+//			SetQueryParams(map[string]string{
+//				"search": "kitchen papers",
+//				"size": "large",
+//			})
+// Also you can override query params value, which was set at client instance level
+//
+func (r *Request) SetQueryParams(params map[string]string) *Request {
+	for p, v := range params {
+		r.SetQueryParam(p, v)
+	}
+
+	return r
+}
+
+// SetMultiValueQueryParams method appends multiple parameters with multi-value
+// at one go in the current request. It will be formed as query string for the request.
+// Example: `status=pending&status=approved&status=open` in the URL after `?` mark.
+// 		resty.R().
+//			SetMultiValueQueryParams(url.Values{
+//				"status": []string{"pending", "approved", "open"},
+//			})
+// Also you can override query params value, which was set at client instance level
+//
+func (r *Request) SetMultiValueQueryParams(params url.Values) *Request {
+	for p, v := range params {
+		for _, pv := range v {
+			r.QueryParam.Add(p, pv)
+		}
+	}
+
+	return r
+}
+
+// SetQueryString method provides ability to use string as an input to set URL query string for the request.
+//
+// Using String as an input
+// 		resty.R().
+//			SetQueryString("productId=232&template=fresh-sample&cat=resty&source=google&kw=buy a lot more")
+//
+func (r *Request) SetQueryString(query string) *Request {
+	params, err := url.ParseQuery(strings.TrimSpace(query))
+	if err == nil {
+		for p, v := range params {
+			for _, pv := range v {
+				r.QueryParam.Add(p, pv)
+			}
+		}
+	} else {
+		r.client.Log.Printf("ERROR %v", err)
+	}
+	return r
+}
+
+// SetFormData method sets Form parameters and their values in the current request.
+// It's applicable only HTTP method `POST` and `PUT` and requests content type would be set as
+// `application/x-www-form-urlencoded`.
+// 		resty.R().
+// 			SetFormData(map[string]string{
+//				"access_token": "BC594900-518B-4F7E-AC75-BD37F019E08F",
+//				"user_id": "3455454545",
+//			})
+// Also you can override form data value, which was set at client instance level
+//
+func (r *Request) SetFormData(data map[string]string) *Request {
+	for k, v := range data {
+		r.FormData.Set(k, v)
+	}
+
+	return r
+}
+
+// SetMultiValueFormData method appends multiple form parameters with multi-value
+// at one go in the current request.
+// 		resty.R().
+//			SetMultiValueFormData(url.Values{
+//				"search_criteria": []string{"book", "glass", "pencil"},
+//			})
+// Also you can override form data value, which was set at client instance level
+//
+func (r *Request) SetMultiValueFormData(params url.Values) *Request {
+	for k, v := range params {
+		for _, kv := range v {
+			r.FormData.Add(k, kv)
+		}
+	}
+
+	return r
+}
+
+// SetBody method sets the request body for the request. It supports various realtime needs as easy.
+// We can say its quite handy or powerful. Supported request body data types is `string`,
+// `[]byte`, `struct`, `map`, `slice` and `io.Reader`. Body value can be pointer or non-pointer.
+// Automatic marshalling for JSON and XML content type, if it is `struct`, `map`, or `slice`.
+//
+// Note: `io.Reader` is processed as bufferless mode while sending request.
+//
+// Example:
+//
+// Struct as a body input, based on content type, it will be marshalled.
+//		resty.R().
+//			SetBody(User{
+//				Username: "jeeva@myjeeva.com",
+//				Password: "welcome2resty",
+//			})
+//
+// Map as a body input, based on content type, it will be marshalled.
+//		resty.R().
+//			SetBody(map[string]interface{}{
+//				"username": "jeeva@myjeeva.com",
+//				"password": "welcome2resty",
+//				"address": &Address{
+//					Address1: "1111 This is my street",
+//					Address2: "Apt 201",
+//					City: "My City",
+//					State: "My State",
+//					ZipCode: 00000,
+//				},
+//			})
+//
+// String as a body input. Suitable for any need as a string input.
+//		resty.R().
+//			SetBody(`{
+//				"username": "jeeva@getrightcare.com",
+//				"password": "admin"
+//			}`)
+//
+// []byte as a body input. Suitable for raw request such as file upload, serialize & deserialize, etc.
+// 		resty.R().
+//			SetBody([]byte("This is my raw request, sent as-is"))
+//
+func (r *Request) SetBody(body interface{}) *Request {
+	r.Body = body
+	return r
+}
+
+// SetResult method is to register the response `Result` object for automatic unmarshalling in the RESTful mode
+// if response status code is between 200 and 299 and content type either JSON or XML.
+//
+// Note: Result object can be pointer or non-pointer.
+//		resty.R().SetResult(&AuthToken{})
+//		// OR
+//		resty.R().SetResult(AuthToken{})
+//
+// Accessing a result value
+//		response.Result().(*AuthToken)
+//
+func (r *Request) SetResult(res interface{}) *Request {
+	r.Result = getPointer(res)
+	return r
+}
+
+// SetError method is to register the request `Error` object for automatic unmarshalling in the RESTful mode
+// if response status code is greater than 399 and content type either JSON or XML.
+//
+// Note: Error object can be pointer or non-pointer.
+// 		resty.R().SetError(&AuthError{})
+//		// OR
+//		resty.R().SetError(AuthError{})
+//
+// Accessing a error value
+//		response.Error().(*AuthError)
+//
+func (r *Request) SetError(err interface{}) *Request {
+	r.Error = getPointer(err)
+	return r
+}
+
+// SetFile method is to set single file field name and its path for multipart upload.
+//	resty.R().
+//		SetFile("my_file", "/Users/jeeva/Gas Bill - Sep.pdf")
+//
+func (r *Request) SetFile(param, filePath string) *Request {
+	r.isMultiPart = true
+	r.FormData.Set("@"+param, filePath)
+	return r
+}
+
+// SetFiles method is to set multiple file field name and its path for multipart upload.
+//	resty.R().
+//		SetFiles(map[string]string{
+//				"my_file1": "/Users/jeeva/Gas Bill - Sep.pdf",
+//				"my_file2": "/Users/jeeva/Electricity Bill - Sep.pdf",
+//				"my_file3": "/Users/jeeva/Water Bill - Sep.pdf",
+//			})
+//
+func (r *Request) SetFiles(files map[string]string) *Request {
+	r.isMultiPart = true
+
+	for f, fp := range files {
+		r.FormData.Set("@"+f, fp)
+	}
+
+	return r
+}
+
+// SetFileReader method is to set single file using io.Reader for multipart upload.
+//	resty.R().
+//		SetFileReader("profile_img", "my-profile-img.png", bytes.NewReader(profileImgBytes)).
+//		SetFileReader("notes", "user-notes.txt", bytes.NewReader(notesBytes))
+//
+func (r *Request) SetFileReader(param, fileName string, reader io.Reader) *Request {
+	r.isMultiPart = true
+	r.multipartFiles = append(r.multipartFiles, &File{
+		Name:      fileName,
+		ParamName: param,
+		Reader:    reader,
+	})
+	return r
+}
+
+// SetMultipartField method is to set custom data using io.Reader for multipart upload.
+func (r *Request) SetMultipartField(param, fileName, contentType string, reader io.Reader) *Request {
+	r.isMultiPart = true
+	r.multipartFields = append(r.multipartFields, &MultipartField{
+		Param:       param,
+		FileName:    fileName,
+		ContentType: contentType,
+		Reader:      reader,
+	})
+	return r
+}
+
+// SetMultipartFields method is to set multiple data fields using io.Reader for multipart upload.
+// Example:
+// 	resty.R().SetMultipartFields(
+// 		&resty.MultipartField{
+//			Param:       "uploadManifest1",
+//			FileName:    "upload-file-1.json",
+//			ContentType: "application/json",
+//			Reader:      strings.NewReader(`{"input": {"name": "Uploaded document 1", "_filename" : ["file1.txt"]}}`),
+//		},
+//		&resty.MultipartField{
+//			Param:       "uploadManifest2",
+//			FileName:    "upload-file-2.json",
+//			ContentType: "application/json",
+//			Reader:      strings.NewReader(`{"input": {"name": "Uploaded document 2", "_filename" : ["file2.txt"]}}`),
+//		})
+//
+// If you have slice already, then simply call-
+// 	resty.R().SetMultipartFields(fields...)
+func (r *Request) SetMultipartFields(fields ...*MultipartField) *Request {
+	r.isMultiPart = true
+	r.multipartFields = append(r.multipartFields, fields...)
+	return r
+}
+
+// SetContentLength method sets the HTTP header `Content-Length` value for current request.
+// By default go-resty won't set `Content-Length`. Also you have an option to enable for every
+// request. See `resty.SetContentLength`
+// 		resty.R().SetContentLength(true)
+//
+func (r *Request) SetContentLength(l bool) *Request {
+	r.setContentLength = true
+	return r
+}
+
+// SetBasicAuth method sets the basic authentication header in the current HTTP request.
+// For Header example:
+//		Authorization: Basic <base64-encoded-value>
+//
+// To set the header for username "go-resty" and password "welcome"
+// 		resty.R().SetBasicAuth("go-resty", "welcome")
+//
+// This method overrides the credentials set by method `resty.SetBasicAuth`.
+//
+func (r *Request) SetBasicAuth(username, password string) *Request {
+	r.UserInfo = &User{Username: username, Password: password}
+	return r
+}
+
+// SetAuthToken method sets bearer auth token header in the current HTTP request. Header example:
+// 		Authorization: Bearer <auth-token-value-comes-here>
+//
+// Example: To set auth token BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F
+//
+// 		resty.R().SetAuthToken("BC594900518B4F7EAC75BD37F019E08FBC594900518B4F7EAC75BD37F019E08F")
+//
+// This method overrides the Auth token set by method `resty.SetAuthToken`.
+//
+func (r *Request) SetAuthToken(token string) *Request {
+	r.Token = token
+	return r
+}
+
+// SetOutput method sets the output file for current HTTP request. Current HTTP response will be
+// saved into given file. It is similar to `curl -o` flag. Absolute path or relative path can be used.
+// If is it relative path then output file goes under the output directory, as mentioned
+// in the `Client.SetOutputDirectory`.
+// 		resty.R().
+// 			SetOutput("/Users/jeeva/Downloads/ReplyWithHeader-v5.1-beta.zip").
+// 			Get("http://bit.ly/1LouEKr")
+//
+// Note: In this scenario `Response.Body` might be nil.
+func (r *Request) SetOutput(file string) *Request {
+	r.outputFile = file
+	r.isSaveResponse = true
+	return r
+}
+
+// SetSRV method sets the details to query the service SRV record and execute the
+// request.
+// 		resty.R().
+//			SetSRV(SRVRecord{"web", "testservice.com"}).
+//			Get("/get")
+func (r *Request) SetSRV(srv *SRVRecord) *Request {
+	r.SRV = srv
+	return r
+}
+
+// SetDoNotParseResponse method instructs `Resty` not to parse the response body automatically.
+// Resty exposes the raw response body as `io.ReadCloser`. Also do not forget to close the body,
+// otherwise you might get into connection leaks, no connection reuse.
+//
+// Please Note: Response middlewares are not applicable, if you use this option. Basically you have
+// taken over the control of response parsing from `Resty`.
+func (r *Request) SetDoNotParseResponse(parse bool) *Request {
+	r.notParseResponse = parse
+	return r
+}
+
+// SetPathParams method sets multiple URL path key-value pairs at one go in the
+// resty current request instance.
+// 		resty.R().SetPathParams(map[string]string{
+// 		   "userId": "sample@sample.com",
+// 		   "subAccountId": "100002",
+// 		})
+//
+// 		Result:
+// 		   URL - /v1/users/{userId}/{subAccountId}/details
+// 		   Composed URL - /v1/users/sample@sample.com/100002/details
+// It replace the value of the key while composing request URL. Also you can
+// override Path Params value, which was set at client instance level.
+func (r *Request) SetPathParams(params map[string]string) *Request {
+	for p, v := range params {
+		r.pathParams[p] = v
+	}
+	return r
+}
+
+// ExpectContentType method allows to provide fallback `Content-Type` for automatic unmarshalling
+// when `Content-Type` response header is unavailable.
+func (r *Request) ExpectContentType(contentType string) *Request {
+	r.fallbackContentType = contentType
+	return r
+}
+
+// SetJSONEscapeHTML method is to enable/disable the HTML escape on JSON marshal.
+//
+// NOTE: This option only applicable to standard JSON Marshaller.
+func (r *Request) SetJSONEscapeHTML(b bool) *Request {
+	r.jsonEscapeHTML = b
+	return r
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// HTTP verb method starts here
+//___________________________________
+
+// Get method does GET HTTP request. It's defined in section 4.3.1 of RFC7231.
+func (r *Request) Get(url string) (*Response, error) {
+	return r.Execute(MethodGet, url)
+}
+
+// Head method does HEAD HTTP request. It's defined in section 4.3.2 of RFC7231.
+func (r *Request) Head(url string) (*Response, error) {
+	return r.Execute(MethodHead, url)
+}
+
+// Post method does POST HTTP request. It's defined in section 4.3.3 of RFC7231.
+func (r *Request) Post(url string) (*Response, error) {
+	return r.Execute(MethodPost, url)
+}
+
+// Put method does PUT HTTP request. It's defined in section 4.3.4 of RFC7231.
+func (r *Request) Put(url string) (*Response, error) {
+	return r.Execute(MethodPut, url)
+}
+
+// Delete method does DELETE HTTP request. It's defined in section 4.3.5 of RFC7231.
+func (r *Request) Delete(url string) (*Response, error) {
+	return r.Execute(MethodDelete, url)
+}
+
+// Options method does OPTIONS HTTP request. It's defined in section 4.3.7 of RFC7231.
+func (r *Request) Options(url string) (*Response, error) {
+	return r.Execute(MethodOptions, url)
+}
+
+// Patch method does PATCH HTTP request. It's defined in section 2 of RFC5789.
+func (r *Request) Patch(url string) (*Response, error) {
+	return r.Execute(MethodPatch, url)
+}
+
+// Execute method performs the HTTP request with given HTTP method and URL
+// for current `Request`.
+// 		resp, err := resty.R().Execute(resty.GET, "http://httpbin.org/get")
+//
+func (r *Request) Execute(method, url string) (*Response, error) {
+	var addrs []*net.SRV
+	var err error
+
+	if r.isMultiPart && !(method == MethodPost || method == MethodPut) {
+		return nil, fmt.Errorf("multipart content is not allowed in HTTP verb [%v]", method)
+	}
+
+	if r.SRV != nil {
+		_, addrs, err = net.LookupSRV(r.SRV.Service, "tcp", r.SRV.Domain)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	r.Method = method
+	r.URL = r.selectAddr(addrs, url, 0)
+
+	if r.client.RetryCount == 0 {
+		return r.client.execute(r)
+	}
+
+	var resp *Response
+	attempt := 0
+	_ = Backoff(
+		func() (*Response, error) {
+			attempt++
+
+			r.URL = r.selectAddr(addrs, url, attempt)
+
+			resp, err = r.client.execute(r)
+			if err != nil {
+				r.client.Log.Printf("ERROR %v, Attempt %v", err, attempt)
+				if r.isContextCancelledIfAvailable() {
+					// stop Backoff from retrying request if request has been
+					// canceled by context
+					return resp, nil
+				}
+			}
+
+			return resp, err
+		},
+		Retries(r.client.RetryCount),
+		WaitTime(r.client.RetryWaitTime),
+		MaxWaitTime(r.client.RetryMaxWaitTime),
+		RetryConditions(r.client.RetryConditions),
+	)
+
+	return resp, err
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Request Unexported methods
+//___________________________________
+
+func (r *Request) fmtBodyString() (body string) {
+	body = "***** NO CONTENT *****"
+	if isPayloadSupported(r.Method, r.client.AllowGetMethodPayload) {
+		if _, ok := r.Body.(io.Reader); ok {
+			body = "***** BODY IS io.Reader *****"
+			return
+		}
+
+		// multipart or form-data
+		if r.isMultiPart || r.isFormData {
+			body = r.bodyBuf.String()
+			return
+		}
+
+		// request body data
+		if r.Body == nil {
+			return
+		}
+		var prtBodyBytes []byte
+		var err error
+
+		contentType := r.Header.Get(hdrContentTypeKey)
+		kind := kindOf(r.Body)
+		if canJSONMarshal(contentType, kind) {
+			prtBodyBytes, err = json.MarshalIndent(&r.Body, "", "   ")
+		} else if IsXMLType(contentType) && (kind == reflect.Struct) {
+			prtBodyBytes, err = xml.MarshalIndent(&r.Body, "", "   ")
+		} else if b, ok := r.Body.(string); ok {
+			if IsJSONType(contentType) {
+				bodyBytes := []byte(b)
+				out := acquireBuffer()
+				defer releaseBuffer(out)
+				if err = json.Indent(out, bodyBytes, "", "   "); err == nil {
+					prtBodyBytes = out.Bytes()
+				}
+			} else {
+				body = b
+				return
+			}
+		} else if b, ok := r.Body.([]byte); ok {
+			body = base64.StdEncoding.EncodeToString(b)
+		}
+
+		if prtBodyBytes != nil && err == nil {
+			body = string(prtBodyBytes)
+		}
+	}
+
+	return
+}
+
+func (r *Request) selectAddr(addrs []*net.SRV, path string, attempt int) string {
+	if addrs == nil {
+		return path
+	}
+
+	idx := attempt % len(addrs)
+	domain := strings.TrimRight(addrs[idx].Target, ".")
+	path = strings.TrimLeft(path, "/")
+
+	return fmt.Sprintf("%s://%s:%d/%s", r.client.scheme, domain, addrs[idx].Port, path)
+}
--- a/vendor/gopkg.in/resty.v1/request16.go
+++ b/vendor/gopkg.in/resty.v1/request16.go
@ -0,0 +1,63 @@
+// +build !go1.7
+
+// Copyright (c) 2015-2019 Jeevanandam M (jeeva@myjeeva.com)
+// 2016 Andrew Grigorev (https://github.com/ei-grad)
+// All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"bytes"
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+// Request type is used to compose and send individual request from client
+// go-resty is provide option override client level settings such as
+// Auth Token, Basic Auth credentials, Header, Query Param, Form Data, Error object
+// and also you can add more options for that particular request
+type Request struct {
+	URL        string
+	Method     string
+	Token      string
+	QueryParam url.Values
+	FormData   url.Values
+	Header     http.Header
+	Time       time.Time
+	Body       interface{}
+	Result     interface{}
+	Error      interface{}
+	RawRequest *http.Request
+	SRV        *SRVRecord
+	UserInfo   *User
+
+	isMultiPart         bool
+	isFormData          bool
+	setContentLength    bool
+	isSaveResponse      bool
+	notParseResponse    bool
+	jsonEscapeHTML      bool
+	outputFile          string
+	fallbackContentType string
+	pathParams          map[string]string
+	client              *Client
+	bodyBuf             *bytes.Buffer
+	multipartFiles      []*File
+	multipartFields     []*MultipartField
+}
+
+func (r *Request) addContextIfAvailable() {
+	// nothing to do for golang<1.7
+}
+
+func (r *Request) isContextCancelledIfAvailable() bool {
+	// just always return false golang<1.7
+	return false
+}
+
+// for !go1.7
+var noescapeJSONMarshal = json.Marshal
--- a/vendor/gopkg.in/resty.v1/request17.go
+++ b/vendor/gopkg.in/resty.v1/request17.go
@ -0,0 +1,96 @@
+// +build go1.7 go1.8
+
+// Copyright (c) 2015-2019 Jeevanandam M (jeeva@myjeeva.com)
+// 2016 Andrew Grigorev (https://github.com/ei-grad)
+// All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/url"
+	"time"
+)
+
+// Request type is used to compose and send individual request from client
+// go-resty is provide option override client level settings such as
+// Auth Token, Basic Auth credentials, Header, Query Param, Form Data, Error object
+// and also you can add more options for that particular request
+type Request struct {
+	URL        string
+	Method     string
+	Token      string
+	QueryParam url.Values
+	FormData   url.Values
+	Header     http.Header
+	Time       time.Time
+	Body       interface{}
+	Result     interface{}
+	Error      interface{}
+	RawRequest *http.Request
+	SRV        *SRVRecord
+	UserInfo   *User
+
+	isMultiPart         bool
+	isFormData          bool
+	setContentLength    bool
+	isSaveResponse      bool
+	notParseResponse    bool
+	jsonEscapeHTML      bool
+	outputFile          string
+	fallbackContentType string
+	ctx                 context.Context
+	pathParams          map[string]string
+	client              *Client
+	bodyBuf             *bytes.Buffer
+	multipartFiles      []*File
+	multipartFields     []*MultipartField
+}
+
+// Context method returns the Context if its already set in request
+// otherwise it creates new one using `context.Background()`.
+func (r *Request) Context() context.Context {
+	if r.ctx == nil {
+		return context.Background()
+	}
+	return r.ctx
+}
+
+// SetContext method sets the context.Context for current Request. It allows
+// to interrupt the request execution if ctx.Done() channel is closed.
+// See https://blog.golang.org/context article and the "context" package
+// documentation.
+func (r *Request) SetContext(ctx context.Context) *Request {
+	r.ctx = ctx
+	return r
+}
+
+func (r *Request) addContextIfAvailable() {
+	if r.ctx != nil {
+		r.RawRequest = r.RawRequest.WithContext(r.ctx)
+	}
+}
+
+func (r *Request) isContextCancelledIfAvailable() bool {
+	if r.ctx != nil {
+		if r.ctx.Err() != nil {
+			return true
+		}
+	}
+	return false
+}
+
+// for go1.7+
+var noescapeJSONMarshal = func(v interface{}) ([]byte, error) {
+	buf := acquireBuffer()
+	defer releaseBuffer(buf)
+	encoder := json.NewEncoder(buf)
+	encoder.SetEscapeHTML(false)
+	err := encoder.Encode(v)
+	return buf.Bytes(), err
+}
--- a/vendor/gopkg.in/resty.v1/response.go
+++ b/vendor/gopkg.in/resty.v1/response.go
@ -0,0 +1,150 @@
+// Copyright (c) 2015-2019 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// Response is an object represents executed request and its values.
+type Response struct {
+	Request     *Request
+	RawResponse *http.Response
+
+	body       []byte
+	size       int64
+	receivedAt time.Time
+}
+
+// Body method returns HTTP response as []byte array for the executed request.
+// Note: `Response.Body` might be nil, if `Request.SetOutput` is used.
+func (r *Response) Body() []byte {
+	if r.RawResponse == nil {
+		return []byte{}
+	}
+	return r.body
+}
+
+// Status method returns the HTTP status string for the executed request.
+//	Example: 200 OK
+func (r *Response) Status() string {
+	if r.RawResponse == nil {
+		return ""
+	}
+
+	return r.RawResponse.Status
+}
+
+// StatusCode method returns the HTTP status code for the executed request.
+//	Example: 200
+func (r *Response) StatusCode() int {
+	if r.RawResponse == nil {
+		return 0
+	}
+
+	return r.RawResponse.StatusCode
+}
+
+// Result method returns the response value as an object if it has one
+func (r *Response) Result() interface{} {
+	return r.Request.Result
+}
+
+// Error method returns the error object if it has one
+func (r *Response) Error() interface{} {
+	return r.Request.Error
+}
+
+// Header method returns the response headers
+func (r *Response) Header() http.Header {
+	if r.RawResponse == nil {
+		return http.Header{}
+	}
+
+	return r.RawResponse.Header
+}
+
+// Cookies method to access all the response cookies
+func (r *Response) Cookies() []*http.Cookie {
+	if r.RawResponse == nil {
+		return make([]*http.Cookie, 0)
+	}
+
+	return r.RawResponse.Cookies()
+}
+
+// String method returns the body of the server response as String.
+func (r *Response) String() string {
+	if r.body == nil {
+		return ""
+	}
+
+	return strings.TrimSpace(string(r.body))
+}
+
+// Time method returns the time of HTTP response time that from request we sent and received a request.
+// See `response.ReceivedAt` to know when client recevied response and see `response.Request.Time` to know
+// when client sent a request.
+func (r *Response) Time() time.Duration {
+	return r.receivedAt.Sub(r.Request.Time)
+}
+
+// ReceivedAt method returns when response got recevied from server for the request.
+func (r *Response) ReceivedAt() time.Time {
+	return r.receivedAt
+}
+
+// Size method returns the HTTP response size in bytes. Ya, you can relay on HTTP `Content-Length` header,
+// however it won't be good for chucked transfer/compressed response. Since Resty calculates response size
+// at the client end. You will get actual size of the http response.
+func (r *Response) Size() int64 {
+	return r.size
+}
+
+// RawBody method exposes the HTTP raw response body. Use this method in-conjunction with `SetDoNotParseResponse`
+// option otherwise you get an error as `read err: http: read on closed response body`.
+//
+// Do not forget to close the body, otherwise you might get into connection leaks, no connection reuse.
+// Basically you have taken over the control of response parsing from `Resty`.
+func (r *Response) RawBody() io.ReadCloser {
+	if r.RawResponse == nil {
+		return nil
+	}
+	return r.RawResponse.Body
+}
+
+// IsSuccess method returns true if HTTP status code >= 200 and <= 299 otherwise false.
+func (r *Response) IsSuccess() bool {
+	return r.StatusCode() > 199 && r.StatusCode() < 300
+}
+
+// IsError method returns true if HTTP status code >= 400 otherwise false.
+func (r *Response) IsError() bool {
+	return r.StatusCode() > 399
+}
+
+func (r *Response) fmtBodyString(sl int64) string {
+	if r.body != nil {
+		if int64(len(r.body)) > sl {
+			return fmt.Sprintf("***** RESPONSE TOO LARGE (size - %d) *****", len(r.body))
+		}
+		ct := r.Header().Get(hdrContentTypeKey)
+		if IsJSONType(ct) {
+			out := acquireBuffer()
+			defer releaseBuffer(out)
+			if err := json.Indent(out, r.body, "", "   "); err == nil {
+				return out.String()
+			}
+		}
+		return r.String()
+	}
+
+	return "***** NO CONTENT *****"
+}
--- a/vendor/gopkg.in/resty.v1/resty.go
+++ b/vendor/gopkg.in/resty.v1/resty.go
@ -0,0 +1,9 @@
+// Copyright (c) 2015-2019 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+// Package resty provides Simple HTTP and REST client library for Go.
+package resty
+
+// Version # of resty
+const Version = "1.12.0"
--- a/vendor/gopkg.in/resty.v1/retry.go
+++ b/vendor/gopkg.in/resty.v1/retry.go
@ -0,0 +1,118 @@
+// Copyright (c) 2015-2019 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"math"
+	"math/rand"
+	"time"
+)
+
+const (
+	defaultMaxRetries  = 3
+	defaultWaitTime    = time.Duration(100) * time.Millisecond
+	defaultMaxWaitTime = time.Duration(2000) * time.Millisecond
+)
+
+type (
+	// Option is to create convenient retry options like wait time, max retries, etc.
+	Option func(*Options)
+
+	// RetryConditionFunc type is for retry condition function
+	RetryConditionFunc func(*Response) (bool, error)
+
+	// Options to hold go-resty retry values
+	Options struct {
+		maxRetries      int
+		waitTime        time.Duration
+		maxWaitTime     time.Duration
+		retryConditions []RetryConditionFunc
+	}
+)
+
+// Retries sets the max number of retries
+func Retries(value int) Option {
+	return func(o *Options) {
+		o.maxRetries = value
+	}
+}
+
+// WaitTime sets the default wait time to sleep between requests
+func WaitTime(value time.Duration) Option {
+	return func(o *Options) {
+		o.waitTime = value
+	}
+}
+
+// MaxWaitTime sets the max wait time to sleep between requests
+func MaxWaitTime(value time.Duration) Option {
+	return func(o *Options) {
+		o.maxWaitTime = value
+	}
+}
+
+// RetryConditions sets the conditions that will be checked for retry.
+func RetryConditions(conditions []RetryConditionFunc) Option {
+	return func(o *Options) {
+		o.retryConditions = conditions
+	}
+}
+
+// Backoff retries with increasing timeout duration up until X amount of retries
+// (Default is 3 attempts, Override with option Retries(n))
+func Backoff(operation func() (*Response, error), options ...Option) error {
+	// Defaults
+	opts := Options{
+		maxRetries:      defaultMaxRetries,
+		waitTime:        defaultWaitTime,
+		maxWaitTime:     defaultMaxWaitTime,
+		retryConditions: []RetryConditionFunc{},
+	}
+
+	for _, o := range options {
+		o(&opts)
+	}
+
+	var (
+		resp *Response
+		err  error
+	)
+	base := float64(opts.waitTime)        // Time to wait between each attempt
+	capLevel := float64(opts.maxWaitTime) // Maximum amount of wait time for the retry
+	for attempt := 0; attempt < opts.maxRetries; attempt++ {
+		resp, err = operation()
+
+		var needsRetry bool
+		var conditionErr error
+		for _, condition := range opts.retryConditions {
+			needsRetry, conditionErr = condition(resp)
+			if needsRetry || conditionErr != nil {
+				break
+			}
+		}
+
+		// If the operation returned no error, there was no condition satisfied and
+		// there was no error caused by the conditional functions.
+		if err == nil && !needsRetry && conditionErr == nil {
+			return nil
+		}
+		// Adding capped exponential backup with jitter
+		// See the following article...
+		// http://www.awsarchitectureblog.com/2015/03/backoff.html
+		temp := math.Min(capLevel, base*math.Exp2(float64(attempt)))
+		ri := int(temp / 2)
+		if ri <= 0 {
+			ri = 1<<31 - 1 // max int for arch 386
+		}
+		sleepDuration := time.Duration(math.Abs(float64(ri + rand.Intn(ri))))
+
+		if sleepDuration < opts.waitTime {
+			sleepDuration = opts.waitTime
+		}
+		time.Sleep(sleepDuration)
+	}
+
+	return err
+}
--- a/vendor/gopkg.in/resty.v1/util.go
+++ b/vendor/gopkg.in/resty.v1/util.go
@ -0,0 +1,281 @@
+// Copyright (c) 2015-2019 Jeevanandam M (jeeva@myjeeva.com), All rights reserved.
+// resty source code and usage is governed by a MIT style
+// license that can be found in the LICENSE file.
+
+package resty
+
+import (
+	"bytes"
+	"encoding/json"
+	"encoding/xml"
+	"fmt"
+	"io"
+	"log"
+	"mime/multipart"
+	"net/http"
+	"net/textproto"
+	"os"
+	"path/filepath"
+	"reflect"
+	"runtime"
+	"sort"
+	"strings"
+)
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Package Helper methods
+//___________________________________
+
+// IsStringEmpty method tells whether given string is empty or not
+func IsStringEmpty(str string) bool {
+	return len(strings.TrimSpace(str)) == 0
+}
+
+// DetectContentType method is used to figure out `Request.Body` content type for request header
+func DetectContentType(body interface{}) string {
+	contentType := plainTextType
+	kind := kindOf(body)
+	switch kind {
+	case reflect.Struct, reflect.Map:
+		contentType = jsonContentType
+	case reflect.String:
+		contentType = plainTextType
+	default:
+		if b, ok := body.([]byte); ok {
+			contentType = http.DetectContentType(b)
+		} else if kind == reflect.Slice {
+			contentType = jsonContentType
+		}
+	}
+
+	return contentType
+}
+
+// IsJSONType method is to check JSON content type or not
+func IsJSONType(ct string) bool {
+	return jsonCheck.MatchString(ct)
+}
+
+// IsXMLType method is to check XML content type or not
+func IsXMLType(ct string) bool {
+	return xmlCheck.MatchString(ct)
+}
+
+// Unmarshal content into object from JSON or XML
+// Deprecated: kept for backward compatibility
+func Unmarshal(ct string, b []byte, d interface{}) (err error) {
+	if IsJSONType(ct) {
+		err = json.Unmarshal(b, d)
+	} else if IsXMLType(ct) {
+		err = xml.Unmarshal(b, d)
+	}
+
+	return
+}
+
+// Unmarshalc content into object from JSON or XML
+func Unmarshalc(c *Client, ct string, b []byte, d interface{}) (err error) {
+	if IsJSONType(ct) {
+		err = c.JSONUnmarshal(b, d)
+	} else if IsXMLType(ct) {
+		err = xml.Unmarshal(b, d)
+	}
+
+	return
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// RequestLog and ResponseLog type
+//___________________________________
+
+// RequestLog struct is used to collected information from resty request
+// instance for debug logging. It sent to request log callback before resty
+// actually logs the information.
+type RequestLog struct {
+	Header http.Header
+	Body   string
+}
+
+// ResponseLog struct is used to collected information from resty response
+// instance for debug logging. It sent to response log callback before resty
+// actually logs the information.
+type ResponseLog struct {
+	Header http.Header
+	Body   string
+}
+
+//‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾‾
+// Package Unexported methods
+//___________________________________
+
+// way to disable the HTML escape as opt-in
+func jsonMarshal(c *Client, r *Request, d interface{}) ([]byte, error) {
+	if !r.jsonEscapeHTML {
+		return noescapeJSONMarshal(d)
+	} else if !c.jsonEscapeHTML {
+		return noescapeJSONMarshal(d)
+	}
+	return c.JSONMarshal(d)
+}
+
+func firstNonEmpty(v ...string) string {
+	for _, s := range v {
+		if !IsStringEmpty(s) {
+			return s
+		}
+	}
+	return ""
+}
+
+func getLogger(w io.Writer) *log.Logger {
+	return log.New(w, "RESTY ", log.LstdFlags)
+}
+
+var quoteEscaper = strings.NewReplacer("\\", "\\\\", `"`, "\\\"")
+
+func escapeQuotes(s string) string {
+	return quoteEscaper.Replace(s)
+}
+
+func createMultipartHeader(param, fileName, contentType string) textproto.MIMEHeader {
+	hdr := make(textproto.MIMEHeader)
+	hdr.Set("Content-Disposition", fmt.Sprintf(`form-data; name="%s"; filename="%s"`,
+		escapeQuotes(param), escapeQuotes(fileName)))
+	hdr.Set("Content-Type", contentType)
+	return hdr
+}
+
+func addMultipartFormField(w *multipart.Writer, mf *MultipartField) error {
+	partWriter, err := w.CreatePart(createMultipartHeader(mf.Param, mf.FileName, mf.ContentType))
+	if err != nil {
+		return err
+	}
+
+	_, err = io.Copy(partWriter, mf.Reader)
+	return err
+}
+
+func writeMultipartFormFile(w *multipart.Writer, fieldName, fileName string, r io.Reader) error {
+	// Auto detect actual multipart content type
+	cbuf := make([]byte, 512)
+	size, err := r.Read(cbuf)
+	if err != nil {
+		return err
+	}
+
+	partWriter, err := w.CreatePart(createMultipartHeader(fieldName, fileName, http.DetectContentType(cbuf)))
+	if err != nil {
+		return err
+	}
+
+	if _, err = partWriter.Write(cbuf[:size]); err != nil {
+		return err
+	}
+
+	_, err = io.Copy(partWriter, r)
+	return err
+}
+
+func addFile(w *multipart.Writer, fieldName, path string) error {
+	file, err := os.Open(path)
+	if err != nil {
+		return err
+	}
+	defer closeq(file)
+	return writeMultipartFormFile(w, fieldName, filepath.Base(path), file)
+}
+
+func addFileReader(w *multipart.Writer, f *File) error {
+	return writeMultipartFormFile(w, f.ParamName, f.Name, f.Reader)
+}
+
+func getPointer(v interface{}) interface{} {
+	vv := valueOf(v)
+	if vv.Kind() == reflect.Ptr {
+		return v
+	}
+	return reflect.New(vv.Type()).Interface()
+}
+
+func isPayloadSupported(m string, allowMethodGet bool) bool {
+	return !(m == MethodHead || m == MethodOptions || (m == MethodGet && !allowMethodGet))
+}
+
+func typeOf(i interface{}) reflect.Type {
+	return indirect(valueOf(i)).Type()
+}
+
+func valueOf(i interface{}) reflect.Value {
+	return reflect.ValueOf(i)
+}
+
+func indirect(v reflect.Value) reflect.Value {
+	return reflect.Indirect(v)
+}
+
+func kindOf(v interface{}) reflect.Kind {
+	return typeOf(v).Kind()
+}
+
+func createDirectory(dir string) (err error) {
+	if _, err = os.Stat(dir); err != nil {
+		if os.IsNotExist(err) {
+			if err = os.MkdirAll(dir, 0755); err != nil {
+				return
+			}
+		}
+	}
+	return
+}
+
+func canJSONMarshal(contentType string, kind reflect.Kind) bool {
+	return IsJSONType(contentType) && (kind == reflect.Struct || kind == reflect.Map || kind == reflect.Slice)
+}
+
+func functionName(i interface{}) string {
+	return runtime.FuncForPC(reflect.ValueOf(i).Pointer()).Name()
+}
+
+func acquireBuffer() *bytes.Buffer {
+	return bufPool.Get().(*bytes.Buffer)
+}
+
+func releaseBuffer(buf *bytes.Buffer) {
+	if buf != nil {
+		buf.Reset()
+		bufPool.Put(buf)
+	}
+}
+
+func closeq(v interface{}) {
+	if c, ok := v.(io.Closer); ok {
+		sliently(c.Close())
+	}
+}
+
+func sliently(_ ...interface{}) {}
+
+func composeHeaders(hdrs http.Header) string {
+	var str []string
+	for _, k := range sortHeaderKeys(hdrs) {
+		str = append(str, fmt.Sprintf("%25s: %s", k, strings.Join(hdrs[k], ", ")))
+	}
+	return strings.Join(str, "\n")
+}
+
+func sortHeaderKeys(hdrs http.Header) []string {
+	var keys []string
+	for key := range hdrs {
+		keys = append(keys, key)
+	}
+	sort.Strings(keys)
+	return keys
+}
+
+func copyHeaders(hdrs http.Header) http.Header {
+	nh := http.Header{}
+	for k, v := range hdrs {
+		nh[k] = v
+	}
+	return nh
+}