From e5c13ffe62d2f99c9a4b18bac72ebda57bfd7d56 Mon Sep 17 00:00:00 2001
From: John Vu <johnvu@asana.com>
Date: Thu, 25 Apr 2024 16:37:27 -0700
Subject: [PATCH] Update v1 to v1.0.3 + Add important message in README.md

---
 .../workflows/publish-to-github-releases.yml  |   4 +-
 README.md                                     |  22 ++--
 bower.json                                    |   2 +-
 lib/client.js                                 | 106 ++++++++++-----
 lib/resources/allocations.js                  |   3 +
 lib/resources/gen/allocations.js              | 114 +++++++++++++++++
 lib/resources/gen/attachments.js              |   8 +-
 lib/resources/gen/audit_log_api.js            |   4 +-
 lib/resources/gen/custom_field_settings.js    |   8 +-
 lib/resources/gen/custom_fields.js            |   6 +-
 lib/resources/gen/events.js                   |   4 +-
 lib/resources/gen/goal_relationships.js       | 115 +++++++++++++++++
 lib/resources/gen/goals.js                    | 121 +-----------------
 lib/resources/gen/jobs.js                     |   2 +-
 lib/resources/gen/memberships.js              | 113 ++++++++++++++++
 lib/resources/gen/organization_exports.js     |   2 +-
 lib/resources/gen/portfolio_memberships.js    |  10 +-
 lib/resources/gen/portfolios.js               |  12 +-
 lib/resources/gen/project_briefs.js           |   2 +-
 lib/resources/gen/project_memberships.js      |   6 +-
 lib/resources/gen/project_statuses.js         |   6 +-
 lib/resources/gen/project_templates.js        |  28 +++-
 lib/resources/gen/projects.js                 |  22 ++--
 lib/resources/gen/rules.js                    |  37 ++++++
 lib/resources/gen/sections.js                 |   6 +-
 lib/resources/gen/status_updates.js           |  18 +--
 lib/resources/gen/stories.js                  |   8 +-
 lib/resources/gen/tags.js                     |  16 +--
 lib/resources/gen/task_templates.js           |  96 ++++++++++++++
 lib/resources/gen/tasks.js                    |  59 ++++++---
 lib/resources/gen/team_memberships.js         |  14 +-
 lib/resources/gen/teams.js                    |  30 ++++-
 lib/resources/gen/time_periods.js             |   6 +-
 lib/resources/gen/time_tracking_entries.js    | 115 +++++++++++++++++
 lib/resources/gen/typeahead.js                |   6 +-
 lib/resources/gen/user_task_lists.js          |   4 +-
 lib/resources/gen/users.js                    |  20 +--
 lib/resources/gen/webhooks.js                 |   6 +-
 lib/resources/gen/workspace_memberships.js    |  10 +-
 lib/resources/gen/workspaces.js               |   6 +-
 lib/resources/goal_relationships.js           |   3 +
 lib/resources/goals.js                        |   3 +
 lib/resources/index.js                        |  18 ++-
 lib/resources/memberships.js                  |   3 +
 lib/resources/project_briefs.js               |   3 +
 lib/resources/project_templates.js            |   3 +
 lib/resources/rules.js                        |   3 +
 lib/resources/status_updates.js               |   3 +
 lib/resources/task_templates.js               |   3 +
 lib/resources/time_periods.js                 |   3 +
 lib/resources/time_tracking_entries.js        |   3 +
 package.json                                  |   2 +-
 samples/allocations_sample.yaml               |  56 ++++++++
 samples/attachments_sample.yaml               |   4 +-
 samples/goal_relationships_sample.yaml        |  56 ++++++++
 samples/goals_sample.yaml                     |  66 ----------
 samples/memberships_sample.yaml               |  56 ++++++++
 samples/project_templates_sample.yaml         |  11 ++
 samples/rules_sample.yaml                     |  12 ++
 samples/status_updates_sample.yaml            |   4 +-
 samples/task_templates_sample.yaml            |  45 +++++++
 samples/tasks_sample.yaml                     |  11 ++
 samples/teams_sample.yaml                     |  11 ++
 samples/time_tracking_entries_sample.yaml     |  56 ++++++++
 64 files changed, 1238 insertions(+), 377 deletions(-)
 create mode 100644 lib/resources/allocations.js
 create mode 100644 lib/resources/gen/allocations.js
 create mode 100644 lib/resources/gen/goal_relationships.js
 create mode 100644 lib/resources/gen/memberships.js
 create mode 100644 lib/resources/gen/rules.js
 create mode 100644 lib/resources/gen/task_templates.js
 create mode 100644 lib/resources/gen/time_tracking_entries.js
 create mode 100644 lib/resources/goal_relationships.js
 create mode 100644 lib/resources/goals.js
 create mode 100644 lib/resources/memberships.js
 create mode 100644 lib/resources/project_briefs.js
 create mode 100644 lib/resources/project_templates.js
 create mode 100644 lib/resources/rules.js
 create mode 100644 lib/resources/status_updates.js
 create mode 100644 lib/resources/task_templates.js
 create mode 100644 lib/resources/time_periods.js
 create mode 100644 lib/resources/time_tracking_entries.js
 create mode 100644 samples/allocations_sample.yaml
 create mode 100644 samples/goal_relationships_sample.yaml
 create mode 100644 samples/memberships_sample.yaml
 create mode 100644 samples/rules_sample.yaml
 create mode 100644 samples/task_templates_sample.yaml
 create mode 100644 samples/time_tracking_entries_sample.yaml

diff --git a/.github/workflows/publish-to-github-releases.yml b/.github/workflows/publish-to-github-releases.yml
index 54259cb3..f68912ca 100644
--- a/.github/workflows/publish-to-github-releases.yml
+++ b/.github/workflows/publish-to-github-releases.yml
@@ -13,10 +13,10 @@ jobs:
       - uses: actions/checkout@v3
       - uses: actions/setup-node@v3
         with:
-          node-version: '8.x'
+          node-version: '10.x'
       - name: Bundle the code, full version to asana.js and minified to asana-min.js
         run: |
-          npm i gulp
+          npm i gulp@4.0.2
           gulp bundle
       - name: Publish to GitHub Releases
         uses: softprops/action-gh-release@v1
diff --git a/README.md b/README.md
index 9d5d7236..d8a36260 100644
--- a/README.md
+++ b/README.md
@@ -1,4 +1,8 @@
-# Asana [![GitHub release][release-image]]() [![Build Status][github-actions-image]][github-actions-url] [![NPM Version][npm-image]][npm-url]
+# Asana
+> **Important:**
+> Versions 1.X.X and earlier of this package are no longer supported. For new features and support, please upgrade to [the latest version](https://www.npmjs.com/package/asana).
+>
+>To view sample code for version 1, select the `node-sdk-v1` tab on a specific endpoint's page in the [Asana API reference](https://developers.asana.com/reference/rest-api-reference), or check the [v1 samples](https://github.com/Asana/node-asana/tree/v1.0.3/samples) directory on GitHub.
 
 A JavaScript client (for both Node and browser) for the Asana API v1.0.
 
@@ -9,20 +13,20 @@ A JavaScript client (for both Node and browser) for the Asana API v1.0.
 Install with npm:
 
 ```sh
-npm install asana --save
+npm install asana@1.0.3 --save
 ```
 
 ### Browser
 
-Include the latest release directly from GitHub.
+Include the v1.0.3 release directly from GitHub.
 
 ```html
-<script src="https://github.com/Asana/node-asana/releases/download/<LATEST_RELEASE>/asana-min.js"></script>
+<script src="https://github.com/Asana/node-asana/releases/download/v1.03/asana-min.js"></script>
 ```
 
 **OR:**
 
-1. Download the latest distribution in [releases](https://github.com/Asana/node-asana/releases).
+1. Download the v1.0.3 distribution in [releases](https://github.com/Asana/node-asana/releases).
 2. Make sure to serve it from your webserver.
 3. Include it on the client from a `<script>` tag.
 
@@ -338,14 +342,6 @@ GitHub Actions will automatically build and deploy the tagged release.
 
 :reminder_ribbon: Make sure to edit the [new release](https://github.com/Asana/node-asana/releases) description on GitHub after it has been deployed. Please use bullet points to indicate notable changes since the last version.
 
-[release-image]: https://img.shields.io/github/release/asana/node-asana.svg
-
-[github-actions-url]: https://github.com/Asana/node-asana/actions
-[github-actions-image]: https://github.com/Asana/node-asana/workflows/Build/badge.svg
-
-[npm-url]: https://www.npmjs.org/package/asana
-[npm-image]: http://img.shields.io/npm/v/asana.svg?style=flat-square
-
 [bluebird]: https://github.com/petkaantonov/bluebird
 [co]: https://github.com/visionmedia/co
 [highland]: http://highlandjs.org/
diff --git a/bower.json b/bower.json
index bbedc5ff..7416f00f 100644
--- a/bower.json
+++ b/bower.json
@@ -1,7 +1,7 @@
 {
   "name": "asana",
   "main": "dist/asana.js",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "homepage": "https://github.com/Asana/node-asana",
   "authors": [
     "Greg Slovacek <greg@asana.com>",
diff --git a/lib/client.js b/lib/client.js
index e27df1da..17e38aab 100644
--- a/lib/client.js
+++ b/lib/client.js
@@ -27,6 +27,11 @@ function Client(dispatcher, options) {
    * @type {Dispatcher}
    */
   this.dispatcher = dispatcher;
+  /**
+   * An instance of the Allocations resource.
+   * @type {Allocations}
+   */
+  this.allocations = new resources.Allocations(this.dispatcher);
   /**
    * An instance of the Attachments resource.
    * @type {Attachments}
@@ -36,68 +41,98 @@ function Client(dispatcher, options) {
    * An instance of the AuditLogAPI resource.
    * @type {AuditLogAPI}
    */
-  this.auditLogAPI = new resources.AuditLogAPI(this.dispatcher);
+  this.auditlogapi = new resources.AuditLogAPI(this.dispatcher);
   /**
    * An instance of the BatchAPI resource.
    * @type {BatchAPI}
    */
-  this.batchAPI = new resources.BatchAPI(this.dispatcher);
+  this.batchapi = new resources.BatchAPI(this.dispatcher);
   /**
    * An instance of the CustomFieldSettings resource.
    * @type {CustomFieldSettings}
    */
-  this.customFieldSettings = new resources.CustomFieldSettings(this.dispatcher);
+  this.customfieldsettings = new resources.CustomFieldSettings(this.dispatcher);
   /**
    * An instance of the CustomFields resource.
    * @type {CustomFields}
    */
-  this.customFields = new resources.CustomFields(this.dispatcher);
+  this.customfields = new resources.CustomFields(this.dispatcher);
   /**
    * An instance of the Events resource.
    * @type {Events}
    */
   this.events = new resources.Events(this.dispatcher);
+  /**
+   * An instance of the GoalRelationships resource.
+   * @type {GoalRelationships}
+   */
+  this.goalrelationships = new resources.GoalRelationships(this.dispatcher);
+  /**
+   * An instance of the Goals resource.
+   * @type {Goals}
+   */
+  this.goals = new resources.Goals(this.dispatcher);
   /**
    * An instance of the Jobs resource.
    * @type {Jobs}
    */
   this.jobs = new resources.Jobs(this.dispatcher);
   /**
-   * An instance of the OrganizationExports resource.
-   * @type {Events}
+   * An instance of the Memberships resource.
+   * @type {Memberships}
    */
-  this.organizationExports = new resources.OrganizationExports(this.dispatcher);
+  this.memberships = new resources.Memberships(this.dispatcher);
   /**
-   * An instance of the Portfolios resource.
-   * @type {Portfolios}
+   * An instance of the OrganizationExports resource.
+   * @type {OrganizationExports}
    */
-  this.portfolios = new resources.Portfolios(this.dispatcher);
+  this.organizationexports = new resources.OrganizationExports(this.dispatcher);
   /**
    * An instance of the PortfolioMemberships resource.
    * @type {PortfolioMemberships}
    */
-  this.portfolioMemberships =
+  this.portfoliomemberships =
       new resources.PortfolioMemberships(this.dispatcher);
   /**
-   * An instance of the Projects resource.
-   * @type {Projects}
+   * An instance of the Portfolios resource.
+   * @type {Portfolios}
    */
-  this.projects = new resources.Projects(this.dispatcher);
+  this.portfolios = new resources.Portfolios(this.dispatcher);
+  /**
+   * An instance of the ProjectBriefs resource.
+   * @type {ProjectBriefs}
+   */
+  this.projectbriefs = new resources.ProjectBriefs(this.dispatcher);
   /**
    * An instance of the ProjectMemberships resource.
    * @type {ProjectMemberships}
    */
-  this.projectMemberships = new resources.ProjectMemberships(this.dispatcher);
+  this.projectmemberships = new resources.ProjectMemberships(this.dispatcher);
   /**
    * An instance of the ProjectStatuses resource.
    * @type {ProjectStatuses}
    */
-  this.projectStatuses = new resources.ProjectStatuses(this.dispatcher);
+  this.projectstatuses = new resources.ProjectStatuses(this.dispatcher);
+  /**
+   * An instance of the ProjectTemplates resource.
+   * @type {ProjectTemplates}
+   */
+  this.projecttemplates = new resources.ProjectTemplates(this.dispatcher);
+  /**
+   * An instance of the Projects resource.
+   * @type {Projects}
+   */
+  this.projects = new resources.Projects(this.dispatcher);
   /**
    * An instance of the Sections resource.
    * @type {Sections}
    */
   this.sections = new resources.Sections(this.dispatcher);
+  /**
+   * An instance of the StatusUpdates resource.
+   * @type {StatusUpdates}
+   */
+  this.statusupdates = new resources.StatusUpdates(this.dispatcher);
   /**
    * An instance of the Stories resource.
    * @type {Stories}
@@ -118,38 +153,47 @@ function Client(dispatcher, options) {
    * @type {Teams}
    */
   this.teams = new resources.Teams(this.dispatcher);
+  /**
+   * An instance of the TimePeriods resource.
+   * @type {TimePeriods}
+   */
+  this.timeperiods = new resources.TimePeriods(this.dispatcher);
+  /**
+   * An instance of the TimeTrackingEntries resource.
+   * @type {TimeTrackingEntries}
+   */
+  this.timetrackingentries = new resources.TimeTrackingEntries(this.dispatcher);
   /**
    * An instance of the Typeahead resource.
-   * @type {Teams}
+   * @type {Typeahead}
    */
   this.typeahead = new resources.Typeahead(this.dispatcher);
+  /**
+   * An instance of the UserTaskLists resource.
+   * @type {UserTaskLists}
+   */
+  this.usertasklists = new resources.UserTaskLists(this.dispatcher);
   /**
    * An instance of the Users resource.
    * @type {Users}
    */
   this.users = new resources.Users(this.dispatcher);
   /**
-   * An instance of the UserTaskLists resource.
-   * @type {UserTaskLists}
-   */
-  this.userTaskLists = new resources.UserTaskLists(this.dispatcher);
-  /**
-   * An instance of the Workspaces resource.
-   * @type {Workspaces}
+   * An instance of the Webhooks resource.
+   * @type {Webhooks}
    */
-  this.workspaces = new resources.Workspaces(this.dispatcher);
+  this.webhooks = new resources.Webhooks(this.dispatcher);
   /**
    * An instance of the WorkspaceMemberships resource.
-   * @type {Workspaces}
+   * @type {WorkspaceMemberships}
    */
-  this.workspaceMemberships =
+  this.workspacememberships =
       new resources.WorkspaceMemberships(this.dispatcher);
   /**
-   * An instance of the Webhooks resource.
-   * @type {Webhooks}
+   * An instance of the Workspaces resource.
+   * @type {Workspaces}
    */
-  this.webhooks = new resources.Webhooks(this.dispatcher);
-
+  this.workspaces = new resources.Workspaces(this.dispatcher);
   // Store off Oauth info.
   this.app = new App(options);
 }
diff --git a/lib/resources/allocations.js b/lib/resources/allocations.js
new file mode 100644
index 00000000..00f1f793
--- /dev/null
+++ b/lib/resources/allocations.js
@@ -0,0 +1,3 @@
+var Allocations = require('./gen/allocations');
+
+module.exports = Allocations;
diff --git a/lib/resources/gen/allocations.js b/lib/resources/gen/allocations.js
new file mode 100644
index 00000000..e85e397d
--- /dev/null
+++ b/lib/resources/gen/allocations.js
@@ -0,0 +1,114 @@
+/**
+ * This file is auto-generated by our openapi spec.
+ * We try to keep the generated code pretty clean but there will be lint
+ * errors that are just not worth fixing (like unused requires).
+ * TODO: maybe we can just disable those specifically and keep this code
+ * pretty lint-free too!
+ */
+/* jshint ignore:start */
+var Resource = require('../resource');
+var util = require('util');
+var _ = require('lodash');
+
+function Allocations(dispatcher) {
+    Resource.call(this, dispatcher);
+}
+util.inherits(Allocations, Resource);
+
+
+/**
+ * Create an allocation
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+Allocations.prototype.createAllocation = function(
+    data,
+    dispatchOptions
+) {
+    var path = "/allocations";
+
+    return this.dispatchPost(path, data, dispatchOptions)
+};
+
+
+/**
+ * Delete an allocation
+ * @param {String} allocationGid: (required) Globally unique identifier for the allocation.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+Allocations.prototype.deleteAllocation = function(
+    allocationGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/allocations/{allocation_gid}".replace("{allocation_gid}", allocationGid);
+
+    return this.dispatchDelete(path, data, dispatchOptions)
+};
+
+
+/**
+ * Get an allocation
+ * @param {String} allocationGid: (required) Globally unique identifier for the allocation.
+ * @param {Object} params: Parameters for the request
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
+     - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+Allocations.prototype.getAllocation = function(
+    allocationGid,
+    params,
+    dispatchOptions
+) {
+    var path = "/allocations/{allocation_gid}".replace("{allocation_gid}", allocationGid);
+
+    return this.dispatchGet(path, params, dispatchOptions)
+};
+
+
+/**
+ * Get multiple allocations
+ * @param {Object} params: Parameters for the request
+     - parent {String}:  Globally unique identifier for the project to filter allocations by.
+     - assignee {String}:  Globally unique identifier for the user the allocation is assigned to.
+     - workspace {String}:  Globally unique identifier for the workspace.
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
+     - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
+     - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+Allocations.prototype.getAllocations = function(
+    params,
+    dispatchOptions
+) {
+    var path = "/allocations";
+
+    return this.dispatchGetCollection(path, params, dispatchOptions)
+};
+
+
+/**
+ * Update an allocation
+ * @param {String} allocationGid: (required) Globally unique identifier for the allocation.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+Allocations.prototype.updateAllocation = function(
+    allocationGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/allocations/{allocation_gid}".replace("{allocation_gid}", allocationGid);
+
+    return this.dispatchPut(path, data, dispatchOptions)
+};
+
+module.exports = Allocations;
+/* jshint ignore:end */
diff --git a/lib/resources/gen/attachments.js b/lib/resources/gen/attachments.js
index 792ed074..cc3c4595 100644
--- a/lib/resources/gen/attachments.js
+++ b/lib/resources/gen/attachments.js
@@ -38,7 +38,7 @@ Attachments.prototype.deleteAttachment = function(
  * Get an attachment
  * @param {String} attachmentGid: (required) Globally unique identifier for the attachment.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -57,10 +57,10 @@ Attachments.prototype.getAttachment = function(
 /**
  * Get attachments from an object
  * @param {Object} params: Parameters for the request
-     - parent {String}:  (required) Globally unique identifier for object to fetch statuses from. Must be a GID for a task or project_brief.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - parent {String}:  (required) Globally unique identifier for object to fetch statuses from. Must be a GID for a `project`, `project_brief`, or `task`.
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/audit_log_api.js b/lib/resources/gen/audit_log_api.js
index d1a7aff7..cb4fb167 100644
--- a/lib/resources/gen/audit_log_api.js
+++ b/lib/resources/gen/audit_log_api.js
@@ -22,11 +22,11 @@ util.inherits(AuditLogAPI, Resource);
  * @param {Object} params: Parameters for the request
      - startAt {Date}:  Filter to events created after this time (inclusive).
      - endAt {Date}:  Filter to events created before this time (exclusive).
-     - eventType {String}:  Filter to events of this type. Refer to the [Supported AuditLogEvents](/docs/supported-auditlogevents) for a full list of values.
+     - eventType {String}:  Filter to events of this type. Refer to the [supported audit log events](/docs/audit-log-events#supported-audit-log-events) for a full list of values.
      - actorType {String}:  Filter to events with an actor of this type. This only needs to be included if querying for actor types without an ID. If `actor_gid` is included, this should be excluded.
      - actorGid {String}:  Filter to events triggered by the actor with this ID.
      - resourceGid {String}:  Filter to events with this resource ID.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/custom_field_settings.js b/lib/resources/gen/custom_field_settings.js
index 479cc127..6c3a9b85 100644
--- a/lib/resources/gen/custom_field_settings.js
+++ b/lib/resources/gen/custom_field_settings.js
@@ -20,9 +20,9 @@ util.inherits(CustomFieldSettings, Resource);
  * Get a portfolio's custom fields
  * @param {String} portfolioGid: (required) Globally unique identifier for the portfolio.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -42,9 +42,9 @@ CustomFieldSettings.prototype.getCustomFieldSettingsForPortfolio = function(
  * Get a project's custom fields
  * @param {String} projectGid: (required) Globally unique identifier for the project.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/custom_fields.js b/lib/resources/gen/custom_fields.js
index bb654bed..407d1ea1 100644
--- a/lib/resources/gen/custom_fields.js
+++ b/lib/resources/gen/custom_fields.js
@@ -72,7 +72,7 @@ CustomFields.prototype.deleteCustomField = function(
  * Get a custom field
  * @param {String} customFieldGid: (required) Globally unique identifier for the custom field.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -92,9 +92,9 @@ CustomFields.prototype.getCustomField = function(
  * Get a workspace's custom fields
  * @param {String} workspaceGid: (required) Globally unique identifier for the workspace or organization.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/events.js b/lib/resources/gen/events.js
index 79509734..8f59b707 100644
--- a/lib/resources/gen/events.js
+++ b/lib/resources/gen/events.js
@@ -19,9 +19,9 @@ util.inherits(Events, Resource);
 /**
  * Get events on a resource
  * @param {Object} params: Parameters for the request
-     - resource {String}:  (required) A resource ID to subscribe to. The resource can be a task or project.
+     - resource {String}:  (required) A resource ID to subscribe to. The resource can be a task, project, or goal.
      - sync {String}:  A sync token received from the last request, or none on first sync. Events will be returned from the point in time that the sync token was generated. *Note: On your first request, omit the sync token. The response will be the same as for an expired sync token, and will include a new valid sync token.If the sync token is too old (which may happen from time to time) the API will return a `412 Precondition Failed` error, and include a fresh sync token in the response.*
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/goal_relationships.js b/lib/resources/gen/goal_relationships.js
new file mode 100644
index 00000000..80480350
--- /dev/null
+++ b/lib/resources/gen/goal_relationships.js
@@ -0,0 +1,115 @@
+/**
+ * This file is auto-generated by our openapi spec.
+ * We try to keep the generated code pretty clean but there will be lint
+ * errors that are just not worth fixing (like unused requires).
+ * TODO: maybe we can just disable those specifically and keep this code
+ * pretty lint-free too!
+ */
+/* jshint ignore:start */
+var Resource = require('../resource');
+var util = require('util');
+var _ = require('lodash');
+
+function GoalRelationships(dispatcher) {
+    Resource.call(this, dispatcher);
+}
+util.inherits(GoalRelationships, Resource);
+
+
+/**
+ * Add a supporting goal relationship
+ * @param {String} goalGid: (required) Globally unique identifier for the goal.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+GoalRelationships.prototype.addSupportingRelationship = function(
+    goalGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/goals/{goal_gid}/addSupportingRelationship".replace("{goal_gid}", goalGid);
+
+    return this.dispatchPost(path, data, dispatchOptions)
+};
+
+
+/**
+ * Get a goal relationship
+ * @param {String} goalRelationshipGid: (required) Globally unique identifier for the goal relationship.
+ * @param {Object} params: Parameters for the request
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
+     - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+GoalRelationships.prototype.getGoalRelationship = function(
+    goalRelationshipGid,
+    params,
+    dispatchOptions
+) {
+    var path = "/goal_relationships/{goal_relationship_gid}".replace("{goal_relationship_gid}", goalRelationshipGid);
+
+    return this.dispatchGet(path, params, dispatchOptions)
+};
+
+
+/**
+ * Get goal relationships
+ * @param {Object} params: Parameters for the request
+     - supportedGoal {String}:  (required) Globally unique identifier for the supported goal in the goal relationship.
+     - resourceSubtype {String}:  If provided, filter to goal relationships with a given resource_subtype.
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
+     - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
+     - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+GoalRelationships.prototype.getGoalRelationships = function(
+    params,
+    dispatchOptions
+) {
+    var path = "/goal_relationships";
+
+    return this.dispatchGetCollection(path, params, dispatchOptions)
+};
+
+
+/**
+ * Removes a supporting goal relationship
+ * @param {String} goalGid: (required) Globally unique identifier for the goal.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+GoalRelationships.prototype.removeSupportingRelationship = function(
+    goalGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/goals/{goal_gid}/removeSupportingRelationship".replace("{goal_gid}", goalGid);
+
+    return this.dispatchPost(path, data, dispatchOptions)
+};
+
+
+/**
+ * Update a goal relationship
+ * @param {String} goalRelationshipGid: (required) Globally unique identifier for the goal relationship.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+GoalRelationships.prototype.updateGoalRelationship = function(
+    goalRelationshipGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/goal_relationships/{goal_relationship_gid}".replace("{goal_relationship_gid}", goalRelationshipGid);
+
+    return this.dispatchPut(path, data, dispatchOptions)
+};
+
+module.exports = GoalRelationships;
+/* jshint ignore:end */
diff --git a/lib/resources/gen/goals.js b/lib/resources/gen/goals.js
index 0551e77c..7ba2306a 100644
--- a/lib/resources/gen/goals.js
+++ b/lib/resources/gen/goals.js
@@ -34,42 +34,6 @@ Goals.prototype.addFollowers = function(
 };
 
 
-/**
- * Add a subgoal to a parent goal
- * @param {String} goalGid: (required) Globally unique identifier for the goal.
- * @param {Object} data: Data for the request
- * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
- * @return {Promise} The requested resource
- */
-Goals.prototype.addSubgoal = function(
-    goalGid,
-    data,
-    dispatchOptions
-) {
-    var path = "/goals/{goal_gid}/addSubgoal".replace("{goal_gid}", goalGid);
-
-    return this.dispatchPost(path, data, dispatchOptions)
-};
-
-
-/**
- * Add a project/portfolio as supporting work for a goal.
- * @param {String} goalGid: (required) Globally unique identifier for the goal.
- * @param {Object} data: Data for the request
- * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
- * @return {Promise} The requested resource
- */
-Goals.prototype.addSupportingWorkForGoal = function(
-    goalGid,
-    data,
-    dispatchOptions
-) {
-    var path = "/goals/{goal_gid}/addSupportingWork".replace("{goal_gid}", goalGid);
-
-    return this.dispatchPost(path, data, dispatchOptions)
-};
-
-
 /**
  * Create a goal
  * @param {Object} data: Data for the request
@@ -126,7 +90,7 @@ Goals.prototype.deleteGoal = function(
  * Get a goal
  * @param {String} goalGid: (required) Globally unique identifier for the goal.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -147,13 +111,14 @@ Goals.prototype.getGoal = function(
  * @param {Object} params: Parameters for the request
      - portfolio {String}:  Globally unique identifier for supporting portfolio.
      - project {String}:  Globally unique identifier for supporting project.
+     - task {String}:  Globally unique identifier for supporting task.
      - isWorkspaceLevel {Boolean}:  Filter to goals with is_workspace_level set to query value. Must be used with the workspace parameter.
      - team {String}:  Globally unique identifier for the team.
      - workspace {String}:  Globally unique identifier for the workspace.
      - timePeriods {[String]}:  Globally unique identifiers for the time periods.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -172,7 +137,7 @@ Goals.prototype.getGoals = function(
  * Get parent goals from a goal
  * @param {String} goalGid: (required) Globally unique identifier for the goal.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -188,26 +153,6 @@ Goals.prototype.getParentGoalsForGoal = function(
 };
 
 
-/**
- * Get subgoals from a goal
- * @param {String} goalGid: (required) Globally unique identifier for the goal.
- * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
-     - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
- * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
- * @return {Promise} The requested resource
- */
-Goals.prototype.getSubgoalsForGoal = function(
-    goalGid,
-    params,
-    dispatchOptions
-) {
-    var path = "/goals/{goal_gid}/subgoals".replace("{goal_gid}", goalGid);
-
-    return this.dispatchGetCollection(path, params, dispatchOptions)
-};
-
-
 /**
  * Remove a collaborator from a goal
  * @param {String} goalGid: (required) Globally unique identifier for the goal.
@@ -226,62 +171,6 @@ Goals.prototype.removeFollowers = function(
 };
 
 
-/**
- * Remove a subgoal from a goal
- * @param {String} goalGid: (required) Globally unique identifier for the goal.
- * @param {Object} data: Data for the request
- * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
- * @return {Promise} The requested resource
- */
-Goals.prototype.removeSubgoal = function(
-    goalGid,
-    data,
-    dispatchOptions
-) {
-    var path = "/goals/{goal_gid}/removeSubgoal".replace("{goal_gid}", goalGid);
-
-    return this.dispatchPost(path, data, dispatchOptions)
-};
-
-
-/**
- * Remove a project/portfolio as supporting work for a goal.
- * @param {String} goalGid: (required) Globally unique identifier for the goal.
- * @param {Object} data: Data for the request
- * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
- * @return {Promise} The requested resource
- */
-Goals.prototype.removeSupportingWorkForGoal = function(
-    goalGid,
-    data,
-    dispatchOptions
-) {
-    var path = "/goals/{goal_gid}/removeSupportingWork".replace("{goal_gid}", goalGid);
-
-    return this.dispatchPost(path, data, dispatchOptions)
-};
-
-
-/**
- * Get supporting work from a goal
- * @param {String} goalGid: (required) Globally unique identifier for the goal.
- * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
-     - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
- * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
- * @return {Promise} The requested resource
- */
-Goals.prototype.supportingWork = function(
-    goalGid,
-    params,
-    dispatchOptions
-) {
-    var path = "/goals/{goal_gid}/supportingWork".replace("{goal_gid}", goalGid);
-
-    return this.dispatchGetCollection(path, params, dispatchOptions)
-};
-
-
 /**
  * Update a goal
  * @param {String} goalGid: (required) Globally unique identifier for the goal.
diff --git a/lib/resources/gen/jobs.js b/lib/resources/gen/jobs.js
index 31e909a4..c0180d0e 100644
--- a/lib/resources/gen/jobs.js
+++ b/lib/resources/gen/jobs.js
@@ -20,7 +20,7 @@ util.inherits(Jobs, Resource);
  * Get a job by id
  * @param {String} jobGid: (required) Globally unique identifier for the job.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/memberships.js b/lib/resources/gen/memberships.js
new file mode 100644
index 00000000..dc141b4c
--- /dev/null
+++ b/lib/resources/gen/memberships.js
@@ -0,0 +1,113 @@
+/**
+ * This file is auto-generated by our openapi spec.
+ * We try to keep the generated code pretty clean but there will be lint
+ * errors that are just not worth fixing (like unused requires).
+ * TODO: maybe we can just disable those specifically and keep this code
+ * pretty lint-free too!
+ */
+/* jshint ignore:start */
+var Resource = require('../resource');
+var util = require('util');
+var _ = require('lodash');
+
+function Memberships(dispatcher) {
+    Resource.call(this, dispatcher);
+}
+util.inherits(Memberships, Resource);
+
+
+/**
+ * Create a membership
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+Memberships.prototype.createMembership = function(
+    data,
+    dispatchOptions
+) {
+    var path = "/memberships";
+
+    return this.dispatchPost(path, data, dispatchOptions)
+};
+
+
+/**
+ * Delete a membership
+ * @param {String} membershipGid: (required) Globally unique identifier for the membership.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+Memberships.prototype.deleteMembership = function(
+    membershipGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/memberships/{membership_gid}".replace("{membership_gid}", membershipGid);
+
+    return this.dispatchDelete(path, data, dispatchOptions)
+};
+
+
+/**
+ * Get a membership
+ * @param {String} membershipGid: (required) Globally unique identifier for the membership.
+ * @param {Object} params: Parameters for the request
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
+     - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+Memberships.prototype.getMembership = function(
+    membershipGid,
+    params,
+    dispatchOptions
+) {
+    var path = "/memberships/{membership_gid}".replace("{membership_gid}", membershipGid);
+
+    return this.dispatchGet(path, params, dispatchOptions)
+};
+
+
+/**
+ * Get multiple memberships
+ * @param {Object} params: Parameters for the request
+     - parent {String}:  Globally unique identifier for `goal` or `project`.
+     - member {String}:  Globally unique identifier for `team` or `user`.
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
+     - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
+     - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+Memberships.prototype.getMemberships = function(
+    params,
+    dispatchOptions
+) {
+    var path = "/memberships";
+
+    return this.dispatchGetCollection(path, params, dispatchOptions)
+};
+
+
+/**
+ * Update a membership
+ * @param {String} membershipGid: (required) Globally unique identifier for the membership.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+Memberships.prototype.updateMembership = function(
+    membershipGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/memberships/{membership_gid}".replace("{membership_gid}", membershipGid);
+
+    return this.dispatchPut(path, data, dispatchOptions)
+};
+
+module.exports = Memberships;
+/* jshint ignore:end */
diff --git a/lib/resources/gen/organization_exports.js b/lib/resources/gen/organization_exports.js
index 24e5b1a9..a0e94c5b 100644
--- a/lib/resources/gen/organization_exports.js
+++ b/lib/resources/gen/organization_exports.js
@@ -36,7 +36,7 @@ OrganizationExports.prototype.createOrganizationExport = function(
  * Get details on an org export request
  * @param {String} organizationExportGid: (required) Globally unique identifier for the organization export.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/portfolio_memberships.js b/lib/resources/gen/portfolio_memberships.js
index c5544f1f..8a13e5f6 100644
--- a/lib/resources/gen/portfolio_memberships.js
+++ b/lib/resources/gen/portfolio_memberships.js
@@ -20,7 +20,7 @@ util.inherits(PortfolioMemberships, Resource);
  * Get a portfolio membership
  * @param {String} portfolioMembershipGid: (required)
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -42,9 +42,9 @@ PortfolioMemberships.prototype.getPortfolioMembership = function(
      - portfolio {String}:  The portfolio to filter results on.
      - workspace {String}:  The workspace to filter results on.
      - user {String}:  A string identifying a user. This can either be the string \"me\", an email, or the gid of a user.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -64,9 +64,9 @@ PortfolioMemberships.prototype.getPortfolioMemberships = function(
  * @param {String} portfolioGid: (required) Globally unique identifier for the portfolio.
  * @param {Object} params: Parameters for the request
      - user {String}:  A string identifying a user. This can either be the string \"me\", an email, or the gid of a user.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/portfolios.js b/lib/resources/gen/portfolios.js
index 3d8b8ec4..d34f180c 100644
--- a/lib/resources/gen/portfolios.js
+++ b/lib/resources/gen/portfolios.js
@@ -108,9 +108,9 @@ Portfolios.prototype.deletePortfolio = function(
  * Get portfolio items
  * @param {String} portfolioGid: (required) Globally unique identifier for the portfolio.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -130,7 +130,7 @@ Portfolios.prototype.getItemsForPortfolio = function(
  * Get a portfolio
  * @param {String} portfolioGid: (required) Globally unique identifier for the portfolio.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -150,10 +150,10 @@ Portfolios.prototype.getPortfolio = function(
  * Get multiple portfolios
  * @param {Object} params: Parameters for the request
      - workspace {String}:  (required) The workspace or organization to filter portfolios on.
-     - owner {String}:  (required) The user who owns the portfolio. Currently, API users can only get a list of portfolios that they themselves own.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - owner {String}:  The user who owns the portfolio. Currently, API users can only get a list of portfolios that they themselves own, unless the request is made from a Service Account. In the case of a Service Account, if this parameter is specified, then all portfolios owned by this parameter are returned. Otherwise, all portfolios across the workspace are returned.
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/project_briefs.js b/lib/resources/gen/project_briefs.js
index f0a9f3e6..b9b35dc6 100644
--- a/lib/resources/gen/project_briefs.js
+++ b/lib/resources/gen/project_briefs.js
@@ -56,7 +56,7 @@ ProjectBriefs.prototype.deleteProjectBrief = function(
  * Get a project brief
  * @param {String} projectBriefGid: (required) Globally unique identifier for the project brief.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/project_memberships.js b/lib/resources/gen/project_memberships.js
index 45338bbb..09612b63 100644
--- a/lib/resources/gen/project_memberships.js
+++ b/lib/resources/gen/project_memberships.js
@@ -20,7 +20,7 @@ util.inherits(ProjectMemberships, Resource);
  * Get a project membership
  * @param {String} projectMembershipGid: (required)
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -41,9 +41,9 @@ ProjectMemberships.prototype.getProjectMembership = function(
  * @param {String} projectGid: (required) Globally unique identifier for the project.
  * @param {Object} params: Parameters for the request
      - user {String}:  A string identifying a user. This can either be the string \"me\", an email, or the gid of a user.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/project_statuses.js b/lib/resources/gen/project_statuses.js
index ad649163..c911f058 100644
--- a/lib/resources/gen/project_statuses.js
+++ b/lib/resources/gen/project_statuses.js
@@ -56,7 +56,7 @@ ProjectStatuses.prototype.deleteProjectStatus = function(
  * Get a project status
  * @param {String} projectStatusGid: (required) The project status update to get.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -76,9 +76,9 @@ ProjectStatuses.prototype.getProjectStatus = function(
  * Get statuses from a project
  * @param {String} projectGid: (required) Globally unique identifier for the project.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/project_templates.js b/lib/resources/gen/project_templates.js
index 1862ab40..a7f1fed5 100644
--- a/lib/resources/gen/project_templates.js
+++ b/lib/resources/gen/project_templates.js
@@ -16,11 +16,29 @@ function ProjectTemplates(dispatcher) {
 util.inherits(ProjectTemplates, Resource);
 
 
+/**
+ * Delete a project template
+ * @param {String} projectTemplateGid: (required) Globally unique identifier for the project template.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+ProjectTemplates.prototype.deleteProjectTemplate = function(
+    projectTemplateGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/project_templates/{project_template_gid}".replace("{project_template_gid}", projectTemplateGid);
+
+    return this.dispatchDelete(path, data, dispatchOptions)
+};
+
+
 /**
  * Get a project template
  * @param {String} projectTemplateGid: (required) Globally unique identifier for the project template.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -41,9 +59,9 @@ ProjectTemplates.prototype.getProjectTemplate = function(
  * @param {Object} params: Parameters for the request
      - workspace {String}:  The workspace to filter results on.
      - team {String}:  The team to filter projects on.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -62,9 +80,9 @@ ProjectTemplates.prototype.getProjectTemplates = function(
  * Get a team's project templates
  * @param {String} teamGid: (required) Globally unique identifier for the team.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/projects.js b/lib/resources/gen/projects.js
index 59c53783..cfe1a57e 100644
--- a/lib/resources/gen/projects.js
+++ b/lib/resources/gen/projects.js
@@ -162,7 +162,7 @@ Projects.prototype.duplicateProject = function(
  * Get a project
  * @param {String} projectGid: (required) Globally unique identifier for the project.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -184,9 +184,9 @@ Projects.prototype.getProject = function(
      - workspace {String}:  The workspace or organization to filter projects on.
      - team {String}:  The team to filter projects on.
      - archived {Boolean}:  Only return projects whose `archived` field takes on the value of this parameter.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -205,9 +205,9 @@ Projects.prototype.getProjects = function(
  * Get projects a task is in
  * @param {String} taskGid: (required) The task to operate on.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -228,9 +228,9 @@ Projects.prototype.getProjectsForTask = function(
  * @param {String} teamGid: (required) Globally unique identifier for the team.
  * @param {Object} params: Parameters for the request
      - archived {Boolean}:  Only return projects whose `archived` field takes on the value of this parameter.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -251,9 +251,9 @@ Projects.prototype.getProjectsForTeam = function(
  * @param {String} workspaceGid: (required) Globally unique identifier for the workspace or organization.
  * @param {Object} params: Parameters for the request
      - archived {Boolean}:  Only return projects whose `archived` field takes on the value of this parameter.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -273,9 +273,7 @@ Projects.prototype.getProjectsForWorkspace = function(
  * Get task count of a project
  * @param {String} projectGid: (required) Globally unique identifier for the project.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
-     - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/rules.js b/lib/resources/gen/rules.js
new file mode 100644
index 00000000..63635e7e
--- /dev/null
+++ b/lib/resources/gen/rules.js
@@ -0,0 +1,37 @@
+/**
+ * This file is auto-generated by our openapi spec.
+ * We try to keep the generated code pretty clean but there will be lint
+ * errors that are just not worth fixing (like unused requires).
+ * TODO: maybe we can just disable those specifically and keep this code
+ * pretty lint-free too!
+ */
+/* jshint ignore:start */
+var Resource = require('../resource');
+var util = require('util');
+var _ = require('lodash');
+
+function Rules(dispatcher) {
+    Resource.call(this, dispatcher);
+}
+util.inherits(Rules, Resource);
+
+
+/**
+ * Trigger a rule
+ * @param {String} ruleTriggerGid: (required) The ID of the incoming web request trigger. This value is a path parameter that is automatically generated for the API endpoint.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+Rules.prototype.triggerRule = function(
+    ruleTriggerGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/rule_triggers/{rule_trigger_gid}/run".replace("{rule_trigger_gid}", ruleTriggerGid);
+
+    return this.dispatchPost(path, data, dispatchOptions)
+};
+
+module.exports = Rules;
+/* jshint ignore:end */
diff --git a/lib/resources/gen/sections.js b/lib/resources/gen/sections.js
index a469288f..5383e644 100644
--- a/lib/resources/gen/sections.js
+++ b/lib/resources/gen/sections.js
@@ -74,7 +74,7 @@ Sections.prototype.deleteSection = function(
  * Get a section
  * @param {String} sectionGid: (required) The globally unique identifier for the section.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -94,9 +94,9 @@ Sections.prototype.getSection = function(
  * Get sections in a project
  * @param {String} projectGid: (required) Globally unique identifier for the project.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/status_updates.js b/lib/resources/gen/status_updates.js
index 763a11ac..71b2671c 100644
--- a/lib/resources/gen/status_updates.js
+++ b/lib/resources/gen/status_updates.js
@@ -34,17 +34,17 @@ StatusUpdates.prototype.createStatusForObject = function(
 
 /**
  * Delete a status update
- * @param {String} statusGid: (required) The status update to get.
+ * @param {String} statusUpdateGid: (required) The status update to get.
  * @param {Object} data: Data for the request
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
  */
 StatusUpdates.prototype.deleteStatus = function(
-    statusGid,
+    statusUpdateGid,
     data,
     dispatchOptions
 ) {
-    var path = "/status_updates/{status_gid}".replace("{status_gid}", statusGid);
+    var path = "/status_updates/{status_update_gid}".replace("{status_update_gid}", statusUpdateGid);
 
     return this.dispatchDelete(path, data, dispatchOptions)
 };
@@ -52,19 +52,19 @@ StatusUpdates.prototype.deleteStatus = function(
 
 /**
  * Get a status update
- * @param {String} statusGid: (required) The status update to get.
+ * @param {String} statusUpdateGid: (required) The status update to get.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
  */
 StatusUpdates.prototype.getStatus = function(
-    statusGid,
+    statusUpdateGid,
     params,
     dispatchOptions
 ) {
-    var path = "/status_updates/{status_gid}".replace("{status_gid}", statusGid);
+    var path = "/status_updates/{status_update_gid}".replace("{status_update_gid}", statusUpdateGid);
 
     return this.dispatchGet(path, params, dispatchOptions)
 };
@@ -75,9 +75,9 @@ StatusUpdates.prototype.getStatus = function(
  * @param {Object} params: Parameters for the request
      - parent {String}:  (required) Globally unique identifier for object to fetch statuses from. Must be a GID for a project, portfolio, or goal.
      - createdSince {Date}:  Only return statuses that have been created since the given time.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/stories.js b/lib/resources/gen/stories.js
index aecbf1d0..a32fb6dc 100644
--- a/lib/resources/gen/stories.js
+++ b/lib/resources/gen/stories.js
@@ -56,9 +56,9 @@ Stories.prototype.deleteStory = function(
  * Get stories from a task
  * @param {String} taskGid: (required) The task to operate on.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -78,9 +78,7 @@ Stories.prototype.getStoriesForTask = function(
  * Get a story
  * @param {String} storyGid: (required) Globally unique identifier for the story.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
-     - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/tags.js b/lib/resources/gen/tags.js
index 41751ca9..51738b17 100644
--- a/lib/resources/gen/tags.js
+++ b/lib/resources/gen/tags.js
@@ -72,9 +72,7 @@ Tags.prototype.deleteTag = function(
  * Get a tag
  * @param {String} tagGid: (required) Globally unique identifier for the tag.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
-     - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -94,9 +92,9 @@ Tags.prototype.getTag = function(
  * Get multiple tags
  * @param {Object} params: Parameters for the request
      - workspace {String}:  The workspace to filter tags on.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -115,9 +113,9 @@ Tags.prototype.getTags = function(
  * Get a task's tags
  * @param {String} taskGid: (required) The task to operate on.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -137,9 +135,9 @@ Tags.prototype.getTagsForTask = function(
  * Get tags in a workspace
  * @param {String} workspaceGid: (required) Globally unique identifier for the workspace or organization.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/task_templates.js b/lib/resources/gen/task_templates.js
new file mode 100644
index 00000000..771b4219
--- /dev/null
+++ b/lib/resources/gen/task_templates.js
@@ -0,0 +1,96 @@
+/**
+ * This file is auto-generated by our openapi spec.
+ * We try to keep the generated code pretty clean but there will be lint
+ * errors that are just not worth fixing (like unused requires).
+ * TODO: maybe we can just disable those specifically and keep this code
+ * pretty lint-free too!
+ */
+/* jshint ignore:start */
+var Resource = require('../resource');
+var util = require('util');
+var _ = require('lodash');
+
+function TaskTemplates(dispatcher) {
+    Resource.call(this, dispatcher);
+}
+util.inherits(TaskTemplates, Resource);
+
+
+/**
+ * Delete a task template
+ * @param {String} taskTemplateGid: (required) Globally unique identifier for the task template.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+TaskTemplates.prototype.deleteTaskTemplate = function(
+    taskTemplateGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/task_templates/{task_template_gid}".replace("{task_template_gid}", taskTemplateGid);
+
+    return this.dispatchDelete(path, data, dispatchOptions)
+};
+
+
+/**
+ * Get a task template
+ * @param {String} taskTemplateGid: (required) Globally unique identifier for the task template.
+ * @param {Object} params: Parameters for the request
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
+     - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+TaskTemplates.prototype.getTaskTemplate = function(
+    taskTemplateGid,
+    params,
+    dispatchOptions
+) {
+    var path = "/task_templates/{task_template_gid}".replace("{task_template_gid}", taskTemplateGid);
+
+    return this.dispatchGet(path, params, dispatchOptions)
+};
+
+
+/**
+ * Get multiple task templates
+ * @param {Object} params: Parameters for the request
+     - project {String}:  The project to filter task templates on.
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
+     - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
+     - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+TaskTemplates.prototype.getTaskTemplates = function(
+    params,
+    dispatchOptions
+) {
+    var path = "/task_templates";
+
+    return this.dispatchGetCollection(path, params, dispatchOptions)
+};
+
+
+/**
+ * Instantiate a task from a task template
+ * @param {String} taskTemplateGid: (required) Globally unique identifier for the task template.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+TaskTemplates.prototype.instantiateTask = function(
+    taskTemplateGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/task_templates/{task_template_gid}/instantiateTask".replace("{task_template_gid}", taskTemplateGid);
+
+    return this.dispatchPost(path, data, dispatchOptions)
+};
+
+module.exports = TaskTemplates;
+/* jshint ignore:end */
diff --git a/lib/resources/gen/tasks.js b/lib/resources/gen/tasks.js
index 33911f44..dd92af39 100644
--- a/lib/resources/gen/tasks.js
+++ b/lib/resources/gen/tasks.js
@@ -180,9 +180,9 @@ Tasks.prototype.duplicateTask = function(
  * Get dependencies from a task
  * @param {String} taskGid: (required) The task to operate on.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -202,9 +202,9 @@ Tasks.prototype.getDependenciesForTask = function(
  * Get dependents from a task
  * @param {String} taskGid: (required) The task to operate on.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -224,9 +224,9 @@ Tasks.prototype.getDependentsForTask = function(
  * Get subtasks from a task
  * @param {String} taskGid: (required) The task to operate on.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -246,7 +246,7 @@ Tasks.prototype.getSubtasksForTask = function(
  * Get a task
  * @param {String} taskGid: (required) The task to operate on.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -262,18 +262,38 @@ Tasks.prototype.getTask = function(
 };
 
 
+/**
+ * Get a task for a given custom ID
+ * @param {String} workspaceGid: (required) Globally unique identifier for the workspace or organization.
+ * @param {String} customId: (required) Generated custom ID for a task.
+ * @param {Object} params: Parameters for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+Tasks.prototype.getTaskForCustomID = function(
+    workspaceGid,
+    customId,
+    params,
+    dispatchOptions
+) {
+    var path = "/workspaces/{workspace_gid}/tasks/custom_id/{custom_id}".replace("{workspace_gid}", workspaceGid).replace("{custom_id}", customId);
+
+    return this.dispatchGet(path, params, dispatchOptions)
+};
+
+
 /**
  * Get multiple tasks
  * @param {Object} params: Parameters for the request
      - assignee {String}:  The assignee to filter tasks on. If searching for unassigned tasks, assignee.any = null can be specified. *Note: If you specify `assignee`, you must also specify the `workspace` to filter on.*
      - project {String}:  The project to filter tasks on.
-     - section {String}:  The section to filter tasks on. *Note: Currently, this is only supported in board views.*
+     - section {String}:  The section to filter tasks on.
      - workspace {String}:  The workspace to filter tasks on. *Note: If you specify `workspace`, you must also specify the `assignee` to filter on.*
      - completedSince {Date}:  Only return tasks that are either incomplete or that have been completed since this time.
      - modifiedSince {Date}:  Only return tasks that have been modified since the given time.  *Note: A task is considered “modified” if any of its properties change, or associations between it and other objects are modified (e.g.  a task being added to a project). A task is not considered modified just because another object it is associated with (e.g. a subtask) is modified. Actions that count as modifying the task include assigning, renaming, completing, and adding stories.*
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -293,9 +313,9 @@ Tasks.prototype.getTasks = function(
  * @param {String} projectGid: (required) Globally unique identifier for the project.
  * @param {Object} params: Parameters for the request
      - completedSince {String}:  Only return tasks that are either incomplete or that have been completed since this time. Accepts a date-time string or the keyword *now*. 
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -315,9 +335,10 @@ Tasks.prototype.getTasksForProject = function(
  * Get tasks from a section
  * @param {String} sectionGid: (required) The globally unique identifier for the section.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - completedSince {String}:  Only return tasks that are either incomplete or that have been completed since this time. Accepts a date-time string or the keyword *now*. 
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -337,9 +358,9 @@ Tasks.prototype.getTasksForSection = function(
  * Get tasks from a tag
  * @param {String} tagGid: (required) Globally unique identifier for the tag.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -360,9 +381,9 @@ Tasks.prototype.getTasksForTag = function(
  * @param {String} userTaskListGid: (required) Globally unique identifier for the user task list.
  * @param {Object} params: Parameters for the request
      - completedSince {String}:  Only return tasks that are either incomplete or that have been completed since this time. Accepts a date-time string or the keyword *now*. 
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -524,7 +545,7 @@ Tasks.prototype.removeTagForTask = function(
      - isSubtask {Boolean}:  Filter to subtasks
      - sortBy {String}:  One of `due_date`, `created_at`, `completed_at`, `likes`, or `modified_at`, defaults to `modified_at`
      - sortAscending {Boolean}:  Default `false`
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/team_memberships.js b/lib/resources/gen/team_memberships.js
index fd275427..e511af7c 100644
--- a/lib/resources/gen/team_memberships.js
+++ b/lib/resources/gen/team_memberships.js
@@ -20,7 +20,7 @@ util.inherits(TeamMemberships, Resource);
  * Get a team membership
  * @param {String} teamMembershipGid: (required)
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -42,9 +42,9 @@ TeamMemberships.prototype.getTeamMembership = function(
      - team {String}:  Globally unique identifier for the team.
      - user {String}:  A string identifying a user. This can either be the string \"me\", an email, or the gid of a user. This parameter must be used with the workspace parameter.
      - workspace {String}:  Globally unique identifier for the workspace. This parameter must be used with the user parameter.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -63,9 +63,9 @@ TeamMemberships.prototype.getTeamMemberships = function(
  * Get memberships from a team
  * @param {String} teamGid: (required) Globally unique identifier for the team.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -86,9 +86,9 @@ TeamMemberships.prototype.getTeamMembershipsForTeam = function(
  * @param {String} userGid: (required) A string identifying a user. This can either be the string \"me\", an email, or the gid of a user.
  * @param {Object} params: Parameters for the request
      - workspace {String}:  (required) Globally unique identifier for the workspace.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/teams.js b/lib/resources/gen/teams.js
index aa26db25..c1a97118 100644
--- a/lib/resources/gen/teams.js
+++ b/lib/resources/gen/teams.js
@@ -54,9 +54,7 @@ Teams.prototype.createTeam = function(
  * Get a team
  * @param {String} teamGid: (required) Globally unique identifier for the team.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
-     - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -77,9 +75,9 @@ Teams.prototype.getTeam = function(
  * @param {String} userGid: (required) A string identifying a user. This can either be the string \"me\", an email, or the gid of a user.
  * @param {Object} params: Parameters for the request
      - organization {String}:  (required) The workspace or organization to filter teams on.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -99,9 +97,9 @@ Teams.prototype.getTeamsForUser = function(
  * Get teams in a workspace
  * @param {String} workspaceGid: (required) Globally unique identifier for the workspace or organization.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -134,5 +132,23 @@ Teams.prototype.removeUserForTeam = function(
     return this.dispatchPost(path, data, dispatchOptions)
 };
 
+
+/**
+ * Update a team
+ * @param {String} teamGid: (required) Globally unique identifier for the team.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+Teams.prototype.updateTeam = function(
+    teamGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/teams/{team_gid}".replace("{team_gid}", teamGid);
+
+    return this.dispatchPut(path, data, dispatchOptions)
+};
+
 module.exports = Teams;
 /* jshint ignore:end */
diff --git a/lib/resources/gen/time_periods.js b/lib/resources/gen/time_periods.js
index 7b998241..5d7ff9eb 100644
--- a/lib/resources/gen/time_periods.js
+++ b/lib/resources/gen/time_periods.js
@@ -20,7 +20,7 @@ util.inherits(TimePeriods, Resource);
  * Get a time period
  * @param {String} timePeriodGid: (required) Globally unique identifier for the time period.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -42,9 +42,9 @@ TimePeriods.prototype.getTimePeriod = function(
      - startOn {Date}:  ISO 8601 date string
      - endOn {Date}:  ISO 8601 date string
      - workspace {String}:  (required) Globally unique identifier for the workspace.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/time_tracking_entries.js b/lib/resources/gen/time_tracking_entries.js
new file mode 100644
index 00000000..404761b4
--- /dev/null
+++ b/lib/resources/gen/time_tracking_entries.js
@@ -0,0 +1,115 @@
+/**
+ * This file is auto-generated by our openapi spec.
+ * We try to keep the generated code pretty clean but there will be lint
+ * errors that are just not worth fixing (like unused requires).
+ * TODO: maybe we can just disable those specifically and keep this code
+ * pretty lint-free too!
+ */
+/* jshint ignore:start */
+var Resource = require('../resource');
+var util = require('util');
+var _ = require('lodash');
+
+function TimeTrackingEntries(dispatcher) {
+    Resource.call(this, dispatcher);
+}
+util.inherits(TimeTrackingEntries, Resource);
+
+
+/**
+ * Create a time tracking entry
+ * @param {String} taskGid: (required) The task to operate on.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+TimeTrackingEntries.prototype.createTimeTrackingEntry = function(
+    taskGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/tasks/{task_gid}/time_tracking_entries".replace("{task_gid}", taskGid);
+
+    return this.dispatchPost(path, data, dispatchOptions)
+};
+
+
+/**
+ * Delete a time tracking entry
+ * @param {String} timeTrackingEntryGid: (required) Globally unique identifier for the time tracking entry.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+TimeTrackingEntries.prototype.deleteTimeTrackingEntry = function(
+    timeTrackingEntryGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/time_tracking_entries/{time_tracking_entry_gid}".replace("{time_tracking_entry_gid}", timeTrackingEntryGid);
+
+    return this.dispatchDelete(path, data, dispatchOptions)
+};
+
+
+/**
+ * Get time tracking entries for a task
+ * @param {String} taskGid: (required) The task to operate on.
+ * @param {Object} params: Parameters for the request
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
+     - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
+     - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+TimeTrackingEntries.prototype.getTimeTrackingEntriesForTask = function(
+    taskGid,
+    params,
+    dispatchOptions
+) {
+    var path = "/tasks/{task_gid}/time_tracking_entries".replace("{task_gid}", taskGid);
+
+    return this.dispatchGetCollection(path, params, dispatchOptions)
+};
+
+
+/**
+ * Get a time tracking entry
+ * @param {String} timeTrackingEntryGid: (required) Globally unique identifier for the time tracking entry.
+ * @param {Object} params: Parameters for the request
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
+     - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+TimeTrackingEntries.prototype.getTimeTrackingEntry = function(
+    timeTrackingEntryGid,
+    params,
+    dispatchOptions
+) {
+    var path = "/time_tracking_entries/{time_tracking_entry_gid}".replace("{time_tracking_entry_gid}", timeTrackingEntryGid);
+
+    return this.dispatchGet(path, params, dispatchOptions)
+};
+
+
+/**
+ * Update a time tracking entry
+ * @param {String} timeTrackingEntryGid: (required) Globally unique identifier for the time tracking entry.
+ * @param {Object} data: Data for the request
+ * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
+ * @return {Promise} The requested resource
+ */
+TimeTrackingEntries.prototype.updateTimeTrackingEntry = function(
+    timeTrackingEntryGid,
+    data,
+    dispatchOptions
+) {
+    var path = "/time_tracking_entries/{time_tracking_entry_gid}".replace("{time_tracking_entry_gid}", timeTrackingEntryGid);
+
+    return this.dispatchPut(path, data, dispatchOptions)
+};
+
+module.exports = TimeTrackingEntries;
+/* jshint ignore:end */
diff --git a/lib/resources/gen/typeahead.js b/lib/resources/gen/typeahead.js
index 1b1b6fd8..0190a3f9 100644
--- a/lib/resources/gen/typeahead.js
+++ b/lib/resources/gen/typeahead.js
@@ -20,11 +20,11 @@ util.inherits(Typeahead, Resource);
  * Get objects via typeahead
  * @param {String} workspaceGid: (required) Globally unique identifier for the workspace or organization.
  * @param {Object} params: Parameters for the request
-     - resourceType {String}:  (required) The type of values the typeahead should return. You can choose from one of the following: `custom_field`, `project`, `project_template`, `portfolio`, `tag`, `task`, and `user`. Note that unlike in the names of endpoints, the types listed here are in singular form (e.g. `task`). Using multiple types is not yet supported.
+     - resourceType {String}:  (required) The type of values the typeahead should return. You can choose from one of the following: `custom_field`, `goal`, `project`, `project_template`, `portfolio`, `tag`, `task`, `team`, and `user`. Note that unlike in the names of endpoints, the types listed here are in singular form (e.g. `task`). Using multiple types is not yet supported.
      - type {String}:  *Deprecated: new integrations should prefer the resource_type field.*
-     - query {String}:  The string that will be used to search for relevant objects. If an empty string is passed in, the API will currently return an empty result set.
+     - query {String}:  The string that will be used to search for relevant objects. If an empty string is passed in, the API will return results.
      - count {Number}:  The number of results to return. The default is 20 if this parameter is omitted, with a minimum of 1 and a maximum of 100. If there are fewer results found than requested, all will be returned.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/user_task_lists.js b/lib/resources/gen/user_task_lists.js
index dff05f47..b0d5ab5a 100644
--- a/lib/resources/gen/user_task_lists.js
+++ b/lib/resources/gen/user_task_lists.js
@@ -20,7 +20,7 @@ util.inherits(UserTaskLists, Resource);
  * Get a user task list
  * @param {String} userTaskListGid: (required) Globally unique identifier for the user task list.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -41,7 +41,7 @@ UserTaskLists.prototype.getUserTaskList = function(
  * @param {String} userGid: (required) A string identifying a user. This can either be the string \"me\", an email, or the gid of a user.
  * @param {Object} params: Parameters for the request
      - workspace {String}:  (required) The workspace in which to get the user task list.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/users.js b/lib/resources/gen/users.js
index d5a41375..3351cd06 100644
--- a/lib/resources/gen/users.js
+++ b/lib/resources/gen/users.js
@@ -22,7 +22,9 @@ util.inherits(Users, Resource);
  * @param {Object} params: Parameters for the request
      - resourceType {String}:  (required) The resource type of favorites to be returned.
      - workspace {String}:  (required) The workspace in which to get favorites.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
+     - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -42,7 +44,7 @@ Users.prototype.getFavoritesForUser = function(
  * Get a user
  * @param {String} userGid: (required) A string identifying a user. This can either be the string \"me\", an email, or the gid of a user.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -63,9 +65,9 @@ Users.prototype.getUser = function(
  * @param {Object} params: Parameters for the request
      - workspace {String}:  The workspace or organization ID to filter users on.
      - team {String}:  The team ID to filter users on.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -76,7 +78,7 @@ Users.prototype.getUsers = function(
 ) {
     var path = "/users";
 
-    return this.dispatchGetCollection(path, params, dispatchOptions)
+    return this.dispatchGet(path, params, dispatchOptions)
 };
 
 
@@ -84,8 +86,8 @@ Users.prototype.getUsers = function(
  * Get users in a team
  * @param {String} teamGid: (required) Globally unique identifier for the team.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -105,8 +107,8 @@ Users.prototype.getUsersForTeam = function(
  * Get users in a workspace or organization
  * @param {String} workspaceGid: (required) Globally unique identifier for the workspace or organization.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/webhooks.js b/lib/resources/gen/webhooks.js
index 9e5303d2..0bf338b5 100644
--- a/lib/resources/gen/webhooks.js
+++ b/lib/resources/gen/webhooks.js
@@ -54,7 +54,7 @@ Webhooks.prototype.deleteWebhook = function(
  * Get a webhook
  * @param {String} webhookGid: (required) Globally unique identifier for the webhook.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -75,9 +75,9 @@ Webhooks.prototype.getWebhook = function(
  * @param {Object} params: Parameters for the request
      - workspace {String}:  (required) The workspace to query for webhooks in.
      - resource {String}:  Only return webhooks for the given resource.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/workspace_memberships.js b/lib/resources/gen/workspace_memberships.js
index b42c743e..dde50cdc 100644
--- a/lib/resources/gen/workspace_memberships.js
+++ b/lib/resources/gen/workspace_memberships.js
@@ -20,7 +20,7 @@ util.inherits(WorkspaceMemberships, Resource);
  * Get a workspace membership
  * @param {String} workspaceMembershipGid: (required)
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -40,9 +40,9 @@ WorkspaceMemberships.prototype.getWorkspaceMembership = function(
  * Get workspace memberships for a user
  * @param {String} userGid: (required) A string identifying a user. This can either be the string \"me\", an email, or the gid of a user.
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -63,9 +63,9 @@ WorkspaceMemberships.prototype.getWorkspaceMembershipsForUser = function(
  * @param {String} workspaceGid: (required) Globally unique identifier for the workspace or organization.
  * @param {Object} params: Parameters for the request
      - user {String}:  A string identifying a user. This can either be the string \"me\", an email, or the gid of a user.
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/gen/workspaces.js b/lib/resources/gen/workspaces.js
index 29177382..e84b27c4 100644
--- a/lib/resources/gen/workspaces.js
+++ b/lib/resources/gen/workspaces.js
@@ -38,7 +38,7 @@ Workspaces.prototype.addUserForWorkspace = function(
  * Get a workspace
  * @param {String} workspaceGid: (required) Globally unique identifier for the workspace or organization.
  * @param {Object} params: Parameters for the request
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
@@ -57,9 +57,9 @@ Workspaces.prototype.getWorkspace = function(
 /**
  * Get multiple workspaces
  * @param {Object} params: Parameters for the request
-     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. 'Note: You can only pass in an offset that was returned to you via a previously paginated request.'
+     - offset {String}:  Offset token. An offset to the next page returned by the API. A pagination request will return an offset token, which can be used as an input parameter to the next request. If an offset is not passed in, the API will return the first page of results. *Note: You can only pass in an offset that was returned to you via a previously paginated request.*
      - limit {Number}:  Results per page. The number of objects to return per page. The value must be between 1 and 100.
-     - optFields {[String]}:  Defines fields to return. Some requests return *compact* representations of objects in order to conserve resources and complete the request more efficiently. Other times requests return more information than you may need. This option allows you to list the exact set of fields that the API should be sure to return for the objects. The field names should be provided as paths, described below. The id of included objects will always be returned, regardless of the field options.
+     - optFields {[String]}:  This endpoint returns a compact resource, which excludes some properties by default. To include those optional properties, set this query parameter to a comma-separated list of the properties you wish to include.
      - optPretty {Boolean}:  Provides “pretty” output. Provides the response in a “pretty” format. In the case of JSON this means doing proper line breaking and indentation to make it readable. This will take extra time and increase the response size so it is advisable only to use this during debugging.
  * @param {Object} [dispatchOptions]: Options, if any, to pass the dispatcher for the request
  * @return {Promise} The requested resource
diff --git a/lib/resources/goal_relationships.js b/lib/resources/goal_relationships.js
new file mode 100644
index 00000000..f4787114
--- /dev/null
+++ b/lib/resources/goal_relationships.js
@@ -0,0 +1,3 @@
+var GoalRelationships = require('./gen/goal_relationships');
+
+module.exports = GoalRelationships;
diff --git a/lib/resources/goals.js b/lib/resources/goals.js
new file mode 100644
index 00000000..d3c6cc03
--- /dev/null
+++ b/lib/resources/goals.js
@@ -0,0 +1,3 @@
+var Goals = require('./gen/goals');
+
+module.exports = Goals;
diff --git a/lib/resources/index.js b/lib/resources/index.js
index 89b5c7ff..24377395 100644
--- a/lib/resources/index.js
+++ b/lib/resources/index.js
@@ -1,26 +1,36 @@
 exports.Resource = require('./resource');
 
+exports.Allocations = require('./allocations');
 exports.Attachments = require('./attachments');
 exports.AuditLogAPI = require('./audit_log_api');
 exports.BatchAPI = require('./batch_api');
 exports.CustomFieldSettings = require('./custom_field_settings');
 exports.CustomFields = require('./custom_fields');
 exports.Events = require('./events');
+exports.GoalRelationships = require('./goal_relationships');
+exports.Goals = require('./goals');
 exports.Jobs = require('./jobs');
+exports.Memberships = require('./memberships');
 exports.OrganizationExports = require('./organization_exports');
-exports.Projects = require('./projects');
 exports.PortfolioMemberships = require('./portfolio_memberships');
 exports.Portfolios = require('./portfolios');
+exports.ProjectBriefs = require('./project_briefs');
 exports.ProjectMemberships = require('./project_memberships');
 exports.ProjectStatuses = require('./project_statuses');
+exports.ProjectTemplates = require('./project_templates');
+exports.Projects = require('./projects');
 exports.Sections = require('./sections');
+exports.StatusUpdates = require('./status_updates');
 exports.Stories = require('./stories');
 exports.Tags = require('./tags');
+exports.TaskTemplates = require('./task_templates');
 exports.Tasks = require('./tasks');
 exports.Teams = require('./teams');
+exports.TimePeriods = require('./time_periods');
+exports.TimeTrackingEntries = require('./time_tracking_entries');
 exports.Typeahead = require('./typeahead');
-exports.Users = require('./users');
 exports.UserTaskLists = require('./user_task_lists');
-exports.Workspaces = require('./workspaces');
-exports.WorkspaceMemberships = require('./workspace_memberships');
+exports.Users = require('./users');
 exports.Webhooks = require('./webhooks');
+exports.WorkspaceMemberships = require('./workspace_memberships');
+exports.Workspaces = require('./workspaces');
diff --git a/lib/resources/memberships.js b/lib/resources/memberships.js
new file mode 100644
index 00000000..14c72e45
--- /dev/null
+++ b/lib/resources/memberships.js
@@ -0,0 +1,3 @@
+var Memberships = require('./gen/memberships');
+
+module.exports = Memberships;
diff --git a/lib/resources/project_briefs.js b/lib/resources/project_briefs.js
new file mode 100644
index 00000000..cde38472
--- /dev/null
+++ b/lib/resources/project_briefs.js
@@ -0,0 +1,3 @@
+var ProjectBriefs = require('./gen/project_briefs');
+
+module.exports = ProjectBriefs;
diff --git a/lib/resources/project_templates.js b/lib/resources/project_templates.js
new file mode 100644
index 00000000..7fcc589e
--- /dev/null
+++ b/lib/resources/project_templates.js
@@ -0,0 +1,3 @@
+var ProjectTemplates = require('./gen/project_templates');
+
+module.exports = ProjectTemplates;
diff --git a/lib/resources/rules.js b/lib/resources/rules.js
new file mode 100644
index 00000000..0a5af5ec
--- /dev/null
+++ b/lib/resources/rules.js
@@ -0,0 +1,3 @@
+var Rules = require('./gen/rules');
+
+module.exports = Rules;
diff --git a/lib/resources/status_updates.js b/lib/resources/status_updates.js
new file mode 100644
index 00000000..f38ebcc7
--- /dev/null
+++ b/lib/resources/status_updates.js
@@ -0,0 +1,3 @@
+var StatusUpdates = require('./gen/status_updates');
+
+module.exports = StatusUpdates;
diff --git a/lib/resources/task_templates.js b/lib/resources/task_templates.js
new file mode 100644
index 00000000..7fa35f6a
--- /dev/null
+++ b/lib/resources/task_templates.js
@@ -0,0 +1,3 @@
+var TaskTemplates = require('./gen/task_templates');
+
+module.exports = TaskTemplates;
diff --git a/lib/resources/time_periods.js b/lib/resources/time_periods.js
new file mode 100644
index 00000000..b45abcce
--- /dev/null
+++ b/lib/resources/time_periods.js
@@ -0,0 +1,3 @@
+var TimePeriods = require('./gen/time_periods');
+
+module.exports = TimePeriods;
diff --git a/lib/resources/time_tracking_entries.js b/lib/resources/time_tracking_entries.js
new file mode 100644
index 00000000..3e1c745a
--- /dev/null
+++ b/lib/resources/time_tracking_entries.js
@@ -0,0 +1,3 @@
+var TimeTrackingEntries = require('./gen/time_tracking_entries');
+
+module.exports = TimeTrackingEntries;
diff --git a/package.json b/package.json
index 0ad612d4..21c9cd33 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "asana",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Official NodeJS and BrowserJS client for the Asana API",
   "main": "index.js",
   "scripts": {
diff --git a/samples/allocations_sample.yaml b/samples/allocations_sample.yaml
new file mode 100644
index 00000000..80004fd8
--- /dev/null
+++ b/samples/allocations_sample.yaml
@@ -0,0 +1,56 @@
+allocations: 
+    createAllocation: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.allocations.createAllocation({field: "value", field: "value", pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    deleteAllocation: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.allocations.deleteAllocation(allocationGid)
+            .then((result) => {
+                console.log(result);
+            });
+    getAllocation: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.allocations.getAllocation(allocationGid, {param: "value", param: "value", opt_pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    getAllocations: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.allocations.getAllocations({param: "value", param: "value", opt_pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    updateAllocation: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.allocations.updateAllocation(allocationGid, {field: "value", field: "value", pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
diff --git a/samples/attachments_sample.yaml b/samples/attachments_sample.yaml
index a16bcb60..b65a96d6 100644
--- a/samples/attachments_sample.yaml
+++ b/samples/attachments_sample.yaml
@@ -1,12 +1,12 @@
 attachments: 
-    createAttachmentForTask: >-
+    createAttachmentForObject: >-
         const asana = require('asana');
 
 
         const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
 
 
-        client.attachments.createAttachmentForTask({field: "value", field: "value", pretty: true})
+        client.attachments.createAttachmentForObject({field: "value", field: "value", pretty: true})
             .then((result) => {
                 console.log(result);
             });
diff --git a/samples/goal_relationships_sample.yaml b/samples/goal_relationships_sample.yaml
new file mode 100644
index 00000000..5bc22a53
--- /dev/null
+++ b/samples/goal_relationships_sample.yaml
@@ -0,0 +1,56 @@
+goalrelationships: 
+    addSupportingRelationship: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.goalrelationships.addSupportingRelationship(goalGid, {field: "value", field: "value", pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    getGoalRelationship: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.goalrelationships.getGoalRelationship(goalRelationshipGid, {param: "value", param: "value", opt_pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    getGoalRelationships: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.goalrelationships.getGoalRelationships({param: "value", param: "value", opt_pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    removeSupportingRelationship: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.goalrelationships.removeSupportingRelationship(goalGid, {field: "value", field: "value", pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    updateGoalRelationship: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.goalrelationships.updateGoalRelationship(goalRelationshipGid, {field: "value", field: "value", pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
diff --git a/samples/goals_sample.yaml b/samples/goals_sample.yaml
index e2ccdf5a..c73dfce2 100644
--- a/samples/goals_sample.yaml
+++ b/samples/goals_sample.yaml
@@ -10,28 +10,6 @@ goals:
             .then((result) => {
                 console.log(result);
             });
-    addSubgoal: >-
-        const asana = require('asana');
-
-
-        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
-
-
-        client.goals.addSubgoal(goalGid, {field: "value", field: "value", pretty: true})
-            .then((result) => {
-                console.log(result);
-            });
-    addSupportingWorkForGoal: >-
-        const asana = require('asana');
-
-
-        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
-
-
-        client.goals.addSupportingWorkForGoal(goalGid, {field: "value", field: "value", pretty: true})
-            .then((result) => {
-                console.log(result);
-            });
     createGoal: >-
         const asana = require('asana');
 
@@ -98,17 +76,6 @@ goals:
             .then((result) => {
                 console.log(result);
             });
-    getSubgoalsForGoal: >-
-        const asana = require('asana');
-
-
-        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
-
-
-        client.goals.getSubgoalsForGoal(goalGid, {param: "value", param: "value", opt_pretty: true})
-            .then((result) => {
-                console.log(result);
-            });
     removeFollowers: >-
         const asana = require('asana');
 
@@ -120,39 +87,6 @@ goals:
             .then((result) => {
                 console.log(result);
             });
-    removeSubgoal: >-
-        const asana = require('asana');
-
-
-        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
-
-
-        client.goals.removeSubgoal(goalGid, {field: "value", field: "value", pretty: true})
-            .then((result) => {
-                console.log(result);
-            });
-    removeSupportingWorkForGoal: >-
-        const asana = require('asana');
-
-
-        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
-
-
-        client.goals.removeSupportingWorkForGoal(goalGid, {field: "value", field: "value", pretty: true})
-            .then((result) => {
-                console.log(result);
-            });
-    supportingWork: >-
-        const asana = require('asana');
-
-
-        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
-
-
-        client.goals.supportingWork(goalGid, {param: "value", param: "value", opt_pretty: true})
-            .then((result) => {
-                console.log(result);
-            });
     updateGoal: >-
         const asana = require('asana');
 
diff --git a/samples/memberships_sample.yaml b/samples/memberships_sample.yaml
new file mode 100644
index 00000000..0b6a66b0
--- /dev/null
+++ b/samples/memberships_sample.yaml
@@ -0,0 +1,56 @@
+memberships: 
+    createMembership: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.memberships.createMembership({field: "value", field: "value", pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    deleteMembership: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.memberships.deleteMembership(membershipGid)
+            .then((result) => {
+                console.log(result);
+            });
+    getMembership: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.memberships.getMembership(membershipGid, {param: "value", param: "value", opt_pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    getMemberships: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.memberships.getMemberships({param: "value", param: "value", opt_pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    updateMembership: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.memberships.updateMembership(membershipGid, {field: "value", field: "value", pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
diff --git a/samples/project_templates_sample.yaml b/samples/project_templates_sample.yaml
index 1b071f94..f8829a46 100644
--- a/samples/project_templates_sample.yaml
+++ b/samples/project_templates_sample.yaml
@@ -1,4 +1,15 @@
 projecttemplates: 
+    deleteProjectTemplate: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.projecttemplates.deleteProjectTemplate(projectTemplateGid)
+            .then((result) => {
+                console.log(result);
+            });
     getProjectTemplate: >-
         const asana = require('asana');
 
diff --git a/samples/rules_sample.yaml b/samples/rules_sample.yaml
new file mode 100644
index 00000000..fc2ab83a
--- /dev/null
+++ b/samples/rules_sample.yaml
@@ -0,0 +1,12 @@
+rules: 
+    triggerRule: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.rules.triggerRule(ruleTriggerGid, {field: "value", field: "value", pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
diff --git a/samples/status_updates_sample.yaml b/samples/status_updates_sample.yaml
index 05c1b998..382b6701 100644
--- a/samples/status_updates_sample.yaml
+++ b/samples/status_updates_sample.yaml
@@ -17,7 +17,7 @@ statusupdates:
         const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
 
 
-        client.statusupdates.deleteStatus(statusGid)
+        client.statusupdates.deleteStatus(statusUpdateGid)
             .then((result) => {
                 console.log(result);
             });
@@ -28,7 +28,7 @@ statusupdates:
         const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
 
 
-        client.statusupdates.getStatus(statusGid, {param: "value", param: "value", opt_pretty: true})
+        client.statusupdates.getStatus(statusUpdateGid, {param: "value", param: "value", opt_pretty: true})
             .then((result) => {
                 console.log(result);
             });
diff --git a/samples/task_templates_sample.yaml b/samples/task_templates_sample.yaml
new file mode 100644
index 00000000..f0b5aeee
--- /dev/null
+++ b/samples/task_templates_sample.yaml
@@ -0,0 +1,45 @@
+tasktemplates: 
+    deleteTaskTemplate: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.tasktemplates.deleteTaskTemplate(taskTemplateGid)
+            .then((result) => {
+                console.log(result);
+            });
+    getTaskTemplate: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.tasktemplates.getTaskTemplate(taskTemplateGid, {param: "value", param: "value", opt_pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    getTaskTemplates: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.tasktemplates.getTaskTemplates({param: "value", param: "value", opt_pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    instantiateTask: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.tasktemplates.instantiateTask(taskTemplateGid, {field: "value", field: "value", pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
diff --git a/samples/tasks_sample.yaml b/samples/tasks_sample.yaml
index c701face..bf7dfe30 100644
--- a/samples/tasks_sample.yaml
+++ b/samples/tasks_sample.yaml
@@ -142,6 +142,17 @@ tasks:
             .then((result) => {
                 console.log(result);
             });
+    getTaskForCustomID: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.tasks.getTaskForCustomID(workspaceGid, customId, {param: "value", param: "value", opt_pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
     getTasks: >-
         const asana = require('asana');
 
diff --git a/samples/teams_sample.yaml b/samples/teams_sample.yaml
index 60002bc1..4f7c5b99 100644
--- a/samples/teams_sample.yaml
+++ b/samples/teams_sample.yaml
@@ -65,3 +65,14 @@ teams:
             .then((result) => {
                 console.log(result);
             });
+    updateTeam: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.teams.updateTeam(teamGid, {field: "value", field: "value", pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
diff --git a/samples/time_tracking_entries_sample.yaml b/samples/time_tracking_entries_sample.yaml
new file mode 100644
index 00000000..fec33848
--- /dev/null
+++ b/samples/time_tracking_entries_sample.yaml
@@ -0,0 +1,56 @@
+timetrackingentries: 
+    createTimeTrackingEntry: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.timetrackingentries.createTimeTrackingEntry(taskGid, {field: "value", field: "value", pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    deleteTimeTrackingEntry: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.timetrackingentries.deleteTimeTrackingEntry(timeTrackingEntryGid)
+            .then((result) => {
+                console.log(result);
+            });
+    getTimeTrackingEntriesForTask: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.timetrackingentries.getTimeTrackingEntriesForTask(taskGid, {param: "value", param: "value", opt_pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    getTimeTrackingEntry: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.timetrackingentries.getTimeTrackingEntry(timeTrackingEntryGid, {param: "value", param: "value", opt_pretty: true})
+            .then((result) => {
+                console.log(result);
+            });
+    updateTimeTrackingEntry: >-
+        const asana = require('asana');
+
+
+        const client = asana.Client.create().useAccessToken('PERSONAL_ACCESS_TOKEN');
+
+
+        client.timetrackingentries.updateTimeTrackingEntry(timeTrackingEntryGid, {field: "value", field: "value", pretty: true})
+            .then((result) => {
+                console.log(result);
+            });