docspring 4.3.0 → 4.4.0

package/dist/api/Client.js

@@ -11,8 +11,11 @@ var _AuthenticationCheck = _interopRequireDefault(require("../model/Authenticati
 var _CombinedPdf = _interopRequireDefault(require("../model/CombinedPdf"));
 var _CombinedPdfList = _interopRequireDefault(require("../model/CombinedPdfList"));
 var _CopyTemplateRequest = _interopRequireDefault(require("../model/CopyTemplateRequest"));
+var _CreateAccountEmailActionRequest = _interopRequireDefault(require("../model/CreateAccountEmailActionRequest"));
 var _CreateCombinedPdfRequest = _interopRequireDefault(require("../model/CreateCombinedPdfRequest"));
 var _CreateCustomFileFromUploadRequest = _interopRequireDefault(require("../model/CreateCustomFileFromUploadRequest"));
+var _CreateEmailActionRequest = _interopRequireDefault(require("../model/CreateEmailActionRequest"));
+var _CreateEmailDomainRequest = _interopRequireDefault(require("../model/CreateEmailDomainRequest"));
 var _CreateFolderRequest = _interopRequireDefault(require("../model/CreateFolderRequest"));
 var _CreateSignatureRequestEventRequest = _interopRequireDefault(require("../model/CreateSignatureRequestEventRequest"));
 var _CreateSignatureRequestTokenRequest = _interopRequireDefault(require("../model/CreateSignatureRequestTokenRequest"));
@@ -23,6 +26,11 @@ var _CreateTemplateRequest = _interopRequireDefault(require("../model/CreateTemp
 var _CreateWebhookRequest = _interopRequireDefault(require("../model/CreateWebhookRequest"));
 var _CustomFile = _interopRequireDefault(require("../model/CustomFile"));
 var _CustomFileList = _interopRequireDefault(require("../model/CustomFileList"));
+var _EmailAction = _interopRequireDefault(require("../model/EmailAction"));
+var _EmailActionList = _interopRequireDefault(require("../model/EmailActionList"));
+var _EmailActionTestEmail = _interopRequireDefault(require("../model/EmailActionTestEmail"));
+var _EmailDomain = _interopRequireDefault(require("../model/EmailDomain"));
+var _EmailDomainList = _interopRequireDefault(require("../model/EmailDomainList"));
 var _ErrorResponse = _interopRequireDefault(require("../model/ErrorResponse"));
 var _FieldSetupLogic = _interopRequireDefault(require("../model/FieldSetupLogic"));
 var _FieldSetupNaming = _interopRequireDefault(require("../model/FieldSetupNaming"));
@@ -39,6 +47,7 @@ var _RemoveTemplateFieldsRequest = _interopRequireDefault(require("../model/Remo
 var _RenameFolderRequest = _interopRequireDefault(require("../model/RenameFolderRequest"));
 var _ReorderTemplateFieldsRequest = _interopRequireDefault(require("../model/ReorderTemplateFieldsRequest"));
 var _RestoreTemplateVersionRequest = _interopRequireDefault(require("../model/RestoreTemplateVersionRequest"));
+var _SendAccountEmailActionTestEmailRequest = _interopRequireDefault(require("../model/SendAccountEmailActionTestEmailRequest"));
 var _SignatureRequest = _interopRequireDefault(require("../model/SignatureRequest"));
 var _SignatureRequestEvent = _interopRequireDefault(require("../model/SignatureRequestEvent"));
 var _SignatureRequestToken = _interopRequireDefault(require("../model/SignatureRequestToken"));
@@ -55,6 +64,9 @@ var _TemplatePageImages = _interopRequireDefault(require("../model/TemplatePageI
 var _TemplatePreview = _interopRequireDefault(require("../model/TemplatePreview"));
 var _TemplateSummaryList = _interopRequireDefault(require("../model/TemplateSummaryList"));
 var _TemplateVersion = _interopRequireDefault(require("../model/TemplateVersion"));
+var _UpdateAccountEmailActionRequest = _interopRequireDefault(require("../model/UpdateAccountEmailActionRequest"));
+var _UpdateEmailActionCustomizationRequest = _interopRequireDefault(require("../model/UpdateEmailActionCustomizationRequest"));
+var _UpdateEmailActionRequest = _interopRequireDefault(require("../model/UpdateEmailActionRequest"));
 var _UpdateSignatureRequestRequest = _interopRequireDefault(require("../model/UpdateSignatureRequestRequest"));
 var _UpdateTemplateDocumentRequest = _interopRequireDefault(require("../model/UpdateTemplateDocumentRequest"));
 var _UpdateTemplateFieldsRequest = _interopRequireDefault(require("../model/UpdateTemplateFieldsRequest"));
@@ -87,7 +99,7 @@ function _toPrimitive(t, e) { if ("object" != _typeof(t) || !t) return t; var r;
 /**
 * Client service.
 * @module api/Client
-* @version 4.3.0
+* @version 4.4.0
 */
 var Client = exports["default"] = /*#__PURE__*/function () {
   /**
@@ -145,14 +157,17 @@ var Client = exports["default"] = /*#__PURE__*/function () {
 
   /**
    * Add fields to a template
-   * Adds fields to a template's draft and returns all of its fields. Publish a version for submissions of published versions to have them. 
+   * Adds fields to a template's draft and returns all of its fields. Publish a version for submissions of published versions to have them. A field with the name of one of the template's fields shares its settings (`type`, `required`, `default`, ...), so a field that sets one to another value is refused: PUT /templates/{template_id}/fields changes them for every field with the name. 
    * @param {String} template_id The template's ID.
    * @param {module:model/AddTemplateFieldsRequest} body The fields to add to the template's draft.
+   * @param {Object} opts Optional parameters
+   * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
    * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/TemplateFields} and HTTP response
    */
   return _createClass(Client, [{
     key: "addTemplateFieldsWithHttpInfo",
-    value: function addTemplateFieldsWithHttpInfo(template_id, body) {
+    value: function addTemplateFieldsWithHttpInfo(template_id, body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'template_id' is set
       if (template_id === undefined || template_id === null) {
@@ -166,7 +181,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'template_id': template_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -177,15 +194,17 @@ var Client = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Add fields to a template
-     * Adds fields to a template's draft and returns all of its fields. Publish a version for submissions of published versions to have them. 
+     * Adds fields to a template's draft and returns all of its fields. Publish a version for submissions of published versions to have them. A field with the name of one of the template's fields shares its settings (`type`, `required`, `default`, ...), so a field that sets one to another value is refused: PUT /templates/{template_id}/fields changes them for every field with the name. 
      * @param {String} template_id The template's ID.
      * @param {module:model/AddTemplateFieldsRequest} body The fields to add to the template's draft.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/TemplateFields}
      */
   }, {
     key: "addTemplateFields",
-    value: function addTemplateFields(template_id, body) {
-      return this.addTemplateFieldsWithHttpInfo(template_id, body).then(function (response_and_data) {
+    value: function addTemplateFields(template_id, body, opts) {
+      return this.addTemplateFieldsWithHttpInfo(template_id, body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -196,6 +215,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {String} template_id The template's ID.
      * @param {Object} opts Optional parameters
      * @param {module:model/CopyTemplateRequest} [body] Settings for the copy.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Template} and HTTP response
      */
   }, {
@@ -211,7 +231,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'template_id': template_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -226,6 +248,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {String} template_id The template's ID.
      * @param {Object} opts Optional parameters
      * @param {module:model/CopyTemplateRequest} opts.body Settings for the copy.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Template}
      */
   }, {
@@ -236,13 +259,59 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       });
     }
 
+    /**
+     * Create an account email action
+     * Adds an email action to your account. It sends for every template, or only for the templates in `template_ids` and the templates in the folders in `folder_ids` (and the folders inside them). Each template can turn it off or change its settings for that template only (`PUT /templates/{template_id}/email_actions/{email_action_id}/customization`). Without a paid plan (Starter or higher), email actions only email your team: test submissions' emails go to your account's users, and live submissions' emails aren't sent. 
+     * @param {module:model/CreateAccountEmailActionRequest} body The account email action to create. Properties left out get their defaults, and it sends for every template unless it lists `template_ids` or `folder_ids`.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailAction} and HTTP response
+     */
+  }, {
+    key: "createAccountEmailActionWithHttpInfo",
+    value: function createAccountEmailActionWithHttpInfo(body, opts) {
+      opts = opts || {};
+      var postBody = body;
+      // verify the required parameter 'body' is set
+      if (body === undefined || body === null) {
+        throw new Error("Missing the required parameter 'body' when calling createAccountEmailAction");
+      }
+      var pathParams = {};
+      var queryParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = _EmailAction["default"];
+      return this.apiClient.callApi('/email_actions', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Create an account email action
+     * Adds an email action to your account. It sends for every template, or only for the templates in `template_ids` and the templates in the folders in `folder_ids` (and the folders inside them). Each template can turn it off or change its settings for that template only (`PUT /templates/{template_id}/email_actions/{email_action_id}/customization`). Without a paid plan (Starter or higher), email actions only email your team: test submissions' emails go to your account's users, and live submissions' emails aren't sent. 
+     * @param {module:model/CreateAccountEmailActionRequest} body The account email action to create. Properties left out get their defaults, and it sends for every template unless it lists `template_ids` or `folder_ids`.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailAction}
+     */
+  }, {
+    key: "createAccountEmailAction",
+    value: function createAccountEmailAction(body, opts) {
+      return this.createAccountEmailActionWithHttpInfo(body, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
     /**
      * Combine PDFs
      * Merges PDFs into one: submissions, other combined PDFs, templates, custom files (POST /custom_files) and PDFs from URLs, in the order of `source_pdfs`. The PDF is generated in the background: on sync.api hosts the request waits for it (unless you pass `wait=false`), otherwise poll GET /combined_pdfs/{combined_pdf_id} until `state` isn't `pending`.  A template source merges the template's processed PDF by default: the PDF submissions are filled in on, decrypted and with its form fields removed. Pass `processed: false` to merge the PDF as it was uploaded. 
      * @param {module:model/CreateCombinedPdfRequest} body The PDFs to merge, and the combined PDF's settings.
      * @param {Object} opts Optional parameters
      * @param {Boolean} [wait] Wait until the PDF has been generated before responding. Default true on sync.api hosts.
-     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of creating another combined PDF. Send a new key with each new combined PDF, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` means the first request is still being processed: send the request again in a few seconds.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/CombinedPdf} and HTTP response
      */
   }, {
@@ -275,7 +344,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {module:model/CreateCombinedPdfRequest} body The PDFs to merge, and the combined PDF's settings.
      * @param {Object} opts Optional parameters
      * @param {Boolean} opts.wait Wait until the PDF has been generated before responding. Default true on sync.api hosts.
-     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of creating another combined PDF. Send a new key with each new combined PDF, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` means the first request is still being processed: send the request again in a few seconds.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/CombinedPdf}
      */
   }, {
@@ -290,11 +359,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Create a custom file from an upload
      * Creates a custom file from a PDF you uploaded, so you can merge it with other PDFs. Upload the file with the presigned upload (GET /uploads/presign) first, then pass its `fields.key` as `cache_id`. 
      * @param {module:model/CreateCustomFileFromUploadRequest} body The uploaded file to create the custom file from.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/CustomFile} and HTTP response
      */
   }, {
     key: "createCustomFileFromUploadWithHttpInfo",
-    value: function createCustomFileFromUploadWithHttpInfo(body) {
+    value: function createCustomFileFromUploadWithHttpInfo(body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'body' is set
       if (body === undefined || body === null) {
@@ -302,7 +374,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       }
       var pathParams = {};
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -315,12 +389,114 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Create a custom file from an upload
      * Creates a custom file from a PDF you uploaded, so you can merge it with other PDFs. Upload the file with the presigned upload (GET /uploads/presign) first, then pass its `fields.key` as `cache_id`. 
      * @param {module:model/CreateCustomFileFromUploadRequest} body The uploaded file to create the custom file from.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/CustomFile}
      */
   }, {
     key: "createCustomFileFromUpload",
-    value: function createCustomFileFromUpload(body) {
-      return this.createCustomFileFromUploadWithHttpInfo(body).then(function (response_and_data) {
+    value: function createCustomFileFromUpload(body, opts) {
+      return this.createCustomFileFromUploadWithHttpInfo(body, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Create an email action
+     * Adds an email action to a template's draft. From then on, each processed submission emails its PDF to the recipients in `to`, `cc` and `bcc`: addresses, and tags for the address in one of the submission's fields (`{{ data.tenant_email }}`) or in its metadata (`{{ metadata.agent_email }}`). With `send_when`, only the submissions whose values meet its conditions send one. Without a paid plan (Starter or higher), email actions only email your team: test submissions' emails go to your account's users, and live submissions' emails aren't sent. 
+     * @param {String} template_id The template's ID.
+     * @param {module:model/CreateEmailActionRequest} body The email action to create. Properties left out get their defaults.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailAction} and HTTP response
+     */
+  }, {
+    key: "createEmailActionWithHttpInfo",
+    value: function createEmailActionWithHttpInfo(template_id, body, opts) {
+      opts = opts || {};
+      var postBody = body;
+      // verify the required parameter 'template_id' is set
+      if (template_id === undefined || template_id === null) {
+        throw new Error("Missing the required parameter 'template_id' when calling createEmailAction");
+      }
+      // verify the required parameter 'body' is set
+      if (body === undefined || body === null) {
+        throw new Error("Missing the required parameter 'body' when calling createEmailAction");
+      }
+      var pathParams = {
+        'template_id': template_id
+      };
+      var queryParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = _EmailAction["default"];
+      return this.apiClient.callApi('/templates/{template_id}/email_actions', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Create an email action
+     * Adds an email action to a template's draft. From then on, each processed submission emails its PDF to the recipients in `to`, `cc` and `bcc`: addresses, and tags for the address in one of the submission's fields (`{{ data.tenant_email }}`) or in its metadata (`{{ metadata.agent_email }}`). With `send_when`, only the submissions whose values meet its conditions send one. Without a paid plan (Starter or higher), email actions only email your team: test submissions' emails go to your account's users, and live submissions' emails aren't sent. 
+     * @param {String} template_id The template's ID.
+     * @param {module:model/CreateEmailActionRequest} body The email action to create. Properties left out get their defaults.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailAction}
+     */
+  }, {
+    key: "createEmailAction",
+    value: function createEmailAction(template_id, body, opts) {
+      return this.createEmailActionWithHttpInfo(template_id, body, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Add an email domain
+     * Adds a domain for email actions to send from, and returns the DNS records to add to it. DocSpring checks for them every few minutes, and the domain is verified once its DKIM and DMARC records are found. Needs a paid monthly plan. 
+     * @param {module:model/CreateEmailDomainRequest} body The domain to add.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailDomain} and HTTP response
+     */
+  }, {
+    key: "createEmailDomainWithHttpInfo",
+    value: function createEmailDomainWithHttpInfo(body, opts) {
+      opts = opts || {};
+      var postBody = body;
+      // verify the required parameter 'body' is set
+      if (body === undefined || body === null) {
+        throw new Error("Missing the required parameter 'body' when calling createEmailDomain");
+      }
+      var pathParams = {};
+      var queryParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = _EmailDomain["default"];
+      return this.apiClient.callApi('/email_domains', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Add an email domain
+     * Adds a domain for email actions to send from, and returns the DNS records to add to it. DocSpring checks for them every few minutes, and the domain is verified once its DKIM and DMARC records are found. Needs a paid monthly plan. 
+     * @param {module:model/CreateEmailDomainRequest} body The domain to add.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailDomain}
+     */
+  }, {
+    key: "createEmailDomain",
+    value: function createEmailDomain(body, opts) {
+      return this.createEmailDomainWithHttpInfo(body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -329,11 +505,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Create a folder
      * Creates a folder for organizing templates. Pass `parent_folder_id` to create it inside another folder. Folder names are unique within their parent folder. 
      * @param {module:model/CreateFolderRequest} body The folder to create.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Folder} and HTTP response
      */
   }, {
     key: "createFolderWithHttpInfo",
-    value: function createFolderWithHttpInfo(body) {
+    value: function createFolderWithHttpInfo(body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'body' is set
       if (body === undefined || body === null) {
@@ -341,7 +520,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       }
       var pathParams = {};
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -354,12 +535,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Create a folder
      * Creates a folder for organizing templates. Pass `parent_folder_id` to create it inside another folder. Folder names are unique within their parent folder. 
      * @param {module:model/CreateFolderRequest} body The folder to create.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Folder}
      */
   }, {
     key: "createFolder",
-    value: function createFolder(body) {
-      return this.createFolderWithHttpInfo(body).then(function (response_and_data) {
+    value: function createFolder(body, opts) {
+      return this.createFolderWithHttpInfo(body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -369,11 +552,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Records something that happened outside DocSpring in the signature request's audit trail: you sent the request to the person (`send_request`). The audit trail shows it as reported by your account. A finished (completed, declined or expired) signature request's audit trail takes no more events, and a test API token can't record one for a live signature request. 
      * @param {String} signature_request_id The signature request's ID.
      * @param {module:model/CreateSignatureRequestEventRequest} body The event to record.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/SignatureRequestEvent} and HTTP response
      */
   }, {
     key: "createSignatureRequestEventWithHttpInfo",
-    value: function createSignatureRequestEventWithHttpInfo(signature_request_id, body) {
+    value: function createSignatureRequestEventWithHttpInfo(signature_request_id, body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'signature_request_id' is set
       if (signature_request_id === undefined || signature_request_id === null) {
@@ -387,7 +573,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'signature_request_id': signature_request_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -401,12 +589,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Records something that happened outside DocSpring in the signature request's audit trail: you sent the request to the person (`send_request`). The audit trail shows it as reported by your account. A finished (completed, declined or expired) signature request's audit trail takes no more events, and a test API token can't record one for a live signature request. 
      * @param {String} signature_request_id The signature request's ID.
      * @param {module:model/CreateSignatureRequestEventRequest} body The event to record.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/SignatureRequestEvent}
      */
   }, {
     key: "createSignatureRequestEvent",
-    value: function createSignatureRequestEvent(signature_request_id, body) {
-      return this.createSignatureRequestEventWithHttpInfo(signature_request_id, body).then(function (response_and_data) {
+    value: function createSignatureRequestEvent(signature_request_id, body, opts) {
+      return this.createSignatureRequestEventWithHttpInfo(signature_request_id, body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -417,6 +607,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {String} signature_request_id The signature request's ID.
      * @param {Object} opts Optional parameters
      * @param {module:model/CreateSignatureRequestTokenRequest} [body] The kind of link to make. Send no body for an `api` token.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/SignatureRequestToken} and HTTP response
      */
   }, {
@@ -432,7 +623,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'signature_request_id': signature_request_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -447,6 +640,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {String} signature_request_id The signature request's ID.
      * @param {Object} opts Optional parameters
      * @param {module:model/CreateSignatureRequestTokenRequest} opts.body The kind of link to make. Send no body for an `api` token.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/SignatureRequestToken}
      */
   }, {
@@ -459,13 +653,13 @@ var Client = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Generate a PDF
-     * Creates a submission: fills in a template with your data and generates a PDF. The PDF is generated in the background: on sync.api hosts the request waits for it (unless you pass `wait=false`), otherwise poll GET /submissions/{submission_id} until `state` isn't `pending`.  Data that doesn't match the template's fields returns a 422 with an `invalid_data` error. The submission is still saved, with its errors, so you can find it in DocSpring: the error's `submission_id` is its ID. 
+     * Creates a submission: fills in a template with your data and generates a PDF. The PDF is generated in the background: on sync.api hosts the request waits for it (unless you pass `wait=false`), otherwise poll GET /submissions/{submission_id} until `state` isn't `pending`.  Data that doesn't match the template's fields returns a 422 with an `invalid_data` error. The submission is still saved, with its errors, so you can find it in DocSpring: the error's `submission_id` is its ID.  With `signature_requests`, the PDF is generated once everyone has signed. DocSpring emails each signer a link to sign, unless `send_email` is false, and can send reminders and the completed document. 
      * @param {String} template_id The template's ID.
      * @param {module:model/CreateSubmissionRequest} body The submission's data and settings.
      * @param {Object} opts Optional parameters
-     * @param {String} [version] The template version to use: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `latest` (the draft when no version has been published).
+     * @param {String} [version] The template version to use: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `latest`.
      * @param {Boolean} [wait] Wait until the files have been generated before responding. Default true on sync.api hosts.
-     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of creating another submission. Send a new key with each new submission, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` means the first request is still being processed: send the request again in a few seconds.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Submission} and HTTP response
      */
   }, {
@@ -501,13 +695,13 @@ var Client = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Generate a PDF
-     * Creates a submission: fills in a template with your data and generates a PDF. The PDF is generated in the background: on sync.api hosts the request waits for it (unless you pass `wait=false`), otherwise poll GET /submissions/{submission_id} until `state` isn't `pending`.  Data that doesn't match the template's fields returns a 422 with an `invalid_data` error. The submission is still saved, with its errors, so you can find it in DocSpring: the error's `submission_id` is its ID. 
+     * Creates a submission: fills in a template with your data and generates a PDF. The PDF is generated in the background: on sync.api hosts the request waits for it (unless you pass `wait=false`), otherwise poll GET /submissions/{submission_id} until `state` isn't `pending`.  Data that doesn't match the template's fields returns a 422 with an `invalid_data` error. The submission is still saved, with its errors, so you can find it in DocSpring: the error's `submission_id` is its ID.  With `signature_requests`, the PDF is generated once everyone has signed. DocSpring emails each signer a link to sign, unless `send_email` is false, and can send reminders and the completed document. 
      * @param {String} template_id The template's ID.
      * @param {module:model/CreateSubmissionRequest} body The submission's data and settings.
      * @param {Object} opts Optional parameters
-     * @param {String} opts.version The template version to use: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `latest` (the draft when no version has been published).
+     * @param {String} opts.version The template version to use: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `latest`.
      * @param {Boolean} opts.wait Wait until the files have been generated before responding. Default true on sync.api hosts.
-     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of creating another submission. Send a new key with each new submission, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` means the first request is still being processed: send the request again in a few seconds.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Submission}
      */
   }, {
@@ -524,7 +718,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {module:model/CreateSubmissionBatchRequest} body The submissions to create, and the settings they share.
      * @param {Object} opts Optional parameters
      * @param {Boolean} [wait] Wait until every file in the batch has been generated before responding. Default true on sync.api hosts.
-     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of creating another batch. Send a new key with each new batch, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` means the first request is still being processed: send the request again in a few seconds.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/SubmissionBatch} and HTTP response
      */
   }, {
@@ -557,7 +751,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {module:model/CreateSubmissionBatchRequest} body The submissions to create, and the settings they share.
      * @param {Object} opts Optional parameters
      * @param {Boolean} opts.wait Wait until every file in the batch has been generated before responding. Default true on sync.api hosts.
-     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of creating another batch. Send a new key with each new batch, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` means the first request is still being processed: send the request again in a few seconds.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/SubmissionBatch}
      */
   }, {
@@ -570,10 +764,11 @@ var Client = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Create a template
-     * Creates an HTML template, or a PDF or Word template from a file you uploaded with the presigned upload (GET /uploads/presign): pass its `fields.key` as `cache_id`. You can send a link to the file (`document_url`) or the file in base64 (`document_base64`) instead, or send the file with the request with POST /templates/upload. A Word template is made from a Word document (.docx) or an OpenDocument text file (.odt), which DocSpring converts to a Word document. It needs its `output_format`: what each submission makes, a Word document (`docx`), an OpenDocument file (`odt`) or a PDF.  A PDF template is ready to generate PDFs once DocSpring has processed its PDF, a template created from a `document_url` once its document has been downloaded, and one created from an .odt once it has been converted (`ready` is true). On sync.api hosts the request waits for that unless you pass `wait=false`. 
+     * Creates an HTML template, or a PDF or Word template from a file you uploaded with the presigned upload (GET /uploads/presign): pass its `fields.key` as `cache_id`. You can send a link to the file (`document_url`) or the file in base64 (`document_base64`) instead, or send the file with the request with POST /templates/upload. A Word template is made from a Word document (.docx) or an OpenDocument text file (.odt), which DocSpring converts to a Word document. It needs its `output_format`: what each submission makes, a Word document (`docx`), an OpenDocument file (`odt`) or a PDF. A page design (`page_designer`) takes its `layout` in the Page Designer layout format, or starts with an empty page without one.  A PDF template is ready to generate PDFs once DocSpring has processed its PDF, a template created from a `document_url` once its document has been downloaded, and one created from an .odt once it has been converted (`ready` is true). On sync.api hosts the request waits for that unless you pass `wait=false`. 
      * @param {module:model/CreateTemplateRequest} body The template to create.
      * @param {Object} opts Optional parameters
      * @param {Boolean} [wait] Wait until the PDF has been processed, a `document_url`'s PDF or Word document downloaded, and an OpenDocument file converted, before responding. Default true on sync.api hosts.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Template} and HTTP response
      */
   }, {
@@ -589,7 +784,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       var queryParams = {
         'wait': opts['wait']
       };
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -600,10 +797,11 @@ var Client = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Create a template
-     * Creates an HTML template, or a PDF or Word template from a file you uploaded with the presigned upload (GET /uploads/presign): pass its `fields.key` as `cache_id`. You can send a link to the file (`document_url`) or the file in base64 (`document_base64`) instead, or send the file with the request with POST /templates/upload. A Word template is made from a Word document (.docx) or an OpenDocument text file (.odt), which DocSpring converts to a Word document. It needs its `output_format`: what each submission makes, a Word document (`docx`), an OpenDocument file (`odt`) or a PDF.  A PDF template is ready to generate PDFs once DocSpring has processed its PDF, a template created from a `document_url` once its document has been downloaded, and one created from an .odt once it has been converted (`ready` is true). On sync.api hosts the request waits for that unless you pass `wait=false`. 
+     * Creates an HTML template, or a PDF or Word template from a file you uploaded with the presigned upload (GET /uploads/presign): pass its `fields.key` as `cache_id`. You can send a link to the file (`document_url`) or the file in base64 (`document_base64`) instead, or send the file with the request with POST /templates/upload. A Word template is made from a Word document (.docx) or an OpenDocument text file (.odt), which DocSpring converts to a Word document. It needs its `output_format`: what each submission makes, a Word document (`docx`), an OpenDocument file (`odt`) or a PDF. A page design (`page_designer`) takes its `layout` in the Page Designer layout format, or starts with an empty page without one.  A PDF template is ready to generate PDFs once DocSpring has processed its PDF, a template created from a `document_url` once its document has been downloaded, and one created from an .odt once it has been converted (`ready` is true). On sync.api hosts the request waits for that unless you pass `wait=false`. 
      * @param {module:model/CreateTemplateRequest} body The template to create.
      * @param {Object} opts Optional parameters
      * @param {Boolean} opts.wait Wait until the PDF has been processed, a `document_url`'s PDF or Word document downloaded, and an OpenDocument file converted, before responding. Default true on sync.api hosts.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Template}
      */
   }, {
@@ -616,11 +814,12 @@ var Client = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Preview a template with data
-     * Makes PNG images of a template's pages filled in with the data you send (not a PDF), so you can check how an HTML, PDF or Word template prints with your data before you publish a version or send live data. A Word template's pages are its PDF's, whatever its `output_format`. It renders the template's draft, or the published `version` you ask for. A preview makes no submission and uses no credits, and its pages are watermarked like a test submission's PDF. It's `pending` while it renders: get it with GET /templates/{template_id}/previews/{preview_id} until it's `processed`, with an image of each page, or `error`. 
+     * Makes PNG images of a template's pages filled in with the data you send (not a PDF), so you can check how an HTML, PDF or Word template or a page design prints with your data before you publish a version or send live data. A Word template's pages are its PDF's, whatever its `output_format`. It renders the template's draft, or the published `version` you ask for. A preview makes no submission and uses no credits, and its pages are watermarked like a test submission's PDF. It's `pending` while it renders: get it with GET /templates/{template_id}/previews/{preview_id} until it's `processed`, with an image of each page, or `error`. 
      * @param {String} template_id The template's ID.
      * @param {module:model/CreateTemplatePreviewRequest} body The data to render the template with.
      * @param {Object} opts Optional parameters
-     * @param {String} [version] A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `draft`.
+     * @param {String} [version] A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `draft`.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/TemplatePreview} and HTTP response
      */
   }, {
@@ -642,7 +841,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       var queryParams = {
         'version': opts['version']
       };
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -653,11 +854,12 @@ var Client = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Preview a template with data
-     * Makes PNG images of a template's pages filled in with the data you send (not a PDF), so you can check how an HTML, PDF or Word template prints with your data before you publish a version or send live data. A Word template's pages are its PDF's, whatever its `output_format`. It renders the template's draft, or the published `version` you ask for. A preview makes no submission and uses no credits, and its pages are watermarked like a test submission's PDF. It's `pending` while it renders: get it with GET /templates/{template_id}/previews/{preview_id} until it's `processed`, with an image of each page, or `error`. 
+     * Makes PNG images of a template's pages filled in with the data you send (not a PDF), so you can check how an HTML, PDF or Word template or a page design prints with your data before you publish a version or send live data. A Word template's pages are its PDF's, whatever its `output_format`. It renders the template's draft, or the published `version` you ask for. A preview makes no submission and uses no credits, and its pages are watermarked like a test submission's PDF. It's `pending` while it renders: get it with GET /templates/{template_id}/previews/{preview_id} until it's `processed`, with an image of each page, or `error`. 
      * @param {String} template_id The template's ID.
      * @param {module:model/CreateTemplatePreviewRequest} body The data to render the template with.
      * @param {Object} opts Optional parameters
-     * @param {String} opts.version A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `draft`.
+     * @param {String} opts.version A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `draft`.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/TemplatePreview}
      */
   }, {
@@ -672,11 +874,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Create a webhook
      * Creates a webhook that sends a POST request to your endpoint whenever a subscribed event happens. Scope it to API tokens, templates or folders to receive only their events. 
      * @param {module:model/CreateWebhookRequest} body The webhook to create.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Webhook} and HTTP response
      */
   }, {
     key: "createWebhookWithHttpInfo",
-    value: function createWebhookWithHttpInfo(body) {
+    value: function createWebhookWithHttpInfo(body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'body' is set
       if (body === undefined || body === null) {
@@ -684,7 +889,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       }
       var pathParams = {};
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -697,12 +904,62 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Create a webhook
      * Creates a webhook that sends a POST request to your endpoint whenever a subscribed event happens. Scope it to API tokens, templates or folders to receive only their events. 
      * @param {module:model/CreateWebhookRequest} body The webhook to create.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Webhook}
      */
   }, {
     key: "createWebhook",
-    value: function createWebhook(body) {
-      return this.createWebhookWithHttpInfo(body).then(function (response_and_data) {
+    value: function createWebhook(body, opts) {
+      return this.createWebhookWithHttpInfo(body, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Delete an account email action
+     * Deletes one of your account's email actions, with every template's customization of it. Emails it has already queued for submissions aren't sent. Submissions keep the record of the emails it sent. 
+     * @param {String} email_action_id The account email action's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailAction} and HTTP response
+     */
+  }, {
+    key: "deleteAccountEmailActionWithHttpInfo",
+    value: function deleteAccountEmailActionWithHttpInfo(email_action_id, opts) {
+      opts = opts || {};
+      var postBody = null;
+      // verify the required parameter 'email_action_id' is set
+      if (email_action_id === undefined || email_action_id === null) {
+        throw new Error("Missing the required parameter 'email_action_id' when calling deleteAccountEmailAction");
+      }
+      var pathParams = {
+        'email_action_id': email_action_id
+      };
+      var queryParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _EmailAction["default"];
+      return this.apiClient.callApi('/email_actions/{email_action_id}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Delete an account email action
+     * Deletes one of your account's email actions, with every template's customization of it. Emails it has already queued for submissions aren't sent. Submissions keep the record of the emails it sent. 
+     * @param {String} email_action_id The account email action's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailAction}
+     */
+  }, {
+    key: "deleteAccountEmailAction",
+    value: function deleteAccountEmailAction(email_action_id, opts) {
+      return this.deleteAccountEmailActionWithHttpInfo(email_action_id, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -711,11 +968,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Delete a custom file
      * Deletes a custom file and returns it. Use a live API token: test tokens can't delete custom files. 
      * @param {String} custom_file_id The custom file's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/CustomFile} and HTTP response
      */
   }, {
     key: "deleteCustomFileWithHttpInfo",
-    value: function deleteCustomFileWithHttpInfo(custom_file_id) {
+    value: function deleteCustomFileWithHttpInfo(custom_file_id, opts) {
+      opts = opts || {};
       var postBody = null;
       // verify the required parameter 'custom_file_id' is set
       if (custom_file_id === undefined || custom_file_id === null) {
@@ -725,7 +985,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'custom_file_id': custom_file_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = [];
@@ -738,155 +1000,336 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Delete a custom file
      * Deletes a custom file and returns it. Use a live API token: test tokens can't delete custom files. 
      * @param {String} custom_file_id The custom file's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/CustomFile}
      */
   }, {
     key: "deleteCustomFile",
-    value: function deleteCustomFile(custom_file_id) {
-      return this.deleteCustomFileWithHttpInfo(custom_file_id).then(function (response_and_data) {
+    value: function deleteCustomFile(custom_file_id, opts) {
+      return this.deleteCustomFileWithHttpInfo(custom_file_id, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Delete a folder
-     * Deletes an empty folder and returns it. A folder that still has templates or folders in it can't be deleted. 
-     * @param {String} folder_id The folder's ID.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Folder} and HTTP response
+     * Delete an email action
+     * Deletes an email action. Emails it has already queued for submissions aren't sent. Submissions keep the record of the emails it sent. 
+     * @param {String} template_id The template's ID.
+     * @param {String} email_action_id The email action's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailAction} and HTTP response
      */
   }, {
-    key: "deleteFolderWithHttpInfo",
-    value: function deleteFolderWithHttpInfo(folder_id) {
+    key: "deleteEmailActionWithHttpInfo",
+    value: function deleteEmailActionWithHttpInfo(template_id, email_action_id, opts) {
+      opts = opts || {};
       var postBody = null;
-      // verify the required parameter 'folder_id' is set
-      if (folder_id === undefined || folder_id === null) {
-        throw new Error("Missing the required parameter 'folder_id' when calling deleteFolder");
+      // verify the required parameter 'template_id' is set
+      if (template_id === undefined || template_id === null) {
+        throw new Error("Missing the required parameter 'template_id' when calling deleteEmailAction");
+      }
+      // verify the required parameter 'email_action_id' is set
+      if (email_action_id === undefined || email_action_id === null) {
+        throw new Error("Missing the required parameter 'email_action_id' when calling deleteEmailAction");
       }
       var pathParams = {
-        'folder_id': folder_id
+        'template_id': template_id,
+        'email_action_id': email_action_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = [];
       var accepts = ['application/json'];
-      var returnType = _Folder["default"];
-      return this.apiClient.callApi('/folders/{folder_id}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var returnType = _EmailAction["default"];
+      return this.apiClient.callApi('/templates/{template_id}/email_actions/{email_action_id}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Delete a folder
-     * Deletes an empty folder and returns it. A folder that still has templates or folders in it can't be deleted. 
-     * @param {String} folder_id The folder's ID.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Folder}
+     * Delete an email action
+     * Deletes an email action. Emails it has already queued for submissions aren't sent. Submissions keep the record of the emails it sent. 
+     * @param {String} template_id The template's ID.
+     * @param {String} email_action_id The email action's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailAction}
      */
   }, {
-    key: "deleteFolder",
-    value: function deleteFolder(folder_id) {
-      return this.deleteFolderWithHttpInfo(folder_id).then(function (response_and_data) {
+    key: "deleteEmailAction",
+    value: function deleteEmailAction(template_id, email_action_id, opts) {
+      return this.deleteEmailActionWithHttpInfo(template_id, email_action_id, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Delete a template
-     * Deletes a template's draft and all of its published versions, or one published version (`version`). Returns the template as it was before it was deleted. 
+     * Reset an account email action's customization
+     * Removes the template's changes to one of your account's email actions: it sends for this template as it is, and again if the template had turned it off. 
      * @param {String} template_id The template's ID.
+     * @param {String} email_action_id The ID of one of your account's email actions that sends for the template.
      * @param {Object} opts Optional parameters
-     * @param {String} [version] Delete only this published version (`1.2.0`) or the draft (`draft`, when no version has been published). Without it, the draft and every published version are deleted.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Template} and HTTP response
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailAction} and HTTP response
      */
   }, {
-    key: "deleteTemplateWithHttpInfo",
-    value: function deleteTemplateWithHttpInfo(template_id, opts) {
+    key: "deleteEmailActionCustomizationWithHttpInfo",
+    value: function deleteEmailActionCustomizationWithHttpInfo(template_id, email_action_id, opts) {
       opts = opts || {};
       var postBody = null;
       // verify the required parameter 'template_id' is set
       if (template_id === undefined || template_id === null) {
-        throw new Error("Missing the required parameter 'template_id' when calling deleteTemplate");
+        throw new Error("Missing the required parameter 'template_id' when calling deleteEmailActionCustomization");
+      }
+      // verify the required parameter 'email_action_id' is set
+      if (email_action_id === undefined || email_action_id === null) {
+        throw new Error("Missing the required parameter 'email_action_id' when calling deleteEmailActionCustomization");
       }
       var pathParams = {
-        'template_id': template_id
+        'template_id': template_id,
+        'email_action_id': email_action_id
       };
-      var queryParams = {
-        'version': opts['version']
+      var queryParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
       };
-      var headerParams = {};
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = [];
       var accepts = ['application/json'];
-      var returnType = _Template["default"];
-      return this.apiClient.callApi('/templates/{template_id}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var returnType = _EmailAction["default"];
+      return this.apiClient.callApi('/templates/{template_id}/email_actions/{email_action_id}/customization', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Delete a template
-     * Deletes a template's draft and all of its published versions, or one published version (`version`). Returns the template as it was before it was deleted. 
+     * Reset an account email action's customization
+     * Removes the template's changes to one of your account's email actions: it sends for this template as it is, and again if the template had turned it off. 
      * @param {String} template_id The template's ID.
+     * @param {String} email_action_id The ID of one of your account's email actions that sends for the template.
      * @param {Object} opts Optional parameters
-     * @param {String} opts.version Delete only this published version (`1.2.0`) or the draft (`draft`, when no version has been published). Without it, the draft and every published version are deleted.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Template}
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailAction}
      */
   }, {
-    key: "deleteTemplate",
-    value: function deleteTemplate(template_id, opts) {
-      return this.deleteTemplateWithHttpInfo(template_id, opts).then(function (response_and_data) {
+    key: "deleteEmailActionCustomization",
+    value: function deleteEmailActionCustomization(template_id, email_action_id, opts) {
+      return this.deleteEmailActionCustomizationWithHttpInfo(template_id, email_action_id, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Delete a webhook
-     * Deletes a webhook so it stops receiving events, and returns it.
-     * @param {String} webhook_id The webhook's ID.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Webhook} and HTTP response
+     * Remove an email domain
+     * Removes an email domain. Email actions that send from an address at it fail until you add and verify it again, or change their `from_address`. You can then remove its DNS records. 
+     * @param {String} email_domain_id The email domain's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailDomain} and HTTP response
      */
   }, {
-    key: "deleteWebhookWithHttpInfo",
-    value: function deleteWebhookWithHttpInfo(webhook_id) {
+    key: "deleteEmailDomainWithHttpInfo",
+    value: function deleteEmailDomainWithHttpInfo(email_domain_id, opts) {
+      opts = opts || {};
       var postBody = null;
-      // verify the required parameter 'webhook_id' is set
-      if (webhook_id === undefined || webhook_id === null) {
-        throw new Error("Missing the required parameter 'webhook_id' when calling deleteWebhook");
+      // verify the required parameter 'email_domain_id' is set
+      if (email_domain_id === undefined || email_domain_id === null) {
+        throw new Error("Missing the required parameter 'email_domain_id' when calling deleteEmailDomain");
       }
       var pathParams = {
-        'webhook_id': webhook_id
+        'email_domain_id': email_domain_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = [];
       var accepts = ['application/json'];
-      var returnType = _Webhook["default"];
-      return this.apiClient.callApi('/webhooks/{webhook_id}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var returnType = _EmailDomain["default"];
+      return this.apiClient.callApi('/email_domains/{email_domain_id}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * Delete a webhook
-     * Deletes a webhook so it stops receiving events, and returns it.
-     * @param {String} webhook_id The webhook's ID.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Webhook}
+     * Remove an email domain
+     * Removes an email domain. Email actions that send from an address at it fail until you add and verify it again, or change their `from_address`. You can then remove its DNS records. 
+     * @param {String} email_domain_id The email domain's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailDomain}
      */
   }, {
-    key: "deleteWebhook",
-    value: function deleteWebhook(webhook_id) {
-      return this.deleteWebhookWithHttpInfo(webhook_id).then(function (response_and_data) {
+    key: "deleteEmailDomain",
+    value: function deleteEmailDomain(email_domain_id, opts) {
+      return this.deleteEmailDomainWithHttpInfo(email_domain_id, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * Expire a combined PDF
-     * Deletes a combined PDF's PDF and returns the expired combined PDF.
-     * @param {String} combined_pdf_id The combined PDF's ID.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/CombinedPdf} and HTTP response
+     * Delete a folder
+     * Deletes an empty folder and returns it. A folder that still has templates or folders in it can't be deleted. 
+     * @param {String} folder_id The folder's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Folder} and HTTP response
+     */
+  }, {
+    key: "deleteFolderWithHttpInfo",
+    value: function deleteFolderWithHttpInfo(folder_id, opts) {
+      opts = opts || {};
+      var postBody = null;
+      // verify the required parameter 'folder_id' is set
+      if (folder_id === undefined || folder_id === null) {
+        throw new Error("Missing the required parameter 'folder_id' when calling deleteFolder");
+      }
+      var pathParams = {
+        'folder_id': folder_id
+      };
+      var queryParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _Folder["default"];
+      return this.apiClient.callApi('/folders/{folder_id}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Delete a folder
+     * Deletes an empty folder and returns it. A folder that still has templates or folders in it can't be deleted. 
+     * @param {String} folder_id The folder's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Folder}
+     */
+  }, {
+    key: "deleteFolder",
+    value: function deleteFolder(folder_id, opts) {
+      return this.deleteFolderWithHttpInfo(folder_id, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Delete a template
+     * Deletes a template's draft and all of its published versions, or one published version (`version`). Returns the template as it was before it was deleted. 
+     * @param {String} template_id The template's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} [version] Delete only this published version (`1.2.0`) or the draft (`draft`, when no version has been published). Without it, the draft and every published version are deleted.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Template} and HTTP response
+     */
+  }, {
+    key: "deleteTemplateWithHttpInfo",
+    value: function deleteTemplateWithHttpInfo(template_id, opts) {
+      opts = opts || {};
+      var postBody = null;
+      // verify the required parameter 'template_id' is set
+      if (template_id === undefined || template_id === null) {
+        throw new Error("Missing the required parameter 'template_id' when calling deleteTemplate");
+      }
+      var pathParams = {
+        'template_id': template_id
+      };
+      var queryParams = {
+        'version': opts['version']
+      };
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _Template["default"];
+      return this.apiClient.callApi('/templates/{template_id}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Delete a template
+     * Deletes a template's draft and all of its published versions, or one published version (`version`). Returns the template as it was before it was deleted. 
+     * @param {String} template_id The template's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.version Delete only this published version (`1.2.0`) or the draft (`draft`, when no version has been published). Without it, the draft and every published version are deleted.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Template}
+     */
+  }, {
+    key: "deleteTemplate",
+    value: function deleteTemplate(template_id, opts) {
+      return this.deleteTemplateWithHttpInfo(template_id, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Delete a webhook
+     * Deletes a webhook so it stops receiving events, and returns it.
+     * @param {String} webhook_id The webhook's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Webhook} and HTTP response
+     */
+  }, {
+    key: "deleteWebhookWithHttpInfo",
+    value: function deleteWebhookWithHttpInfo(webhook_id, opts) {
+      opts = opts || {};
+      var postBody = null;
+      // verify the required parameter 'webhook_id' is set
+      if (webhook_id === undefined || webhook_id === null) {
+        throw new Error("Missing the required parameter 'webhook_id' when calling deleteWebhook");
+      }
+      var pathParams = {
+        'webhook_id': webhook_id
+      };
+      var queryParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _Webhook["default"];
+      return this.apiClient.callApi('/webhooks/{webhook_id}', 'DELETE', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Delete a webhook
+     * Deletes a webhook so it stops receiving events, and returns it.
+     * @param {String} webhook_id The webhook's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Webhook}
+     */
+  }, {
+    key: "deleteWebhook",
+    value: function deleteWebhook(webhook_id, opts) {
+      return this.deleteWebhookWithHttpInfo(webhook_id, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Expire a combined PDF
+     * Deletes a combined PDF's PDF and returns the expired combined PDF.
+     * @param {String} combined_pdf_id The combined PDF's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/CombinedPdf} and HTTP response
      */
   }, {
     key: "expireCombinedPdfWithHttpInfo",
-    value: function expireCombinedPdfWithHttpInfo(combined_pdf_id) {
+    value: function expireCombinedPdfWithHttpInfo(combined_pdf_id, opts) {
+      opts = opts || {};
       var postBody = null;
       // verify the required parameter 'combined_pdf_id' is set
       if (combined_pdf_id === undefined || combined_pdf_id === null) {
@@ -896,7 +1339,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'combined_pdf_id': combined_pdf_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = [];
@@ -909,12 +1354,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Expire a combined PDF
      * Deletes a combined PDF's PDF and returns the expired combined PDF.
      * @param {String} combined_pdf_id The combined PDF's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/CombinedPdf}
      */
   }, {
     key: "expireCombinedPdf",
-    value: function expireCombinedPdf(combined_pdf_id) {
-      return this.expireCombinedPdfWithHttpInfo(combined_pdf_id).then(function (response_and_data) {
+    value: function expireCombinedPdf(combined_pdf_id, opts) {
+      return this.expireCombinedPdfWithHttpInfo(combined_pdf_id, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -923,11 +1370,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Expire a submission
      * Deletes a submission's data and PDF now, and returns the expired submission.
      * @param {String} submission_id The submission's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Submission} and HTTP response
      */
   }, {
     key: "expireSubmissionWithHttpInfo",
-    value: function expireSubmissionWithHttpInfo(submission_id) {
+    value: function expireSubmissionWithHttpInfo(submission_id, opts) {
+      opts = opts || {};
       var postBody = null;
       // verify the required parameter 'submission_id' is set
       if (submission_id === undefined || submission_id === null) {
@@ -937,7 +1387,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'submission_id': submission_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = [];
@@ -950,12 +1402,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Expire a submission
      * Deletes a submission's data and PDF now, and returns the expired submission.
      * @param {String} submission_id The submission's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Submission}
      */
   }, {
     key: "expireSubmission",
-    value: function expireSubmission(submission_id) {
-      return this.expireSubmissionWithHttpInfo(submission_id).then(function (response_and_data) {
+    value: function expireSubmission(submission_id, opts) {
+      return this.expireSubmissionWithHttpInfo(submission_id, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -967,6 +1421,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {module:model/GenerateSubmissionFilesRequest} body The formats to make.
      * @param {Object} opts Optional parameters
      * @param {Boolean} [wait] Wait until the files have been generated before responding. Default true on sync.api hosts.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Submission} and HTTP response
      */
   }, {
@@ -988,7 +1443,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       var queryParams = {
         'wait': opts['wait']
       };
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -1004,6 +1461,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {module:model/GenerateSubmissionFilesRequest} body The formats to make.
      * @param {Object} opts Optional parameters
      * @param {Boolean} opts.wait Wait until the files have been generated before responding. Default true on sync.api hosts.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Submission}
      */
   }, {
@@ -1018,11 +1476,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Generate a preview PDF
      * Generates a preview of a submission's PDF in the background, such as for a submission still waiting for its signature requests. It's in `files.preview` once `preview_generated_at` changes. 
      * @param {String} submission_id The submission's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Submission} and HTTP response
      */
   }, {
     key: "generateSubmissionPreviewWithHttpInfo",
-    value: function generateSubmissionPreviewWithHttpInfo(submission_id) {
+    value: function generateSubmissionPreviewWithHttpInfo(submission_id, opts) {
+      opts = opts || {};
       var postBody = null;
       // verify the required parameter 'submission_id' is set
       if (submission_id === undefined || submission_id === null) {
@@ -1032,7 +1493,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'submission_id': submission_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = [];
@@ -1045,12 +1508,55 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Generate a preview PDF
      * Generates a preview of a submission's PDF in the background, such as for a submission still waiting for its signature requests. It's in `files.preview` once `preview_generated_at` changes. 
      * @param {String} submission_id The submission's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Submission}
      */
   }, {
     key: "generateSubmissionPreview",
-    value: function generateSubmissionPreview(submission_id) {
-      return this.generateSubmissionPreviewWithHttpInfo(submission_id).then(function (response_and_data) {
+    value: function generateSubmissionPreview(submission_id, opts) {
+      return this.generateSubmissionPreviewWithHttpInfo(submission_id, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Get an account email action
+     * Returns one of your account's email actions, with its settings and whether its emails are failing.
+     * @param {String} email_action_id The account email action's ID.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailAction} and HTTP response
+     */
+  }, {
+    key: "getAccountEmailActionWithHttpInfo",
+    value: function getAccountEmailActionWithHttpInfo(email_action_id) {
+      var postBody = null;
+      // verify the required parameter 'email_action_id' is set
+      if (email_action_id === undefined || email_action_id === null) {
+        throw new Error("Missing the required parameter 'email_action_id' when calling getAccountEmailAction");
+      }
+      var pathParams = {
+        'email_action_id': email_action_id
+      };
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _EmailAction["default"];
+      return this.apiClient.callApi('/email_actions/{email_action_id}', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Get an account email action
+     * Returns one of your account's email actions, with its settings and whether its emails are failing.
+     * @param {String} email_action_id The account email action's ID.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailAction}
+     */
+  }, {
+    key: "getAccountEmailAction",
+    value: function getAccountEmailAction(email_action_id) {
+      return this.getAccountEmailActionWithHttpInfo(email_action_id).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -1137,6 +1643,95 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       });
     }
 
+    /**
+     * Get an email action
+     * Returns one of a template's email actions, with its settings and whether its emails are failing.
+     * @param {String} template_id The template's ID.
+     * @param {String} email_action_id The email action's ID.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailAction} and HTTP response
+     */
+  }, {
+    key: "getEmailActionWithHttpInfo",
+    value: function getEmailActionWithHttpInfo(template_id, email_action_id) {
+      var postBody = null;
+      // verify the required parameter 'template_id' is set
+      if (template_id === undefined || template_id === null) {
+        throw new Error("Missing the required parameter 'template_id' when calling getEmailAction");
+      }
+      // verify the required parameter 'email_action_id' is set
+      if (email_action_id === undefined || email_action_id === null) {
+        throw new Error("Missing the required parameter 'email_action_id' when calling getEmailAction");
+      }
+      var pathParams = {
+        'template_id': template_id,
+        'email_action_id': email_action_id
+      };
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _EmailAction["default"];
+      return this.apiClient.callApi('/templates/{template_id}/email_actions/{email_action_id}', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Get an email action
+     * Returns one of a template's email actions, with its settings and whether its emails are failing.
+     * @param {String} template_id The template's ID.
+     * @param {String} email_action_id The email action's ID.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailAction}
+     */
+  }, {
+    key: "getEmailAction",
+    value: function getEmailAction(template_id, email_action_id) {
+      return this.getEmailActionWithHttpInfo(template_id, email_action_id).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Get an email domain
+     * Returns an email domain, whether it's verified, and the DNS records to add to it.
+     * @param {String} email_domain_id The email domain's ID.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailDomain} and HTTP response
+     */
+  }, {
+    key: "getEmailDomainWithHttpInfo",
+    value: function getEmailDomainWithHttpInfo(email_domain_id) {
+      var postBody = null;
+      // verify the required parameter 'email_domain_id' is set
+      if (email_domain_id === undefined || email_domain_id === null) {
+        throw new Error("Missing the required parameter 'email_domain_id' when calling getEmailDomain");
+      }
+      var pathParams = {
+        'email_domain_id': email_domain_id
+      };
+      var queryParams = {};
+      var headerParams = {};
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _EmailDomain["default"];
+      return this.apiClient.callApi('/email_domains/{email_domain_id}', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Get an email domain
+     * Returns an email domain, whether it's verified, and the DNS records to add to it.
+     * @param {String} email_domain_id The email domain's ID.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailDomain}
+     */
+  }, {
+    key: "getEmailDomain",
+    value: function getEmailDomain(email_domain_id) {
+      return this.getEmailDomainWithHttpInfo(email_domain_id).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
     /**
      * Get a folder
      * Returns a folder.
@@ -1346,7 +1941,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Returns a template: its draft, or one of its published versions.
      * @param {String} template_id The template's ID.
      * @param {Object} opts Optional parameters
-     * @param {String} [version] A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `draft`.
+     * @param {String} [version] A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `draft`.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Template} and HTTP response
      */
   }, {
@@ -1378,7 +1973,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Returns a template: its draft, or one of its published versions.
      * @param {String} template_id The template's ID.
      * @param {Object} opts Optional parameters
-     * @param {String} opts.version A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `draft`.
+     * @param {String} opts.version A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `draft`.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Template}
      */
   }, {
@@ -1394,7 +1989,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Returns what changed in the template's draft since its latest published version (or in a published version since the one before it): fields added, removed, changed and moved, the settings that changed, and whether the document was replaced. Check it before you publish a version. 
      * @param {String} template_id The template's ID.
      * @param {Object} opts Optional parameters
-     * @param {String} [version] A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `draft`.
+     * @param {String} [version] A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `draft`.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/TemplateDiff} and HTTP response
      */
   }, {
@@ -1426,7 +2021,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Returns what changed in the template's draft since its latest published version (or in a published version since the one before it): fields added, removed, changed and moved, the settings that changed, and whether the document was replaced. Check it before you publish a version. 
      * @param {String} template_id The template's ID.
      * @param {Object} opts Optional parameters
-     * @param {String} opts.version A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `draft`.
+     * @param {String} opts.version A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `draft`.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/TemplateDiff}
      */
   }, {
@@ -1443,7 +2038,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {String} template_id The template's ID.
      * @param {module:model/ModelCodeLanguage} lang The language to generate the code in.
      * @param {Object} opts Optional parameters
-     * @param {String} [version] The template version: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `latest` (the draft when no version has been published), the version a submission uses by default.
+     * @param {String} [version] The template version: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `latest`, the version a submission uses by default.
      * @param {Boolean} [just_types] Return only the types (interfaces, classes or structs), without the code that converts JSON to and from them. Default false. JavaScript has no types, PHP has no types-only code, and Rust's code is only types (serde converts the JSON), so theirs is the same either way.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/TemplateModelCode} and HTTP response
      */
@@ -1483,7 +2078,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {String} template_id The template's ID.
      * @param {module:model/ModelCodeLanguage} lang The language to generate the code in.
      * @param {Object} opts Optional parameters
-     * @param {String} opts.version The template version: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `latest` (the draft when no version has been published), the version a submission uses by default.
+     * @param {String} opts.version The template version: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `latest`, the version a submission uses by default.
      * @param {Boolean} opts.just_types Return only the types (interfaces, classes or structs), without the code that converts JSON to and from them. Default false. JavaScript has no types, PHP has no types-only code, and Rust's code is only types (serde converts the JSON), so theirs is the same either way.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/TemplateModelCode}
      */
@@ -1500,7 +2095,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Returns a JPEG image of each page of a PDF template's PDF, with temporary links to download them: the draft's PDF, or a published version's. Use them to see the pages that fields are placed on. 
      * @param {String} template_id The template's ID.
      * @param {Object} opts Optional parameters
-     * @param {String} [version] A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `draft`.
+     * @param {String} [version] A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `draft`.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/TemplatePageImages} and HTTP response
      */
   }, {
@@ -1532,7 +2127,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Returns a JPEG image of each page of a PDF template's PDF, with temporary links to download them: the draft's PDF, or a published version's. Use them to see the pages that fields are placed on. 
      * @param {String} template_id The template's ID.
      * @param {Object} opts Optional parameters
-     * @param {String} opts.version A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `draft`.
+     * @param {String} opts.version A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `draft`.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/TemplatePageImages}
      */
   }, {
@@ -1596,7 +2191,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Returns the JSON Schema that a submission's `data` must match. Use it to check data before you create submissions, or to build a form for the template's fields. 
      * @param {String} template_id The template's ID.
      * @param {Object} opts Optional parameters
-     * @param {String} [version] The template version: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `latest` (the draft when no version has been published), the version a submission uses by default.
+     * @param {String} [version] The template version: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `latest`, the version a submission uses by default.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link Object.<String, {String: Object}>} and HTTP response
      */
   }, {
@@ -1630,7 +2225,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Returns the JSON Schema that a submission's `data` must match. Use it to check data before you create submissions, or to build a form for the template's fields. 
      * @param {String} template_id The template's ID.
      * @param {Object} opts Optional parameters
-     * @param {String} opts.version The template version: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `latest` (the draft when no version has been published), the version a submission uses by default.
+     * @param {String} opts.version The template version: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `latest`, the version a submission uses by default.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link Object.<String, {String: Object}>}
      */
   }, {
@@ -1683,16 +2278,16 @@ var Client = exports["default"] = /*#__PURE__*/function () {
     }
 
     /**
-     * List combined PDFs
-     * Returns the combined PDFs in your account, newest first, one page at a time.
+     * List account email actions
+     * Returns your account's email actions, newest first, one page at a time. Each one emails the files of every template's processed submissions, or of the templates and folders it lists. A template's own email actions are listed with the template (`GET /templates/{template_id}/email_actions`). 
      * @param {Object} opts Optional parameters
      * @param {Number} [limit = 50)] How many items to return (1-100, default 50).
      * @param {String} [cursor] The previous page's `next_cursor`, to get the next page. It's the ID of that page's last item, so get the next page before you delete or change the items on this one.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/CombinedPdfList} and HTTP response
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailActionList} and HTTP response
      */
   }, {
-    key: "listCombinedPdfsWithHttpInfo",
-    value: function listCombinedPdfsWithHttpInfo(opts) {
+    key: "listAccountEmailActionsWithHttpInfo",
+    value: function listAccountEmailActionsWithHttpInfo(opts) {
       opts = opts || {};
       var postBody = null;
       var pathParams = {};
@@ -1705,33 +2300,76 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       var authNames = ['api_token_basic'];
       var contentTypes = [];
       var accepts = ['application/json'];
-      var returnType = _CombinedPdfList["default"];
-      return this.apiClient.callApi('/combined_pdfs', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+      var returnType = _EmailActionList["default"];
+      return this.apiClient.callApi('/email_actions', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
     }
 
     /**
-     * List combined PDFs
-     * Returns the combined PDFs in your account, newest first, one page at a time.
+     * List account email actions
+     * Returns your account's email actions, newest first, one page at a time. Each one emails the files of every template's processed submissions, or of the templates and folders it lists. A template's own email actions are listed with the template (`GET /templates/{template_id}/email_actions`). 
      * @param {Object} opts Optional parameters
      * @param {Number} opts.limit How many items to return (1-100, default 50). (default to 50)
      * @param {String} opts.cursor The previous page's `next_cursor`, to get the next page. It's the ID of that page's last item, so get the next page before you delete or change the items on this one.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/CombinedPdfList}
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailActionList}
      */
   }, {
-    key: "listCombinedPdfs",
-    value: function listCombinedPdfs(opts) {
-      return this.listCombinedPdfsWithHttpInfo(opts).then(function (response_and_data) {
+    key: "listAccountEmailActions",
+    value: function listAccountEmailActions(opts) {
+      return this.listAccountEmailActionsWithHttpInfo(opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
-     * List custom files
-     * Returns the custom files in your account, newest first, one page at a time.
+     * List combined PDFs
+     * Returns the combined PDFs in your account, newest first, one page at a time.
      * @param {Object} opts Optional parameters
      * @param {Number} [limit = 50)] How many items to return (1-100, default 50).
      * @param {String} [cursor] The previous page's `next_cursor`, to get the next page. It's the ID of that page's last item, so get the next page before you delete or change the items on this one.
-     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/CustomFileList} and HTTP response
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/CombinedPdfList} and HTTP response
+     */
+  }, {
+    key: "listCombinedPdfsWithHttpInfo",
+    value: function listCombinedPdfsWithHttpInfo(opts) {
+      opts = opts || {};
+      var postBody = null;
+      var pathParams = {};
+      var queryParams = {
+        'limit': opts['limit'],
+        'cursor': opts['cursor']
+      };
+      var headerParams = {};
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _CombinedPdfList["default"];
+      return this.apiClient.callApi('/combined_pdfs', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * List combined PDFs
+     * Returns the combined PDFs in your account, newest first, one page at a time.
+     * @param {Object} opts Optional parameters
+     * @param {Number} opts.limit How many items to return (1-100, default 50). (default to 50)
+     * @param {String} opts.cursor The previous page's `next_cursor`, to get the next page. It's the ID of that page's last item, so get the next page before you delete or change the items on this one.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/CombinedPdfList}
+     */
+  }, {
+    key: "listCombinedPdfs",
+    value: function listCombinedPdfs(opts) {
+      return this.listCombinedPdfsWithHttpInfo(opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * List custom files
+     * Returns the custom files in your account, newest first, one page at a time.
+     * @param {Object} opts Optional parameters
+     * @param {Number} [limit = 50)] How many items to return (1-100, default 50).
+     * @param {String} [cursor] The previous page's `next_cursor`, to get the next page. It's the ID of that page's last item, so get the next page before you delete or change the items on this one.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/CustomFileList} and HTTP response
      */
   }, {
     key: "listCustomFilesWithHttpInfo",
@@ -1768,6 +2406,100 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       });
     }
 
+    /**
+     * List email actions
+     * Returns the email actions of a template's draft, and your account's email actions that send for it, newest first, one page at a time. Each one emails every processed submission's files to the people it lists. An account email action (`template_id` null) shows the settings it sends for this template, with the template's changes in `customization`. 
+     * @param {String} template_id The template's ID.
+     * @param {Object} opts Optional parameters
+     * @param {Number} [limit = 50)] How many items to return (1-100, default 50).
+     * @param {String} [cursor] The previous page's `next_cursor`, to get the next page. It's the ID of that page's last item, so get the next page before you delete or change the items on this one.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailActionList} and HTTP response
+     */
+  }, {
+    key: "listEmailActionsWithHttpInfo",
+    value: function listEmailActionsWithHttpInfo(template_id, opts) {
+      opts = opts || {};
+      var postBody = null;
+      // verify the required parameter 'template_id' is set
+      if (template_id === undefined || template_id === null) {
+        throw new Error("Missing the required parameter 'template_id' when calling listEmailActions");
+      }
+      var pathParams = {
+        'template_id': template_id
+      };
+      var queryParams = {
+        'limit': opts['limit'],
+        'cursor': opts['cursor']
+      };
+      var headerParams = {};
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _EmailActionList["default"];
+      return this.apiClient.callApi('/templates/{template_id}/email_actions', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * List email actions
+     * Returns the email actions of a template's draft, and your account's email actions that send for it, newest first, one page at a time. Each one emails every processed submission's files to the people it lists. An account email action (`template_id` null) shows the settings it sends for this template, with the template's changes in `customization`. 
+     * @param {String} template_id The template's ID.
+     * @param {Object} opts Optional parameters
+     * @param {Number} opts.limit How many items to return (1-100, default 50). (default to 50)
+     * @param {String} opts.cursor The previous page's `next_cursor`, to get the next page. It's the ID of that page's last item, so get the next page before you delete or change the items on this one.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailActionList}
+     */
+  }, {
+    key: "listEmailActions",
+    value: function listEmailActions(template_id, opts) {
+      return this.listEmailActionsWithHttpInfo(template_id, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * List email domains
+     * Returns the domains in your account that email actions can send from once they're verified, newest first, one page at a time. 
+     * @param {Object} opts Optional parameters
+     * @param {Number} [limit = 50)] How many items to return (1-100, default 50).
+     * @param {String} [cursor] The previous page's `next_cursor`, to get the next page. It's the ID of that page's last item, so get the next page before you delete or change the items on this one.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailDomainList} and HTTP response
+     */
+  }, {
+    key: "listEmailDomainsWithHttpInfo",
+    value: function listEmailDomainsWithHttpInfo(opts) {
+      opts = opts || {};
+      var postBody = null;
+      var pathParams = {};
+      var queryParams = {
+        'limit': opts['limit'],
+        'cursor': opts['cursor']
+      };
+      var headerParams = {};
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _EmailDomainList["default"];
+      return this.apiClient.callApi('/email_domains', 'GET', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * List email domains
+     * Returns the domains in your account that email actions can send from once they're verified, newest first, one page at a time. 
+     * @param {Object} opts Optional parameters
+     * @param {Number} opts.limit How many items to return (1-100, default 50). (default to 50)
+     * @param {String} opts.cursor The previous page's `next_cursor`, to get the next page. It's the ID of that page's last item, so get the next page before you delete or change the items on this one.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailDomainList}
+     */
+  }, {
+    key: "listEmailDomains",
+    value: function listEmailDomains(opts) {
+      return this.listEmailDomainsWithHttpInfo(opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
     /**
      * List folders
      * Returns the folders in your account, newest first, one page at a time. Pass `parent_folder_id` to list the folders in one folder. 
@@ -1883,7 +2615,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Returns a template's fields with all of their settings, page by page: the draft's fields, or a published version's. A PDF template's fields are placed on its pages: GET /templates/{template_id}/page_images has images of the pages. 
      * @param {String} template_id The template's ID.
      * @param {Object} opts Optional parameters
-     * @param {String} [version] A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `draft`.
+     * @param {String} [version] A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `draft`.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/TemplateFields} and HTTP response
      */
   }, {
@@ -1915,7 +2647,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Returns a template's fields with all of their settings, page by page: the draft's fields, or a published version's. A PDF template's fields are placed on its pages: GET /templates/{template_id}/page_images has images of the pages. 
      * @param {String} template_id The template's ID.
      * @param {Object} opts Optional parameters
-     * @param {String} opts.version A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `draft`.
+     * @param {String} opts.version A published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `draft`.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/TemplateFields}
      */
   }, {
@@ -1999,7 +2731,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * List templates
      * Returns the templates in your account (their drafts), newest first, one page at a time. Each one is a summary: get a template by its ID for its settings, its PDF in full, its HTML, defaults and published versions. 
      * @param {Object} opts Optional parameters
-     * @param {String} [query] Only list templates whose name contains this text (ignoring case).
+     * @param {String} [query] Only list templates whose name contains this text (ignoring case). `%` and `_` match themselves.
      * @param {String} [parent_folder_id] Only list the templates in this folder (not in its subfolders).
      * @param {Number} [limit = 50)] How many items to return (1-100, default 50).
      * @param {String} [cursor] The previous page's `next_cursor`, to get the next page. It's the ID of that page's last item, so get the next page before you delete or change the items on this one.
@@ -2030,7 +2762,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * List templates
      * Returns the templates in your account (their drafts), newest first, one page at a time. Each one is a summary: get a template by its ID for its settings, its PDF in full, its HTML, defaults and published versions. 
      * @param {Object} opts Optional parameters
-     * @param {String} opts.query Only list templates whose name contains this text (ignoring case).
+     * @param {String} opts.query Only list templates whose name contains this text (ignoring case). `%` and `_` match themselves.
      * @param {String} opts.parent_folder_id Only list the templates in this folder (not in its subfolders).
      * @param {Number} opts.limit How many items to return (1-100, default 50). (default to 50)
      * @param {String} opts.cursor The previous page's `next_cursor`, to get the next page. It's the ID of that page's last item, so get the next page before you delete or change the items on this one.
@@ -2107,11 +2839,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Moves a folder into another folder, or to the root with `parent_folder_id: null`. Its templates and folders move with it. A folder can't move into itself or one of its own folders. 
      * @param {String} folder_id The folder's ID.
      * @param {module:model/MoveFolderRequest} body Where to move the folder.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Folder} and HTTP response
      */
   }, {
     key: "moveFolderWithHttpInfo",
-    value: function moveFolderWithHttpInfo(folder_id, body) {
+    value: function moveFolderWithHttpInfo(folder_id, body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'folder_id' is set
       if (folder_id === undefined || folder_id === null) {
@@ -2125,7 +2860,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'folder_id': folder_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -2139,12 +2876,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Moves a folder into another folder, or to the root with `parent_folder_id: null`. Its templates and folders move with it. A folder can't move into itself or one of its own folders. 
      * @param {String} folder_id The folder's ID.
      * @param {module:model/MoveFolderRequest} body Where to move the folder.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Folder}
      */
   }, {
     key: "moveFolder",
-    value: function moveFolder(folder_id, body) {
-      return this.moveFolderWithHttpInfo(folder_id, body).then(function (response_and_data) {
+    value: function moveFolder(folder_id, body, opts) {
+      return this.moveFolderWithHttpInfo(folder_id, body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -2154,11 +2893,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Moves a template and all of its published versions to a folder, or to the root (`null`).
      * @param {String} template_id The template's ID.
      * @param {module:model/MoveTemplateRequest} body Where to move the template.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Template} and HTTP response
      */
   }, {
     key: "moveTemplateWithHttpInfo",
-    value: function moveTemplateWithHttpInfo(template_id, body) {
+    value: function moveTemplateWithHttpInfo(template_id, body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'template_id' is set
       if (template_id === undefined || template_id === null) {
@@ -2172,7 +2914,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'template_id': template_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -2186,12 +2930,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Moves a template and all of its published versions to a folder, or to the root (`null`).
      * @param {String} template_id The template's ID.
      * @param {module:model/MoveTemplateRequest} body Where to move the template.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Template}
      */
   }, {
     key: "moveTemplate",
-    value: function moveTemplate(template_id, body) {
-      return this.moveTemplateWithHttpInfo(template_id, body).then(function (response_and_data) {
+    value: function moveTemplate(template_id, body, opts) {
+      return this.moveTemplateWithHttpInfo(template_id, body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -2201,11 +2947,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Publishes the template's draft as a new version. Its content (the PDF or HTML, fields, name and description) never changes, while settings such as `webhook_url` and `public_submissions` keep following the draft. `version_type` says which part of the latest version number goes up. While the template's PDF is downloading or being processed, or DocSpring is setting up its fields, it returns a 409 that says so. 
      * @param {String} template_id The template's ID.
      * @param {module:model/PublishTemplateVersionRequest} body The version to publish.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/TemplateVersion} and HTTP response
      */
   }, {
     key: "publishTemplateVersionWithHttpInfo",
-    value: function publishTemplateVersionWithHttpInfo(template_id, body) {
+    value: function publishTemplateVersionWithHttpInfo(template_id, body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'template_id' is set
       if (template_id === undefined || template_id === null) {
@@ -2219,7 +2968,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'template_id': template_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -2233,12 +2984,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Publishes the template's draft as a new version. Its content (the PDF or HTML, fields, name and description) never changes, while settings such as `webhook_url` and `public_submissions` keep following the draft. `version_type` says which part of the latest version number goes up. While the template's PDF is downloading or being processed, or DocSpring is setting up its fields, it returns a 409 that says so. 
      * @param {String} template_id The template's ID.
      * @param {module:model/PublishTemplateVersionRequest} body The version to publish.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/TemplateVersion}
      */
   }, {
     key: "publishTemplateVersion",
-    value: function publishTemplateVersion(template_id, body) {
-      return this.publishTemplateVersionWithHttpInfo(template_id, body).then(function (response_and_data) {
+    value: function publishTemplateVersion(template_id, body, opts) {
+      return this.publishTemplateVersionWithHttpInfo(template_id, body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -2248,11 +3001,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Removes fields from a template's draft and returns the fields that are left. Conditional logic that used only the removed fields is removed too. 
      * @param {String} template_id The template's ID.
      * @param {module:model/RemoveTemplateFieldsRequest} body The fields to remove from the template's draft.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/TemplateFields} and HTTP response
      */
   }, {
     key: "removeTemplateFieldsWithHttpInfo",
-    value: function removeTemplateFieldsWithHttpInfo(template_id, body) {
+    value: function removeTemplateFieldsWithHttpInfo(template_id, body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'template_id' is set
       if (template_id === undefined || template_id === null) {
@@ -2266,7 +3022,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'template_id': template_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -2280,12 +3038,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Removes fields from a template's draft and returns the fields that are left. Conditional logic that used only the removed fields is removed too. 
      * @param {String} template_id The template's ID.
      * @param {module:model/RemoveTemplateFieldsRequest} body The fields to remove from the template's draft.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/TemplateFields}
      */
   }, {
     key: "removeTemplateFields",
-    value: function removeTemplateFields(template_id, body) {
-      return this.removeTemplateFieldsWithHttpInfo(template_id, body).then(function (response_and_data) {
+    value: function removeTemplateFields(template_id, body, opts) {
+      return this.removeTemplateFieldsWithHttpInfo(template_id, body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -2295,11 +3055,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Renames a folder. The name must be unique within its parent folder. 
      * @param {String} folder_id The folder's ID.
      * @param {module:model/RenameFolderRequest} body The folder's new name.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Folder} and HTTP response
      */
   }, {
     key: "renameFolderWithHttpInfo",
-    value: function renameFolderWithHttpInfo(folder_id, body) {
+    value: function renameFolderWithHttpInfo(folder_id, body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'folder_id' is set
       if (folder_id === undefined || folder_id === null) {
@@ -2313,7 +3076,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'folder_id': folder_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -2327,12 +3092,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Renames a folder. The name must be unique within its parent folder. 
      * @param {String} folder_id The folder's ID.
      * @param {module:model/RenameFolderRequest} body The folder's new name.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Folder}
      */
   }, {
     key: "renameFolder",
-    value: function renameFolder(folder_id, body) {
-      return this.renameFolderWithHttpInfo(folder_id, body).then(function (response_and_data) {
+    value: function renameFolder(folder_id, body, opts) {
+      return this.renameFolderWithHttpInfo(folder_id, body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -2342,11 +3109,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Changes the order of the fields in a template's draft and returns them in their new order. Send every field's ID: each field stays on its page, and a page's fields are printed in this order, so a later field prints over an earlier one where they overlap. Their values are in this order in the template's data schema and forms. 
      * @param {String} template_id The template's ID.
      * @param {module:model/ReorderTemplateFieldsRequest} body The new order of the fields in the template's draft.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/TemplateFields} and HTTP response
      */
   }, {
     key: "reorderTemplateFieldsWithHttpInfo",
-    value: function reorderTemplateFieldsWithHttpInfo(template_id, body) {
+    value: function reorderTemplateFieldsWithHttpInfo(template_id, body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'template_id' is set
       if (template_id === undefined || template_id === null) {
@@ -2360,7 +3130,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'template_id': template_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -2374,12 +3146,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Changes the order of the fields in a template's draft and returns them in their new order. Send every field's ID: each field stays on its page, and a page's fields are printed in this order, so a later field prints over an earlier one where they overlap. Their values are in this order in the template's data schema and forms. 
      * @param {String} template_id The template's ID.
      * @param {module:model/ReorderTemplateFieldsRequest} body The new order of the fields in the template's draft.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/TemplateFields}
      */
   }, {
     key: "reorderTemplateFields",
-    value: function reorderTemplateFields(template_id, body) {
-      return this.reorderTemplateFieldsWithHttpInfo(template_id, body).then(function (response_and_data) {
+    value: function reorderTemplateFields(template_id, body, opts) {
+      return this.reorderTemplateFieldsWithHttpInfo(template_id, body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -2389,11 +3163,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Replaces the template's draft with a copy of one of its published versions. The draft keeps its settings that apply to every version, such as `webhook_url`.
      * @param {String} template_id The template's ID.
      * @param {module:model/RestoreTemplateVersionRequest} body The version to restore.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Template} and HTTP response
      */
   }, {
     key: "restoreTemplateVersionWithHttpInfo",
-    value: function restoreTemplateVersionWithHttpInfo(template_id, body) {
+    value: function restoreTemplateVersionWithHttpInfo(template_id, body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'template_id' is set
       if (template_id === undefined || template_id === null) {
@@ -2407,7 +3184,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'template_id': template_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -2421,12 +3200,119 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Replaces the template's draft with a copy of one of its published versions. The draft keeps its settings that apply to every version, such as `webhook_url`.
      * @param {String} template_id The template's ID.
      * @param {module:model/RestoreTemplateVersionRequest} body The version to restore.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Template}
      */
   }, {
     key: "restoreTemplateVersion",
-    value: function restoreTemplateVersion(template_id, body) {
-      return this.restoreTemplateVersionWithHttpInfo(template_id, body).then(function (response_and_data) {
+    value: function restoreTemplateVersion(template_id, body, opts) {
+      return this.restoreTemplateVersionWithHttpInfo(template_id, body, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Send a test email for an account email action
+     * Sends the account email action's email to the API token's user only, as it would go for one template it sends for, with each field shown as its name in brackets, so you can check how it looks. When the email action attaches its files and that template is a PDF template, the test attaches the template's blank PDF. It isn't recorded on any submission. 
+     * @param {String} email_action_id The account email action's ID.
+     * @param {Object} opts Optional parameters
+     * @param {module:model/SendAccountEmailActionTestEmailRequest} [body] Which template the test email is for.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailActionTestEmail} and HTTP response
+     */
+  }, {
+    key: "sendAccountEmailActionTestEmailWithHttpInfo",
+    value: function sendAccountEmailActionTestEmailWithHttpInfo(email_action_id, opts) {
+      opts = opts || {};
+      var postBody = opts['body'];
+      // verify the required parameter 'email_action_id' is set
+      if (email_action_id === undefined || email_action_id === null) {
+        throw new Error("Missing the required parameter 'email_action_id' when calling sendAccountEmailActionTestEmail");
+      }
+      var pathParams = {
+        'email_action_id': email_action_id
+      };
+      var queryParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = _EmailActionTestEmail["default"];
+      return this.apiClient.callApi('/email_actions/{email_action_id}/test_email', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Send a test email for an account email action
+     * Sends the account email action's email to the API token's user only, as it would go for one template it sends for, with each field shown as its name in brackets, so you can check how it looks. When the email action attaches its files and that template is a PDF template, the test attaches the template's blank PDF. It isn't recorded on any submission. 
+     * @param {String} email_action_id The account email action's ID.
+     * @param {Object} opts Optional parameters
+     * @param {module:model/SendAccountEmailActionTestEmailRequest} opts.body Which template the test email is for.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailActionTestEmail}
+     */
+  }, {
+    key: "sendAccountEmailActionTestEmail",
+    value: function sendAccountEmailActionTestEmail(email_action_id, opts) {
+      return this.sendAccountEmailActionTestEmailWithHttpInfo(email_action_id, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Send a test email
+     * Sends the email action's email to the API token's user only, with each field and metadata value shown as its name in brackets, so you can check how it looks. When the email action attaches its files and the template is a PDF template, the test attaches the template's blank PDF. It isn't recorded on any submission. Without a paid plan, the user needs a confirmed email address. 
+     * @param {String} template_id The template's ID.
+     * @param {String} email_action_id The email action's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailActionTestEmail} and HTTP response
+     */
+  }, {
+    key: "sendEmailActionTestEmailWithHttpInfo",
+    value: function sendEmailActionTestEmailWithHttpInfo(template_id, email_action_id, opts) {
+      opts = opts || {};
+      var postBody = null;
+      // verify the required parameter 'template_id' is set
+      if (template_id === undefined || template_id === null) {
+        throw new Error("Missing the required parameter 'template_id' when calling sendEmailActionTestEmail");
+      }
+      // verify the required parameter 'email_action_id' is set
+      if (email_action_id === undefined || email_action_id === null) {
+        throw new Error("Missing the required parameter 'email_action_id' when calling sendEmailActionTestEmail");
+      }
+      var pathParams = {
+        'template_id': template_id,
+        'email_action_id': email_action_id
+      };
+      var queryParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _EmailActionTestEmail["default"];
+      return this.apiClient.callApi('/templates/{template_id}/email_actions/{email_action_id}/test_email', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Send a test email
+     * Sends the email action's email to the API token's user only, with each field and metadata value shown as its name in brackets, so you can check how it looks. When the email action attaches its files and the template is a PDF template, the test attaches the template's blank PDF. It isn't recorded on any submission. Without a paid plan, the user needs a confirmed email address. 
+     * @param {String} template_id The template's ID.
+     * @param {String} email_action_id The email action's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailActionTestEmail}
+     */
+  }, {
+    key: "sendEmailActionTestEmail",
+    value: function sendEmailActionTestEmail(template_id, email_action_id, opts) {
+      return this.sendEmailActionTestEmailWithHttpInfo(template_id, email_action_id, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -2464,16 +3350,195 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       });
     }
 
+    /**
+     * Update an account email action
+     * Changes one of your account's email actions. Properties left out keep their values. Its templates' customizations keep their own changes, and follow the rest. Set `enabled` to false to stop its emails for every template. 
+     * @param {String} email_action_id The account email action's ID.
+     * @param {module:model/UpdateAccountEmailActionRequest} body The settings to change. Properties left out keep their values.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailAction} and HTTP response
+     */
+  }, {
+    key: "updateAccountEmailActionWithHttpInfo",
+    value: function updateAccountEmailActionWithHttpInfo(email_action_id, body, opts) {
+      opts = opts || {};
+      var postBody = body;
+      // verify the required parameter 'email_action_id' is set
+      if (email_action_id === undefined || email_action_id === null) {
+        throw new Error("Missing the required parameter 'email_action_id' when calling updateAccountEmailAction");
+      }
+      // verify the required parameter 'body' is set
+      if (body === undefined || body === null) {
+        throw new Error("Missing the required parameter 'body' when calling updateAccountEmailAction");
+      }
+      var pathParams = {
+        'email_action_id': email_action_id
+      };
+      var queryParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = _EmailAction["default"];
+      return this.apiClient.callApi('/email_actions/{email_action_id}', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Update an account email action
+     * Changes one of your account's email actions. Properties left out keep their values. Its templates' customizations keep their own changes, and follow the rest. Set `enabled` to false to stop its emails for every template. 
+     * @param {String} email_action_id The account email action's ID.
+     * @param {module:model/UpdateAccountEmailActionRequest} body The settings to change. Properties left out keep their values.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailAction}
+     */
+  }, {
+    key: "updateAccountEmailAction",
+    value: function updateAccountEmailAction(email_action_id, body, opts) {
+      return this.updateAccountEmailActionWithHttpInfo(email_action_id, body, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Update an email action
+     * Changes an email action's settings. Properties left out keep their values. Set `enabled` to false to stop its emails, or to true to turn it back on after DocSpring turned it off. 
+     * @param {String} template_id The template's ID.
+     * @param {String} email_action_id The email action's ID.
+     * @param {module:model/UpdateEmailActionRequest} body The settings to change. Properties left out keep their values.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailAction} and HTTP response
+     */
+  }, {
+    key: "updateEmailActionWithHttpInfo",
+    value: function updateEmailActionWithHttpInfo(template_id, email_action_id, body, opts) {
+      opts = opts || {};
+      var postBody = body;
+      // verify the required parameter 'template_id' is set
+      if (template_id === undefined || template_id === null) {
+        throw new Error("Missing the required parameter 'template_id' when calling updateEmailAction");
+      }
+      // verify the required parameter 'email_action_id' is set
+      if (email_action_id === undefined || email_action_id === null) {
+        throw new Error("Missing the required parameter 'email_action_id' when calling updateEmailAction");
+      }
+      // verify the required parameter 'body' is set
+      if (body === undefined || body === null) {
+        throw new Error("Missing the required parameter 'body' when calling updateEmailAction");
+      }
+      var pathParams = {
+        'template_id': template_id,
+        'email_action_id': email_action_id
+      };
+      var queryParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = _EmailAction["default"];
+      return this.apiClient.callApi('/templates/{template_id}/email_actions/{email_action_id}', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Update an email action
+     * Changes an email action's settings. Properties left out keep their values. Set `enabled` to false to stop its emails, or to true to turn it back on after DocSpring turned it off. 
+     * @param {String} template_id The template's ID.
+     * @param {String} email_action_id The email action's ID.
+     * @param {module:model/UpdateEmailActionRequest} body The settings to change. Properties left out keep their values.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailAction}
+     */
+  }, {
+    key: "updateEmailAction",
+    value: function updateEmailAction(template_id, email_action_id, body, opts) {
+      return this.updateEmailActionWithHttpInfo(template_id, email_action_id, body, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
+    /**
+     * Customize an account email action for a template
+     * Changes one of your account's email actions for this template only, replacing any changes the template had. Each setting you send is changed for this template, and the ones you leave out follow the account email action, including later changes to it. Set `enabled` to false to stop it sending for this template. 
+     * @param {String} template_id The template's ID.
+     * @param {String} email_action_id The ID of one of your account's email actions that sends for the template.
+     * @param {module:model/UpdateEmailActionCustomizationRequest} body The template's changes to the account email action, replacing any it had. Each setting you send is changed for this template, and the ones you leave out follow the account email action. `enabled: false` stops it sending for this template; left out, it sends.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailAction} and HTTP response
+     */
+  }, {
+    key: "updateEmailActionCustomizationWithHttpInfo",
+    value: function updateEmailActionCustomizationWithHttpInfo(template_id, email_action_id, body, opts) {
+      opts = opts || {};
+      var postBody = body;
+      // verify the required parameter 'template_id' is set
+      if (template_id === undefined || template_id === null) {
+        throw new Error("Missing the required parameter 'template_id' when calling updateEmailActionCustomization");
+      }
+      // verify the required parameter 'email_action_id' is set
+      if (email_action_id === undefined || email_action_id === null) {
+        throw new Error("Missing the required parameter 'email_action_id' when calling updateEmailActionCustomization");
+      }
+      // verify the required parameter 'body' is set
+      if (body === undefined || body === null) {
+        throw new Error("Missing the required parameter 'body' when calling updateEmailActionCustomization");
+      }
+      var pathParams = {
+        'template_id': template_id,
+        'email_action_id': email_action_id
+      };
+      var queryParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = ['application/json'];
+      var accepts = ['application/json'];
+      var returnType = _EmailAction["default"];
+      return this.apiClient.callApi('/templates/{template_id}/email_actions/{email_action_id}/customization', 'PUT', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Customize an account email action for a template
+     * Changes one of your account's email actions for this template only, replacing any changes the template had. Each setting you send is changed for this template, and the ones you leave out follow the account email action, including later changes to it. Set `enabled` to false to stop it sending for this template. 
+     * @param {String} template_id The template's ID.
+     * @param {String} email_action_id The ID of one of your account's email actions that sends for the template.
+     * @param {module:model/UpdateEmailActionCustomizationRequest} body The template's changes to the account email action, replacing any it had. Each setting you send is changed for this template, and the ones you leave out follow the account email action. `enabled: false` stops it sending for this template; left out, it sends.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailAction}
+     */
+  }, {
+    key: "updateEmailActionCustomization",
+    value: function updateEmailActionCustomization(template_id, email_action_id, body, opts) {
+      return this.updateEmailActionCustomizationWithHttpInfo(template_id, email_action_id, body, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
+
     /**
      * Update a signature request
      * Changes a pending signature request's metadata, or how your app authenticated the person (for the audit trail). Once the person has opened it, only its metadata can be changed, and a completed or declined signature request can't be changed. 
      * @param {String} signature_request_id The signature request's ID.
      * @param {module:model/UpdateSignatureRequestRequest} body The settings to change. Properties left out keep their values.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/SignatureRequest} and HTTP response
      */
   }, {
     key: "updateSignatureRequestWithHttpInfo",
-    value: function updateSignatureRequestWithHttpInfo(signature_request_id, body) {
+    value: function updateSignatureRequestWithHttpInfo(signature_request_id, body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'signature_request_id' is set
       if (signature_request_id === undefined || signature_request_id === null) {
@@ -2487,7 +3552,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'signature_request_id': signature_request_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -2501,26 +3568,31 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Changes a pending signature request's metadata, or how your app authenticated the person (for the audit trail). Once the person has opened it, only its metadata can be changed, and a completed or declined signature request can't be changed. 
      * @param {String} signature_request_id The signature request's ID.
      * @param {module:model/UpdateSignatureRequestRequest} body The settings to change. Properties left out keep their values.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/SignatureRequest}
      */
   }, {
     key: "updateSignatureRequest",
-    value: function updateSignatureRequest(signature_request_id, body) {
-      return this.updateSignatureRequestWithHttpInfo(signature_request_id, body).then(function (response_and_data) {
+    value: function updateSignatureRequest(signature_request_id, body, opts) {
+      return this.updateSignatureRequestWithHttpInfo(signature_request_id, body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
 
     /**
      * Update a template
-     * Changes a template's draft. Properties left out keep their values. `defaults` and `html_engine_options` replace the whole object, and `field_groups` changes only the groups it lists. Settings such as `webhook_url`, `public_submissions` and `expire_after` apply to every published version too, and setting `parent_folder_id` moves the template and all of its published versions. 
+     * Changes a template's draft. Properties left out keep their values. `defaults`, `html_engine_options` and a page design's `layout` replace the whole object, and `field_groups` changes only the groups it lists. A new layout adds a field for each new value it reads. Settings such as `webhook_url`, `public_submissions` and `expire_after` apply to every published version too, and setting `parent_folder_id` moves the template and all of its published versions. 
      * @param {String} template_id The template's ID.
      * @param {module:model/UpdateTemplateRequest} body The settings to change. Properties left out keep their values.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Template} and HTTP response
      */
   }, {
     key: "updateTemplateWithHttpInfo",
-    value: function updateTemplateWithHttpInfo(template_id, body) {
+    value: function updateTemplateWithHttpInfo(template_id, body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'template_id' is set
       if (template_id === undefined || template_id === null) {
@@ -2534,7 +3606,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'template_id': template_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -2545,15 +3619,17 @@ var Client = exports["default"] = /*#__PURE__*/function () {
 
     /**
      * Update a template
-     * Changes a template's draft. Properties left out keep their values. `defaults` and `html_engine_options` replace the whole object, and `field_groups` changes only the groups it lists. Settings such as `webhook_url`, `public_submissions` and `expire_after` apply to every published version too, and setting `parent_folder_id` moves the template and all of its published versions. 
+     * Changes a template's draft. Properties left out keep their values. `defaults`, `html_engine_options` and a page design's `layout` replace the whole object, and `field_groups` changes only the groups it lists. A new layout adds a field for each new value it reads. Settings such as `webhook_url`, `public_submissions` and `expire_after` apply to every published version too, and setting `parent_folder_id` moves the template and all of its published versions. 
      * @param {String} template_id The template's ID.
      * @param {module:model/UpdateTemplateRequest} body The settings to change. Properties left out keep their values.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Template}
      */
   }, {
     key: "updateTemplate",
-    value: function updateTemplate(template_id, body) {
-      return this.updateTemplateWithHttpInfo(template_id, body).then(function (response_and_data) {
+    value: function updateTemplate(template_id, body, opts) {
+      return this.updateTemplateWithHttpInfo(template_id, body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -2565,6 +3641,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {module:model/UpdateTemplateDocumentRequest} body The new PDF, or a Word template's new Word document, as one of `cache_id`, `document_url` and `document_base64`.
      * @param {Object} opts Optional parameters
      * @param {Boolean} [wait] Wait until the PDF has been processed, a `document_url`'s PDF or Word document downloaded, and an OpenDocument file converted, before responding. Default true on sync.api hosts.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Template} and HTTP response
      */
   }, {
@@ -2586,7 +3663,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       var queryParams = {
         'wait': opts['wait']
       };
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -2602,6 +3681,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {module:model/UpdateTemplateDocumentRequest} body The new PDF, or a Word template's new Word document, as one of `cache_id`, `document_url` and `document_base64`.
      * @param {Object} opts Optional parameters
      * @param {Boolean} opts.wait Wait until the PDF has been processed, a `document_url`'s PDF or Word document downloaded, and an OpenDocument file converted, before responding. Default true on sync.api hosts.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Template}
      */
   }, {
@@ -2617,11 +3697,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Changes fields of a template's draft and returns all of its fields. Settings left out keep their values. A shared setting (`type`, `required`, `default`, ...) changes for every field with the same name. 
      * @param {String} template_id The template's ID.
      * @param {module:model/UpdateTemplateFieldsRequest} body The fields to change in the template's draft.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/TemplateFields} and HTTP response
      */
   }, {
     key: "updateTemplateFieldsWithHttpInfo",
-    value: function updateTemplateFieldsWithHttpInfo(template_id, body) {
+    value: function updateTemplateFieldsWithHttpInfo(template_id, body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'template_id' is set
       if (template_id === undefined || template_id === null) {
@@ -2635,7 +3718,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'template_id': template_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -2649,12 +3734,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Changes fields of a template's draft and returns all of its fields. Settings left out keep their values. A shared setting (`type`, `required`, `default`, ...) changes for every field with the same name. 
      * @param {String} template_id The template's ID.
      * @param {module:model/UpdateTemplateFieldsRequest} body The fields to change in the template's draft.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/TemplateFields}
      */
   }, {
     key: "updateTemplateFields",
-    value: function updateTemplateFields(template_id, body) {
-      return this.updateTemplateFieldsWithHttpInfo(template_id, body).then(function (response_and_data) {
+    value: function updateTemplateFields(template_id, body, opts) {
+      return this.updateTemplateFieldsWithHttpInfo(template_id, body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -2664,11 +3751,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Updates a webhook. Only the properties you send change.
      * @param {String} webhook_id The webhook's ID.
      * @param {module:model/UpdateWebhookRequest} body The settings to change. Properties left out keep their values.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Webhook} and HTTP response
      */
   }, {
     key: "updateWebhookWithHttpInfo",
-    value: function updateWebhookWithHttpInfo(webhook_id, body) {
+    value: function updateWebhookWithHttpInfo(webhook_id, body, opts) {
+      opts = opts || {};
       var postBody = body;
       // verify the required parameter 'webhook_id' is set
       if (webhook_id === undefined || webhook_id === null) {
@@ -2682,7 +3772,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         'webhook_id': webhook_id
       };
       var queryParams = {};
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -2696,12 +3788,14 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * Updates a webhook. Only the properties you send change.
      * @param {String} webhook_id The webhook's ID.
      * @param {module:model/UpdateWebhookRequest} body The settings to change. Properties left out keep their values.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Webhook}
      */
   }, {
     key: "updateWebhook",
-    value: function updateWebhook(webhook_id, body) {
-      return this.updateWebhookWithHttpInfo(webhook_id, body).then(function (response_and_data) {
+    value: function updateWebhook(webhook_id, body, opts) {
+      return this.updateWebhookWithHttpInfo(webhook_id, body, opts).then(function (response_and_data) {
         return response_and_data.data;
       });
     }
@@ -2721,6 +3815,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {module:model/FieldSetupNaming} [field_naming] With `detect_fields`, how the fields are named. `ai` (the default) names them and sets their types and settings with AI; `preserve` keeps the names of the PDF's form fields, and AI only names the fields it detected. `preserve` needs `field_source` `auto` or `pdf_form_fields`.
      * @param {module:model/FieldSetupLogic} [field_logic] With `detect_fields`, whether AI reads the whole form once the fields are named and sets up conditional logic and required fields (`ai`) or not (`none`). Default: your account's template settings.
      * @param {module:model/OutputFormat} [output_format] What each submission of a Word template makes unless its request sets `output_formats`: `docx` (a Word document), `odt` (an OpenDocument file, converted from the Word document) or `pdf`. Required when `document` is a Word document.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Template} and HTTP response
      */
   }, {
@@ -2736,7 +3831,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       var queryParams = {
         'wait': opts['wait']
       };
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {
         'document': document,
         'name': opts['name'],
@@ -2771,6 +3868,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {module:model/FieldSetupNaming} opts.field_naming With `detect_fields`, how the fields are named. `ai` (the default) names them and sets their types and settings with AI; `preserve` keeps the names of the PDF's form fields, and AI only names the fields it detected. `preserve` needs `field_source` `auto` or `pdf_form_fields`.
      * @param {module:model/FieldSetupLogic} opts.field_logic With `detect_fields`, whether AI reads the whole form once the fields are named and sets up conditional logic and required fields (`ai`) or not (`none`). Default: your account's template settings.
      * @param {module:model/OutputFormat} opts.output_format What each submission of a Word template makes unless its request sets `output_formats`: `docx` (a Word document), `odt` (an OpenDocument file, converted from the Word document) or `pdf`. Required when `document` is a Word document.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Template}
      */
   }, {
@@ -2789,6 +3887,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {Object} opts Optional parameters
      * @param {Boolean} [wait] Wait until the PDF has been processed, a `document_url`'s PDF or Word document downloaded, and an OpenDocument file converted, before responding. Default true on sync.api hosts.
      * @param {Boolean} [reimport_fields] Replace all of the template's fields with the fillable fields in the new PDF, once DocSpring has processed it (`document.field_reimport_state`). As on a first upload, the default typeface, font size, bold and color are taken from the PDF's fields; the template's other settings are kept. If the PDF has no fillable fields, the template keeps its fields. A locked template can't re-import its fields. Only for PDF templates: a Word template adds a field for each new tag.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/Template} and HTTP response
      */
   }, {
@@ -2810,7 +3909,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       var queryParams = {
         'wait': opts['wait']
       };
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {
         'document': document,
         'reimport_fields': opts['reimport_fields']
@@ -2830,6 +3931,7 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {Object} opts Optional parameters
      * @param {Boolean} opts.wait Wait until the PDF has been processed, a `document_url`'s PDF or Word document downloaded, and an OpenDocument file converted, before responding. Default true on sync.api hosts.
      * @param {Boolean} opts.reimport_fields Replace all of the template's fields with the fillable fields in the new PDF, once DocSpring has processed it (`document.field_reimport_state`). As on a first upload, the default typeface, font size, bold and color are taken from the PDF's fields; the template's other settings are kept. If the PDF has no fillable fields, the template keeps its fields. A locked template can't re-import its fields. Only for PDF templates: a Word template adds a field for each new tag.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/Template}
      */
   }, {
@@ -2846,7 +3948,8 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {String} template_id The template's ID.
      * @param {module:model/ValidateSubmissionRequest} body The submission's data and settings.
      * @param {Object} opts Optional parameters
-     * @param {String} [version] The template version to use: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `latest` (the draft when no version has been published).
+     * @param {String} [version] The template version to use: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `latest`.
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/SubmissionValidation} and HTTP response
      */
   }, {
@@ -2868,7 +3971,9 @@ var Client = exports["default"] = /*#__PURE__*/function () {
       var queryParams = {
         'version': opts['version']
       };
-      var headerParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
       var formParams = {};
       var authNames = ['api_token_basic'];
       var contentTypes = ['application/json'];
@@ -2883,7 +3988,8 @@ var Client = exports["default"] = /*#__PURE__*/function () {
      * @param {String} template_id The template's ID.
      * @param {module:model/ValidateSubmissionRequest} body The submission's data and settings.
      * @param {Object} opts Optional parameters
-     * @param {String} opts.version The template version to use: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` or `draft`. Default `latest` (the draft when no version has been published).
+     * @param {String} opts.version The template version to use: a published version (`1.2.0`, or `1` for the latest 1.x.x), `latest` (the newest published version, or the draft when none has been published) or `draft`. Default `latest`.
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
      * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/SubmissionValidation}
      */
   }, {
@@ -2893,5 +3999,53 @@ var Client = exports["default"] = /*#__PURE__*/function () {
         return response_and_data.data;
       });
     }
+
+    /**
+     * Verify an email domain
+     * Checks the email domain's DNS records now, instead of waiting for the next check. If DocSpring has stopped looking for its DKIM records (3 days after they were created), it starts again with new ones: replace the CNAME records with them. 
+     * @param {String} email_domain_id The email domain's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} [idempotencyKey] A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with an object containing data of type {@link module:model/EmailDomain} and HTTP response
+     */
+  }, {
+    key: "verifyEmailDomainWithHttpInfo",
+    value: function verifyEmailDomainWithHttpInfo(email_domain_id, opts) {
+      opts = opts || {};
+      var postBody = null;
+      // verify the required parameter 'email_domain_id' is set
+      if (email_domain_id === undefined || email_domain_id === null) {
+        throw new Error("Missing the required parameter 'email_domain_id' when calling verifyEmailDomain");
+      }
+      var pathParams = {
+        'email_domain_id': email_domain_id
+      };
+      var queryParams = {};
+      var headerParams = {
+        'Idempotency-Key': opts['idempotencyKey']
+      };
+      var formParams = {};
+      var authNames = ['api_token_basic'];
+      var contentTypes = [];
+      var accepts = ['application/json'];
+      var returnType = _EmailDomain["default"];
+      return this.apiClient.callApi('/email_domains/{email_domain_id}/verify', 'POST', pathParams, queryParams, headerParams, formParams, postBody, authNames, contentTypes, accepts, returnType, null);
+    }
+
+    /**
+     * Verify an email domain
+     * Checks the email domain's DNS records now, instead of waiting for the next check. If DocSpring has stopped looking for its DKIM records (3 days after they were created), it starts again with new ones: replace the CNAME records with them. 
+     * @param {String} email_domain_id The email domain's ID.
+     * @param {Object} opts Optional parameters
+     * @param {String} opts.idempotencyKey A key of your own, such as a UUID, that makes it safe to send this request again: for 24 hours, DocSpring answers a request with the same key from the same API token with the first request's response (and an `Idempotent-Replayed: true` header) instead of processing it again. Send a new key with each new request, and the same key each time you send the same request again, such as after a timeout, a network error or a 5xx. The same key with a different request is a 422 `idempotency_key_reused`. A 409 `idempotency_key_in_use` with a `Retry-After` header means the first request is still being processed: send the request again then.
+     * @return {Promise} a {@link https://www.promisejs.org/|Promise}, with data of type {@link module:model/EmailDomain}
+     */
+  }, {
+    key: "verifyEmailDomain",
+    value: function verifyEmailDomain(email_domain_id, opts) {
+      return this.verifyEmailDomainWithHttpInfo(email_domain_id, opts).then(function (response_and_data) {
+        return response_and_data.data;
+      });
+    }
   }]);
 }();