• Home
• com.docusign
• docusign-esign-java
• 4.4.0
• source code
• EnvelopesApi.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

com.docusign.esign.api.EnvelopesApi Maven / Gradle / Ivy

package com.docusign.esign.api;

import com.docusign.esign.client.ApiClient;
import com.docusign.esign.client.ApiException;
import com.docusign.esign.client.ApiResponse;
import com.docusign.esign.client.Configuration;
import com.docusign.esign.client.Pair;
import com.docusign.esign.model.*;
import jakarta.ws.rs.core.GenericType;

/** EnvelopesApi class. */
public class EnvelopesApi {
  private ApiClient apiClient;

  /** EnvelopesApi. */
  public EnvelopesApi() {
    this(Configuration.getDefaultApiClient());
  }

  /** EnvelopesApi. */
  public EnvelopesApi(ApiClient apiClient) {
    this.apiClient = apiClient;
  }

  /**
   * getApiClient Method.
   *
   * @return ApiClient
   */
  public ApiClient getApiClient() {
    return apiClient;
  }

  /** setApiClient Method. */
  public void setApiClient(ApiClient apiClient) {
    this.apiClient = apiClient;
  }

  /// 

  /// Adds templates to an envelope. Adds templates to the specified envelope.
  /// 

  /** ApplyTemplateOptions Class. */
  public class ApplyTemplateOptions {
    private String preserveTemplateRecipient = null;

    /** setPreserveTemplateRecipient method. */
    public void setPreserveTemplateRecipient(String preserveTemplateRecipient) {
      this.preserveTemplateRecipient = preserveTemplateRecipient;
    }

    /**
     * getPreserveTemplateRecipient method.
     *
     * @return String
     */
    public String getPreserveTemplateRecipient() {
      return this.preserveTemplateRecipient;
    }
  }

  /**
   * Adds templates to an envelope.. Adds templates to the specified envelope.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentTemplateList (optional)
   * @return DocumentTemplateList
   */
  public DocumentTemplateList applyTemplate(
      String accountId, String envelopeId, DocumentTemplateList documentTemplateList)
      throws ApiException {
    return applyTemplate(accountId, envelopeId, documentTemplateList, null);
  }

  /**
   * Adds templates to an envelope.. Adds templates to the specified envelope.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentTemplateList (optional)
   * @param options for modifying the method behavior.
   * @return DocumentTemplateList
   * @throws ApiException if fails to make API call
   */
  public DocumentTemplateList applyTemplate(
      String accountId,
      String envelopeId,
      DocumentTemplateList documentTemplateList,
      EnvelopesApi.ApplyTemplateOptions options)
      throws ApiException {
    ApiResponse localVarResponse =
        applyTemplateWithHttpInfo(accountId, envelopeId, documentTemplateList, options);
    return localVarResponse.getData();
  }

  /**
   * Adds templates to an envelope. Adds templates to the specified envelope.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentTemplateList (optional)
   * @param options for modifying the method behavior.
   * @return DocumentTemplateList
   * @throws ApiException if fails to make API call
   */
  public ApiResponse applyTemplateWithHttpInfo(
      String accountId,
      String envelopeId,
      DocumentTemplateList documentTemplateList,
      EnvelopesApi.ApplyTemplateOptions options)
      throws ApiException {
    Object localVarPostBody = documentTemplateList;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling applyTemplate");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling applyTemplate");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/templates"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    if (options != null) {
      localVarQueryParams.addAll(
          apiClient.parameterToPair(
              "preserve_template_recipient", options.preserveTemplateRecipient));
    }

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType =
        new GenericType() {};
    DocumentTemplateList localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }
  /// 

  /// Adds templates to a document in an  envelope. Adds templates to a document in the specified
  // envelope.
  /// 

  /** ApplyTemplateToDocumentOptions Class. */
  public class ApplyTemplateToDocumentOptions {
    private String preserveTemplateRecipient = null;

    /** setPreserveTemplateRecipient method. */
    public void setPreserveTemplateRecipient(String preserveTemplateRecipient) {
      this.preserveTemplateRecipient = preserveTemplateRecipient;
    }

    /**
     * getPreserveTemplateRecipient method.
     *
     * @return String
     */
    public String getPreserveTemplateRecipient() {
      return this.preserveTemplateRecipient;
    }
  }

  /**
   * Adds templates to a document in an envelope.. Adds templates to a document in the specified
   * envelope.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentId The ID of the document being accessed. (required)
   * @param documentTemplateList (optional)
   * @return DocumentTemplateList
   */
  public DocumentTemplateList applyTemplateToDocument(
      String accountId,
      String envelopeId,
      String documentId,
      DocumentTemplateList documentTemplateList)
      throws ApiException {
    return applyTemplateToDocument(accountId, envelopeId, documentId, documentTemplateList, null);
  }

  /**
   * Adds templates to a document in an envelope.. Adds templates to a document in the specified
   * envelope.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentId The ID of the document being accessed. (required)
   * @param documentTemplateList (optional)
   * @param options for modifying the method behavior.
   * @return DocumentTemplateList
   * @throws ApiException if fails to make API call
   */
  public DocumentTemplateList applyTemplateToDocument(
      String accountId,
      String envelopeId,
      String documentId,
      DocumentTemplateList documentTemplateList,
      EnvelopesApi.ApplyTemplateToDocumentOptions options)
      throws ApiException {
    ApiResponse localVarResponse =
        applyTemplateToDocumentWithHttpInfo(
            accountId, envelopeId, documentId, documentTemplateList, options);
    return localVarResponse.getData();
  }

  /**
   * Adds templates to a document in an envelope. Adds templates to a document in the specified
   * envelope.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentId The ID of the document being accessed. (required)
   * @param documentTemplateList (optional)
   * @param options for modifying the method behavior.
   * @return DocumentTemplateList
   * @throws ApiException if fails to make API call
   */
  public ApiResponse applyTemplateToDocumentWithHttpInfo(
      String accountId,
      String envelopeId,
      String documentId,
      DocumentTemplateList documentTemplateList,
      EnvelopesApi.ApplyTemplateToDocumentOptions options)
      throws ApiException {
    Object localVarPostBody = documentTemplateList;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling applyTemplateToDocument");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling applyTemplateToDocument");
    }

    // verify the required parameter 'documentId' is set
    if (documentId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'documentId' when calling applyTemplateToDocument");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/templates"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll("\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()))
            .replaceAll(
                "\\{" + "documentId" + "\\}", apiClient.escapeString(documentId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    if (options != null) {
      localVarQueryParams.addAll(
          apiClient.parameterToPair(
              "preserve_template_recipient", options.preserveTemplateRecipient));
    }

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType =
        new GenericType() {};
    DocumentTemplateList localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Initiate a new ChunkedUpload.. This method initiates a new chunked upload with the first part
   * of the content.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param chunkedUploadRequest (optional)
   * @return ChunkedUploadResponse
   * @throws ApiException if fails to make API call
   */
  public ChunkedUploadResponse createChunkedUpload(
      String accountId, ChunkedUploadRequest chunkedUploadRequest) throws ApiException {
    ApiResponse localVarResponse =
        createChunkedUploadWithHttpInfo(accountId, chunkedUploadRequest);
    return localVarResponse.getData();
  }

  /**
   * Initiate a new ChunkedUpload. This method initiates a new chunked upload with the first part of
   * the content.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param chunkedUploadRequest (optional)
   * @return ChunkedUploadResponse
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createChunkedUploadWithHttpInfo(
      String accountId, ChunkedUploadRequest chunkedUploadRequest) throws ApiException {
    Object localVarPostBody = chunkedUploadRequest;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createChunkedUpload");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/chunked_uploads"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType =
        new GenericType() {};
    ChunkedUploadResponse localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Returns a URL to the authentication view UI.. Returns a URL that allows you to embed the
   * authentication view of the DocuSign UI in your applications.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param consoleViewRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ViewUrl createConsoleView(String accountId, ConsoleViewRequest consoleViewRequest)
      throws ApiException {
    ApiResponse localVarResponse =
        createConsoleViewWithHttpInfo(accountId, consoleViewRequest);
    return localVarResponse.getData();
  }

  /**
   * Returns a URL to the authentication view UI. Returns a URL that allows you to embed the
   * authentication view of the DocuSign UI in your applications.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param consoleViewRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createConsoleViewWithHttpInfo(
      String accountId, ConsoleViewRequest consoleViewRequest) throws ApiException {
    Object localVarPostBody = consoleViewRequest;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createConsoleView");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/views/console"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    ViewUrl localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Returns a URL to the envelope correction UI.. Returns a URL that allows you to embed the
   * envelope correction view of the DocuSign UI in your applications. Important: iFrames should not
   * be used for embedded operations on mobile devices due to screen space issues. For iOS devices
   * DocuSign recommends using a WebView.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param correctViewRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ViewUrl createCorrectView(
      String accountId, String envelopeId, CorrectViewRequest correctViewRequest)
      throws ApiException {
    ApiResponse localVarResponse =
        createCorrectViewWithHttpInfo(accountId, envelopeId, correctViewRequest);
    return localVarResponse.getData();
  }

  /**
   * Returns a URL to the envelope correction UI. Returns a URL that allows you to embed the
   * envelope correction view of the DocuSign UI in your applications. Important: iFrames should not
   * be used for embedded operations on mobile devices due to screen space issues. For iOS devices
   * DocuSign recommends using a WebView.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param correctViewRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createCorrectViewWithHttpInfo(
      String accountId, String envelopeId, CorrectViewRequest correctViewRequest)
      throws ApiException {
    Object localVarPostBody = correctViewRequest;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createCorrectView");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling createCorrectView");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/correct"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    ViewUrl localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Updates envelope custom fields for an envelope.. Updates the envelope custom fields for draft
   * and in-process envelopes. Each custom field used in an envelope must have a unique name.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param customFields (optional)
   * @return CustomFields
   * @throws ApiException if fails to make API call
   */
  public CustomFields createCustomFields(
      String accountId, String envelopeId, CustomFields customFields) throws ApiException {
    ApiResponse localVarResponse =
        createCustomFieldsWithHttpInfo(accountId, envelopeId, customFields);
    return localVarResponse.getData();
  }

  /**
   * Updates envelope custom fields for an envelope. Updates the envelope custom fields for draft
   * and in-process envelopes. Each custom field used in an envelope must have a unique name.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param customFields (optional)
   * @return CustomFields
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createCustomFieldsWithHttpInfo(
      String accountId, String envelopeId, CustomFields customFields) throws ApiException {
    Object localVarPostBody = customFields;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createCustomFields");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling createCustomFields");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    CustomFields localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Creates custom document fields in an existing envelope document.. Creates custom document
   * fields in an existing envelope document.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentId The ID of the document being accessed. (required)
   * @param documentFieldsInformation (optional)
   * @return DocumentFieldsInformation
   * @throws ApiException if fails to make API call
   */
  public DocumentFieldsInformation createDocumentFields(
      String accountId,
      String envelopeId,
      String documentId,
      DocumentFieldsInformation documentFieldsInformation)
      throws ApiException {
    ApiResponse localVarResponse =
        createDocumentFieldsWithHttpInfo(
            accountId, envelopeId, documentId, documentFieldsInformation);
    return localVarResponse.getData();
  }

  /**
   * Creates custom document fields in an existing envelope document. Creates custom document fields
   * in an existing envelope document.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentId The ID of the document being accessed. (required)
   * @param documentFieldsInformation (optional)
   * @return DocumentFieldsInformation
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createDocumentFieldsWithHttpInfo(
      String accountId,
      String envelopeId,
      String documentId,
      DocumentFieldsInformation documentFieldsInformation)
      throws ApiException {
    Object localVarPostBody = documentFieldsInformation;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createDocumentFields");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling createDocumentFields");
    }

    // verify the required parameter 'documentId' is set
    if (documentId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'documentId' when calling createDocumentFields");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll("\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()))
            .replaceAll(
                "\\{" + "documentId" + "\\}", apiClient.escapeString(documentId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType =
        new GenericType() {};
    DocumentFieldsInformation localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Get Responsive HTML Preview for a document in an envelope.. Creates a preview of the
   * [responsive](/docs/esign-rest-api/esign101/concepts/responsive/) HTML version of a specific
   * document. This method enables you to preview a PDF document conversion to responsive HTML
   * across device types prior to sending. The request body is a `documentHtmlDefinition`
   * object, which holds the responsive signing parameters that define how to generate the HTML
   * version of the signing document.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentId The ID of the document being accessed. (required)
   * @param documentHtmlDefinition (optional)
   * @return DocumentHtmlDefinitions
   * @throws ApiException if fails to make API call
   */
  public DocumentHtmlDefinitions createDocumentResponsiveHtmlPreview(
      String accountId,
      String envelopeId,
      String documentId,
      DocumentHtmlDefinition documentHtmlDefinition)
      throws ApiException {
    ApiResponse localVarResponse =
        createDocumentResponsiveHtmlPreviewWithHttpInfo(
            accountId, envelopeId, documentId, documentHtmlDefinition);
    return localVarResponse.getData();
  }

  /**
   * Get Responsive HTML Preview for a document in an envelope. Creates a preview of the
   * [responsive](/docs/esign-rest-api/esign101/concepts/responsive/) HTML version of a specific
   * document. This method enables you to preview a PDF document conversion to responsive HTML
   * across device types prior to sending. The request body is a `documentHtmlDefinition`
   * object, which holds the responsive signing parameters that define how to generate the HTML
   * version of the signing document.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentId The ID of the document being accessed. (required)
   * @param documentHtmlDefinition (optional)
   * @return DocumentHtmlDefinitions
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createDocumentResponsiveHtmlPreviewWithHttpInfo(
      String accountId,
      String envelopeId,
      String documentId,
      DocumentHtmlDefinition documentHtmlDefinition)
      throws ApiException {
    Object localVarPostBody = documentHtmlDefinition;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'accountId' when calling createDocumentResponsiveHtmlPreview");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'envelopeId' when calling createDocumentResponsiveHtmlPreview");
    }

    // verify the required parameter 'documentId' is set
    if (documentId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'documentId' when calling createDocumentResponsiveHtmlPreview");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/responsive_html_preview"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll("\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()))
            .replaceAll(
                "\\{" + "documentId" + "\\}", apiClient.escapeString(documentId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType =
        new GenericType() {};
    DocumentHtmlDefinitions localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Adds the tabs to an envelope document. Adds tabs to the document specified by
   * `documentId` in the envelope specified by `envelopeId`. In the request
   * body, you only need to specify the tabs that your are adding. For example, to add a text
   * [prefill
   * tab](/docs/esign-rest-api/reference/envelopes/envelopedocumenttabs/create/#definition__tabs_prefilltabs),
   * your request body might look like this: ``` { \"prefillTabs\": {
   * \"textTabs\": [ { \"value\": \"a prefill text tab\",
   * \"pageNumber\": \"1\", \"documentId\": \"1\",
   * \"xPosition\": 316, \"yPosition\": 97 } ] } } ```
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentId The ID of the document being accessed. (required)
   * @param tabs (optional)
   * @return Tabs
   * @throws ApiException if fails to make API call
   */
  public Tabs createDocumentTabs(String accountId, String envelopeId, String documentId, Tabs tabs)
      throws ApiException {
    ApiResponse localVarResponse =
        createDocumentTabsWithHttpInfo(accountId, envelopeId, documentId, tabs);
    return localVarResponse.getData();
  }

  /**
   * Adds the tabs to an envelope document Adds tabs to the document specified by
   * `documentId` in the envelope specified by `envelopeId`. In the request
   * body, you only need to specify the tabs that your are adding. For example, to add a text
   * [prefill
   * tab](/docs/esign-rest-api/reference/envelopes/envelopedocumenttabs/create/#definition__tabs_prefilltabs),
   * your request body might look like this: ``` { \"prefillTabs\": {
   * \"textTabs\": [ { \"value\": \"a prefill text tab\",
   * \"pageNumber\": \"1\", \"documentId\": \"1\",
   * \"xPosition\": 316, \"yPosition\": 97 } ] } } ```
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentId The ID of the document being accessed. (required)
   * @param tabs (optional)
   * @return Tabs
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createDocumentTabsWithHttpInfo(
      String accountId, String envelopeId, String documentId, Tabs tabs) throws ApiException {
    Object localVarPostBody = tabs;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createDocumentTabs");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling createDocumentTabs");
    }

    // verify the required parameter 'documentId' is set
    if (documentId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'documentId' when calling createDocumentTabs");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/tabs"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll("\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()))
            .replaceAll(
                "\\{" + "documentId" + "\\}", apiClient.escapeString(documentId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    Tabs localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Returns a URL to the edit view UI.. Returns a URL that allows you to embed the edit view of the
   * DocuSign UI in your applications. This is a one-time use login token that allows the user to be
   * placed into the DocuSign editing view. Upon sending completion, the user is returned to the
   * return URL provided by the API application. Important: iFrames should not be used for embedded
   * operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends
   * using a WebView.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param returnUrlRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ViewUrl createEditView(
      String accountId, String envelopeId, ReturnUrlRequest returnUrlRequest) throws ApiException {
    ApiResponse localVarResponse =
        createEditViewWithHttpInfo(accountId, envelopeId, returnUrlRequest);
    return localVarResponse.getData();
  }

  /**
   * Returns a URL to the edit view UI. Returns a URL that allows you to embed the edit view of the
   * DocuSign UI in your applications. This is a one-time use login token that allows the user to be
   * placed into the DocuSign editing view. Upon sending completion, the user is returned to the
   * return URL provided by the API application. Important: iFrames should not be used for embedded
   * operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends
   * using a WebView.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param returnUrlRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createEditViewWithHttpInfo(
      String accountId, String envelopeId, ReturnUrlRequest returnUrlRequest) throws ApiException {
    Object localVarPostBody = returnUrlRequest;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createEditView");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling createEditView");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/edit"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    ViewUrl localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Adds email setting overrides to an envelope.. Adds email override settings, changing the email
   * address to reply to an email address, name, or the BCC for email archive information, for the
   * envelope. Note that adding email settings will only affect email communications that occur
   * after the addition was made. ### Important: The BCC Email address feature is designed to
   * provide a copy of all email communications for external archiving purposes. DocuSign recommends
   * that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override
   * option, include additional signer authentication options. To send a copy of the envelope to a
   * recipient who does not need to sign, use a Carbon Copies or Certified Deliveries Recipient
   * Type.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param emailSettings (optional)
   * @return EmailSettings
   * @throws ApiException if fails to make API call
   */
  public EmailSettings createEmailSettings(
      String accountId, String envelopeId, EmailSettings emailSettings) throws ApiException {
    ApiResponse localVarResponse =
        createEmailSettingsWithHttpInfo(accountId, envelopeId, emailSettings);
    return localVarResponse.getData();
  }

  /**
   * Adds email setting overrides to an envelope. Adds email override settings, changing the email
   * address to reply to an email address, name, or the BCC for email archive information, for the
   * envelope. Note that adding email settings will only affect email communications that occur
   * after the addition was made. ### Important: The BCC Email address feature is designed to
   * provide a copy of all email communications for external archiving purposes. DocuSign recommends
   * that envelopes sent using the BCC for Email Archive feature, including the BCC Email Override
   * option, include additional signer authentication options. To send a copy of the envelope to a
   * recipient who does not need to sign, use a Carbon Copies or Certified Deliveries Recipient
   * Type.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param emailSettings (optional)
   * @return EmailSettings
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createEmailSettingsWithHttpInfo(
      String accountId, String envelopeId, EmailSettings emailSettings) throws ApiException {
    Object localVarPostBody = emailSettings;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createEmailSettings");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling createEmailSettings");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/email_settings"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    EmailSettings localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }
  /// 

  /// Creates an envelope. Creates an envelope.   Using this function you can: * Create an envelope
  // and send it. * Create an envelope from an existing template and send it.  In either case, you
  // can choose to save the envelope as a draft envelope instead of sending it by setting the
  // request's `status` property to `created` instead of `sent`.
  // ## Sending Envelopes  Documents can be included with the Envelopes::create call itself or a
  // template can include documents. Documents can be added by using a multi-part/form request or by
  // using the `documentBase64` field of the [`document`
  // object](#/definitions/document)  ### Recipient Types An [`envelopeDefinition`
  // object](#/definitions/envelopeDefinition) is used as the method's body. Envelope recipients
  // can be defined in the envelope or in templates. The `envelopeDefinition` object's
  // `recipients` field is an [`EnvelopeRecipients` resource
  // object](#/definitions/EnvelopeRecipients). It includes arrays of the seven types of recipients
  // defined by DocuSign:  Recipient type | Object definition -------------- | -----------------
  // agent (can add name and email information for later recipients/signers) |
  // [`agent`](#/definitions/agent) carbon copy (receives a copy of the documents) |
  // [`carbonCopy`](#/definitions/carbonCopy) certified delivery  (receives a copy of the
  // documents and must acknowledge receipt) |
  // [`certifiedDelivery`](#/definitions/certifiedDelivery) editor (can change recipients
  // and document fields for later recipients/signers) | [`editor`](#/definitions/editor)
  // in-person signer (\"hosts\" someone who signs in-person) |
  // [`inPersonSigner`](#/definitions/inPersonSigner) intermediary (can add name and email
  // information for some later recipients/signers.) |
  // [`intermediary`](#/definitions/intermediary) signer (signs and/or updates document
  // fields) | [`signer`](#/definitions/signer)  Additional information about the
  // different types of recipients is available from the [`EnvelopeRecipients` resource
  // page](../../EnvelopeRecipients) and from the [Developer
  // Center](https://www.docusign.com/developer-center/explore/features/recipients)  ### Tabs Tabs
  // (also referred to as `tags` and as `fields` in the web sending user
  // interface), can be defined in the `envelopeDefinition`, in templates, by transforming
  // PDF Form Fields, or by using Composite Templates (see below).  Defining tabs: the
  // `inPersonSigner`, and `signer` recipient objects include a `tabs`
  // field. It is an [`EnvelopeTabs` resource object](#/definitions/EnvelopeTabs). It
  // includes arrays of the 24 different tab types available. See the [`EnvelopeTabs`
  // resource](../../EnvelopeTabs) for more information.  ## Using Templates Envelopes use specific
  // people or groups as recipients. Templates can specify a role, eg `account_manager.`
  // When a template is used in an envelope, the roles must be replaced with specific people or
  // groups.  When you create an envelope using a `templateId`, the different recipient
  // type objects within the [`EnvelopeRecipients`
  // object](#/definitions/EnvelopeRecipients) are used to assign recipients to the template's
  // roles via the `roleName` property. The recipient objects can also override settings
  // that were specified in the template, and set values for tab fields that were defined in the
  // template.  ### Message Lock When a template is added or applied to an envelope and the template
  // has a locked email subject and message, that subject and message are used for the envelope and
  // cannot be changed even if another locked template is subsequently added or applied to the
  // envelope. The field `messageLock` is used to lock the email subject and message.  If
  // an email subject or message is entered before adding or applying a template with
  // `messageLock` **true**, the email subject and message is overwritten with the locked
  // email subject and message from the template.  ## Envelope Status The status of sent envelopes
  // can be determined through the DocuSign webhook system or by polling. Webhooks are highly
  // recommended: they provide your application with the quickest updates when an envelope's
  // status changes. DocuSign limits polling to once every 15 minutes or less frequently.  When a
  // webhook is used, DocuSign calls your application, via the URL you provide, with a notification
  // XML message.   See the [Webhook
  // recipe](https://www.docusign.com/developer-center/recipes/webhook-status) for examples and live
  // demos of using webhooks.  ## Webhook Options The two webhook options, *eventNotification* and
  // *Connect* use the same notification mechanism and message formats. eventNotification is used to
  // create a webhook for a specific envelope sent via the API. Connect webhooks can be used for any
  // envelope sent from an account, from any user, from any client.   ### eventNotification Webhooks
  // The Envelopes::create method includes an optional [eventNotification
  // object](#definition-eventNotification) that adds a webhook to the envelope. eventNotification
  // webhooks are available for all DocuSign accounts with API access.  ### Connect Webhooks Connect
  // can be used to create a webhook for all envelopes sent by all users in an account, either
  // through the API or via other DocuSign clients (web, mobile, etc). Connect configurations are
  // independent of specific envelopes. A Connect configuration includes a filter that may be used
  // to limit the webhook to specific users, envelope statuses, etc.   Connect configurations may be
  // created and managed using the [ConnectConfigurations
  // resource](../../Connect/ConnectConfigurations). Configurations can also be created and managed
  // from the Administration tool accessed by selecting \"Go to Admin\" from the menu next
  // to your picture on the DocuSign web app. See the Integrations/Connect section of the Admin
  // tool. For repeatability, and to minimize support questions, creating Connect configurations via
  // the API is recommended, especially for ISVs.  Connect is available for some DocuSign account
  // types. Please contact DocuSign Sales for more information.  ## Composite Templates  The
  // Composite Templates feature, like [compositing in film
  // production](https://en.wikipedia.org/wiki/Compositing), enables you to *overlay* document,
  // recipient, and tab definitions from multiple sources, including PDF Form Field definitions,
  // templates defined on the server, and more.  Each Composite Template consists of optional
  // elements: server templates, inline templates, PDF Metadata templates, and documents.  * The
  // Composite Template ID is an optional element used to identify the composite template. It is
  // used as a reference when adding document object information via a multi-part HTTP message. If
  // used, the document content-disposition must include the `compositeTemplateId` to
  // which the document should be added. If `compositeTemplateId` is not specified in the
  // content-disposition, the document is applied based on the `documentId` only. If no
  // document object is specified, the composite template inherits the first document.  * Server
  // Templates are server-side templates stored on the DocuSign platform. If supplied, they are
  // overlaid into the envelope in the order of their Sequence value.  * Inline Templates provide a
  // container to add documents, recipients, tabs, and custom fields. If inline templates are
  // supplied, they are overlaid into the envelope in the order of their Sequence value.  * Document
  // objects are optional structures that provide a container to pass in a document or form. If this
  // object is not included, the composite template inherits the *first* document it finds from a
  // server template or inline template, starting with the lowest sequence value.  PDF Form objects
  // are only transformed from the document object. DocuSign does not derive PDF form properties
  // from server templates or inline templates. To instruct DocuSign to transform fields from the
  // PDF form, set `transformPdfFields` to \"true\" for the document. See the
  // Transform PDF Fields section for more information about process.  * PDF Metadata Templates
  // provide a container to embed design-time template information into a PDF document. DocuSign
  // uses this information when processing the Envelope. This convention allows the document to
  // carry the signing instructions with it, so that less information needs to be provided at
  // run-time through an inline template or synchronized with an external structure like a server
  // template. PDF Metadata templates are stored in the Metadata layer of a PDF in accordance with
  // Acrobat's XMP specification. DocuSign will only find PDF Metadata templates inside
  // documents passed in the Document object (see below). If supplied, the PDF metadata template
  // will be overlaid into the envelope in the order of its Sequence value.  ### Compositing the
  // definitions Each Composite Template adds a new document and templates overlay into the
  // envelope. For each Composite Template these rules are applied:  * Templates are overlaid in the
  // order of their Sequence value. * If Document is not passed into the Composite Template's
  // `document` field, the *first* template's document (based on the template's
  // Sequence value) is used. * Last in wins in all cases except for the document (i.e. envelope
  // information, recipient information, secure field information). There is no special casing.  For
  // example, if you want higher security on a tab, then that needs to be specified in a later
  // template (by sequence number) then where the tab is included. If you want higher security on a
  // role recipient, then it needs to be in a later template then where that role recipient is
  // specified.  * Recipient matching is based on Recipient Role and Routing Order. If there are
  // matches, the recipient information is merged together. A final pass is done on all Composite
  // Templates, after all template overlays have been applied, to collapse recipients with the same
  // email, username and routing order. This prevents having the same recipients at the same routing
  // order.  * If you specify in a template that a recipient is locked, once that recipient is
  // overlaid the recipient attributes can no longer be changed. The only items that can be changed
  // for the recipient in this case are the email, username, access code and
  // IDCheckInformationInput.  * Tab matching is based on Tab Labels, Tab Types and Documents. If a
  // Tab Label matches but the Document is not supplied, the Tab is overlaid for all the Documents.
  // For example, if you have a simple inline template with only one tab in it with a label and a
  // value, the Signature, Initial, Company, Envelope ID, User Name tabs will only be matched and
  // collapsed if they fall in the exact same X and Y locations.  * roleName and tabLabel matching
  // is case sensitive.  * The defaultRecipient field enables you to specify which recipient the
  // generated tabs from a PDF form are mapped to. You can also set PDF form generated tabs to a
  // recipient other than the DefaultRecipient by specifying the mapping of the tab label that is
  // created to one of the template recipients.  * You can use tabLabel wild carding to map a series
  // of tabs from the PDF form. To use this you must end a tab label with \"\\*\" and then
  // the system matches tabs that start with the label.  * If no DefaultRecipient is specified, tabs
  // must be explicitly mapped to recipients in order to be generated from the form. Unmapped form
  // objects will not be generated into their DocuSign equivalents. (In the case of
  // Signature/Initials, the tabs will be disregarded entirely; in the case of pdf text fields, the
  // field data will be flattened on the Envelope document, but there will not be a corresponding
  // DocuSign data tab.)  ### Including the Document Content for Composite Templates Document
  // content can be supplied inline, using the `documentBase64` or can be included in a
  // multi-part HTTP message.  If a multi-part message is used and there are multiple Composite
  // Templates, the document content-disposition can include the `compositeTemplateId` to
  // which the document should be added. Using the `compositeTemplateId` sets which
  // documents are associated with particular composite templates. An example of this usage is:
  // ```    --5cd3320a-5aac-4453-b3a4-cbb52a4cba5d    Content-Type: application/pdf
  //  Content-Disposition: file; filename=\"eula.pdf\"; documentId=1;
  // compositeTemplateId=\"1\"    Content-Transfer-Encoding: base64
  // ```  ### PDF Form Field Transformation Only the following PDF Form FieldTypes
  // will be transformed to DocuSign tabs: CheckBox, DateTime, ListBox, Numeric, Password, Radio,
  // Signature, and Text  Field Properties that will be transformed: Read Only, Required, Max
  // Length, Positions, and Initial Data.  When transforming a *PDF Form Digital Signature Field,*
  // the following rules are used:  If the PDF Field Name Contains | Then the DocuSign Tab Will be
  // ------- | -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or
  // eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials
  // DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials  Any other PDF Form
  // Digital Signature Field will be transformed to a DocuSign Signature tab  When transforming *PDF
  // Form Text Fields,* the following rules are used:  If the PDF Field Name Contains | Then the
  // DocuSign Tab Will be ------- | -------- DocuSignSignHere or eSignSignHere | Signature
  // DocuSignSignHereOptional or eSignSignHereOptional | Optional Signature DocuSignInitialHere or
  // eSignInitialHere | Initials DocuSignInitialHereOptional or eSignInitialHereOptional | Optional
  // Initials DocuSignEnvelopeID or eSignEnvelopeID | EnvelopeID DocuSignCompany or eSignCompany |
  // Company DocuSignDateSigned or eSignDateSigned | Date Signed DocuSignTitle or eSignTitle | Title
  // DocuSignFullName or eSignFullName |  Full Name DocuSignSignerAttachmentOptional or
  // eSignSignerAttachmentOptional | Optional Signer Attachment  Any other PDF Form Text Field will
  // be transformed to a DocuSign data (text) tab.  PDF Form Field Names that include
  // \"DocuSignIgnoreTransform\" or \"eSignIgnoreTransform\" will not be
  // transformed.  PDF Form Date fields will be transformed to Date Signed fields if their name
  // includes DocuSignDateSigned or eSignDateSigned.  ## Template Email Subject Merge Fields This
  // feature enables you to insert recipient name and email address merge fields into the email
  // subject line when creating or sending from a template.  The merge fields, based on the
  // recipient's `roleName`, are added to the `emailSubject` when the
  // template is created or when the template is used to create an envelope. After a template sender
  // adds the name and email information for the recipient and sends the envelope, the recipient
  // information is automatically merged into the appropriate fields in the email subject line.
  // Both the sender and the recipients will see the information in the email subject line for any
  // emails associated with the template. This provides an easy way for senders to organize their
  // envelope emails without having to open an envelope to check the recipient.  If merging the
  // recipient information into the subject line causes the subject line to exceed 100 characters,
  // then any characters over the 100 character limit are not included in the subject line. For
  // cases where the recipient name or email is expected to be long, you should consider placing the
  // merge field at the start of the email subject.  * To add a recipient's name in the subject
  // line add the following text in the `emailSubject` when creating the template or when
  // sending an envelope from a template:     [[<roleName>_UserName]]     Example:
  // `\"emailSubject\":\"[[Signer 1_UserName]], Please sign this
  // NDA\",`  * To add a recipient's email address in the subject line add the
  // following text in the emailSubject when creating the template or when sending an envelope from
  // a template:     [[<roleName>_Email]]     Example:
  // `\"emailSubject\":\"[[Signer 1_Email]], Please sign this NDA\",`
  // In both cases the <roleName> is the recipient's `roleName` in the template.
  //  For cases where another recipient (such as an Agent, Editor, or Intermediary recipient) is
  // entering the name and email information for the recipient included in the email subject, then
  // [[<roleName>_UserName]] or [[<roleName>_Email]] is shown in the email subject.  ##
  // Branding an envelope The following rules are used to determine the `brandId` used in
  // an envelope:  * If a `brandId` is specified in the envelope/template and that brandId
  // is available to the account, that brand is used in the envelope. * If more than one template is
  // used in an envelope and more than one `brandId` is specified, the first
  // `brandId` specified is used throughout the envelope. * In cases where no brand is
  // specified and the sender belongs to a Group; if there is only one brand associated with the
  // Group, then that brand is used in the envelope. Otherwise, the account's default signing
  // brand is used. * For envelopes that do not meet any of the previous criteria, the account's
  // default signing brand is used for the envelope.  ## BCC Email address feature  The BCC Email
  // address feature is designed to provide a copy of all email communications for external
  // archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive
  // feature, including the BCC Email Override option, include additional signer authentication
  // options. To send a copy of the envelope to a recipient who does not need to sign, don't use
  // the BCC Email field. Use a Carbon Copy or Certified Delivery Recipient type.  ## Merge
  // Recipient Roles for Draft Envelopes When an envelope with multiple templates is sent, the
  // recipients from the templates are merged according to the template roles, and empty recipients
  // are removed. When creating an envelope with multiple templates, but not sending it (keeping it
  // in a created state), duplicate recipients are not merged, which could cause leave duplicate
  // recipients in the envelope.  To prevent this, the query parameter
  // `merge_roles_on_draft` should be added when posting a draft envelope
  // (status=created) with multiple templates. Doing this will merge template roles and remove
  // empty recipients.  ###### Note: DocuSign recommends that the `merge_roles_on_draft`
  // query parameter be used anytime you are creating an envelope with multiple templates and
  // keeping it in draft (created) status.
  /// 

  /** CreateEnvelopeOptions Class. */
  public class CreateEnvelopeOptions {
    private String cdseMode = null;
    private String changeRoutingOrder = null;
    private String completedDocumentsOnly = null;
    private String mergeRolesOnDraft = null;
    private String tabLabelExactMatches = null;

    /** setCdseMode method. */
    public void setCdseMode(String cdseMode) {
      this.cdseMode = cdseMode;
    }

    /**
     * getCdseMode method.
     *
     * @return String
     */
    public String getCdseMode() {
      return this.cdseMode;
    }

    /** setChangeRoutingOrder method. */
    public void setChangeRoutingOrder(String changeRoutingOrder) {
      this.changeRoutingOrder = changeRoutingOrder;
    }

    /**
     * getChangeRoutingOrder method.
     *
     * @return String
     */
    public String getChangeRoutingOrder() {
      return this.changeRoutingOrder;
    }

    /** setCompletedDocumentsOnly method. */
    public void setCompletedDocumentsOnly(String completedDocumentsOnly) {
      this.completedDocumentsOnly = completedDocumentsOnly;
    }

    /**
     * getCompletedDocumentsOnly method.
     *
     * @return String
     */
    public String getCompletedDocumentsOnly() {
      return this.completedDocumentsOnly;
    }

    /** setMergeRolesOnDraft method. */
    public void setMergeRolesOnDraft(String mergeRolesOnDraft) {
      this.mergeRolesOnDraft = mergeRolesOnDraft;
    }

    /**
     * getMergeRolesOnDraft method.
     *
     * @return String
     */
    public String getMergeRolesOnDraft() {
      return this.mergeRolesOnDraft;
    }

    /** setTabLabelExactMatches method. */
    public void setTabLabelExactMatches(String tabLabelExactMatches) {
      this.tabLabelExactMatches = tabLabelExactMatches;
    }

    /**
     * getTabLabelExactMatches method.
     *
     * @return String
     */
    public String getTabLabelExactMatches() {
      return this.tabLabelExactMatches;
    }
  }

  /**
   * Creates an envelope.. Creates an envelope. Using this function you can: * Create an envelope
   * and send it. * Create an envelope from an existing template and send it. In either case, you
   * can choose to save the envelope as a draft envelope instead of sending it by setting the
   * request's `status` property to `created` instead of `sent`.
   * ## Sending Envelopes Documents can be included with the Envelopes::create call itself or a
   * template can include documents. Documents can be added by using a multi-part/form request or by
   * using the `documentBase64` field of the [`document`
   * object](#/definitions/document) ### Recipient Types An [`envelopeDefinition`
   * object](#/definitions/envelopeDefinition) is used as the method's body. Envelope recipients
   * can be defined in the envelope or in templates. The `envelopeDefinition` object's
   * `recipients` field is an [`EnvelopeRecipients` resource
   * object](#/definitions/EnvelopeRecipients). It includes arrays of the seven types of recipients
   * defined by DocuSign: Recipient type | Object definition -------------- | -----------------
   * agent (can add name and email information for later recipients/signers) |
   * [`agent`](#/definitions/agent) carbon copy (receives a copy of the documents) |
   * [`carbonCopy`](#/definitions/carbonCopy) certified delivery (receives a copy of the
   * documents and must acknowledge receipt) |
   * [`certifiedDelivery`](#/definitions/certifiedDelivery) editor (can change recipients
   * and document fields for later recipients/signers) | [`editor`](#/definitions/editor)
   * in-person signer (\"hosts\" someone who signs in-person) |
   * [`inPersonSigner`](#/definitions/inPersonSigner) intermediary (can add name and email
   * information for some later recipients/signers.) |
   * [`intermediary`](#/definitions/intermediary) signer (signs and/or updates document
   * fields) | [`signer`](#/definitions/signer) Additional information about the different
   * types of recipients is available from the [`EnvelopeRecipients` resource
   * page](../../EnvelopeRecipients) and from the [Developer
   * Center](https://www.docusign.com/developer-center/explore/features/recipients) ### Tabs Tabs
   * (also referred to as `tags` and as `fields` in the web sending user
   * interface), can be defined in the `envelopeDefinition`, in templates, by transforming
   * PDF Form Fields, or by using Composite Templates (see below). Defining tabs: the
   * `inPersonSigner`, and `signer` recipient objects include a `tabs`
   * field. It is an [`EnvelopeTabs` resource object](#/definitions/EnvelopeTabs). It
   * includes arrays of the 24 different tab types available. See the [`EnvelopeTabs`
   * resource](../../EnvelopeTabs) for more information. ## Using Templates Envelopes use specific
   * people or groups as recipients. Templates can specify a role, eg `account_manager.`
   * When a template is used in an envelope, the roles must be replaced with specific people or
   * groups. When you create an envelope using a `templateId`, the different recipient
   * type objects within the [`EnvelopeRecipients`
   * object](#/definitions/EnvelopeRecipients) are used to assign recipients to the template's
   * roles via the `roleName` property. The recipient objects can also override settings
   * that were specified in the template, and set values for tab fields that were defined in the
   * template. ### Message Lock When a template is added or applied to an envelope and the template
   * has a locked email subject and message, that subject and message are used for the envelope and
   * cannot be changed even if another locked template is subsequently added or applied to the
   * envelope. The field `messageLock` is used to lock the email subject and message. If
   * an email subject or message is entered before adding or applying a template with
   * `messageLock` **true**, the email subject and message is overwritten with the locked
   * email subject and message from the template. ## Envelope Status The status of sent envelopes
   * can be determined through the DocuSign webhook system or by polling. Webhooks are highly
   * recommended: they provide your application with the quickest updates when an envelope's
   * status changes. DocuSign limits polling to once every 15 minutes or less frequently. When a
   * webhook is used, DocuSign calls your application, via the URL you provide, with a notification
   * XML message. See the [Webhook
   * recipe](https://www.docusign.com/developer-center/recipes/webhook-status) for examples and live
   * demos of using webhooks. ## Webhook Options The two webhook options, *eventNotification* and
   * *Connect* use the same notification mechanism and message formats. eventNotification is used to
   * create a webhook for a specific envelope sent via the API. Connect webhooks can be used for any
   * envelope sent from an account, from any user, from any client. ### eventNotification Webhooks
   * The Envelopes::create method includes an optional [eventNotification
   * object](#definition-eventNotification) that adds a webhook to the envelope. eventNotification
   * webhooks are available for all DocuSign accounts with API access. ### Connect Webhooks Connect
   * can be used to create a webhook for all envelopes sent by all users in an account, either
   * through the API or via other DocuSign clients (web, mobile, etc). Connect configurations are
   * independent of specific envelopes. A Connect configuration includes a filter that may be used
   * to limit the webhook to specific users, envelope statuses, etc. Connect configurations may be
   * created and managed using the [ConnectConfigurations
   * resource](../../Connect/ConnectConfigurations). Configurations can also be created and managed
   * from the Administration tool accessed by selecting \"Go to Admin\" from the menu next
   * to your picture on the DocuSign web app. See the Integrations/Connect section of the Admin
   * tool. For repeatability, and to minimize support questions, creating Connect configurations via
   * the API is recommended, especially for ISVs. Connect is available for some DocuSign account
   * types. Please contact DocuSign Sales for more information. ## Composite Templates The Composite
   * Templates feature, like [compositing in film
   * production](https://en.wikipedia.org/wiki/Compositing), enables you to *overlay* document,
   * recipient, and tab definitions from multiple sources, including PDF Form Field definitions,
   * templates defined on the server, and more. Each Composite Template consists of optional
   * elements: server templates, inline templates, PDF Metadata templates, and documents. * The
   * Composite Template ID is an optional element used to identify the composite template. It is
   * used as a reference when adding document object information via a multi-part HTTP message. If
   * used, the document content-disposition must include the `compositeTemplateId` to
   * which the document should be added. If `compositeTemplateId` is not specified in the
   * content-disposition, the document is applied based on the `documentId` only. If no
   * document object is specified, the composite template inherits the first document. * Server
   * Templates are server-side templates stored on the DocuSign platform. If supplied, they are
   * overlaid into the envelope in the order of their Sequence value. * Inline Templates provide a
   * container to add documents, recipients, tabs, and custom fields. If inline templates are
   * supplied, they are overlaid into the envelope in the order of their Sequence value. * Document
   * objects are optional structures that provide a container to pass in a document or form. If this
   * object is not included, the composite template inherits the *first* document it finds from a
   * server template or inline template, starting with the lowest sequence value. PDF Form objects
   * are only transformed from the document object. DocuSign does not derive PDF form properties
   * from server templates or inline templates. To instruct DocuSign to transform fields from the
   * PDF form, set `transformPdfFields` to \"true\" for the document. See the
   * Transform PDF Fields section for more information about process. * PDF Metadata Templates
   * provide a container to embed design-time template information into a PDF document. DocuSign
   * uses this information when processing the Envelope. This convention allows the document to
   * carry the signing instructions with it, so that less information needs to be provided at
   * run-time through an inline template or synchronized with an external structure like a server
   * template. PDF Metadata templates are stored in the Metadata layer of a PDF in accordance with
   * Acrobat's XMP specification. DocuSign will only find PDF Metadata templates inside
   * documents passed in the Document object (see below). If supplied, the PDF metadata template
   * will be overlaid into the envelope in the order of its Sequence value. ### Compositing the
   * definitions Each Composite Template adds a new document and templates overlay into the
   * envelope. For each Composite Template these rules are applied: * Templates are overlaid in the
   * order of their Sequence value. * If Document is not passed into the Composite Template's
   * `document` field, the *first* template's document (based on the template's
   * Sequence value) is used. * Last in wins in all cases except for the document (i.e. envelope
   * information, recipient information, secure field information). There is no special casing. For
   * example, if you want higher security on a tab, then that needs to be specified in a later
   * template (by sequence number) then where the tab is included. If you want higher security on a
   * role recipient, then it needs to be in a later template then where that role recipient is
   * specified. * Recipient matching is based on Recipient Role and Routing Order. If there are
   * matches, the recipient information is merged together. A final pass is done on all Composite
   * Templates, after all template overlays have been applied, to collapse recipients with the same
   * email, username and routing order. This prevents having the same recipients at the same routing
   * order. * If you specify in a template that a recipient is locked, once that recipient is
   * overlaid the recipient attributes can no longer be changed. The only items that can be changed
   * for the recipient in this case are the email, username, access code and
   * IDCheckInformationInput. * Tab matching is based on Tab Labels, Tab Types and Documents. If a
   * Tab Label matches but the Document is not supplied, the Tab is overlaid for all the Documents.
   * For example, if you have a simple inline template with only one tab in it with a label and a
   * value, the Signature, Initial, Company, Envelope ID, User Name tabs will only be matched and
   * collapsed if they fall in the exact same X and Y locations. * roleName and tabLabel matching is
   * case sensitive. * The defaultRecipient field enables you to specify which recipient the
   * generated tabs from a PDF form are mapped to. You can also set PDF form generated tabs to a
   * recipient other than the DefaultRecipient by specifying the mapping of the tab label that is
   * created to one of the template recipients. * You can use tabLabel wild carding to map a series
   * of tabs from the PDF form. To use this you must end a tab label with \"\\*\" and then
   * the system matches tabs that start with the label. * If no DefaultRecipient is specified, tabs
   * must be explicitly mapped to recipients in order to be generated from the form. Unmapped form
   * objects will not be generated into their DocuSign equivalents. (In the case of
   * Signature/Initials, the tabs will be disregarded entirely; in the case of pdf text fields, the
   * field data will be flattened on the Envelope document, but there will not be a corresponding
   * DocuSign data tab.) ### Including the Document Content for Composite Templates Document content
   * can be supplied inline, using the `documentBase64` or can be included in a multi-part
   * HTTP message. If a multi-part message is used and there are multiple Composite Templates, the
   * document content-disposition can include the `compositeTemplateId` to which the
   * document should be added. Using the `compositeTemplateId` sets which documents are
   * associated with particular composite templates. An example of this usage is: ```
   * --5cd3320a-5aac-4453-b3a4-cbb52a4cba5d Content-Type: application/pdf Content-Disposition: file;
   * filename=\"eula.pdf\"; documentId=1;
   * compositeTemplateId=\"1\" Content-Transfer-Encoding: base64 ```
   * ### PDF Form Field Transformation Only the following PDF Form FieldTypes will be transformed to
   * DocuSign tabs: CheckBox, DateTime, ListBox, Numeric, Password, Radio, Signature, and Text Field
   * Properties that will be transformed: Read Only, Required, Max Length, Positions, and Initial
   * Data. When transforming a *PDF Form Digital Signature Field,* the following rules are used: If
   * the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere
   * or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional
   * Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or
   * eSignInitialHereOptional | Optional Initials Any other PDF Form Digital Signature Field will be
   * transformed to a DocuSign Signature tab When transforming *PDF Form Text Fields,* the following
   * rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- |
   * -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or
   * eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials
   * DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials DocuSignEnvelopeID
   * or eSignEnvelopeID | EnvelopeID DocuSignCompany or eSignCompany | Company DocuSignDateSigned or
   * eSignDateSigned | Date Signed DocuSignTitle or eSignTitle | Title DocuSignFullName or
   * eSignFullName | Full Name DocuSignSignerAttachmentOptional or eSignSignerAttachmentOptional |
   * Optional Signer Attachment Any other PDF Form Text Field will be transformed to a DocuSign data
   * (text) tab. PDF Form Field Names that include \"DocuSignIgnoreTransform\" or
   * \"eSignIgnoreTransform\" will not be transformed. PDF Form Date fields will be
   * transformed to Date Signed fields if their name includes DocuSignDateSigned or eSignDateSigned.
   * ## Template Email Subject Merge Fields This feature enables you to insert recipient name and
   * email address merge fields into the email subject line when creating or sending from a
   * template. The merge fields, based on the recipient's `roleName`, are added to the
   * `emailSubject` when the template is created or when the template is used to create an
   * envelope. After a template sender adds the name and email information for the recipient and
   * sends the envelope, the recipient information is automatically merged into the appropriate
   * fields in the email subject line. Both the sender and the recipients will see the information
   * in the email subject line for any emails associated with the template. This provides an easy
   * way for senders to organize their envelope emails without having to open an envelope to check
   * the recipient. If merging the recipient information into the subject line causes the subject
   * line to exceed 100 characters, then any characters over the 100 character limit are not
   * included in the subject line. For cases where the recipient name or email is expected to be
   * long, you should consider placing the merge field at the start of the email subject. * To add a
   * recipient's name in the subject line add the following text in the `emailSubject`
   * when creating the template or when sending an envelope from a template:
   * [[<roleName>_UserName]] Example: `\"emailSubject\":\"[[Signer
   * 1_UserName]], Please sign this NDA\",` * To add a recipient's email address in
   * the subject line add the following text in the emailSubject when creating the template or when
   * sending an envelope from a template: [[<roleName>_Email]] Example:
   * `\"emailSubject\":\"[[Signer 1_Email]], Please sign this NDA\",`
   * In both cases the <roleName> is the recipient's `roleName` in the template.
   * For cases where another recipient (such as an Agent, Editor, or Intermediary recipient) is
   * entering the name and email information for the recipient included in the email subject, then
   * [[<roleName>_UserName]] or [[<roleName>_Email]] is shown in the email subject. ##
   * Branding an envelope The following rules are used to determine the `brandId` used in
   * an envelope: * If a `brandId` is specified in the envelope/template and that brandId
   * is available to the account, that brand is used in the envelope. * If more than one template is
   * used in an envelope and more than one `brandId` is specified, the first
   * `brandId` specified is used throughout the envelope. * In cases where no brand is
   * specified and the sender belongs to a Group; if there is only one brand associated with the
   * Group, then that brand is used in the envelope. Otherwise, the account's default signing
   * brand is used. * For envelopes that do not meet any of the previous criteria, the account's
   * default signing brand is used for the envelope. ## BCC Email address feature The BCC Email
   * address feature is designed to provide a copy of all email communications for external
   * archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive
   * feature, including the BCC Email Override option, include additional signer authentication
   * options. To send a copy of the envelope to a recipient who does not need to sign, don't use
   * the BCC Email field. Use a Carbon Copy or Certified Delivery Recipient type. ## Merge Recipient
   * Roles for Draft Envelopes When an envelope with multiple templates is sent, the recipients from
   * the templates are merged according to the template roles, and empty recipients are removed.
   * When creating an envelope with multiple templates, but not sending it (keeping it in a created
   * state), duplicate recipients are not merged, which could cause leave duplicate recipients in
   * the envelope. To prevent this, the query parameter `merge_roles_on_draft` should be
   * added when posting a draft envelope (status=created) with multiple templates. Doing this
   * will merge template roles and remove empty recipients. ###### Note: DocuSign recommends that
   * the `merge_roles_on_draft` query parameter be used anytime you are creating an
   * envelope with multiple templates and keeping it in draft (created) status.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeDefinition (optional)
   * @return EnvelopeSummary
   */
  public EnvelopeSummary createEnvelope(String accountId, EnvelopeDefinition envelopeDefinition)
      throws ApiException {
    return createEnvelope(accountId, envelopeDefinition, null);
  }

  /**
   * Creates an envelope.. Creates an envelope. Using this function you can: * Create an envelope
   * and send it. * Create an envelope from an existing template and send it. In either case, you
   * can choose to save the envelope as a draft envelope instead of sending it by setting the
   * request's `status` property to `created` instead of `sent`.
   * ## Sending Envelopes Documents can be included with the Envelopes::create call itself or a
   * template can include documents. Documents can be added by using a multi-part/form request or by
   * using the `documentBase64` field of the [`document`
   * object](#/definitions/document) ### Recipient Types An [`envelopeDefinition`
   * object](#/definitions/envelopeDefinition) is used as the method's body. Envelope recipients
   * can be defined in the envelope or in templates. The `envelopeDefinition` object's
   * `recipients` field is an [`EnvelopeRecipients` resource
   * object](#/definitions/EnvelopeRecipients). It includes arrays of the seven types of recipients
   * defined by DocuSign: Recipient type | Object definition -------------- | -----------------
   * agent (can add name and email information for later recipients/signers) |
   * [`agent`](#/definitions/agent) carbon copy (receives a copy of the documents) |
   * [`carbonCopy`](#/definitions/carbonCopy) certified delivery (receives a copy of the
   * documents and must acknowledge receipt) |
   * [`certifiedDelivery`](#/definitions/certifiedDelivery) editor (can change recipients
   * and document fields for later recipients/signers) | [`editor`](#/definitions/editor)
   * in-person signer (\"hosts\" someone who signs in-person) |
   * [`inPersonSigner`](#/definitions/inPersonSigner) intermediary (can add name and email
   * information for some later recipients/signers.) |
   * [`intermediary`](#/definitions/intermediary) signer (signs and/or updates document
   * fields) | [`signer`](#/definitions/signer) Additional information about the different
   * types of recipients is available from the [`EnvelopeRecipients` resource
   * page](../../EnvelopeRecipients) and from the [Developer
   * Center](https://www.docusign.com/developer-center/explore/features/recipients) ### Tabs Tabs
   * (also referred to as `tags` and as `fields` in the web sending user
   * interface), can be defined in the `envelopeDefinition`, in templates, by transforming
   * PDF Form Fields, or by using Composite Templates (see below). Defining tabs: the
   * `inPersonSigner`, and `signer` recipient objects include a `tabs`
   * field. It is an [`EnvelopeTabs` resource object](#/definitions/EnvelopeTabs). It
   * includes arrays of the 24 different tab types available. See the [`EnvelopeTabs`
   * resource](../../EnvelopeTabs) for more information. ## Using Templates Envelopes use specific
   * people or groups as recipients. Templates can specify a role, eg `account_manager.`
   * When a template is used in an envelope, the roles must be replaced with specific people or
   * groups. When you create an envelope using a `templateId`, the different recipient
   * type objects within the [`EnvelopeRecipients`
   * object](#/definitions/EnvelopeRecipients) are used to assign recipients to the template's
   * roles via the `roleName` property. The recipient objects can also override settings
   * that were specified in the template, and set values for tab fields that were defined in the
   * template. ### Message Lock When a template is added or applied to an envelope and the template
   * has a locked email subject and message, that subject and message are used for the envelope and
   * cannot be changed even if another locked template is subsequently added or applied to the
   * envelope. The field `messageLock` is used to lock the email subject and message. If
   * an email subject or message is entered before adding or applying a template with
   * `messageLock` **true**, the email subject and message is overwritten with the locked
   * email subject and message from the template. ## Envelope Status The status of sent envelopes
   * can be determined through the DocuSign webhook system or by polling. Webhooks are highly
   * recommended: they provide your application with the quickest updates when an envelope's
   * status changes. DocuSign limits polling to once every 15 minutes or less frequently. When a
   * webhook is used, DocuSign calls your application, via the URL you provide, with a notification
   * XML message. See the [Webhook
   * recipe](https://www.docusign.com/developer-center/recipes/webhook-status) for examples and live
   * demos of using webhooks. ## Webhook Options The two webhook options, *eventNotification* and
   * *Connect* use the same notification mechanism and message formats. eventNotification is used to
   * create a webhook for a specific envelope sent via the API. Connect webhooks can be used for any
   * envelope sent from an account, from any user, from any client. ### eventNotification Webhooks
   * The Envelopes::create method includes an optional [eventNotification
   * object](#definition-eventNotification) that adds a webhook to the envelope. eventNotification
   * webhooks are available for all DocuSign accounts with API access. ### Connect Webhooks Connect
   * can be used to create a webhook for all envelopes sent by all users in an account, either
   * through the API or via other DocuSign clients (web, mobile, etc). Connect configurations are
   * independent of specific envelopes. A Connect configuration includes a filter that may be used
   * to limit the webhook to specific users, envelope statuses, etc. Connect configurations may be
   * created and managed using the [ConnectConfigurations
   * resource](../../Connect/ConnectConfigurations). Configurations can also be created and managed
   * from the Administration tool accessed by selecting \"Go to Admin\" from the menu next
   * to your picture on the DocuSign web app. See the Integrations/Connect section of the Admin
   * tool. For repeatability, and to minimize support questions, creating Connect configurations via
   * the API is recommended, especially for ISVs. Connect is available for some DocuSign account
   * types. Please contact DocuSign Sales for more information. ## Composite Templates The Composite
   * Templates feature, like [compositing in film
   * production](https://en.wikipedia.org/wiki/Compositing), enables you to *overlay* document,
   * recipient, and tab definitions from multiple sources, including PDF Form Field definitions,
   * templates defined on the server, and more. Each Composite Template consists of optional
   * elements: server templates, inline templates, PDF Metadata templates, and documents. * The
   * Composite Template ID is an optional element used to identify the composite template. It is
   * used as a reference when adding document object information via a multi-part HTTP message. If
   * used, the document content-disposition must include the `compositeTemplateId` to
   * which the document should be added. If `compositeTemplateId` is not specified in the
   * content-disposition, the document is applied based on the `documentId` only. If no
   * document object is specified, the composite template inherits the first document. * Server
   * Templates are server-side templates stored on the DocuSign platform. If supplied, they are
   * overlaid into the envelope in the order of their Sequence value. * Inline Templates provide a
   * container to add documents, recipients, tabs, and custom fields. If inline templates are
   * supplied, they are overlaid into the envelope in the order of their Sequence value. * Document
   * objects are optional structures that provide a container to pass in a document or form. If this
   * object is not included, the composite template inherits the *first* document it finds from a
   * server template or inline template, starting with the lowest sequence value. PDF Form objects
   * are only transformed from the document object. DocuSign does not derive PDF form properties
   * from server templates or inline templates. To instruct DocuSign to transform fields from the
   * PDF form, set `transformPdfFields` to \"true\" for the document. See the
   * Transform PDF Fields section for more information about process. * PDF Metadata Templates
   * provide a container to embed design-time template information into a PDF document. DocuSign
   * uses this information when processing the Envelope. This convention allows the document to
   * carry the signing instructions with it, so that less information needs to be provided at
   * run-time through an inline template or synchronized with an external structure like a server
   * template. PDF Metadata templates are stored in the Metadata layer of a PDF in accordance with
   * Acrobat's XMP specification. DocuSign will only find PDF Metadata templates inside
   * documents passed in the Document object (see below). If supplied, the PDF metadata template
   * will be overlaid into the envelope in the order of its Sequence value. ### Compositing the
   * definitions Each Composite Template adds a new document and templates overlay into the
   * envelope. For each Composite Template these rules are applied: * Templates are overlaid in the
   * order of their Sequence value. * If Document is not passed into the Composite Template's
   * `document` field, the *first* template's document (based on the template's
   * Sequence value) is used. * Last in wins in all cases except for the document (i.e. envelope
   * information, recipient information, secure field information). There is no special casing. For
   * example, if you want higher security on a tab, then that needs to be specified in a later
   * template (by sequence number) then where the tab is included. If you want higher security on a
   * role recipient, then it needs to be in a later template then where that role recipient is
   * specified. * Recipient matching is based on Recipient Role and Routing Order. If there are
   * matches, the recipient information is merged together. A final pass is done on all Composite
   * Templates, after all template overlays have been applied, to collapse recipients with the same
   * email, username and routing order. This prevents having the same recipients at the same routing
   * order. * If you specify in a template that a recipient is locked, once that recipient is
   * overlaid the recipient attributes can no longer be changed. The only items that can be changed
   * for the recipient in this case are the email, username, access code and
   * IDCheckInformationInput. * Tab matching is based on Tab Labels, Tab Types and Documents. If a
   * Tab Label matches but the Document is not supplied, the Tab is overlaid for all the Documents.
   * For example, if you have a simple inline template with only one tab in it with a label and a
   * value, the Signature, Initial, Company, Envelope ID, User Name tabs will only be matched and
   * collapsed if they fall in the exact same X and Y locations. * roleName and tabLabel matching is
   * case sensitive. * The defaultRecipient field enables you to specify which recipient the
   * generated tabs from a PDF form are mapped to. You can also set PDF form generated tabs to a
   * recipient other than the DefaultRecipient by specifying the mapping of the tab label that is
   * created to one of the template recipients. * You can use tabLabel wild carding to map a series
   * of tabs from the PDF form. To use this you must end a tab label with \"\\*\" and then
   * the system matches tabs that start with the label. * If no DefaultRecipient is specified, tabs
   * must be explicitly mapped to recipients in order to be generated from the form. Unmapped form
   * objects will not be generated into their DocuSign equivalents. (In the case of
   * Signature/Initials, the tabs will be disregarded entirely; in the case of pdf text fields, the
   * field data will be flattened on the Envelope document, but there will not be a corresponding
   * DocuSign data tab.) ### Including the Document Content for Composite Templates Document content
   * can be supplied inline, using the `documentBase64` or can be included in a multi-part
   * HTTP message. If a multi-part message is used and there are multiple Composite Templates, the
   * document content-disposition can include the `compositeTemplateId` to which the
   * document should be added. Using the `compositeTemplateId` sets which documents are
   * associated with particular composite templates. An example of this usage is: ```
   * --5cd3320a-5aac-4453-b3a4-cbb52a4cba5d Content-Type: application/pdf Content-Disposition: file;
   * filename=\"eula.pdf\"; documentId=1;
   * compositeTemplateId=\"1\" Content-Transfer-Encoding: base64 ```
   * ### PDF Form Field Transformation Only the following PDF Form FieldTypes will be transformed to
   * DocuSign tabs: CheckBox, DateTime, ListBox, Numeric, Password, Radio, Signature, and Text Field
   * Properties that will be transformed: Read Only, Required, Max Length, Positions, and Initial
   * Data. When transforming a *PDF Form Digital Signature Field,* the following rules are used: If
   * the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere
   * or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional
   * Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or
   * eSignInitialHereOptional | Optional Initials Any other PDF Form Digital Signature Field will be
   * transformed to a DocuSign Signature tab When transforming *PDF Form Text Fields,* the following
   * rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- |
   * -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or
   * eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials
   * DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials DocuSignEnvelopeID
   * or eSignEnvelopeID | EnvelopeID DocuSignCompany or eSignCompany | Company DocuSignDateSigned or
   * eSignDateSigned | Date Signed DocuSignTitle or eSignTitle | Title DocuSignFullName or
   * eSignFullName | Full Name DocuSignSignerAttachmentOptional or eSignSignerAttachmentOptional |
   * Optional Signer Attachment Any other PDF Form Text Field will be transformed to a DocuSign data
   * (text) tab. PDF Form Field Names that include \"DocuSignIgnoreTransform\" or
   * \"eSignIgnoreTransform\" will not be transformed. PDF Form Date fields will be
   * transformed to Date Signed fields if their name includes DocuSignDateSigned or eSignDateSigned.
   * ## Template Email Subject Merge Fields This feature enables you to insert recipient name and
   * email address merge fields into the email subject line when creating or sending from a
   * template. The merge fields, based on the recipient's `roleName`, are added to the
   * `emailSubject` when the template is created or when the template is used to create an
   * envelope. After a template sender adds the name and email information for the recipient and
   * sends the envelope, the recipient information is automatically merged into the appropriate
   * fields in the email subject line. Both the sender and the recipients will see the information
   * in the email subject line for any emails associated with the template. This provides an easy
   * way for senders to organize their envelope emails without having to open an envelope to check
   * the recipient. If merging the recipient information into the subject line causes the subject
   * line to exceed 100 characters, then any characters over the 100 character limit are not
   * included in the subject line. For cases where the recipient name or email is expected to be
   * long, you should consider placing the merge field at the start of the email subject. * To add a
   * recipient's name in the subject line add the following text in the `emailSubject`
   * when creating the template or when sending an envelope from a template:
   * [[<roleName>_UserName]] Example: `\"emailSubject\":\"[[Signer
   * 1_UserName]], Please sign this NDA\",` * To add a recipient's email address in
   * the subject line add the following text in the emailSubject when creating the template or when
   * sending an envelope from a template: [[<roleName>_Email]] Example:
   * `\"emailSubject\":\"[[Signer 1_Email]], Please sign this NDA\",`
   * In both cases the <roleName> is the recipient's `roleName` in the template.
   * For cases where another recipient (such as an Agent, Editor, or Intermediary recipient) is
   * entering the name and email information for the recipient included in the email subject, then
   * [[<roleName>_UserName]] or [[<roleName>_Email]] is shown in the email subject. ##
   * Branding an envelope The following rules are used to determine the `brandId` used in
   * an envelope: * If a `brandId` is specified in the envelope/template and that brandId
   * is available to the account, that brand is used in the envelope. * If more than one template is
   * used in an envelope and more than one `brandId` is specified, the first
   * `brandId` specified is used throughout the envelope. * In cases where no brand is
   * specified and the sender belongs to a Group; if there is only one brand associated with the
   * Group, then that brand is used in the envelope. Otherwise, the account's default signing
   * brand is used. * For envelopes that do not meet any of the previous criteria, the account's
   * default signing brand is used for the envelope. ## BCC Email address feature The BCC Email
   * address feature is designed to provide a copy of all email communications for external
   * archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive
   * feature, including the BCC Email Override option, include additional signer authentication
   * options. To send a copy of the envelope to a recipient who does not need to sign, don't use
   * the BCC Email field. Use a Carbon Copy or Certified Delivery Recipient type. ## Merge Recipient
   * Roles for Draft Envelopes When an envelope with multiple templates is sent, the recipients from
   * the templates are merged according to the template roles, and empty recipients are removed.
   * When creating an envelope with multiple templates, but not sending it (keeping it in a created
   * state), duplicate recipients are not merged, which could cause leave duplicate recipients in
   * the envelope. To prevent this, the query parameter `merge_roles_on_draft` should be
   * added when posting a draft envelope (status=created) with multiple templates. Doing this
   * will merge template roles and remove empty recipients. ###### Note: DocuSign recommends that
   * the `merge_roles_on_draft` query parameter be used anytime you are creating an
   * envelope with multiple templates and keeping it in draft (created) status.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeDefinition (optional)
   * @param options for modifying the method behavior.
   * @return EnvelopeSummary
   * @throws ApiException if fails to make API call
   */
  public EnvelopeSummary createEnvelope(
      String accountId,
      EnvelopeDefinition envelopeDefinition,
      EnvelopesApi.CreateEnvelopeOptions options)
      throws ApiException {
    ApiResponse localVarResponse =
        createEnvelopeWithHttpInfo(accountId, envelopeDefinition, options);
    return localVarResponse.getData();
  }

  /**
   * Creates an envelope. Creates an envelope. Using this function you can: * Create an envelope and
   * send it. * Create an envelope from an existing template and send it. In either case, you can
   * choose to save the envelope as a draft envelope instead of sending it by setting the
   * request's `status` property to `created` instead of `sent`.
   * ## Sending Envelopes Documents can be included with the Envelopes::create call itself or a
   * template can include documents. Documents can be added by using a multi-part/form request or by
   * using the `documentBase64` field of the [`document`
   * object](#/definitions/document) ### Recipient Types An [`envelopeDefinition`
   * object](#/definitions/envelopeDefinition) is used as the method's body. Envelope recipients
   * can be defined in the envelope or in templates. The `envelopeDefinition` object's
   * `recipients` field is an [`EnvelopeRecipients` resource
   * object](#/definitions/EnvelopeRecipients). It includes arrays of the seven types of recipients
   * defined by DocuSign: Recipient type | Object definition -------------- | -----------------
   * agent (can add name and email information for later recipients/signers) |
   * [`agent`](#/definitions/agent) carbon copy (receives a copy of the documents) |
   * [`carbonCopy`](#/definitions/carbonCopy) certified delivery (receives a copy of the
   * documents and must acknowledge receipt) |
   * [`certifiedDelivery`](#/definitions/certifiedDelivery) editor (can change recipients
   * and document fields for later recipients/signers) | [`editor`](#/definitions/editor)
   * in-person signer (\"hosts\" someone who signs in-person) |
   * [`inPersonSigner`](#/definitions/inPersonSigner) intermediary (can add name and email
   * information for some later recipients/signers.) |
   * [`intermediary`](#/definitions/intermediary) signer (signs and/or updates document
   * fields) | [`signer`](#/definitions/signer) Additional information about the different
   * types of recipients is available from the [`EnvelopeRecipients` resource
   * page](../../EnvelopeRecipients) and from the [Developer
   * Center](https://www.docusign.com/developer-center/explore/features/recipients) ### Tabs Tabs
   * (also referred to as `tags` and as `fields` in the web sending user
   * interface), can be defined in the `envelopeDefinition`, in templates, by transforming
   * PDF Form Fields, or by using Composite Templates (see below). Defining tabs: the
   * `inPersonSigner`, and `signer` recipient objects include a `tabs`
   * field. It is an [`EnvelopeTabs` resource object](#/definitions/EnvelopeTabs). It
   * includes arrays of the 24 different tab types available. See the [`EnvelopeTabs`
   * resource](../../EnvelopeTabs) for more information. ## Using Templates Envelopes use specific
   * people or groups as recipients. Templates can specify a role, eg `account_manager.`
   * When a template is used in an envelope, the roles must be replaced with specific people or
   * groups. When you create an envelope using a `templateId`, the different recipient
   * type objects within the [`EnvelopeRecipients`
   * object](#/definitions/EnvelopeRecipients) are used to assign recipients to the template's
   * roles via the `roleName` property. The recipient objects can also override settings
   * that were specified in the template, and set values for tab fields that were defined in the
   * template. ### Message Lock When a template is added or applied to an envelope and the template
   * has a locked email subject and message, that subject and message are used for the envelope and
   * cannot be changed even if another locked template is subsequently added or applied to the
   * envelope. The field `messageLock` is used to lock the email subject and message. If
   * an email subject or message is entered before adding or applying a template with
   * `messageLock` **true**, the email subject and message is overwritten with the locked
   * email subject and message from the template. ## Envelope Status The status of sent envelopes
   * can be determined through the DocuSign webhook system or by polling. Webhooks are highly
   * recommended: they provide your application with the quickest updates when an envelope's
   * status changes. DocuSign limits polling to once every 15 minutes or less frequently. When a
   * webhook is used, DocuSign calls your application, via the URL you provide, with a notification
   * XML message. See the [Webhook
   * recipe](https://www.docusign.com/developer-center/recipes/webhook-status) for examples and live
   * demos of using webhooks. ## Webhook Options The two webhook options, *eventNotification* and
   * *Connect* use the same notification mechanism and message formats. eventNotification is used to
   * create a webhook for a specific envelope sent via the API. Connect webhooks can be used for any
   * envelope sent from an account, from any user, from any client. ### eventNotification Webhooks
   * The Envelopes::create method includes an optional [eventNotification
   * object](#definition-eventNotification) that adds a webhook to the envelope. eventNotification
   * webhooks are available for all DocuSign accounts with API access. ### Connect Webhooks Connect
   * can be used to create a webhook for all envelopes sent by all users in an account, either
   * through the API or via other DocuSign clients (web, mobile, etc). Connect configurations are
   * independent of specific envelopes. A Connect configuration includes a filter that may be used
   * to limit the webhook to specific users, envelope statuses, etc. Connect configurations may be
   * created and managed using the [ConnectConfigurations
   * resource](../../Connect/ConnectConfigurations). Configurations can also be created and managed
   * from the Administration tool accessed by selecting \"Go to Admin\" from the menu next
   * to your picture on the DocuSign web app. See the Integrations/Connect section of the Admin
   * tool. For repeatability, and to minimize support questions, creating Connect configurations via
   * the API is recommended, especially for ISVs. Connect is available for some DocuSign account
   * types. Please contact DocuSign Sales for more information. ## Composite Templates The Composite
   * Templates feature, like [compositing in film
   * production](https://en.wikipedia.org/wiki/Compositing), enables you to *overlay* document,
   * recipient, and tab definitions from multiple sources, including PDF Form Field definitions,
   * templates defined on the server, and more. Each Composite Template consists of optional
   * elements: server templates, inline templates, PDF Metadata templates, and documents. * The
   * Composite Template ID is an optional element used to identify the composite template. It is
   * used as a reference when adding document object information via a multi-part HTTP message. If
   * used, the document content-disposition must include the `compositeTemplateId` to
   * which the document should be added. If `compositeTemplateId` is not specified in the
   * content-disposition, the document is applied based on the `documentId` only. If no
   * document object is specified, the composite template inherits the first document. * Server
   * Templates are server-side templates stored on the DocuSign platform. If supplied, they are
   * overlaid into the envelope in the order of their Sequence value. * Inline Templates provide a
   * container to add documents, recipients, tabs, and custom fields. If inline templates are
   * supplied, they are overlaid into the envelope in the order of their Sequence value. * Document
   * objects are optional structures that provide a container to pass in a document or form. If this
   * object is not included, the composite template inherits the *first* document it finds from a
   * server template or inline template, starting with the lowest sequence value. PDF Form objects
   * are only transformed from the document object. DocuSign does not derive PDF form properties
   * from server templates or inline templates. To instruct DocuSign to transform fields from the
   * PDF form, set `transformPdfFields` to \"true\" for the document. See the
   * Transform PDF Fields section for more information about process. * PDF Metadata Templates
   * provide a container to embed design-time template information into a PDF document. DocuSign
   * uses this information when processing the Envelope. This convention allows the document to
   * carry the signing instructions with it, so that less information needs to be provided at
   * run-time through an inline template or synchronized with an external structure like a server
   * template. PDF Metadata templates are stored in the Metadata layer of a PDF in accordance with
   * Acrobat's XMP specification. DocuSign will only find PDF Metadata templates inside
   * documents passed in the Document object (see below). If supplied, the PDF metadata template
   * will be overlaid into the envelope in the order of its Sequence value. ### Compositing the
   * definitions Each Composite Template adds a new document and templates overlay into the
   * envelope. For each Composite Template these rules are applied: * Templates are overlaid in the
   * order of their Sequence value. * If Document is not passed into the Composite Template's
   * `document` field, the *first* template's document (based on the template's
   * Sequence value) is used. * Last in wins in all cases except for the document (i.e. envelope
   * information, recipient information, secure field information). There is no special casing. For
   * example, if you want higher security on a tab, then that needs to be specified in a later
   * template (by sequence number) then where the tab is included. If you want higher security on a
   * role recipient, then it needs to be in a later template then where that role recipient is
   * specified. * Recipient matching is based on Recipient Role and Routing Order. If there are
   * matches, the recipient information is merged together. A final pass is done on all Composite
   * Templates, after all template overlays have been applied, to collapse recipients with the same
   * email, username and routing order. This prevents having the same recipients at the same routing
   * order. * If you specify in a template that a recipient is locked, once that recipient is
   * overlaid the recipient attributes can no longer be changed. The only items that can be changed
   * for the recipient in this case are the email, username, access code and
   * IDCheckInformationInput. * Tab matching is based on Tab Labels, Tab Types and Documents. If a
   * Tab Label matches but the Document is not supplied, the Tab is overlaid for all the Documents.
   * For example, if you have a simple inline template with only one tab in it with a label and a
   * value, the Signature, Initial, Company, Envelope ID, User Name tabs will only be matched and
   * collapsed if they fall in the exact same X and Y locations. * roleName and tabLabel matching is
   * case sensitive. * The defaultRecipient field enables you to specify which recipient the
   * generated tabs from a PDF form are mapped to. You can also set PDF form generated tabs to a
   * recipient other than the DefaultRecipient by specifying the mapping of the tab label that is
   * created to one of the template recipients. * You can use tabLabel wild carding to map a series
   * of tabs from the PDF form. To use this you must end a tab label with \"\\*\" and then
   * the system matches tabs that start with the label. * If no DefaultRecipient is specified, tabs
   * must be explicitly mapped to recipients in order to be generated from the form. Unmapped form
   * objects will not be generated into their DocuSign equivalents. (In the case of
   * Signature/Initials, the tabs will be disregarded entirely; in the case of pdf text fields, the
   * field data will be flattened on the Envelope document, but there will not be a corresponding
   * DocuSign data tab.) ### Including the Document Content for Composite Templates Document content
   * can be supplied inline, using the `documentBase64` or can be included in a multi-part
   * HTTP message. If a multi-part message is used and there are multiple Composite Templates, the
   * document content-disposition can include the `compositeTemplateId` to which the
   * document should be added. Using the `compositeTemplateId` sets which documents are
   * associated with particular composite templates. An example of this usage is: ```
   * --5cd3320a-5aac-4453-b3a4-cbb52a4cba5d Content-Type: application/pdf Content-Disposition: file;
   * filename=\"eula.pdf\"; documentId=1;
   * compositeTemplateId=\"1\" Content-Transfer-Encoding: base64 ```
   * ### PDF Form Field Transformation Only the following PDF Form FieldTypes will be transformed to
   * DocuSign tabs: CheckBox, DateTime, ListBox, Numeric, Password, Radio, Signature, and Text Field
   * Properties that will be transformed: Read Only, Required, Max Length, Positions, and Initial
   * Data. When transforming a *PDF Form Digital Signature Field,* the following rules are used: If
   * the PDF Field Name Contains | Then the DocuSign Tab Will be ------- | -------- DocuSignSignHere
   * or eSignSignHere | Signature DocuSignSignHereOptional or eSignSignHereOptional | Optional
   * Signature DocuSignInitialHere or eSignInitialHere | Initials DocuSignInitialHereOptional or
   * eSignInitialHereOptional | Optional Initials Any other PDF Form Digital Signature Field will be
   * transformed to a DocuSign Signature tab When transforming *PDF Form Text Fields,* the following
   * rules are used: If the PDF Field Name Contains | Then the DocuSign Tab Will be ------- |
   * -------- DocuSignSignHere or eSignSignHere | Signature DocuSignSignHereOptional or
   * eSignSignHereOptional | Optional Signature DocuSignInitialHere or eSignInitialHere | Initials
   * DocuSignInitialHereOptional or eSignInitialHereOptional | Optional Initials DocuSignEnvelopeID
   * or eSignEnvelopeID | EnvelopeID DocuSignCompany or eSignCompany | Company DocuSignDateSigned or
   * eSignDateSigned | Date Signed DocuSignTitle or eSignTitle | Title DocuSignFullName or
   * eSignFullName | Full Name DocuSignSignerAttachmentOptional or eSignSignerAttachmentOptional |
   * Optional Signer Attachment Any other PDF Form Text Field will be transformed to a DocuSign data
   * (text) tab. PDF Form Field Names that include \"DocuSignIgnoreTransform\" or
   * \"eSignIgnoreTransform\" will not be transformed. PDF Form Date fields will be
   * transformed to Date Signed fields if their name includes DocuSignDateSigned or eSignDateSigned.
   * ## Template Email Subject Merge Fields This feature enables you to insert recipient name and
   * email address merge fields into the email subject line when creating or sending from a
   * template. The merge fields, based on the recipient's `roleName`, are added to the
   * `emailSubject` when the template is created or when the template is used to create an
   * envelope. After a template sender adds the name and email information for the recipient and
   * sends the envelope, the recipient information is automatically merged into the appropriate
   * fields in the email subject line. Both the sender and the recipients will see the information
   * in the email subject line for any emails associated with the template. This provides an easy
   * way for senders to organize their envelope emails without having to open an envelope to check
   * the recipient. If merging the recipient information into the subject line causes the subject
   * line to exceed 100 characters, then any characters over the 100 character limit are not
   * included in the subject line. For cases where the recipient name or email is expected to be
   * long, you should consider placing the merge field at the start of the email subject. * To add a
   * recipient's name in the subject line add the following text in the `emailSubject`
   * when creating the template or when sending an envelope from a template:
   * [[<roleName>_UserName]] Example: `\"emailSubject\":\"[[Signer
   * 1_UserName]], Please sign this NDA\",` * To add a recipient's email address in
   * the subject line add the following text in the emailSubject when creating the template or when
   * sending an envelope from a template: [[<roleName>_Email]] Example:
   * `\"emailSubject\":\"[[Signer 1_Email]], Please sign this NDA\",`
   * In both cases the <roleName> is the recipient's `roleName` in the template.
   * For cases where another recipient (such as an Agent, Editor, or Intermediary recipient) is
   * entering the name and email information for the recipient included in the email subject, then
   * [[<roleName>_UserName]] or [[<roleName>_Email]] is shown in the email subject. ##
   * Branding an envelope The following rules are used to determine the `brandId` used in
   * an envelope: * If a `brandId` is specified in the envelope/template and that brandId
   * is available to the account, that brand is used in the envelope. * If more than one template is
   * used in an envelope and more than one `brandId` is specified, the first
   * `brandId` specified is used throughout the envelope. * In cases where no brand is
   * specified and the sender belongs to a Group; if there is only one brand associated with the
   * Group, then that brand is used in the envelope. Otherwise, the account's default signing
   * brand is used. * For envelopes that do not meet any of the previous criteria, the account's
   * default signing brand is used for the envelope. ## BCC Email address feature The BCC Email
   * address feature is designed to provide a copy of all email communications for external
   * archiving purposes. DocuSign recommends that envelopes sent using the BCC for Email Archive
   * feature, including the BCC Email Override option, include additional signer authentication
   * options. To send a copy of the envelope to a recipient who does not need to sign, don't use
   * the BCC Email field. Use a Carbon Copy or Certified Delivery Recipient type. ## Merge Recipient
   * Roles for Draft Envelopes When an envelope with multiple templates is sent, the recipients from
   * the templates are merged according to the template roles, and empty recipients are removed.
   * When creating an envelope with multiple templates, but not sending it (keeping it in a created
   * state), duplicate recipients are not merged, which could cause leave duplicate recipients in
   * the envelope. To prevent this, the query parameter `merge_roles_on_draft` should be
   * added when posting a draft envelope (status=created) with multiple templates. Doing this
   * will merge template roles and remove empty recipients. ###### Note: DocuSign recommends that
   * the `merge_roles_on_draft` query parameter be used anytime you are creating an
   * envelope with multiple templates and keeping it in draft (created) status.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeDefinition (optional)
   * @param options for modifying the method behavior.
   * @return EnvelopeSummary
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createEnvelopeWithHttpInfo(
      String accountId,
      EnvelopeDefinition envelopeDefinition,
      EnvelopesApi.CreateEnvelopeOptions options)
      throws ApiException {
    Object localVarPostBody = envelopeDefinition;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createEnvelope");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    if (options != null) {
      localVarQueryParams.addAll(apiClient.parameterToPair("cdse_mode", options.cdseMode));
    }
    if (options != null) {
      localVarQueryParams.addAll(
          apiClient.parameterToPair("change_routing_order", options.changeRoutingOrder));
    }
    if (options != null) {
      localVarQueryParams.addAll(
          apiClient.parameterToPair("completed_documents_only", options.completedDocumentsOnly));
    }
    if (options != null) {
      localVarQueryParams.addAll(
          apiClient.parameterToPair("merge_roles_on_draft", options.mergeRolesOnDraft));
    }
    if (options != null) {
      localVarQueryParams.addAll(
          apiClient.parameterToPair("tab_label_exact_matches", options.tabLabelExactMatches));
    }

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    EnvelopeSummary localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Posts a list of comments for authorized user.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param commentsPublish (optional)
   * @return CommentHistoryResult
   * @throws ApiException if fails to make API call
   */
  public CommentHistoryResult createEnvelopeComments(
      String accountId, String envelopeId, CommentsPublish commentsPublish) throws ApiException {
    ApiResponse localVarResponse =
        createEnvelopeCommentsWithHttpInfo(accountId, envelopeId, commentsPublish);
    return localVarResponse.getData();
  }

  /**
   * Posts a list of comments for authorized user
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param commentsPublish (optional)
   * @return CommentHistoryResult
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createEnvelopeCommentsWithHttpInfo(
      String accountId, String envelopeId, CommentsPublish commentsPublish) throws ApiException {
    Object localVarPostBody = commentsPublish;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createEnvelopeComments");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling createEnvelopeComments");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/comments"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType =
        new GenericType() {};
    CommentHistoryResult localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Provides a URL to start a recipient view of the Envelope UI. This method returns a URL for an
   * envelope recipient preview in the DocuSign UI that you can embed in your application. You use
   * this method to enable the sender to preview the recipients' experience. For more
   * information, see [Preview and
   * Send](https://support.docusign.com/en/guides/ndse-user-guide-send-your-documents).
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientPreviewRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ViewUrl createEnvelopeRecipientPreview(
      String accountId, String envelopeId, RecipientPreviewRequest recipientPreviewRequest)
      throws ApiException {
    ApiResponse localVarResponse =
        createEnvelopeRecipientPreviewWithHttpInfo(accountId, envelopeId, recipientPreviewRequest);
    return localVarResponse.getData();
  }

  /**
   * Provides a URL to start a recipient view of the Envelope UI This method returns a URL for an
   * envelope recipient preview in the DocuSign UI that you can embed in your application. You use
   * this method to enable the sender to preview the recipients' experience. For more
   * information, see [Preview and
   * Send](https://support.docusign.com/en/guides/ndse-user-guide-send-your-documents).
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientPreviewRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createEnvelopeRecipientPreviewWithHttpInfo(
      String accountId, String envelopeId, RecipientPreviewRequest recipientPreviewRequest)
      throws ApiException {
    Object localVarPostBody = recipientPreviewRequest;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'accountId' when calling createEnvelopeRecipientPreview");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'envelopeId' when calling createEnvelopeRecipientPreview");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/recipient_preview"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    ViewUrl localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Provides a URL to start a shared recipient view of the Envelope UI. Returns a URL that enables
   * you to embed the DocuSign UI recipient view of a [shared
   * envelope](https://support.docusign.com/en/guides/ndse-admin-guide-share-envelopes) in your
   * applications. This is the view that a user sees of an envelope that a recipient on the same
   * account has shared with them. Due to screen space issues, do not use an
   * `<iframe>` for embedded operations on mobile devices. For iOS devices, DocuSign
   * recommends using a WebView. ### Revoking the URL You can revoke this URL by making a DELETE
   * HTTP request to the URL with no request body. ### Related topics - [Embedded signing and
   * sending](/docs/esign-rest-api/esign101/concepts/embedding/) - [How to send an envelope via your
   * app](/docs/esign-rest-api/how-to/embedded-sending/) - [How to embed the DocuSign UI in your
   * app](/docs/esign-rest-api/how-to/embed-ui/)
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientViewRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ViewUrl createEnvelopeRecipientSharedView(
      String accountId, String envelopeId, RecipientViewRequest recipientViewRequest)
      throws ApiException {
    ApiResponse localVarResponse =
        createEnvelopeRecipientSharedViewWithHttpInfo(accountId, envelopeId, recipientViewRequest);
    return localVarResponse.getData();
  }

  /**
   * Provides a URL to start a shared recipient view of the Envelope UI Returns a URL that enables
   * you to embed the DocuSign UI recipient view of a [shared
   * envelope](https://support.docusign.com/en/guides/ndse-admin-guide-share-envelopes) in your
   * applications. This is the view that a user sees of an envelope that a recipient on the same
   * account has shared with them. Due to screen space issues, do not use an
   * `<iframe>` for embedded operations on mobile devices. For iOS devices, DocuSign
   * recommends using a WebView. ### Revoking the URL You can revoke this URL by making a DELETE
   * HTTP request to the URL with no request body. ### Related topics - [Embedded signing and
   * sending](/docs/esign-rest-api/esign101/concepts/embedding/) - [How to send an envelope via your
   * app](/docs/esign-rest-api/how-to/embedded-sending/) - [How to embed the DocuSign UI in your
   * app](/docs/esign-rest-api/how-to/embed-ui/)
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientViewRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createEnvelopeRecipientSharedViewWithHttpInfo(
      String accountId, String envelopeId, RecipientViewRequest recipientViewRequest)
      throws ApiException {
    Object localVarPostBody = recipientViewRequest;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'accountId' when calling createEnvelopeRecipientSharedView");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'envelopeId' when calling createEnvelopeRecipientSharedView");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/shared"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    ViewUrl localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Add envelope transfer rules to an account.. This method creates an envelope transfer rule. When
   * you create an envelope transfer rule, you specify the following properties: -
   * `eventType` - `fromGroups` - `toUser` - `toFolder` -
   * `carbonCopyOriginalOwner` - `enabled` **Note:** Only Administrators can
   * create envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer
   * Custody** feature must be enabled for your account.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeTransferRuleRequest (optional)
   * @return EnvelopeTransferRuleInformation
   * @throws ApiException if fails to make API call
   */
  public EnvelopeTransferRuleInformation createEnvelopeTransferRules(
      String accountId, EnvelopeTransferRuleRequest envelopeTransferRuleRequest)
      throws ApiException {
    ApiResponse localVarResponse =
        createEnvelopeTransferRulesWithHttpInfo(accountId, envelopeTransferRuleRequest);
    return localVarResponse.getData();
  }

  /**
   * Add envelope transfer rules to an account. This method creates an envelope transfer rule. When
   * you create an envelope transfer rule, you specify the following properties: -
   * `eventType` - `fromGroups` - `toUser` - `toFolder` -
   * `carbonCopyOriginalOwner` - `enabled` **Note:** Only Administrators can
   * create envelope transfer rules. In addition, to use envelope transfer rules, the **Transfer
   * Custody** feature must be enabled for your account.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeTransferRuleRequest (optional)
   * @return EnvelopeTransferRuleInformation
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createEnvelopeTransferRulesWithHttpInfo(
      String accountId, EnvelopeTransferRuleRequest envelopeTransferRuleRequest)
      throws ApiException {
    Object localVarPostBody = envelopeTransferRuleRequest;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'accountId' when calling createEnvelopeTransferRules");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/transfer_rules"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType =
        new GenericType() {};
    EnvelopeTransferRuleInformation localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Creates and adds a new workflow step definition for an envelope's workflow.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param workflowStep (optional)
   * @return WorkflowStep
   * @throws ApiException if fails to make API call
   */
  public WorkflowStep createEnvelopeWorkflowStepDefinition(
      String accountId, String envelopeId, WorkflowStep workflowStep) throws ApiException {
    ApiResponse localVarResponse =
        createEnvelopeWorkflowStepDefinitionWithHttpInfo(accountId, envelopeId, workflowStep);
    return localVarResponse.getData();
  }

  /**
   * Creates and adds a new workflow step definition for an envelope's workflow
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param workflowStep (optional)
   * @return WorkflowStep
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createEnvelopeWorkflowStepDefinitionWithHttpInfo(
      String accountId, String envelopeId, WorkflowStep workflowStep) throws ApiException {
    Object localVarPostBody = workflowStep;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'accountId' when calling createEnvelopeWorkflowStepDefinition");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'envelopeId' when calling createEnvelopeWorkflowStepDefinition");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/workflow/steps"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    WorkflowStep localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Submits a batch of historical envelopes for republish to an adhoc config..
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param connectHistoricalEnvelopeRepublish (optional)
   * @return EnvelopePublishTransaction
   * @throws ApiException if fails to make API call
   */
  public EnvelopePublishTransaction createHistoricalEnvelopePublishTransaction(
      String accountId, ConnectHistoricalEnvelopeRepublish connectHistoricalEnvelopeRepublish)
      throws ApiException {
    ApiResponse localVarResponse =
        createHistoricalEnvelopePublishTransactionWithHttpInfo(
            accountId, connectHistoricalEnvelopeRepublish);
    return localVarResponse.getData();
  }

  /**
   * Submits a batch of historical envelopes for republish to an adhoc config.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param connectHistoricalEnvelopeRepublish (optional)
   * @return EnvelopePublishTransaction
   * @throws ApiException if fails to make API call
   */
  public ApiResponse
      createHistoricalEnvelopePublishTransactionWithHttpInfo(
          String accountId, ConnectHistoricalEnvelopeRepublish connectHistoricalEnvelopeRepublish)
          throws ApiException {
    Object localVarPostBody = connectHistoricalEnvelopeRepublish;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'accountId' when calling createHistoricalEnvelopePublishTransaction");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/connect/envelopes/publish/historical"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType =
        new GenericType() {};
    EnvelopePublishTransaction localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Lock an envelope.. Locks the specified envelope, and sets the time until the lock expires, to
   * prevent other users or recipients from accessing and changing the envelope. ###### Note: Users
   * must have envelope locking capability enabled to use this function (userSetting
   * `canLockEnvelopes` must be set to true for the user).
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param lockRequest (optional)
   * @return LockInformation
   * @throws ApiException if fails to make API call
   */
  public LockInformation createLock(String accountId, String envelopeId, LockRequest lockRequest)
      throws ApiException {
    ApiResponse localVarResponse =
        createLockWithHttpInfo(accountId, envelopeId, lockRequest);
    return localVarResponse.getData();
  }

  /**
   * Lock an envelope. Locks the specified envelope, and sets the time until the lock expires, to
   * prevent other users or recipients from accessing and changing the envelope. ###### Note: Users
   * must have envelope locking capability enabled to use this function (userSetting
   * `canLockEnvelopes` must be set to true for the user).
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param lockRequest (optional)
   * @return LockInformation
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createLockWithHttpInfo(
      String accountId, String envelopeId, LockRequest lockRequest) throws ApiException {
    Object localVarPostBody = lockRequest;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createLock");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling createLock");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/lock"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    LockInformation localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }
  /// 

  /// Adds one or more recipients to an envelope. Adds one or more recipients to an envelope.  For
  // an in process envelope, one that has been sent and has not been completed or voided, an email
  // is sent to a new recipient when they are reached in the routing order. If the new
  // recipient's routing order is before or the same as the envelope's next recipient, an
  // email is only sent if the optional `resend_envelope` query string is set to **true**.
  /// 

  /** CreateRecipientOptions Class. */
  public class CreateRecipientOptions {
    private String resendEnvelope = null;

    /** setResendEnvelope method. */
    public void setResendEnvelope(String resendEnvelope) {
      this.resendEnvelope = resendEnvelope;
    }

    /**
     * getResendEnvelope method.
     *
     * @return String
     */
    public String getResendEnvelope() {
      return this.resendEnvelope;
    }
  }

  /**
   * Adds one or more recipients to an envelope.. Adds one or more recipients to an envelope. For an
   * in process envelope, one that has been sent and has not been completed or voided, an email is
   * sent to a new recipient when they are reached in the routing order. If the new recipient's
   * routing order is before or the same as the envelope's next recipient, an email is only sent
   * if the optional `resend_envelope` query string is set to **true**.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipients (optional)
   * @return Recipients
   */
  public Recipients createRecipient(String accountId, String envelopeId, Recipients recipients)
      throws ApiException {
    return createRecipient(accountId, envelopeId, recipients, null);
  }

  /**
   * Adds one or more recipients to an envelope.. Adds one or more recipients to an envelope. For an
   * in process envelope, one that has been sent and has not been completed or voided, an email is
   * sent to a new recipient when they are reached in the routing order. If the new recipient's
   * routing order is before or the same as the envelope's next recipient, an email is only sent
   * if the optional `resend_envelope` query string is set to **true**.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipients (optional)
   * @param options for modifying the method behavior.
   * @return Recipients
   * @throws ApiException if fails to make API call
   */
  public Recipients createRecipient(
      String accountId,
      String envelopeId,
      Recipients recipients,
      EnvelopesApi.CreateRecipientOptions options)
      throws ApiException {
    ApiResponse localVarResponse =
        createRecipientWithHttpInfo(accountId, envelopeId, recipients, options);
    return localVarResponse.getData();
  }

  /**
   * Adds one or more recipients to an envelope. Adds one or more recipients to an envelope. For an
   * in process envelope, one that has been sent and has not been completed or voided, an email is
   * sent to a new recipient when they are reached in the routing order. If the new recipient's
   * routing order is before or the same as the envelope's next recipient, an email is only sent
   * if the optional `resend_envelope` query string is set to **true**.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipients (optional)
   * @param options for modifying the method behavior.
   * @return Recipients
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createRecipientWithHttpInfo(
      String accountId,
      String envelopeId,
      Recipients recipients,
      EnvelopesApi.CreateRecipientOptions options)
      throws ApiException {
    Object localVarPostBody = recipients;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createRecipient");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling createRecipient");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    if (options != null) {
      localVarQueryParams.addAll(
          apiClient.parameterToPair("resend_envelope", options.resendEnvelope));
    }

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    Recipients localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Provides a link to access the Identity manual review related to a recipient.. This method
   * returns the URL of the page that allows a sender to [manually
   * review](https://support.docusign.com/en/guides/ndse-user-guide-send-documents-with-id-verification)
   * the ID of a recipient.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientId The ID of the recipient being accessed. (required)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ViewUrl createRecipientManualReviewView(
      String accountId, String envelopeId, String recipientId) throws ApiException {
    ApiResponse localVarResponse =
        createRecipientManualReviewViewWithHttpInfo(accountId, envelopeId, recipientId);
    return localVarResponse.getData();
  }

  /**
   * Provides a link to access the Identity manual review related to a recipient. This method
   * returns the URL of the page that allows a sender to [manually
   * review](https://support.docusign.com/en/guides/ndse-user-guide-send-documents-with-id-verification)
   * the ID of a recipient.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientId The ID of the recipient being accessed. (required)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createRecipientManualReviewViewWithHttpInfo(
      String accountId, String envelopeId, String recipientId) throws ApiException {
    Object localVarPostBody = "{}";

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'accountId' when calling createRecipientManualReviewView");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'envelopeId' when calling createRecipientManualReviewView");
    }

    // verify the required parameter 'recipientId' is set
    if (recipientId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'recipientId' when calling createRecipientManualReviewView");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/views/identity_manual_review"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll("\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()))
            .replaceAll(
                "\\{" + "recipientId" + "\\}", apiClient.escapeString(recipientId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    ViewUrl localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Returns a link to access to the identity events stored in the proof service related to this
   * recipient..
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientId The ID of the recipient being accessed. (required)
   * @return IdEvidenceViewLink
   * @throws ApiException if fails to make API call
   */
  public IdEvidenceViewLink createRecipientProofFileLink(
      String accountId, String envelopeId, String recipientId) throws ApiException {
    ApiResponse localVarResponse =
        createRecipientProofFileLinkWithHttpInfo(accountId, envelopeId, recipientId);
    return localVarResponse.getData();
  }

  /**
   * Returns a link to access to the identity events stored in the proof service related to this
   * recipient.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientId The ID of the recipient being accessed. (required)
   * @return IdEvidenceViewLink
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createRecipientProofFileLinkWithHttpInfo(
      String accountId, String envelopeId, String recipientId) throws ApiException {
    Object localVarPostBody = "{}";

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'accountId' when calling createRecipientProofFileLink");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'envelopeId' when calling createRecipientProofFileLink");
    }

    // verify the required parameter 'recipientId' is set
    if (recipientId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'recipientId' when calling createRecipientProofFileLink");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/identity_proof"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll("\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()))
            .replaceAll(
                "\\{" + "recipientId" + "\\}", apiClient.escapeString(recipientId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    IdEvidenceViewLink localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Returns a resource token to get access to the identity events stored in the proof service
   * related to this recipient.. Creates a resource token for a sender. This token allows a sender
   * to return identification data for a recipient using the [ID Evidence
   * API](/docs/idevidence-api/).
   *
   * @param tokenScopes (required)
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientId The ID of the recipient being accessed. (required)
   * @return IdEvidenceResourceToken
   * @throws ApiException if fails to make API call
   */
  public IdEvidenceResourceToken createRecipientProofFileResourceToken(
      String tokenScopes, String accountId, String envelopeId, String recipientId)
      throws ApiException {
    ApiResponse localVarResponse =
        createRecipientProofFileResourceTokenWithHttpInfo(
            tokenScopes, accountId, envelopeId, recipientId);
    return localVarResponse.getData();
  }

  /**
   * Returns a resource token to get access to the identity events stored in the proof service
   * related to this recipient. Creates a resource token for a sender. This token allows a sender to
   * return identification data for a recipient using the [ID Evidence API](/docs/idevidence-api/).
   *
   * @param tokenScopes (required)
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientId The ID of the recipient being accessed. (required)
   * @return IdEvidenceResourceToken
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createRecipientProofFileResourceTokenWithHttpInfo(
      String tokenScopes, String accountId, String envelopeId, String recipientId)
      throws ApiException {
    Object localVarPostBody = "{}";

    // verify the required parameter 'tokenScopes' is set
    if (tokenScopes == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'tokenScopes' when calling createRecipientProofFileResourceToken");
    }

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'accountId' when calling createRecipientProofFileResourceToken");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'envelopeId' when calling createRecipientProofFileResourceToken");
    }

    // verify the required parameter 'recipientId' is set
    if (recipientId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'recipientId' when calling createRecipientProofFileResourceToken");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/identity_proof_token"
            .replaceAll(
                "\\{" + "token_scopes" + "\\}", apiClient.escapeString(tokenScopes.toString()))
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll("\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()))
            .replaceAll(
                "\\{" + "recipientId" + "\\}", apiClient.escapeString(recipientId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType =
        new GenericType() {};
    IdEvidenceResourceToken localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Returns a URL to the recipient view UI.. Returns a URL that allows you to embed the recipient
   * view of the DocuSign UI in your applications. This call cannot be used to view draft envelopes,
   * since those envelopes have not been sent. Important: iFrames should not be used for embedded
   * operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends
   * using a WebView. An entry is added into the Security Level section of the DocuSign Certificate
   * of Completion that reflects the `securityDomain` and `authenticationMethod`
   * properties used to verify the user identity.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientViewRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ViewUrl createRecipientView(
      String accountId, String envelopeId, RecipientViewRequest recipientViewRequest)
      throws ApiException {
    ApiResponse localVarResponse =
        createRecipientViewWithHttpInfo(accountId, envelopeId, recipientViewRequest);
    return localVarResponse.getData();
  }

  /**
   * Returns a URL to the recipient view UI. Returns a URL that allows you to embed the recipient
   * view of the DocuSign UI in your applications. This call cannot be used to view draft envelopes,
   * since those envelopes have not been sent. Important: iFrames should not be used for embedded
   * operations on mobile devices due to screen space issues. For iOS devices DocuSign recommends
   * using a WebView. An entry is added into the Security Level section of the DocuSign Certificate
   * of Completion that reflects the `securityDomain` and `authenticationMethod`
   * properties used to verify the user identity.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientViewRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createRecipientViewWithHttpInfo(
      String accountId, String envelopeId, RecipientViewRequest recipientViewRequest)
      throws ApiException {
    Object localVarPostBody = recipientViewRequest;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createRecipientView");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling createRecipientView");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/recipient"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    ViewUrl localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Get Responsive HTML Preview for all documents in an envelope.. Creates a preview of the
   * [responsive](/docs/esign-rest-api/esign101/concepts/responsive/), HTML versions of all of the
   * documents in an envelope. This method enables you to preview the PDF document conversions to
   * responsive HTML across device types prior to sending. The request body is a
   * `documentHtmlDefinition` object, which holds the responsive signing parameters that
   * define how to generate the HTML version of the documents.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentHtmlDefinition (optional)
   * @return DocumentHtmlDefinitions
   * @throws ApiException if fails to make API call
   */
  public DocumentHtmlDefinitions createResponsiveHtmlPreview(
      String accountId, String envelopeId, DocumentHtmlDefinition documentHtmlDefinition)
      throws ApiException {
    ApiResponse localVarResponse =
        createResponsiveHtmlPreviewWithHttpInfo(accountId, envelopeId, documentHtmlDefinition);
    return localVarResponse.getData();
  }

  /**
   * Get Responsive HTML Preview for all documents in an envelope. Creates a preview of the
   * [responsive](/docs/esign-rest-api/esign101/concepts/responsive/), HTML versions of all of the
   * documents in an envelope. This method enables you to preview the PDF document conversions to
   * responsive HTML across device types prior to sending. The request body is a
   * `documentHtmlDefinition` object, which holds the responsive signing parameters that
   * define how to generate the HTML version of the documents.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentHtmlDefinition (optional)
   * @return DocumentHtmlDefinitions
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createResponsiveHtmlPreviewWithHttpInfo(
      String accountId, String envelopeId, DocumentHtmlDefinition documentHtmlDefinition)
      throws ApiException {
    Object localVarPostBody = documentHtmlDefinition;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'accountId' when calling createResponsiveHtmlPreview");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'envelopeId' when calling createResponsiveHtmlPreview");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/responsive_html_preview"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType =
        new GenericType() {};
    DocumentHtmlDefinitions localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Returns a URL to the sender view UI.. Returns a URL that allows you to embed the sender view of
   * the DocuSign UI in your applications. This is a one-time use login token that allows the user
   * to be placed into the DocuSign sending view. Upon sending completion, the user is returned to
   * the return URL provided by the API application. Important: iFrames should not be used for
   * embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign
   * recommends using a WebView.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param returnUrlRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ViewUrl createSenderView(
      String accountId, String envelopeId, ReturnUrlRequest returnUrlRequest) throws ApiException {
    ApiResponse localVarResponse =
        createSenderViewWithHttpInfo(accountId, envelopeId, returnUrlRequest);
    return localVarResponse.getData();
  }

  /**
   * Returns a URL to the sender view UI. Returns a URL that allows you to embed the sender view of
   * the DocuSign UI in your applications. This is a one-time use login token that allows the user
   * to be placed into the DocuSign sending view. Upon sending completion, the user is returned to
   * the return URL provided by the API application. Important: iFrames should not be used for
   * embedded operations on mobile devices due to screen space issues. For iOS devices DocuSign
   * recommends using a WebView.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param returnUrlRequest (optional)
   * @return ViewUrl
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createSenderViewWithHttpInfo(
      String accountId, String envelopeId, ReturnUrlRequest returnUrlRequest) throws ApiException {
    Object localVarPostBody = returnUrlRequest;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createSenderView");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling createSenderView");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/views/sender"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    ViewUrl localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Adds tabs for a recipient.. Adds one or more tabs for a recipient.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientId The ID of the recipient being accessed. (required)
   * @param tabs (optional)
   * @return Tabs
   * @throws ApiException if fails to make API call
   */
  public Tabs createTabs(String accountId, String envelopeId, String recipientId, Tabs tabs)
      throws ApiException {
    ApiResponse localVarResponse =
        createTabsWithHttpInfo(accountId, envelopeId, recipientId, tabs);
    return localVarResponse.getData();
  }

  /**
   * Adds tabs for a recipient. Adds one or more tabs for a recipient.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param recipientId The ID of the recipient being accessed. (required)
   * @param tabs (optional)
   * @return Tabs
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createTabsWithHttpInfo(
      String accountId, String envelopeId, String recipientId, Tabs tabs) throws ApiException {
    Object localVarPostBody = tabs;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling createTabs");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling createTabs");
    }

    // verify the required parameter 'recipientId' is set
    if (recipientId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'recipientId' when calling createTabs");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/recipients/{recipientId}/tabs"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll("\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()))
            .replaceAll(
                "\\{" + "recipientId" + "\\}", apiClient.escapeString(recipientId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    Tabs localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Creates and adds a new workflow step definition for a template's workflow.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param templateId The ID of the template being accessed. (required)
   * @param workflowStep (optional)
   * @return WorkflowStep
   * @throws ApiException if fails to make API call
   */
  public WorkflowStep createTemplateWorkflowStepDefinition(
      String accountId, String templateId, WorkflowStep workflowStep) throws ApiException {
    ApiResponse localVarResponse =
        createTemplateWorkflowStepDefinitionWithHttpInfo(accountId, templateId, workflowStep);
    return localVarResponse.getData();
  }

  /**
   * Creates and adds a new workflow step definition for a template's workflow
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param templateId The ID of the template being accessed. (required)
   * @param workflowStep (optional)
   * @return WorkflowStep
   * @throws ApiException if fails to make API call
   */
  public ApiResponse createTemplateWorkflowStepDefinitionWithHttpInfo(
      String accountId, String templateId, WorkflowStep workflowStep) throws ApiException {
    Object localVarPostBody = workflowStep;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'accountId' when calling createTemplateWorkflowStepDefinition");
    }

    // verify the required parameter 'templateId' is set
    if (templateId == null) {
      throw new ApiException(
          400,
          "Missing the required parameter 'templateId' when calling createTemplateWorkflowStepDefinition");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/templates/{templateId}/workflow/steps"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "templateId" + "\\}", apiClient.escapeString(templateId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    WorkflowStep localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "POST",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Delete one or more attachments from a DRAFT envelope.. Deletes one or more attachments from a
   * draft envelope.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param envelopeAttachmentsRequest (optional)
   * @return EnvelopeAttachmentsResult
   * @throws ApiException if fails to make API call
   */
  public EnvelopeAttachmentsResult deleteAttachments(
      String accountId, String envelopeId, EnvelopeAttachmentsRequest envelopeAttachmentsRequest)
      throws ApiException {
    ApiResponse localVarResponse =
        deleteAttachmentsWithHttpInfo(accountId, envelopeId, envelopeAttachmentsRequest);
    return localVarResponse.getData();
  }

  /**
   * Delete one or more attachments from a DRAFT envelope. Deletes one or more attachments from a
   * draft envelope.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param envelopeAttachmentsRequest (optional)
   * @return EnvelopeAttachmentsResult
   * @throws ApiException if fails to make API call
   */
  public ApiResponse deleteAttachmentsWithHttpInfo(
      String accountId, String envelopeId, EnvelopeAttachmentsRequest envelopeAttachmentsRequest)
      throws ApiException {
    Object localVarPostBody = envelopeAttachmentsRequest;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling deleteAttachments");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling deleteAttachments");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/attachments"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType =
        new GenericType() {};
    EnvelopeAttachmentsResult localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "DELETE",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Delete an existing ChunkedUpload.. Deletes a chunked upload that has been committed but not yet
   * consumed. This method cannot be used to delete the following types of chunked uploads, which
   * the system deletes automatically: - Chunked uploads that have been consumed by use in another
   * API call. - Expired chunked uploads. **Note:** If you are aware of a chunked upload that can be
   * discarded, the best practice is to explicitly delete it. If you wait for the system to
   * automatically delete it after it expires, the chunked upload will continue to count against
   * your quota.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param chunkedUploadId (required)
   * @return ChunkedUploadResponse
   * @throws ApiException if fails to make API call
   */
  public ChunkedUploadResponse deleteChunkedUpload(String accountId, String chunkedUploadId)
      throws ApiException {
    ApiResponse localVarResponse =
        deleteChunkedUploadWithHttpInfo(accountId, chunkedUploadId);
    return localVarResponse.getData();
  }

  /**
   * Delete an existing ChunkedUpload. Deletes a chunked upload that has been committed but not yet
   * consumed. This method cannot be used to delete the following types of chunked uploads, which
   * the system deletes automatically: - Chunked uploads that have been consumed by use in another
   * API call. - Expired chunked uploads. **Note:** If you are aware of a chunked upload that can be
   * discarded, the best practice is to explicitly delete it. If you wait for the system to
   * automatically delete it after it expires, the chunked upload will continue to count against
   * your quota.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param chunkedUploadId (required)
   * @return ChunkedUploadResponse
   * @throws ApiException if fails to make API call
   */
  public ApiResponse deleteChunkedUploadWithHttpInfo(
      String accountId, String chunkedUploadId) throws ApiException {
    Object localVarPostBody = "{}";

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling deleteChunkedUpload");
    }

    // verify the required parameter 'chunkedUploadId' is set
    if (chunkedUploadId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'chunkedUploadId' when calling deleteChunkedUpload");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/chunked_uploads/{chunkedUploadId}"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "chunkedUploadId" + "\\}",
                apiClient.escapeString(chunkedUploadId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType =
        new GenericType() {};
    ChunkedUploadResponse localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "DELETE",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Deletes envelope custom fields for draft and in-process envelopes.. Deletes envelope custom
   * fields for draft and in-process envelopes.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param customFields (optional)
   * @return CustomFields
   * @throws ApiException if fails to make API call
   */
  public CustomFields deleteCustomFields(
      String accountId, String envelopeId, CustomFields customFields) throws ApiException {
    ApiResponse localVarResponse =
        deleteCustomFieldsWithHttpInfo(accountId, envelopeId, customFields);
    return localVarResponse.getData();
  }

  /**
   * Deletes envelope custom fields for draft and in-process envelopes. Deletes envelope custom
   * fields for draft and in-process envelopes.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param customFields (optional)
   * @return CustomFields
   * @throws ApiException if fails to make API call
   */
  public ApiResponse deleteCustomFieldsWithHttpInfo(
      String accountId, String envelopeId, CustomFields customFields) throws ApiException {
    Object localVarPostBody = customFields;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling deleteCustomFields");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling deleteCustomFields");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/custom_fields"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll(
                "\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType = new GenericType() {};
    CustomFields localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "DELETE",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Deletes custom document fields from an existing envelope document.. Deletes custom document
   * fields from an existing envelope document.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentId The ID of the document being accessed. (required)
   * @param documentFieldsInformation (optional)
   * @return DocumentFieldsInformation
   * @throws ApiException if fails to make API call
   */
  public DocumentFieldsInformation deleteDocumentFields(
      String accountId,
      String envelopeId,
      String documentId,
      DocumentFieldsInformation documentFieldsInformation)
      throws ApiException {
    ApiResponse localVarResponse =
        deleteDocumentFieldsWithHttpInfo(
            accountId, envelopeId, documentId, documentFieldsInformation);
    return localVarResponse.getData();
  }

  /**
   * Deletes custom document fields from an existing envelope document. Deletes custom document
   * fields from an existing envelope document.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentId The ID of the document being accessed. (required)
   * @param documentFieldsInformation (optional)
   * @return DocumentFieldsInformation
   * @throws ApiException if fails to make API call
   */
  public ApiResponse deleteDocumentFieldsWithHttpInfo(
      String accountId,
      String envelopeId,
      String documentId,
      DocumentFieldsInformation documentFieldsInformation)
      throws ApiException {
    Object localVarPostBody = documentFieldsInformation;

    // verify the required parameter 'accountId' is set
    if (accountId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'accountId' when calling deleteDocumentFields");
    }

    // verify the required parameter 'envelopeId' is set
    if (envelopeId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'envelopeId' when calling deleteDocumentFields");
    }

    // verify the required parameter 'documentId' is set
    if (documentId == null) {
      throw new ApiException(
          400, "Missing the required parameter 'documentId' when calling deleteDocumentFields");
    }

    // create path and map variables
    String localVarPath =
        "/v2.1/accounts/{accountId}/envelopes/{envelopeId}/documents/{documentId}/fields"
            .replaceAll("\\{" + "accountId" + "\\}", apiClient.escapeString(accountId.toString()))
            .replaceAll("\\{" + "envelopeId" + "\\}", apiClient.escapeString(envelopeId.toString()))
            .replaceAll(
                "\\{" + "documentId" + "\\}", apiClient.escapeString(documentId.toString()));

    // query params
    java.util.List localVarQueryParams = new java.util.ArrayList();
    java.util.List localVarCollectionQueryParams = new java.util.ArrayList();
    java.util.Map localVarHeaderParams = new java.util.HashMap();
    java.util.Map localVarFormParams = new java.util.HashMap();

    final String[] localVarAccepts = {"application/json"};
    final String localVarAccept = apiClient.selectHeaderAccept(localVarAccepts);

    final String[] localVarContentTypes = {};

    final String localVarContentType = apiClient.selectHeaderContentType(localVarContentTypes);

    String[] localVarAuthNames = new String[] {"docusignAccessCode"};

    GenericType localVarReturnType =
        new GenericType() {};
    DocumentFieldsInformation localVarResponse =
        apiClient.invokeAPI(
            localVarPath,
            "DELETE",
            localVarQueryParams,
            localVarCollectionQueryParams,
            localVarPostBody,
            localVarHeaderParams,
            localVarFormParams,
            localVarAccept,
            localVarContentType,
            localVarAuthNames,
            localVarReturnType);
    return new ApiResponse(
        apiClient.getStatusCode(), apiClient.getResponseHeaders(), localVarResponse);
  }

  /**
   * Deletes a page from a document in an envelope.. Deletes a page from a document in an envelope
   * based on the page number.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentId The ID of the document being accessed. (required)
   * @param pageNumber The page number being accessed. (required)
   * @throws ApiException if fails to make API call
   */
  public void deleteDocumentPage(
      String accountId, String envelopeId, String documentId, String pageNumber)
      throws ApiException {
    deleteDocumentPageWithHttpInfo(accountId, envelopeId, documentId, pageNumber);
  }

  /**
   * Deletes a page from a document in an envelope. Deletes a page from a document in an envelope
   * based on the page number.
   *
   * @param accountId The external account number (int) or account ID Guid. (required)
   * @param envelopeId The envelopeId Guid of the envelope being accessed. (required)
   * @param documentId The ID of the document being accessed. (required)
   * @param pageNumber The page number being accessed. (required)
   * @throws ApiException if fails to make API call
   */
  public ApiResponse