WordPress.org
Get WordPress

Plugin Directory

Changeset 1123003


Ignore:
Timestamp:
03/29/2015 09:14:23 AM (11 years ago)
Author:
groupdocs
Message:

Updated GroupDocs SDK

Location:
groupdocs-documents-annotation/trunk
Files:
33 added
43 edited

Legend:

Unmodified
Added
Removed

  • groupdocs-documents-annotation/trunk/grpdocs-dialog.php

    r984057 r1123003  
    9191
    9292<div class="box">
    93  
     93
    9494  <strong>Document Id (GUID)</strong><br />
    9595  <input name="url" type="text" class="opt dwl" id="url" style="width:200px;" /><br/>
    9696  <span id="uri-note"></span>
    97  
     97
    9898</div>
    9999</div><!-- .section -->
    … …  
    172172        $width = (int) $_POST['width'];
    173173        $height = (int) $_POST['height'];
    174         $result = $api->Upload(strip_tags(trim($_POST['userId'])), $name, 'uploaded', null, $fs);
     174        $result = $api->Upload(strip_tags(trim($_POST['userId'])), $name, 'uploaded', null, null, $fs);
    175175       if (!empty($_POST['can_view'])) {
    176176           $can_view = 'True';

  • groupdocs-documents-annotation/trunk/readme.txt

    r1069410 r1123003  
    44Author URI: http://groupdocs.com/apps/annotation
    55Requires at least: 2.8
    6 Tested up to: 4.1
     6Tested up to: 4.0
    77Stable tag: trunk
    88License: GPLv2
    … …  
    101101
    102102= 1.3.13 =
    103 * Added functionality set access rights for collaborator
     103* Updated GroupDocs SDK version in the plugin
    104104
    105105= 1.3.12 =

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/AntApi.php

    r885602 r1123003  
    165165      }
    166166  /**
     167     * DeleteDocumentAnnotations
     168     * Delete document annotations
     169   * userId, string: User GUID (required)
     170   * fileId, string: File ID (required)
     171   * @return DeleteDocumentAnnotationsResponse
     172     */
     173
     174   public function DeleteDocumentAnnotations($userId, $fileId) {
     175      if( $userId === null || $fileId === null ) {
     176        throw new ApiException("missing required parameters", 400);
     177      }
     178      //parse inputs
     179      $resourcePath = str_replace("*", "", "/ant/{userId}/files/{fileId}/annotations");
     180      $resourcePath = str_replace("{format}", "json", $resourcePath);
     181      $method = "DELETE";
     182      $queryParams = array();
     183      $headerParams = array();
     184
     185      if($userId !== null) {
     186            $resourcePath = str_replace("{" . "userId" . "}",
     187                                        $userId, $resourcePath);
     188        }
     189        if($fileId !== null) {
     190            $resourcePath = str_replace("{" . "fileId" . "}",
     191                                        $fileId, $resourcePath);
     192        }
     193        //make the API Call
     194      if (! isset($body)) {
     195        $body = null;
     196      }
     197      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     198                                              $queryParams, $body, $headerParams);
     199      if(! $response){
     200        return null;
     201      }
     202
     203      $responseObject = $this->apiClient->deserialize($response,
     204                                                        'DeleteDocumentAnnotationsResponse');
     205      return $responseObject;
     206      }
     207  /**
    167208     * CreateAnnotationReply
    168209     * Create annotation reply
    … …  
    802843   * userId, string: User GUID (required)
    803844   * fileId, string: File ID (required)
    804    * body, AnnotationReviewerRights: Access Rights for the collaborate link (required)
    805845   * @return GetSharedLinkAccessRightsResponse
    806846     */
    807847
    808    public function GetSharedLinkAccessRights($userId, $fileId, $body) {
    809       if( $userId === null || $fileId === null || $body === null ) {
     848   public function GetSharedLinkAccessRights($userId, $fileId) {
     849      if( $userId === null || $fileId === null ) {
    810850        throw new ApiException("missing required parameters", 400);
    811851      }
    … …  
    844884   * userId, string: User GUID (required)
    845885   * fileId, string: File ID (required)
    846    * body, AnnotationReviewerRights: Access Rights for the collaborate link (required)
     886   * body, string: Access Rights for the collaborate link (required)
    847887   * @return SetSharedLinkAccessRightsResponse
    848888     */

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/AsyncApi.php

    r885602 r1123003  
    469469   * actions, string: Actions (optional)
    470470   * excludedActions, string: Excluded actions (optional)
    471    * jobName, string: Foltred job name (optional)
     471   * jobName, string: Filtred job name (optional)
     472   * orderBy, string: Sorded column name (optional)
     473   * orderAsc, bool: Order ASC (optional)
    472474   * @return GetJobsResponse
    473475     */
    474476
    475    public function GetJobs($userId, $pageIndex=null, $pageSize=null, $DateTime=null, $statusIds=null, $actions=null, $excludedActions=null, $jobName=null) {
     477   public function GetJobs($userId, $pageIndex=null, $pageSize=null, $DateTime=null, $statusIds=null, $actions=null, $excludedActions=null, $jobName=null, $orderBy=null, $orderAsc=null) {
    476478      if( $userId === null ) {
    477479        throw new ApiException("missing required parameters", 400);
    478480      }
    479481      //parse inputs
    480       $resourcePath = str_replace("*", "", "/async/{userId}/jobs?page={pageIndex}&count={pageSize}&date={date}&statusIds={statusIds}&actions={actions}&excluded_actions={excludedActions}&jobName={jobName}");
     482      $resourcePath = str_replace("*", "", "/async/{userId}/jobs?page={pageIndex}&count={pageSize}&date={date}&statusIds={statusIds}&actions={actions}&excluded_actions={excludedActions}&jobName={jobName}&order_by={orderBy}&order_asc={orderAsc}");
    481483      $pos = strpos($resourcePath, "?");
    482484      if($pos !== false){
    … …  
    508510        if($jobName !== null) {
    509511          $queryParams['jobName'] = $this->apiClient->toPathValue($jobName);
     512        }
     513        if($orderBy !== null) {
     514          $queryParams['order_by'] = $this->apiClient->toPathValue($orderBy);
     515        }
     516        if($orderAsc !== null) {
     517          $queryParams['order_asc'] = $this->apiClient->toPathValue($orderAsc);
    510518        }
    511519        if($userId !== null) {
    … …  
    656664      return $responseObject;
    657665      }
     666  /**
     667     * GetPossibleConversions
     668     * Get Possible Conversions
     669   * userId, string: User GUID (required)
     670   * fileExt, string: File extension to check (required)
     671   * @return GetPossibleConversions
     672     */
     673
     674   public function GetPossibleConversions($userId, $fileExt) {
     675      if( $userId === null || $fileExt === null ) {
     676        throw new ApiException("missing required parameters", 400);
     677      }
     678      //parse inputs
     679      $resourcePath = str_replace("*", "", "/async/{userId}/possibleConversions/{fileExt}");
     680      $resourcePath = str_replace("{format}", "json", $resourcePath);
     681      $method = "GET";
     682      $queryParams = array();
     683      $headerParams = array();
     684
     685      if($userId !== null) {
     686            $resourcePath = str_replace("{" . "userId" . "}",
     687                                        $userId, $resourcePath);
     688        }
     689        if($fileExt !== null) {
     690            $resourcePath = str_replace("{" . "fileExt" . "}",
     691                                        $fileExt, $resourcePath);
     692        }
     693        //make the API Call
     694      if (! isset($body)) {
     695        $body = null;
     696      }
     697      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     698                                              $queryParams, $body, $headerParams);
     699      if(! $response){
     700        return null;
     701      }
     702
     703      $responseObject = $this->apiClient->deserialize($response,
     704                                                        'GetPossibleConversions');
     705      return $responseObject;
     706      }
    658707 
    659708}

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/ComparisonApi.php

    r885602 r1123003  
    11<?php
     2
    23/**
    34 *  Copyright 2012 GroupDocs.
    … …  
    2223class ComparisonApi {
    2324
    24     private $basePath = "https://api.groupdocs.com/v2.0";
    25 
    26     function __construct($apiClient) {
    27       $this->apiClient = $apiClient;
    28     }
    29 
    30     public static function newInstance($apiClient) {
    31       return new self($apiClient);
    32     }
     25    private $basePath = "https://api.groupdocs.com/v2.0";
     26
     27    function __construct($apiClient) {
     28        $this->apiClient = $apiClient;
     29    }
     30
     31    public static function newInstance($apiClient) {
     32        return new self($apiClient);
     33    }
    3334
    3435    public function setBasePath($basePath) {
    35       $this->basePath = $basePath;
    36     }
    37      
    38     public function getBasePath() {
    39       $this->basePath;
    40     }
    41 
    42   /**
    43      * Compare
    44      * Compare
    45    * userId, string: User GUID (required)
    46    * sourceFileId, string: Source File GUID (required)
    47    * targetFileId, string: Target File GUID (required)
    48    * callbackUrl, string: Callback Url (required)
    49    * @return CompareResponse
    50      */
    51 
    52    public function Compare($userId, $sourceFileId, $targetFileId, $callbackUrl) {
    53       if( $userId === null || $sourceFileId === null || $targetFileId === null || $callbackUrl === null ) {
    54         throw new ApiException("missing required parameters", 400);
    55       }
    56       //parse inputs
    57       $resourcePath = str_replace("*", "", "/comparison/{userId}/compare?source={sourceFileId}&target={targetFileId}&callback={callbackUrl}");
    58       $pos = strpos($resourcePath, "?");
    59       if($pos !== false){
    60         $resourcePath = substr($resourcePath, 0, $pos);
    61       }
    62       $resourcePath = str_replace("{format}", "json", $resourcePath);
    63       $method = "GET";
    64       $queryParams = array();
    65       $headerParams = array();
    66 
    67       if($sourceFileId !== null) {
    68           $queryParams['source'] = $this->apiClient->toPathValue($sourceFileId);
    69         }
    70         if($targetFileId !== null) {
    71           $queryParams['target'] = $this->apiClient->toPathValue($targetFileId);
    72         }
    73         if($callbackUrl !== null) {
    74           $queryParams['callback'] = $this->apiClient->toPathValue($callbackUrl);
    75         }
    76         if($userId !== null) {
    77             $resourcePath = str_replace("{" . "userId" . "}",
    78                                         $userId, $resourcePath);
    79         }
    80         //make the API Call
    81       if (! isset($body)) {
    82         $body = null;
    83       }
    84       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    85                                               $queryParams, $body, $headerParams);
    86       if(! $response){
    87         return null;
    88       }
    89 
    90       $responseObject = $this->apiClient->deserialize($response,
    91                                                         'CompareResponse');
    92       return $responseObject;
    93       }
    94   /**
    95      * GetDocumentDetails
    96      * Get document details
    97    * userId, string: User GUID (required)
    98    * guid, string: Document GUID (required)
    99    * @return DocumentDetailsResponse
    100      */
    101 
    102    public function GetDocumentDetails($userId, $guid) {
    103       if( $userId === null || $guid === null ) {
    104         throw new ApiException("missing required parameters", 400);
    105       }
    106       //parse inputs
    107       $resourcePath = str_replace("*", "", "/comparison/{userId}/document?guid={guid}");
    108       $pos = strpos($resourcePath, "?");
    109       if($pos !== false){
    110         $resourcePath = substr($resourcePath, 0, $pos);
    111       }
    112       $resourcePath = str_replace("{format}", "json", $resourcePath);
    113       $method = "GET";
    114       $queryParams = array();
    115       $headerParams = array();
    116 
    117       if($guid !== null) {
    118           $queryParams['guid'] = $this->apiClient->toPathValue($guid);
    119         }
    120         if($userId !== null) {
    121             $resourcePath = str_replace("{" . "userId" . "}",
    122                                         $userId, $resourcePath);
    123         }
    124         //make the API Call
    125       if (! isset($body)) {
    126         $body = null;
    127       }
    128       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    129                                               $queryParams, $body, $headerParams);
    130       if(! $response){
    131         return null;
    132       }
    133 
    134       $responseObject = $this->apiClient->deserialize($response,
    135                                                         'DocumentDetailsResponse');
    136       return $responseObject;
    137       }
    138   /**
    139      * DownloadResult
    140      * Download comparison result file
    141    * resultFileId, string: Comparison result file GUID (required)
    142    * format, string: Comparison result file format (optional)
    143    * @return stream
    144      */
    145 
    146    public function DownloadResult($resultFileId, $format=null, FileStream $outFileStream) {
    147       if( $resultFileId === null ) {
    148         throw new ApiException("missing required parameters", 400);
    149       }
    150       //parse inputs
    151       $resourcePath = str_replace("*", "", "/comparison/{resultFileId}/download?format={format}");
    152       $pos = strpos($resourcePath, "?");
    153       if($pos !== false){
    154         $resourcePath = substr($resourcePath, 0, $pos);
    155       }
    156       $resourcePath = str_replace("{format}", "json", $resourcePath);
    157       $method = "GET";
    158       $queryParams = array();
    159       $headerParams = array();
    160 
    161       if($format !== null) {
    162           $queryParams['format'] = $this->apiClient->toPathValue($format);
    163         }
    164         if($resultFileId !== null) {
    165             $resourcePath = str_replace("{" . "resultFileId" . "}",
    166                                         $resultFileId, $resourcePath);
    167         }
    168         //make the API Call
    169       if (! isset($body)) {
    170         $body = null;
    171       }
    172       return $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    173                                               $queryParams, $body, $headerParams, $outFileStream);
    174       }
    175   /**
    176      * GetChanges
    177      * Get changes
    178    * resultFileId, string: Comparison result file GUID (required)
    179    * @return ChangesResponse
    180      */
    181 
    182    public function GetChanges($resultFileId) {
    183       if( $resultFileId === null ) {
    184         throw new ApiException("missing required parameters", 400);
    185       }
    186       //parse inputs
    187       $resourcePath = str_replace("*", "", "/comparison/{resultFileId}/changes");
    188       $pos = strpos($resourcePath, "?");
    189       if($pos !== false){
    190         $resourcePath = substr($resourcePath, 0, $pos);
    191       }
    192       $resourcePath = str_replace("{format}", "json", $resourcePath);
    193       $method = "GET";
    194       $queryParams = array();
    195       $headerParams = array();
    196 
    197       if($resultFileId !== null) {
    198           $queryParams['resultFileId'] = $this->apiClient->toPathValue($resultFileId);
    199         }
    200         //make the API Call
    201       if (! isset($body)) {
    202         $body = null;
    203       }
    204       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    205                                               $queryParams, $body, $headerParams);
    206       if(! $response){
    207         return null;
    208       }
    209 
    210       $responseObject = $this->apiClient->deserialize($response,
    211                                                         'ChangesResponse');
    212       return $responseObject;
    213       }
    214   /**
    215      * UpdateChanges
    216      * Update changes
    217    * resultFileId, string: Comparison result file GUID (required)
    218    * body, List[ChangeInfo]: Comparison changes to update (accept or reject) (required)
    219    * @return ChangesResponse
    220      */
    221 
    222    public function UpdateChanges($resultFileId, $body) {
    223       if( $resultFileId === null || $body === null ) {
    224         throw new ApiException("missing required parameters", 400);
    225       }
    226       //parse inputs
    227       $resourcePath = str_replace("*", "", "/comparison/{resultFileId}/changes");
    228       $pos = strpos($resourcePath, "?");
    229       if($pos !== false){
    230         $resourcePath = substr($resourcePath, 0, $pos);
    231       }
    232       $resourcePath = str_replace("{format}", "json", $resourcePath);
    233       $method = "PUT";
    234       $queryParams = array();
    235       $headerParams = array();
    236 
    237       if($resultFileId !== null) {
    238           $queryParams['resultFileId'] = $this->apiClient->toPathValue($resultFileId);
    239         }
    240         //make the API Call
    241       if (! isset($body)) {
    242         $body = null;
    243       }
    244       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    245                                               $queryParams, $body, $headerParams);
    246       if(! $response){
    247         return null;
    248       }
    249 
    250       $responseObject = $this->apiClient->deserialize($response,
    251                                                         'ChangesResponse');
    252       return $responseObject;
    253       }
    254  
     36        $this->basePath = $basePath;
     37    }
     38
     39    public function getBasePath() {
     40        $this->basePath;
     41    }
     42
     43    /**
     44     * Compare
     45     * Compare
     46     * userId, string: User GUID (required)
     47     * sourceFileId, string: Source File GUID (required)
     48     * targetFileId, string: Target File GUID (required)
     49     * callbackUrl, string: Callback Url (required)
     50     * @return CompareResponse
     51     */
     52    public function Compare($userId, $sourceFileId, $targetFileId, $callbackUrl) {
     53        if ($userId === null || $sourceFileId === null || $targetFileId === null || $callbackUrl === null) {
     54            throw new ApiException("missing required parameters", 400);
     55        }
     56        //parse inputs
     57        $resourcePath = str_replace("*", "", "/comparison/{userId}/compare?source={sourceFileId}&target={targetFileId}&callback={callbackUrl}");
     58        $pos = strpos($resourcePath, "?");
     59        if ($pos !== false) {
     60            $resourcePath = substr($resourcePath, 0, $pos);
     61        }
     62        $resourcePath = str_replace("{format}", "json", $resourcePath);
     63        $method = "GET";
     64        $queryParams = array();
     65        $headerParams = array();
     66
     67        if ($sourceFileId !== null) {
     68            $queryParams['source'] = $this->apiClient->toPathValue($sourceFileId);
     69        }
     70        if ($targetFileId !== null) {
     71            $queryParams['target'] = $this->apiClient->toPathValue($targetFileId);
     72        }
     73        if ($callbackUrl !== null) {
     74            $queryParams['callback'] = $this->apiClient->toPathValue($callbackUrl);
     75        }
     76        if ($userId !== null) {
     77            $resourcePath = str_replace("{" . "userId" . "}", $userId, $resourcePath);
     78        }
     79        //make the API Call
     80        if (!isset($body)) {
     81            $body = null;
     82        }
     83        $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method, $queryParams, $body, $headerParams);
     84        if (!$response) {
     85            return null;
     86        }
     87
     88        $responseObject = $this->apiClient->deserialize($response, 'CompareResponse');
     89        return $responseObject;
     90    }
     91
     92    /**
     93     * GetDocumentDetails
     94     * Get document details
     95     * userId, string: User GUID (required)
     96     * guid, string: Document GUID (required)
     97     * @return DocumentDetailsResponse
     98     */
     99    public function GetDocumentDetails($userId, $guid) {
     100        if ($userId === null || $guid === null) {
     101            throw new ApiException("missing required parameters", 400);
     102        }
     103        //parse inputs
     104        $resourcePath = str_replace("*", "", "/comparison/{userId}/document?guid={guid}");
     105        $pos = strpos($resourcePath, "?");
     106        if ($pos !== false) {
     107            $resourcePath = substr($resourcePath, 0, $pos);
     108        }
     109        $resourcePath = str_replace("{format}", "json", $resourcePath);
     110        $method = "GET";
     111        $queryParams = array();
     112        $headerParams = array();
     113
     114        if ($guid !== null) {
     115            $queryParams['guid'] = $this->apiClient->toPathValue($guid);
     116        }
     117        if ($userId !== null) {
     118            $resourcePath = str_replace("{" . "userId" . "}", $userId, $resourcePath);
     119        }
     120        //make the API Call
     121        if (!isset($body)) {
     122            $body = null;
     123        }
     124        $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method, $queryParams, $body, $headerParams);
     125        if (!$response) {
     126            return null;
     127        }
     128
     129        $responseObject = $this->apiClient->deserialize($response, 'DocumentDetailsResponse');
     130        return $responseObject;
     131    }
     132
     133    /**
     134     * DownloadResult
     135     * Download comparison result file
     136     * resultFileId, string: Comparison result file GUID (required)
     137     * format, string: Comparison result file format (optional)
     138     * @return stream
     139     */
     140    public function DownloadResult($resultFileId, $format = null, FileStream $outFileStream) {
     141        if ($resultFileId === null) {
     142            throw new ApiException("missing required parameters", 400);
     143        }
     144        //parse inputs
     145        $resourcePath = str_replace("*", "", "/comparison/public/{resultFileId}/download?format={format}");
     146        $pos = strpos($resourcePath, "?");
     147        if ($pos !== false) {
     148            $resourcePath = substr($resourcePath, 0, $pos);
     149        }
     150        $resourcePath = str_replace("{format}", "json", $resourcePath);
     151        $method = "GET";
     152        $queryParams = array();
     153        $headerParams = array();
     154
     155        if ($format !== null) {
     156            $queryParams['format'] = $this->apiClient->toPathValue($format);
     157        }
     158        if ($resultFileId !== null) {
     159            $resourcePath = str_replace("{" . "resultFileId" . "}", $resultFileId, $resourcePath);
     160        }
     161        //make the API Call
     162        if (!isset($body)) {
     163            $body = null;
     164        }
     165        return $this->apiClient->callAPI($this->basePath, $resourcePath, $method, $queryParams, $body, $headerParams, $outFileStream);
     166    }
     167
     168    /**
     169     * GetChanges
     170     * Get changes
     171     * resultFileId, string: Comparison result file GUID (required)
     172     * @return ChangesResponse
     173     */
     174    public function GetChanges($resultFileId) {
     175        if ($resultFileId === null) {
     176            throw new ApiException("missing required parameters", 400);
     177        }
     178        //parse inputs
     179        $resourcePath = str_replace("*", "", "/comparison/public/{resultFileId}/changes");
     180        $pos = strpos($resourcePath, "?");
     181        if ($pos !== false) {
     182            $resourcePath = substr($resourcePath, 0, $pos);
     183        }
     184        $resourcePath = str_replace("{resultFileId}", $resultFileId, $resourcePath);
     185        $method = "GET";
     186        $queryParams = array();
     187        $headerParams = array();
     188
     189        if ($resultFileId !== null) {
     190            $queryParams['resultFileId'] = $this->apiClient->toPathValue($resultFileId);
     191        }
     192        //make the API Call
     193        if (!isset($body)) {
     194            $body = null;
     195        }
     196        $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method, $queryParams, $body, $headerParams);
     197        if (!$response) {
     198            return null;
     199        }
     200
     201        $responseObject = $this->apiClient->deserialize($response, 'ChangesResponse');
     202        return $responseObject;
     203    }
     204
     205    /**
     206     * UpdateChanges
     207     * Update changes
     208     * resultFileId, string: Comparison result file GUID (required)
     209     * body, List[ChangeInfo]: Comparison changes to update (accept or reject) (required)
     210     * @return ChangesResponse
     211     */
     212    public function UpdateChanges($resultFileId, $body) {
     213        if ($resultFileId === null || $body === null) {
     214            throw new ApiException("missing required parameters", 400);
     215        }
     216        //parse inputs
     217        $resourcePath = str_replace("*", "", "/comparison/public/{resultFileId}/changes");
     218        $pos = strpos($resourcePath, "?");
     219        if ($pos !== false) {
     220            $resourcePath = substr($resourcePath, 0, $pos);
     221        }
     222        $resourcePath = str_replace("{format}", "json", $resourcePath);
     223        $method = "PUT";
     224        $queryParams = array();
     225        $headerParams = array();
     226
     227        if ($resultFileId !== null) {
     228            $queryParams['resultFileId'] = $this->apiClient->toPathValue($resultFileId);
     229        }
     230        //make the API Call
     231        if (!isset($body)) {
     232            $body = null;
     233        }
     234        $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method, $queryParams, $body, $headerParams);
     235        if (!$response) {
     236            return null;
     237        }
     238
     239        $responseObject = $this->apiClient->deserialize($response, 'ChangesResponse');
     240        return $responseObject;
     241    }
     242
    255243}
    256 

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/DocApi.php

    r885602 r1123003  
    110110      }
    111111  /**
    112      * ViewDocumentAsHtml
    113      * View Document as Html
    114    * userId, string: User GUID (required)
    115    * fileId, string: File GUID (required)
    116    * pageNumber, string: Page Number (optional)
    117    * pageCount, string: Page Count (optional)
    118    * passwordSalt, string: A password hash for password protected documents (optional)
    119    * @return ViewDocumentResponse
    120      */
    121 
    122    public function ViewDocumentAsHtml($userId, $fileId, $pageNumber=null, $pageCount=null, $passwordSalt=null) {
    123       if( $userId === null || $fileId === null ) {
    124         throw new ApiException("missing required parameters", 400);
    125       }
    126       //parse inputs
    127       $resourcePath = str_replace("*", "", "/doc/{userId}/files/{fileId}/htmlRepresentations?page_number={pageNumber}&page_count={pageCount}&passwordSalt={passwordSalt}");
    128       $pos = strpos($resourcePath, "?");
    129       if($pos !== false){
    130         $resourcePath = substr($resourcePath, 0, $pos);
    131       }
    132       $resourcePath = str_replace("{format}", "json", $resourcePath);
    133       $method = "POST";
    134       $queryParams = array();
    135       $headerParams = array();
    136 
    137       if($pageNumber !== null) {
    138           $queryParams['page_number'] = $this->apiClient->toPathValue($pageNumber);
    139         }
    140         if($pageCount !== null) {
    141           $queryParams['page_count'] = $this->apiClient->toPathValue($pageCount);
    142         }
    143         if($passwordSalt !== null) {
    144           $queryParams['passwordSalt'] = $this->apiClient->toPathValue($passwordSalt);
    145         }
    146         if($userId !== null) {
    147             $resourcePath = str_replace("{" . "userId" . "}",
    148                                         $userId, $resourcePath);
    149         }
    150         if($fileId !== null) {
    151             $resourcePath = str_replace("{" . "fileId" . "}",
    152                                         $fileId, $resourcePath);
    153         }
    154         //make the API Call
    155       if (! isset($body)) {
    156         $body = null;
    157       }
    158       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    159                                               $queryParams, $body, $headerParams);
    160       if(! $response){
    161         return null;
    162       }
    163 
    164       $responseObject = $this->apiClient->deserialize($response,
    165                                                         'ViewDocumentResponse');
    166       return $responseObject;
    167       }
    168   /**
    169112     * GetDocumentViews
    170113     * Get Document Views
    … …  
    792735      $responseObject = $this->apiClient->deserialize($response,
    793736                                                        'TemplateFieldsResponse');
     737      return $responseObject;
     738      }
     739  /**
     740     * GetTemplateEditorFields
     741     * Get template editor fields
     742   * userId, string: User GUID (required)
     743   * fileId, string: File GUID (required)
     744   * @return TemplateEditorFieldsResponse
     745     */
     746
     747   public function GetTemplateEditorFields($userId, $fileId) {
     748      if( $userId === null || $fileId === null ) {
     749        throw new ApiException("missing required parameters", 400);
     750      }
     751      //parse inputs
     752      $resourcePath = str_replace("*", "", "/doc/{userId}/files/{fileId}/editor_fields");
     753      $resourcePath = str_replace("{format}", "json", $resourcePath);
     754      $method = "GET";
     755      $queryParams = array();
     756      $headerParams = array();
     757
     758      if($userId !== null) {
     759            $resourcePath = str_replace("{" . "userId" . "}",
     760                                        $userId, $resourcePath);
     761        }
     762        if($fileId !== null) {
     763            $resourcePath = str_replace("{" . "fileId" . "}",
     764                                        $fileId, $resourcePath);
     765        }
     766        //make the API Call
     767      if (! isset($body)) {
     768        $body = null;
     769      }
     770      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     771                                              $queryParams, $body, $headerParams);
     772      if(! $response){
     773        return null;
     774      }
     775
     776      $responseObject = $this->apiClient->deserialize($response,
     777                                                        'TemplateEditorFieldsResponse');
    794778      return $responseObject;
    795779      }
    … …  
    887871            $resourcePath = str_replace("{" . "dimension" . "}",
    888872                                        $dimension, $resourcePath);
    889         }
    890         //make the API Call
    891       if (! isset($body)) {
    892         $body = null;
    893       }
    894       return $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    895                                               $queryParams, $body, $headerParams, $outFileStream);
    896       }
    897   /**
    898      * GetDocumentPageHtmlFixed
    899      * Returns an HTML Fixed representantion of a particular document page.
    900    * userId, string: GroupDocs user global unique identifier. (required)
    901    * fileId, string: Document global unique identifier. (required)
    902    * pageNumber, int: Document page number to get image for. (required)
    903    * expiresOn, bool: The date and time in milliseconds since epoch the URL expires. (optional)
    904    * @return stream
    905      */
    906 
    907    public function GetDocumentPageHtmlFixed($userId, $fileId, $pageNumber, $expiresOn=null, FileStream $outFileStream) {
    908       if( $userId === null || $fileId === null || $pageNumber === null ) {
    909         throw new ApiException("missing required parameters", 400);
    910       }
    911       //parse inputs
    912       $resourcePath = str_replace("*", "", "/doc/{userId}/files/{fileId}/pages/{pageNumber}/htmlFixed?expires={expiresOn}");
    913       $pos = strpos($resourcePath, "?");
    914       if($pos !== false){
    915         $resourcePath = substr($resourcePath, 0, $pos);
    916       }
    917       $resourcePath = str_replace("{format}", "json", $resourcePath);
    918       $method = "GET";
    919       $queryParams = array();
    920       $headerParams = array();
    921 
    922       if($expiresOn !== null) {
    923           $queryParams['expires'] = $this->apiClient->toPathValue($expiresOn);
    924         }
    925         if($userId !== null) {
    926             $resourcePath = str_replace("{" . "userId" . "}",
    927                                         $userId, $resourcePath);
    928         }
    929         if($fileId !== null) {
    930             $resourcePath = str_replace("{" . "fileId" . "}",
    931                                         $fileId, $resourcePath);
    932         }
    933         if($pageNumber !== null) {
    934             $resourcePath = str_replace("{" . "pageNumber" . "}",
    935                                         $pageNumber, $resourcePath);
    936         }
    937         //make the API Call
    938       if (! isset($body)) {
    939         $body = null;
    940       }
    941       return $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    942                                               $queryParams, $body, $headerParams, $outFileStream);
    943       }
    944   /**
    945      * GetDocumentPageHtml
    946      * Returns an HTML representantion of a particular document page.
    947    * userId, string: GroupDocs user global unique identifier. (required)
    948    * fileId, string: Document global unique identifier. (required)
    949    * pageNumber, int: Document page number to get image for. (required)
    950    * expiresOn, bool: The date and time in milliseconds since epoch the URL expires. (optional)
    951    * @return stream
    952      */
    953 
    954    public function GetDocumentPageHtml($userId, $fileId, $pageNumber, $expiresOn=null, FileStream $outFileStream) {
    955       if( $userId === null || $fileId === null || $pageNumber === null ) {
    956         throw new ApiException("missing required parameters", 400);
    957       }
    958       //parse inputs
    959       $resourcePath = str_replace("*", "", "/doc/{userId}/files/{fileId}/pages/{pageNumber}/htmlRepresentations?expires={expiresOn}");
    960       $pos = strpos($resourcePath, "?");
    961       if($pos !== false){
    962         $resourcePath = substr($resourcePath, 0, $pos);
    963       }
    964       $resourcePath = str_replace("{format}", "json", $resourcePath);
    965       $method = "GET";
    966       $queryParams = array();
    967       $headerParams = array();
    968 
    969       if($expiresOn !== null) {
    970           $queryParams['expires'] = $this->apiClient->toPathValue($expiresOn);
    971         }
    972         if($userId !== null) {
    973             $resourcePath = str_replace("{" . "userId" . "}",
    974                                         $userId, $resourcePath);
    975         }
    976         if($fileId !== null) {
    977             $resourcePath = str_replace("{" . "fileId" . "}",
    978                                         $fileId, $resourcePath);
    979         }
    980         if($pageNumber !== null) {
    981             $resourcePath = str_replace("{" . "pageNumber" . "}",
    982                                         $pageNumber, $resourcePath);
    983873        }
    984874        //make the API Call
    … …  
    1060950      }
    1061951  /**
    1062      * GetDocumentPagesHtmlUrls
    1063      * Returns a list of URLs pointing to document page HTML representations.
    1064    * userId, string: GroupDocs user global unique identifier. (required)
    1065    * fileId, string: Document global unique identifier. (required)
    1066    * firstPage, int: Document page number to start from. (optional)
    1067    * pageCount, int: Page count to return URLs for. (optional)
    1068    * @return GetImageUrlsResponse
    1069      */
    1070 
    1071    public function GetDocumentPagesHtmlUrls($userId, $fileId, $firstPage=null, $pageCount=null) {
    1072       if( $userId === null || $fileId === null ) {
    1073         throw new ApiException("missing required parameters", 400);
    1074       }
    1075       //parse inputs
    1076       $resourcePath = str_replace("*", "", "/doc/{userId}/files/{fileId}/pages/htmlRepresentationUrls?first_page={firstPage}&page_count={pageCount}");
    1077       $pos = strpos($resourcePath, "?");
    1078       if($pos !== false){
    1079         $resourcePath = substr($resourcePath, 0, $pos);
    1080       }
    1081       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1082       $method = "GET";
    1083       $queryParams = array();
    1084       $headerParams = array();
    1085 
    1086       if($firstPage !== null) {
    1087           $queryParams['first_page'] = $this->apiClient->toPathValue($firstPage);
    1088         }
    1089         if($pageCount !== null) {
    1090           $queryParams['page_count'] = $this->apiClient->toPathValue($pageCount);
    1091         }
    1092         if($userId !== null) {
    1093             $resourcePath = str_replace("{" . "userId" . "}",
    1094                                         $userId, $resourcePath);
    1095         }
    1096         if($fileId !== null) {
    1097             $resourcePath = str_replace("{" . "fileId" . "}",
    1098                                         $fileId, $resourcePath);
    1099         }
    1100         //make the API Call
    1101       if (! isset($body)) {
    1102         $body = null;
    1103       }
    1104       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1105                                               $queryParams, $body, $headerParams);
    1106       if(! $response){
    1107         return null;
    1108       }
    1109 
    1110       $responseObject = $this->apiClient->deserialize($response,
    1111                                                         'GetImageUrlsResponse');
    1112       return $responseObject;
    1113       }
    1114   /**
    1115952     * GetEditLock
    1116953     * Locks a document for editing and returns editing metadata.

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/MergeApi.php

    r885602 r1123003  
    17971797      }
    17981798  /**
     1799     * DecorateQuestionnaireCollector
     1800     * Decorate questionnaire collector
     1801   * userId, string: User global unique identifier (required)
     1802   * collectorId, string: Questionnaire collector global unique identifier (required)
     1803   * body, QuestionnaireCollectorStyle: Questionnaire collector style (required)
     1804   * @return AddQuestionnaireCollectorStyleResponse
     1805     */
     1806
     1807   public function DecorateQuestionnaireCollector($userId, $collectorId, $body) {
     1808      if( $userId === null || $collectorId === null || $body === null ) {
     1809        throw new ApiException("missing required parameters", 400);
     1810      }
     1811      //parse inputs
     1812      $resourcePath = str_replace("*", "", "/merge/{userId}/questionnaires/collectors/{collectorId}/decorate");
     1813      $resourcePath = str_replace("{format}", "json", $resourcePath);
     1814      $method = "POST";
     1815      $queryParams = array();
     1816      $headerParams = array();
     1817
     1818      if($userId !== null) {
     1819            $resourcePath = str_replace("{" . "userId" . "}",
     1820                                        $userId, $resourcePath);
     1821        }
     1822        if($collectorId !== null) {
     1823            $resourcePath = str_replace("{" . "collectorId" . "}",
     1824                                        $collectorId, $resourcePath);
     1825        }
     1826        //make the API Call
     1827      if (! isset($body)) {
     1828        $body = null;
     1829      }
     1830      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     1831                                              $queryParams, $body, $headerParams);
     1832      if(! $response){
     1833        return null;
     1834      }
     1835
     1836      $responseObject = $this->apiClient->deserialize($response,
     1837                                                        'AddQuestionnaireCollectorStyleResponse');
     1838      return $responseObject;
     1839      }
     1840  /**
     1841     * GetQuestionnaireCollectorStyle
     1842     * Returns questionnaire collector style
     1843   * userId, string: User global unique identifier (required)
     1844   * collectorId, string: Questionnaire collector global unique identifier (required)
     1845   * @return GetQuestionnaireCollectorStyleResponse
     1846     */
     1847
     1848   public function GetQuestionnaireCollectorStyle($userId, $collectorId) {
     1849      if( $userId === null || $collectorId === null ) {
     1850        throw new ApiException("missing required parameters", 400);
     1851      }
     1852      //parse inputs
     1853      $resourcePath = str_replace("*", "", "/merge/{userId}/questionnaires/collector/{collectorId}/style");
     1854      $resourcePath = str_replace("{format}", "json", $resourcePath);
     1855      $method = "GET";
     1856      $queryParams = array();
     1857      $headerParams = array();
     1858
     1859      if($userId !== null) {
     1860            $resourcePath = str_replace("{" . "userId" . "}",
     1861                                        $userId, $resourcePath);
     1862        }
     1863        if($collectorId !== null) {
     1864            $resourcePath = str_replace("{" . "collectorId" . "}",
     1865                                        $collectorId, $resourcePath);
     1866        }
     1867        //make the API Call
     1868      if (! isset($body)) {
     1869        $body = null;
     1870      }
     1871      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     1872                                              $queryParams, $body, $headerParams);
     1873      if(! $response){
     1874        return null;
     1875      }
     1876
     1877      $responseObject = $this->apiClient->deserialize($response,
     1878                                                        'GetQuestionnaireCollectorStyleResponse');
     1879      return $responseObject;
     1880      }
     1881  /**
    17991882     * GetTemplates
    18001883     * Get template documents information
    18011884   * userId, string: User global unique identifier (required)
     1885   * orderBy, string: Order by column (optional)
     1886   * isAscending, bool: Order by ascending or descending (optional)
    18021887   * @return GetTemplatesResponse
    18031888     */
    18041889
    1805    public function GetTemplates($userId) {
     1890   public function GetTemplates($userId, $orderBy=null, $isAscending=null) {
    18061891      if( $userId === null ) {
    18071892        throw new ApiException("missing required parameters", 400);
    18081893      }
    18091894      //parse inputs
    1810       $resourcePath = str_replace("*", "", "/merge/{userId}/templates");
    1811       $resourcePath = str_replace("{format}", "json", $resourcePath);
     1895      $resourcePath = str_replace("*", "", "/merge/{userId}/templates?orderBy={orderBy}&isAscending={isAscending}");
     1896      $pos = strpos($resourcePath, "?");
     1897      if($pos !== false){
     1898        $resourcePath = substr($resourcePath, 0, $pos);
     1899      }
     1900      $resourcePath = str_replace("{format}", "json", $resourcePath);
    18121901      $method = "GET";
    18131902      $queryParams = array();
    18141903      $headerParams = array();
    18151904
    1816       if($userId !== null) {
     1905      if($orderBy !== null) {
     1906          $queryParams['orderBy'] = $this->apiClient->toPathValue($orderBy);
     1907        }
     1908        if($isAscending !== null) {
     1909          $queryParams['isAscending'] = $this->apiClient->toPathValue($isAscending);
     1910        }
     1911        if($userId !== null) {
    18171912            $resourcePath = str_replace("{" . "userId" . "}",
    18181913                                        $userId, $resourcePath);
    … …  
    19702065   * path, string: Path (required)
    19712066   * mode, string: Mode (optional)
     2067   * Groupdocs_Copy, string: File ID (copy) (optional)
    19722068   * Groupdocs_Move, string: File ID (move) (optional)
    1973    * Groupdocs_Copy, string: File ID (copy) (optional)
    19742069   * @return GetTemplatesResponse
    19752070     */
    19762071
    1977    public function CopyFileToTemplates($userId, $path, $mode=null, $Groupdocs_Move=null, $Groupdocs_Copy=null) {
     2072   public function CopyFileToTemplates($userId, $path, $mode=null, $Groupdocs_Copy=null, $Groupdocs_Move=null) {
    19782073      if( $userId === null || $path === null ) {
    19792074        throw new ApiException("missing required parameters", 400);
    … …  
    19932088          $queryParams['mode'] = $this->apiClient->toPathValue($mode);
    19942089        }
    1995         if($Groupdocs_Move !== null) {
     2090        if($Groupdocs_Copy !== null) {
     2091            $headerParams['Groupdocs-Copy'] = $this->apiClient->toPathValue($Groupdocs_Copy);
     2092        }
     2093      if($Groupdocs_Move !== null) {
    19962094            $headerParams['Groupdocs-Move'] = $this->apiClient->toPathValue($Groupdocs_Move);
    1997         }
    1998       if($Groupdocs_Copy !== null) {
    1999             $headerParams['Groupdocs-Copy'] = $this->apiClient->toPathValue($Groupdocs_Copy);
    20002095        }
    20012096      if($userId !== null) {
    … …  
    20622157      return $responseObject;
    20632158      }
     2159  /**
     2160     * CreateQuestionnaireTemplate
     2161     * Create questionnaire template from file
     2162   * userId, string: User GUID (required)
     2163   * fileId, string: File GUID (required)
     2164   * body, List[TemplateEditorField]: Array of template fields (required)
     2165   * @return CreateQuestionnaireTemplateResponse
     2166     */
     2167
     2168   public function CreateQuestionnaireTemplate($userId, $fileId, $body) {
     2169      if( $userId === null || $fileId === null || $body === null ) {
     2170        throw new ApiException("missing required parameters", 400);
     2171      }
     2172      //parse inputs
     2173      $resourcePath = str_replace("*", "", "/merge/{userId}/files/{fileId}/templates");
     2174      $resourcePath = str_replace("{format}", "json", $resourcePath);
     2175      $method = "POST";
     2176      $queryParams = array();
     2177      $headerParams = array();
     2178
     2179      if($userId !== null) {
     2180            $resourcePath = str_replace("{" . "userId" . "}",
     2181                                        $userId, $resourcePath);
     2182        }
     2183        if($fileId !== null) {
     2184            $resourcePath = str_replace("{" . "fileId" . "}",
     2185                                        $fileId, $resourcePath);
     2186        }
     2187        //make the API Call
     2188      if (! isset($body)) {
     2189        $body = null;
     2190      }
     2191      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     2192                                              $queryParams, $body, $headerParams);
     2193      if(! $response){
     2194        return null;
     2195      }
     2196
     2197      $responseObject = $this->apiClient->deserialize($response,
     2198                                                        'CreateQuestionnaireTemplateResponse');
     2199      return $responseObject;
     2200      }
     2201  /**
     2202     * AddQuestionnaireTemplateFields
     2203     * Add template editor fields to the specific document
     2204   * userId, string: User GUID (required)
     2205   * fileId, string: File GUID (required)
     2206   * body, List[TemplateEditorField]: Array of template fields which should be added (required)
     2207   * @return GetQuestionnaireTemplateResponse
     2208     */
     2209
     2210   public function AddQuestionnaireTemplateFields($userId, $fileId, $body) {
     2211      if( $userId === null || $fileId === null || $body === null ) {
     2212        throw new ApiException("missing required parameters", 400);
     2213      }
     2214      //parse inputs
     2215      $resourcePath = str_replace("*", "", "/merge/{userId}/files/{fileId}/templates/add");
     2216      $resourcePath = str_replace("{format}", "json", $resourcePath);
     2217      $method = "POST";
     2218      $queryParams = array();
     2219      $headerParams = array();
     2220
     2221      if($userId !== null) {
     2222            $resourcePath = str_replace("{" . "userId" . "}",
     2223                                        $userId, $resourcePath);
     2224        }
     2225        if($fileId !== null) {
     2226            $resourcePath = str_replace("{" . "fileId" . "}",
     2227                                        $fileId, $resourcePath);
     2228        }
     2229        //make the API Call
     2230      if (! isset($body)) {
     2231        $body = null;
     2232      }
     2233      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     2234                                              $queryParams, $body, $headerParams);
     2235      if(! $response){
     2236        return null;
     2237      }
     2238
     2239      $responseObject = $this->apiClient->deserialize($response,
     2240                                                        'GetQuestionnaireTemplateResponse');
     2241      return $responseObject;
     2242      }
     2243  /**
     2244     * UpdateQuestionnaireTemplateFields
     2245     * Update template's fields
     2246   * userId, string: User GUID (required)
     2247   * fileId, string: File GUID (required)
     2248   * body, List[TemplateEditorField]: Array of template fields which should be updated (required)
     2249   * @return GetQuestionnaireTemplateResponse
     2250     */
     2251
     2252   public function UpdateQuestionnaireTemplateFields($userId, $fileId, $body) {
     2253      if( $userId === null || $fileId === null || $body === null ) {
     2254        throw new ApiException("missing required parameters", 400);
     2255      }
     2256      //parse inputs
     2257      $resourcePath = str_replace("*", "", "/merge/{userId}/files/{fileId}/templates/update");
     2258      $resourcePath = str_replace("{format}", "json", $resourcePath);
     2259      $method = "PUT";
     2260      $queryParams = array();
     2261      $headerParams = array();
     2262
     2263      if($userId !== null) {
     2264            $resourcePath = str_replace("{" . "userId" . "}",
     2265                                        $userId, $resourcePath);
     2266        }
     2267        if($fileId !== null) {
     2268            $resourcePath = str_replace("{" . "fileId" . "}",
     2269                                        $fileId, $resourcePath);
     2270        }
     2271        //make the API Call
     2272      if (! isset($body)) {
     2273        $body = null;
     2274      }
     2275      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     2276                                              $queryParams, $body, $headerParams);
     2277      if(! $response){
     2278        return null;
     2279      }
     2280
     2281      $responseObject = $this->apiClient->deserialize($response,
     2282                                                        'GetQuestionnaireTemplateResponse');
     2283      return $responseObject;
     2284      }
     2285  /**
     2286     * DeleteQuestionnaireTemplateFields
     2287     * Delete template's fields
     2288   * userId, string: User GUID (required)
     2289   * fileId, string: File GUID (required)
     2290   * body, List[TemplateEditorField]: Array of template fields which should be deleted (required)
     2291   * @return GetQuestionnaireTemplateResponse
     2292     */
     2293
     2294   public function DeleteQuestionnaireTemplateFields($userId, $fileId, $body) {
     2295      if( $userId === null || $fileId === null || $body === null ) {
     2296        throw new ApiException("missing required parameters", 400);
     2297      }
     2298      //parse inputs
     2299      $resourcePath = str_replace("*", "", "/merge/{userId}/files/{fileId}/templates/delete");
     2300      $resourcePath = str_replace("{format}", "json", $resourcePath);
     2301      $method = "DELETE";
     2302      $queryParams = array();
     2303      $headerParams = array();
     2304
     2305      if($userId !== null) {
     2306            $resourcePath = str_replace("{" . "userId" . "}",
     2307                                        $userId, $resourcePath);
     2308        }
     2309        if($fileId !== null) {
     2310            $resourcePath = str_replace("{" . "fileId" . "}",
     2311                                        $fileId, $resourcePath);
     2312        }
     2313        //make the API Call
     2314      if (! isset($body)) {
     2315        $body = null;
     2316      }
     2317      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     2318                                              $queryParams, $body, $headerParams);
     2319      if(! $response){
     2320        return null;
     2321      }
     2322
     2323      $responseObject = $this->apiClient->deserialize($response,
     2324                                                        'GetQuestionnaireTemplateResponse');
     2325      return $responseObject;
     2326      }
    20642327 
    20652328}

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/SignatureApi.php

    r885602 r1123003  
    4949   * recipientName, string: Filter templates by recipient nickname (optional)
    5050   * name, string: Filter templates by signatureTemplate name (optional)
     51   * tag, string: Filter templates by tag (optional)
    5152   * @return SignatureTemplatesResponse
    5253     */
    5354
    54    public function GetSignatureTemplates($userId, $page=null, $records=null, $documentGuid=null, $recipientName=null, $name=null) {
     55   public function GetSignatureTemplates($userId, $page=null, $records=null, $documentGuid=null, $recipientName=null, $name=null, $tag=null) {
    5556      if( $userId === null ) {
    5657        throw new ApiException("missing required parameters", 400);
    5758      }
    5859      //parse inputs
    59       $resourcePath = str_replace("*", "", "/signature/{userId}/templates?records={records}&page={page}&documentGuid={documentGuid}&recipientName={recipientName}&name={name}");
     60      $resourcePath = str_replace("*", "", "/signature/{userId}/templates?records={records}&page={page}&documentGuid={documentGuid}&recipientName={recipientName}&name={name}&tag={tag}");
    6061      $pos = strpos($resourcePath, "?");
    6162      if($pos !== false){
    … …  
    8182        if($name !== null) {
    8283          $queryParams['name'] = $this->apiClient->toPathValue($name);
     84        }
     85        if($tag !== null) {
     86          $queryParams['tag'] = $this->apiClient->toPathValue($tag);
    8387        }
    8488        if($userId !== null) {
    … …  
    792796   * templateGuid, string: Template GUID (required)
    793797   * documentGuid, string: Document GUID (required)
     798   * recipientGuid, string: Recipient GUID (required)
    794799   * fieldGuid, string: Field GUID (required)
    795800   * body, SignatureTemplateFieldSettingsInfo: Settings of the field (optional)
    … …  
    797802     */
    798803
    799    public function ModifySignatureTemplateField($userId, $templateGuid, $documentGuid, $fieldGuid, $body=null) {
    800       if( $userId === null || $templateGuid === null || $documentGuid === null || $fieldGuid === null ) {
    801         throw new ApiException("missing required parameters", 400);
    802       }
    803       //parse inputs
    804       $resourcePath = str_replace("*", "", "/signature/{userId}/templates/{templateGuid}/documents/{documentGuid}/field/{fieldGuid}");
     804   public function ModifySignatureTemplateField($userId, $templateGuid, $documentGuid, $recipientGuid, $fieldGuid, $body=null) {
     805      if( $userId === null || $templateGuid === null || $documentGuid === null || $recipientGuid === null || $fieldGuid === null ) {
     806        throw new ApiException("missing required parameters", 400);
     807      }
     808      //parse inputs
     809      $resourcePath = str_replace("*", "", "/signature/{userId}/templates/{templateGuid}/documents/{documentGuid}/recipientGuid/{recipientGuid}/field/{fieldGuid}");
    805810      $resourcePath = str_replace("{format}", "json", $resourcePath);
    806811      $method = "PUT";
    … …  
    819824            $resourcePath = str_replace("{" . "documentGuid" . "}",
    820825                                        $documentGuid, $resourcePath);
     826        }
     827        if($recipientGuid !== null) {
     828            $resourcePath = str_replace("{" . "recipientGuid" . "}",
     829                                        $recipientGuid, $resourcePath);
    821830        }
    822831        if($fieldGuid !== null) {
    … …  
    11451154      }
    11461155  /**
    1147      * SignDocument
    1148      * Sign document
    1149    * userId, string: User GUID (required)
    1150    * body, SignatureSignDocumentSettingsInfo: Settings of the signing document (optional)
    1151    * @return SignatureSignDocumentResponse
    1152      */
    1153 
    1154    public function SignDocument($userId, $body=null) {
    1155       if( $userId === null ) {
    1156         throw new ApiException("missing required parameters", 400);
    1157       }
    1158       //parse inputs
    1159       $resourcePath = str_replace("*", "", "/signature/{userId}/sign");
    1160       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1161       $method = "POST";
    1162       $queryParams = array();
    1163       $headerParams = array();
    1164 
    1165       if($userId !== null) {
    1166             $resourcePath = str_replace("{" . "userId" . "}",
    1167                                         $userId, $resourcePath);
    1168         }
    1169         //make the API Call
    1170       if (! isset($body)) {
    1171         $body = null;
    1172       }
    1173       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1174                                               $queryParams, $body, $headerParams);
    1175       if(! $response){
    1176         return null;
    1177       }
    1178 
    1179       $responseObject = $this->apiClient->deserialize($response,
    1180                                                         'SignatureSignDocumentResponse');
    1181       return $responseObject;
    1182       }
    1183   /**
    1184      * GetSignDocumentStatus
    1185      * Get sign documents status
    1186    * userId, string: User GUID (required)
    1187    * jobGuid, string: Job GUID (required)
    1188    * @return SignatureSignDocumentStatusResponse
    1189      */
    1190 
    1191    public function GetSignDocumentStatus($userId, $jobGuid) {
    1192       if( $userId === null || $jobGuid === null ) {
    1193         throw new ApiException("missing required parameters", 400);
    1194       }
    1195       //parse inputs
    1196       $resourcePath = str_replace("*", "", "/signature/{userId}/documents/{jobGuid}/status");
    1197       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1198       $method = "GET";
    1199       $queryParams = array();
    1200       $headerParams = array();
    1201 
    1202       if($userId !== null) {
    1203             $resourcePath = str_replace("{" . "userId" . "}",
    1204                                         $userId, $resourcePath);
    1205         }
    1206         if($jobGuid !== null) {
    1207             $resourcePath = str_replace("{" . "jobGuid" . "}",
    1208                                         $jobGuid, $resourcePath);
    1209         }
    1210         //make the API Call
    1211       if (! isset($body)) {
    1212         $body = null;
    1213       }
    1214       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1215                                               $queryParams, $body, $headerParams);
    1216       if(! $response){
    1217         return null;
    1218       }
    1219 
    1220       $responseObject = $this->apiClient->deserialize($response,
    1221                                                         'SignatureSignDocumentStatusResponse');
    1222       return $responseObject;
    1223       }
    1224   /**
    1225      * ArchiveSignatureForm
    1226      * Archive signature form
    1227    * userId, string: User GUID (required)
    1228    * formGuid, string: Form GUID (required)
    1229    * @return SignatureStatusResponse
    1230      */
    1231 
    1232    public function ArchiveSignatureForm($userId, $formGuid) {
    1233       if( $userId === null || $formGuid === null ) {
    1234         throw new ApiException("missing required parameters", 400);
    1235       }
    1236       //parse inputs
    1237       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/archive");
    1238       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1239       $method = "PUT";
    1240       $queryParams = array();
    1241       $headerParams = array();
    1242 
    1243       if($userId !== null) {
    1244             $resourcePath = str_replace("{" . "userId" . "}",
    1245                                         $userId, $resourcePath);
    1246         }
    1247         if($formGuid !== null) {
    1248             $resourcePath = str_replace("{" . "formGuid" . "}",
    1249                                         $formGuid, $resourcePath);
    1250         }
    1251         //make the API Call
    1252       if (! isset($body)) {
    1253         $body = null;
    1254       }
    1255       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1256                                               $queryParams, $body, $headerParams);
    1257       if(! $response){
    1258         return null;
    1259       }
    1260 
    1261       $responseObject = $this->apiClient->deserialize($response,
    1262                                                         'SignatureStatusResponse');
    1263       return $responseObject;
    1264       }
    1265   /**
    1266      * CompleteSignatureForm
    1267      * Complete signature form
    1268    * userId, string: User GUID (required)
    1269    * formGuid, string: Form GUID (required)
    1270    * @return SignatureStatusResponse
    1271      */
    1272 
    1273    public function CompleteSignatureForm($userId, $formGuid) {
    1274       if( $userId === null || $formGuid === null ) {
    1275         throw new ApiException("missing required parameters", 400);
    1276       }
    1277       //parse inputs
    1278       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/complete");
    1279       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1280       $method = "PUT";
    1281       $queryParams = array();
    1282       $headerParams = array();
    1283 
    1284       if($userId !== null) {
    1285             $resourcePath = str_replace("{" . "userId" . "}",
    1286                                         $userId, $resourcePath);
    1287         }
    1288         if($formGuid !== null) {
    1289             $resourcePath = str_replace("{" . "formGuid" . "}",
    1290                                         $formGuid, $resourcePath);
    1291         }
    1292         //make the API Call
    1293       if (! isset($body)) {
    1294         $body = null;
    1295       }
    1296       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1297                                               $queryParams, $body, $headerParams);
    1298       if(! $response){
    1299         return null;
    1300       }
    1301 
    1302       $responseObject = $this->apiClient->deserialize($response,
    1303                                                         'SignatureStatusResponse');
    1304       return $responseObject;
    1305       }
    1306   /**
    1307      * CreateSignatureForm
    1308      * Create signature form
    1309    * userId, string: User GUID (required)
    1310    * name, string: Form name (optional)
    1311    * templateGuid, string: A templateGuid of the template which will be used to created the new form (optional)
    1312    * assemblyGuid, string: A guid of the assembly which will be used to created the new form (optional)
    1313    * formGuid, string: A formGuid of the form which will be used to created the new form (optional)
    1314    * body, SignatureFormSettingsInfo: Settings of the new form (optional)
    1315    * @return SignatureFormResponse
    1316      */
    1317 
    1318    public function CreateSignatureForm($userId, $name=null, $templateGuid=null, $assemblyGuid=null, $formGuid=null, $body=null) {
    1319       if( $userId === null ) {
    1320         throw new ApiException("missing required parameters", 400);
    1321       }
    1322       //parse inputs
    1323       $resourcePath = str_replace("*", "", "/signature/{userId}/form?name={name}&templateId={templateGuid}&assemblyId={assemblyGuid}&formId={formGuid}");
    1324       $pos = strpos($resourcePath, "?");
    1325       if($pos !== false){
    1326         $resourcePath = substr($resourcePath, 0, $pos);
    1327       }
    1328       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1329       $method = "POST";
    1330       $queryParams = array();
    1331       $headerParams = array();
    1332 
    1333       if($name !== null) {
    1334           $queryParams['name'] = $this->apiClient->toPathValue($name);
    1335         }
    1336         if($templateGuid !== null) {
    1337           $queryParams['templateId'] = $this->apiClient->toPathValue($templateGuid);
    1338         }
    1339         if($assemblyGuid !== null) {
    1340           $queryParams['assemblyId'] = $this->apiClient->toPathValue($assemblyGuid);
    1341         }
    1342         if($formGuid !== null) {
    1343           $queryParams['formId'] = $this->apiClient->toPathValue($formGuid);
    1344         }
    1345         if($userId !== null) {
    1346             $resourcePath = str_replace("{" . "userId" . "}",
    1347                                         $userId, $resourcePath);
    1348         }
    1349         //make the API Call
    1350       if (! isset($body)) {
    1351         $body = null;
    1352       }
    1353       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1354                                               $queryParams, $body, $headerParams);
    1355       if(! $response){
    1356         return null;
    1357       }
    1358 
    1359       $responseObject = $this->apiClient->deserialize($response,
    1360                                                         'SignatureFormResponse');
    1361       return $responseObject;
    1362       }
    1363   /**
    1364      * DeleteSignatureForm
    1365      * Delete signature form
    1366    * userId, string: User GUID (required)
    1367    * formGuid, string: Form GUID (required)
    1368    * @return SignatureStatusResponse
    1369      */
    1370 
    1371    public function DeleteSignatureForm($userId, $formGuid) {
    1372       if( $userId === null || $formGuid === null ) {
    1373         throw new ApiException("missing required parameters", 400);
    1374       }
    1375       //parse inputs
    1376       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}");
    1377       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1378       $method = "DELETE";
    1379       $queryParams = array();
    1380       $headerParams = array();
    1381 
    1382       if($userId !== null) {
    1383             $resourcePath = str_replace("{" . "userId" . "}",
    1384                                         $userId, $resourcePath);
    1385         }
    1386         if($formGuid !== null) {
    1387             $resourcePath = str_replace("{" . "formGuid" . "}",
    1388                                         $formGuid, $resourcePath);
    1389         }
    1390         //make the API Call
    1391       if (! isset($body)) {
    1392         $body = null;
    1393       }
    1394       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1395                                               $queryParams, $body, $headerParams);
    1396       if(! $response){
    1397         return null;
    1398       }
    1399 
    1400       $responseObject = $this->apiClient->deserialize($response,
    1401                                                         'SignatureStatusResponse');
    1402       return $responseObject;
    1403       }
    1404   /**
    1405      * AddSignatureFormDocument
    1406      * Add document in form
    1407    * userId, string: User GUID (required)
    1408    * formGuid, string: Form GUID (required)
    1409    * documentGuid, string: Document GUID (required)
    1410    * order, int: Document order (optional)
    1411    * parseFields, bool: Try to parse fields in document (optional)
    1412    * @return SignatureFormDocumentResponse
    1413      */
    1414 
    1415    public function AddSignatureFormDocument($userId, $formGuid, $documentGuid, $order=null, $parseFields=null) {
    1416       if( $userId === null || $formGuid === null || $documentGuid === null ) {
    1417         throw new ApiException("missing required parameters", 400);
    1418       }
    1419       //parse inputs
    1420       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/document/{documentGuid}?parseFields={parseFields}&order={order}");
    1421       $pos = strpos($resourcePath, "?");
    1422       if($pos !== false){
    1423         $resourcePath = substr($resourcePath, 0, $pos);
    1424       }
    1425       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1426       $method = "POST";
    1427       $queryParams = array();
    1428       $headerParams = array();
    1429 
    1430       if($order !== null) {
    1431           $queryParams['order'] = $this->apiClient->toPathValue($order);
    1432         }
    1433         if($parseFields !== null) {
    1434           $queryParams['parseFields'] = $this->apiClient->toPathValue($parseFields);
    1435         }
    1436         if($userId !== null) {
    1437             $resourcePath = str_replace("{" . "userId" . "}",
    1438                                         $userId, $resourcePath);
    1439         }
    1440         if($formGuid !== null) {
    1441             $resourcePath = str_replace("{" . "formGuid" . "}",
    1442                                         $formGuid, $resourcePath);
    1443         }
    1444         if($documentGuid !== null) {
    1445             $resourcePath = str_replace("{" . "documentGuid" . "}",
    1446                                         $documentGuid, $resourcePath);
    1447         }
    1448         //make the API Call
    1449       if (! isset($body)) {
    1450         $body = null;
    1451       }
    1452       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1453                                               $queryParams, $body, $headerParams);
    1454       if(! $response){
    1455         return null;
    1456       }
    1457 
    1458       $responseObject = $this->apiClient->deserialize($response,
    1459                                                         'SignatureFormDocumentResponse');
    1460       return $responseObject;
    1461       }
    1462   /**
    1463      * DeleteSignatureFormDocument
    1464      * Delete document from form
    1465    * userId, string: User GUID (required)
    1466    * formGuid, string: Form GUID (required)
    1467    * documentGuid, string: Document GUID (required)
    1468    * @return SignatureStatusResponse
    1469      */
    1470 
    1471    public function DeleteSignatureFormDocument($userId, $formGuid, $documentGuid) {
    1472       if( $userId === null || $formGuid === null || $documentGuid === null ) {
    1473         throw new ApiException("missing required parameters", 400);
    1474       }
    1475       //parse inputs
    1476       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents/{documentGuid}");
    1477       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1478       $method = "DELETE";
    1479       $queryParams = array();
    1480       $headerParams = array();
    1481 
    1482       if($userId !== null) {
    1483             $resourcePath = str_replace("{" . "userId" . "}",
    1484                                         $userId, $resourcePath);
    1485         }
    1486         if($formGuid !== null) {
    1487             $resourcePath = str_replace("{" . "formGuid" . "}",
    1488                                         $formGuid, $resourcePath);
    1489         }
    1490         if($documentGuid !== null) {
    1491             $resourcePath = str_replace("{" . "documentGuid" . "}",
    1492                                         $documentGuid, $resourcePath);
    1493         }
    1494         //make the API Call
    1495       if (! isset($body)) {
    1496         $body = null;
    1497       }
    1498       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1499                                               $queryParams, $body, $headerParams);
    1500       if(! $response){
    1501         return null;
    1502       }
    1503 
    1504       $responseObject = $this->apiClient->deserialize($response,
    1505                                                         'SignatureStatusResponse');
    1506       return $responseObject;
    1507       }
    1508   /**
    1509      * GetSignatureFormDocuments
    1510      * Get documents in form
    1511    * userId, string: User GUID (required)
    1512    * formGuid, string: Form GUID (required)
    1513    * @return SignatureFormDocumentsResponse
    1514      */
    1515 
    1516    public function GetSignatureFormDocuments($userId, $formGuid) {
    1517       if( $userId === null || $formGuid === null ) {
    1518         throw new ApiException("missing required parameters", 400);
    1519       }
    1520       //parse inputs
    1521       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents");
    1522       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1523       $method = "GET";
    1524       $queryParams = array();
    1525       $headerParams = array();
    1526 
    1527       if($userId !== null) {
    1528             $resourcePath = str_replace("{" . "userId" . "}",
    1529                                         $userId, $resourcePath);
    1530         }
    1531         if($formGuid !== null) {
    1532             $resourcePath = str_replace("{" . "formGuid" . "}",
    1533                                         $formGuid, $resourcePath);
    1534         }
    1535         //make the API Call
    1536       if (! isset($body)) {
    1537         $body = null;
    1538       }
    1539       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1540                                               $queryParams, $body, $headerParams);
    1541       if(! $response){
    1542         return null;
    1543       }
    1544 
    1545       $responseObject = $this->apiClient->deserialize($response,
    1546                                                         'SignatureFormDocumentsResponse');
    1547       return $responseObject;
    1548       }
    1549   /**
    1550      * AddSignatureFormField
    1551      * Add signature field for document in form
    1552    * userId, string: User GUID (required)
    1553    * formGuid, string: Form GUID (required)
    1554    * documentGuid, string: Document GUID (required)
    1555    * fieldGuid, string: Field GUID (required)
    1556    * body, SignatureFormFieldSettingsInfo: Settings of the field (optional)
    1557    * @return SignatureFormFieldResponse
    1558      */
    1559 
    1560    public function AddSignatureFormField($userId, $formGuid, $documentGuid, $fieldGuid, $body=null) {
    1561       if( $userId === null || $formGuid === null || $documentGuid === null || $fieldGuid === null ) {
    1562         throw new ApiException("missing required parameters", 400);
    1563       }
    1564       //parse inputs
    1565       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents/{documentGuid}/field/{fieldGuid}");
    1566       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1567       $method = "POST";
    1568       $queryParams = array();
    1569       $headerParams = array();
    1570 
    1571       if($userId !== null) {
    1572             $resourcePath = str_replace("{" . "userId" . "}",
    1573                                         $userId, $resourcePath);
    1574         }
    1575         if($formGuid !== null) {
    1576             $resourcePath = str_replace("{" . "formGuid" . "}",
    1577                                         $formGuid, $resourcePath);
    1578         }
    1579         if($documentGuid !== null) {
    1580             $resourcePath = str_replace("{" . "documentGuid" . "}",
    1581                                         $documentGuid, $resourcePath);
    1582         }
    1583         if($fieldGuid !== null) {
    1584             $resourcePath = str_replace("{" . "fieldGuid" . "}",
    1585                                         $fieldGuid, $resourcePath);
    1586         }
    1587         //make the API Call
    1588       if (! isset($body)) {
    1589         $body = null;
    1590       }
    1591       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1592                                               $queryParams, $body, $headerParams);
    1593       if(! $response){
    1594         return null;
    1595       }
    1596 
    1597       $responseObject = $this->apiClient->deserialize($response,
    1598                                                         'SignatureFormFieldResponse');
    1599       return $responseObject;
    1600       }
    1601   /**
    1602      * ModifySignatureFormFieldLocation
    1603      * Modify signature form field location
    1604    * userId, string: User GUID (required)
    1605    * formGuid, string: Form GUID (required)
    1606    * documentGuid, string: Document GUID (required)
    1607    * fieldGuid, string: Field GUID (required)
    1608    * locationGuid, string: Field location GUID (required)
    1609    * body, SignatureFormFieldLocationSettingsInfo: Settings of the field location (optional)
    1610    * @return SignatureFormFieldResponse
    1611      */
    1612 
    1613    public function ModifySignatureFormFieldLocation($userId, $formGuid, $documentGuid, $fieldGuid, $locationGuid, $body=null) {
    1614       if( $userId === null || $formGuid === null || $documentGuid === null || $fieldGuid === null || $locationGuid === null ) {
    1615         throw new ApiException("missing required parameters", 400);
    1616       }
    1617       //parse inputs
    1618       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents/{documentGuid}/fields/{fieldGuid}/locations/{locationGuid}");
    1619       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1620       $method = "PUT";
    1621       $queryParams = array();
    1622       $headerParams = array();
    1623 
    1624       if($userId !== null) {
    1625             $resourcePath = str_replace("{" . "userId" . "}",
    1626                                         $userId, $resourcePath);
    1627         }
    1628         if($formGuid !== null) {
    1629             $resourcePath = str_replace("{" . "formGuid" . "}",
    1630                                         $formGuid, $resourcePath);
    1631         }
    1632         if($documentGuid !== null) {
    1633             $resourcePath = str_replace("{" . "documentGuid" . "}",
    1634                                         $documentGuid, $resourcePath);
    1635         }
    1636         if($fieldGuid !== null) {
    1637             $resourcePath = str_replace("{" . "fieldGuid" . "}",
    1638                                         $fieldGuid, $resourcePath);
    1639         }
    1640         if($locationGuid !== null) {
    1641             $resourcePath = str_replace("{" . "locationGuid" . "}",
    1642                                         $locationGuid, $resourcePath);
    1643         }
    1644         //make the API Call
    1645       if (! isset($body)) {
    1646         $body = null;
    1647       }
    1648       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1649                                               $queryParams, $body, $headerParams);
    1650       if(! $response){
    1651         return null;
    1652       }
    1653 
    1654       $responseObject = $this->apiClient->deserialize($response,
    1655                                                         'SignatureFormFieldResponse');
    1656       return $responseObject;
    1657       }
    1658   /**
    1659      * DeleteSignatureFormFieldLocation
    1660      * Remove signature form field location
    1661    * userId, string: User GUID (required)
    1662    * formGuid, string: Form GUID (required)
    1663    * fieldGuid, string: Field GUID (required)
    1664    * locationGuid, string: Field location GUID (required)
    1665    * @return SignatureStatusResponse
    1666      */
    1667 
    1668    public function DeleteSignatureFormFieldLocation($userId, $formGuid, $fieldGuid, $locationGuid) {
    1669       if( $userId === null || $formGuid === null || $fieldGuid === null || $locationGuid === null ) {
    1670         throw new ApiException("missing required parameters", 400);
    1671       }
    1672       //parse inputs
    1673       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/fields/{fieldGuid}/locations/{locationGuid}");
    1674       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1675       $method = "DELETE";
    1676       $queryParams = array();
    1677       $headerParams = array();
    1678 
    1679       if($userId !== null) {
    1680             $resourcePath = str_replace("{" . "userId" . "}",
    1681                                         $userId, $resourcePath);
    1682         }
    1683         if($formGuid !== null) {
    1684             $resourcePath = str_replace("{" . "formGuid" . "}",
    1685                                         $formGuid, $resourcePath);
    1686         }
    1687         if($fieldGuid !== null) {
    1688             $resourcePath = str_replace("{" . "fieldGuid" . "}",
    1689                                         $fieldGuid, $resourcePath);
    1690         }
    1691         if($locationGuid !== null) {
    1692             $resourcePath = str_replace("{" . "locationGuid" . "}",
    1693                                         $locationGuid, $resourcePath);
    1694         }
    1695         //make the API Call
    1696       if (! isset($body)) {
    1697         $body = null;
    1698       }
    1699       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1700                                               $queryParams, $body, $headerParams);
    1701       if(! $response){
    1702         return null;
    1703       }
    1704 
    1705       $responseObject = $this->apiClient->deserialize($response,
    1706                                                         'SignatureStatusResponse');
    1707       return $responseObject;
    1708       }
    1709   /**
    1710      * ModifySignatureFormField
    1711      * Modify signature form field
    1712    * userId, string: User GUID (required)
    1713    * formGuid, string: Form GUID (required)
    1714    * documentGuid, string: Document GUID (required)
    1715    * fieldGuid, string: Field GUID (required)
    1716    * body, SignatureFormFieldSettingsInfo: Settings of the field (optional)
    1717    * @return SignatureFormFieldResponse
    1718      */
    1719 
    1720    public function ModifySignatureFormField($userId, $formGuid, $documentGuid, $fieldGuid, $body=null) {
    1721       if( $userId === null || $formGuid === null || $documentGuid === null || $fieldGuid === null ) {
    1722         throw new ApiException("missing required parameters", 400);
    1723       }
    1724       //parse inputs
    1725       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents/{documentGuid}/field/{fieldGuid}");
    1726       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1727       $method = "PUT";
    1728       $queryParams = array();
    1729       $headerParams = array();
    1730 
    1731       if($userId !== null) {
    1732             $resourcePath = str_replace("{" . "userId" . "}",
    1733                                         $userId, $resourcePath);
    1734         }
    1735         if($formGuid !== null) {
    1736             $resourcePath = str_replace("{" . "formGuid" . "}",
    1737                                         $formGuid, $resourcePath);
    1738         }
    1739         if($documentGuid !== null) {
    1740             $resourcePath = str_replace("{" . "documentGuid" . "}",
    1741                                         $documentGuid, $resourcePath);
    1742         }
    1743         if($fieldGuid !== null) {
    1744             $resourcePath = str_replace("{" . "fieldGuid" . "}",
    1745                                         $fieldGuid, $resourcePath);
    1746         }
    1747         //make the API Call
    1748       if (! isset($body)) {
    1749         $body = null;
    1750       }
    1751       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1752                                               $queryParams, $body, $headerParams);
    1753       if(! $response){
    1754         return null;
    1755       }
    1756 
    1757       $responseObject = $this->apiClient->deserialize($response,
    1758                                                         'SignatureFormFieldResponse');
    1759       return $responseObject;
    1760       }
    1761   /**
    1762      * DeleteSignatureFormField
    1763      * Delete signature form field
    1764    * userId, string: User GUID (required)
    1765    * formGuid, string: Form GUID (required)
    1766    * fieldGuid, string: Field GUID (required)
    1767    * @return SignatureStatusResponse
    1768      */
    1769 
    1770    public function DeleteSignatureFormField($userId, $formGuid, $fieldGuid) {
    1771       if( $userId === null || $formGuid === null || $fieldGuid === null ) {
    1772         throw new ApiException("missing required parameters", 400);
    1773       }
    1774       //parse inputs
    1775       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/fields/{fieldGuid}");
    1776       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1777       $method = "DELETE";
    1778       $queryParams = array();
    1779       $headerParams = array();
    1780 
    1781       if($userId !== null) {
    1782             $resourcePath = str_replace("{" . "userId" . "}",
    1783                                         $userId, $resourcePath);
    1784         }
    1785         if($formGuid !== null) {
    1786             $resourcePath = str_replace("{" . "formGuid" . "}",
    1787                                         $formGuid, $resourcePath);
    1788         }
    1789         if($fieldGuid !== null) {
    1790             $resourcePath = str_replace("{" . "fieldGuid" . "}",
    1791                                         $fieldGuid, $resourcePath);
    1792         }
    1793         //make the API Call
    1794       if (! isset($body)) {
    1795         $body = null;
    1796       }
    1797       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1798                                               $queryParams, $body, $headerParams);
    1799       if(! $response){
    1800         return null;
    1801       }
    1802 
    1803       $responseObject = $this->apiClient->deserialize($response,
    1804                                                         'SignatureStatusResponse');
    1805       return $responseObject;
    1806       }
    1807   /**
    1808      * GetSignatureFormFields
    1809      * Get form fields for document in form per participant
    1810    * userId, string: User GUID (required)
    1811    * formGuid, string: Form GUID (required)
    1812    * documentGuid, string: Document GUID (required)
    1813    * fieldGuid, string: Field GUID (optional)
    1814    * @return SignatureFormFieldsResponse
    1815      */
    1816 
    1817    public function GetSignatureFormFields($userId, $formGuid, $documentGuid, $fieldGuid=null) {
    1818       if( $userId === null || $formGuid === null || $documentGuid === null ) {
    1819         throw new ApiException("missing required parameters", 400);
    1820       }
    1821       //parse inputs
    1822       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents/{documentGuid}/fields?field={fieldGuid}");
    1823       $pos = strpos($resourcePath, "?");
    1824       if($pos !== false){
    1825         $resourcePath = substr($resourcePath, 0, $pos);
    1826       }
    1827       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1828       $method = "GET";
    1829       $queryParams = array();
    1830       $headerParams = array();
    1831 
    1832       if($fieldGuid !== null) {
    1833           $queryParams['field'] = $this->apiClient->toPathValue($fieldGuid);
    1834         }
    1835         if($userId !== null) {
    1836             $resourcePath = str_replace("{" . "userId" . "}",
    1837                                         $userId, $resourcePath);
    1838         }
    1839         if($formGuid !== null) {
    1840             $resourcePath = str_replace("{" . "formGuid" . "}",
    1841                                         $formGuid, $resourcePath);
    1842         }
    1843         if($documentGuid !== null) {
    1844             $resourcePath = str_replace("{" . "documentGuid" . "}",
    1845                                         $documentGuid, $resourcePath);
    1846         }
    1847         //make the API Call
    1848       if (! isset($body)) {
    1849         $body = null;
    1850       }
    1851       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1852                                               $queryParams, $body, $headerParams);
    1853       if(! $response){
    1854         return null;
    1855       }
    1856 
    1857       $responseObject = $this->apiClient->deserialize($response,
    1858                                                         'SignatureFormFieldsResponse');
    1859       return $responseObject;
    1860       }
    1861   /**
    1862      * GetSignatureForm
    1863      * Get signature form
    1864    * userId, string: User GUID (required)
    1865    * formGuid, string: Form GUID (required)
    1866    * @return SignatureFormResponse
    1867      */
    1868 
    1869    public function GetSignatureForm($userId, $formGuid) {
    1870       if( $userId === null || $formGuid === null ) {
    1871         throw new ApiException("missing required parameters", 400);
    1872       }
    1873       //parse inputs
    1874       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}");
    1875       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1876       $method = "GET";
    1877       $queryParams = array();
    1878       $headerParams = array();
    1879 
    1880       if($userId !== null) {
    1881             $resourcePath = str_replace("{" . "userId" . "}",
    1882                                         $userId, $resourcePath);
    1883         }
    1884         if($formGuid !== null) {
    1885             $resourcePath = str_replace("{" . "formGuid" . "}",
    1886                                         $formGuid, $resourcePath);
    1887         }
    1888         //make the API Call
    1889       if (! isset($body)) {
    1890         $body = null;
    1891       }
    1892       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1893                                               $queryParams, $body, $headerParams);
    1894       if(! $response){
    1895         return null;
    1896       }
    1897 
    1898       $responseObject = $this->apiClient->deserialize($response,
    1899                                                         'SignatureFormResponse');
    1900       return $responseObject;
    1901       }
    1902   /**
    1903      * ModifySignatureForm
    1904      * Modify signature form
    1905    * userId, string: User GUID (required)
    1906    * formGuid, string: Form GUID (required)
    1907    * body, SignatureFormSettingsInfo: Settings of the form (optional)
    1908    * @return SignatureFormResponse
    1909      */
    1910 
    1911    public function ModifySignatureForm($userId, $formGuid, $body=null) {
    1912       if( $userId === null || $formGuid === null ) {
    1913         throw new ApiException("missing required parameters", 400);
    1914       }
    1915       //parse inputs
    1916       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}");
    1917       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1918       $method = "POST";
    1919       $queryParams = array();
    1920       $headerParams = array();
    1921 
    1922       if($userId !== null) {
    1923             $resourcePath = str_replace("{" . "userId" . "}",
    1924                                         $userId, $resourcePath);
    1925         }
    1926         if($formGuid !== null) {
    1927             $resourcePath = str_replace("{" . "formGuid" . "}",
    1928                                         $formGuid, $resourcePath);
    1929         }
    1930         //make the API Call
    1931       if (! isset($body)) {
    1932         $body = null;
    1933       }
    1934       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1935                                               $queryParams, $body, $headerParams);
    1936       if(! $response){
    1937         return null;
    1938       }
    1939 
    1940       $responseObject = $this->apiClient->deserialize($response,
    1941                                                         'SignatureFormResponse');
    1942       return $responseObject;
    1943       }
    1944   /**
    1945      * PublishSignatureForm
    1946      * Publish signature form
    1947    * userId, string: User GUID (required)
    1948    * formGuid, string: Form GUID (required)
    1949    * body, WebhookInfo: Webhook Callback Url (optional)
    1950    * @return SignatureStatusResponse
    1951      */
    1952 
    1953    public function PublishSignatureForm($userId, $formGuid, $body=null) {
    1954       if( $userId === null || $formGuid === null ) {
    1955         throw new ApiException("missing required parameters", 400);
    1956       }
    1957       //parse inputs
    1958       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/publish");
    1959       $resourcePath = str_replace("{format}", "json", $resourcePath);
    1960       $method = "PUT";
    1961       $queryParams = array();
    1962       $headerParams = array();
    1963 
    1964       if($userId !== null) {
    1965             $resourcePath = str_replace("{" . "userId" . "}",
    1966                                         $userId, $resourcePath);
    1967         }
    1968         if($formGuid !== null) {
    1969             $resourcePath = str_replace("{" . "formGuid" . "}",
    1970                                         $formGuid, $resourcePath);
    1971         }
    1972         //make the API Call
    1973       if (! isset($body)) {
    1974         $body = null;
    1975       }
    1976       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    1977                                               $queryParams, $body, $headerParams);
    1978       if(! $response){
    1979         return null;
    1980       }
    1981 
    1982       $responseObject = $this->apiClient->deserialize($response,
    1983                                                         'SignatureStatusResponse');
    1984       return $responseObject;
    1985       }
    1986   /**
    1987      * RenameSignatureForm
    1988      * Rename signature form
    1989    * userId, string: User GUID (required)
    1990    * formGuid, string: Form GUID (required)
    1991    * name, string: New form name (required)
    1992    * @return SignatureFormResponse
    1993      */
    1994 
    1995    public function RenameSignatureForm($userId, $formGuid, $name) {
    1996       if( $userId === null || $formGuid === null || $name === null ) {
    1997         throw new ApiException("missing required parameters", 400);
    1998       }
    1999       //parse inputs
    2000       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}?new_name={name}");
    2001       $pos = strpos($resourcePath, "?");
    2002       if($pos !== false){
    2003         $resourcePath = substr($resourcePath, 0, $pos);
    2004       }
    2005       $resourcePath = str_replace("{format}", "json", $resourcePath);
    2006       $method = "PUT";
    2007       $queryParams = array();
    2008       $headerParams = array();
    2009 
    2010       if($name !== null) {
    2011           $queryParams['new_name'] = $this->apiClient->toPathValue($name);
    2012         }
    2013         if($userId !== null) {
    2014             $resourcePath = str_replace("{" . "userId" . "}",
    2015                                         $userId, $resourcePath);
    2016         }
    2017         if($formGuid !== null) {
    2018             $resourcePath = str_replace("{" . "formGuid" . "}",
    2019                                         $formGuid, $resourcePath);
    2020         }
    2021         //make the API Call
    2022       if (! isset($body)) {
    2023         $body = null;
    2024       }
    2025       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2026                                               $queryParams, $body, $headerParams);
    2027       if(! $response){
    2028         return null;
    2029       }
    2030 
    2031       $responseObject = $this->apiClient->deserialize($response,
    2032                                                         'SignatureFormResponse');
    2033       return $responseObject;
    2034       }
    2035   /**
    2036      * UpdateSignatureFormFromTemplate
    2037      * Add signature form fields from template
    2038    * userId, string: User GUID (required)
    2039    * formGuid, string: Form GUID (required)
    2040    * templateGuid, string: Template GUID (required)
    2041    * @return SignatureFormResponse
    2042      */
    2043 
    2044    public function UpdateSignatureFormFromTemplate($userId, $formGuid, $templateGuid) {
    2045       if( $userId === null || $formGuid === null || $templateGuid === null ) {
    2046         throw new ApiException("missing required parameters", 400);
    2047       }
    2048       //parse inputs
    2049       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/templates/{templateGuid}");
    2050       $resourcePath = str_replace("{format}", "json", $resourcePath);
    2051       $method = "POST";
    2052       $queryParams = array();
    2053       $headerParams = array();
    2054 
    2055       if($userId !== null) {
    2056             $resourcePath = str_replace("{" . "userId" . "}",
    2057                                         $userId, $resourcePath);
    2058         }
    2059         if($formGuid !== null) {
    2060             $resourcePath = str_replace("{" . "formGuid" . "}",
    2061                                         $formGuid, $resourcePath);
    2062         }
    2063         if($templateGuid !== null) {
    2064             $resourcePath = str_replace("{" . "templateGuid" . "}",
    2065                                         $templateGuid, $resourcePath);
    2066         }
    2067         //make the API Call
    2068       if (! isset($body)) {
    2069         $body = null;
    2070       }
    2071       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2072                                               $queryParams, $body, $headerParams);
    2073       if(! $response){
    2074         return null;
    2075       }
    2076 
    2077       $responseObject = $this->apiClient->deserialize($response,
    2078                                                         'SignatureFormResponse');
    2079       return $responseObject;
    2080       }
    2081   /**
    2082      * GetSignatureForms
    2083      * Get signature forms
    2084    * userId, string: User GUID (required)
    2085    * statusId, int: Filter forms by statusId (optional)
    2086    * page, int: Show records for page number (optional)
    2087    * records, int: Show records count (optional)
    2088    * originalDocumentMD5, string: Filter forms by original document MD5 (optional)
    2089    * DateTime, string: Filter forms by date (optional)
    2090    * name, string: Filter forms by name (optional)
    2091    * @return SignatureFormsResponse
    2092      */
    2093 
    2094    public function GetSignatureForms($userId, $statusId=null, $page=null, $records=null, $originalDocumentMD5=null, $DateTime=null, $name=null) {
    2095       if( $userId === null ) {
    2096         throw new ApiException("missing required parameters", 400);
    2097       }
    2098       //parse inputs
    2099       $resourcePath = str_replace("*", "", "/signature/{userId}/forms?statusId={statusId}&records={records}&page={page}&document={originalDocumentMD5}&date={date}&name={name}");
    2100       $pos = strpos($resourcePath, "?");
    2101       if($pos !== false){
    2102         $resourcePath = substr($resourcePath, 0, $pos);
    2103       }
    2104       $resourcePath = str_replace("{format}", "json", $resourcePath);
    2105       $method = "GET";
    2106       $queryParams = array();
    2107       $headerParams = array();
    2108 
    2109       if($statusId !== null) {
    2110           $queryParams['statusId'] = $this->apiClient->toPathValue($statusId);
    2111         }
    2112         if($page !== null) {
    2113           $queryParams['page'] = $this->apiClient->toPathValue($page);
    2114         }
    2115         if($records !== null) {
    2116           $queryParams['records'] = $this->apiClient->toPathValue($records);
    2117         }
    2118         if($originalDocumentMD5 !== null) {
    2119           $queryParams['document'] = $this->apiClient->toPathValue($originalDocumentMD5);
    2120         }
    2121         if($DateTime !== null) {
    2122           $queryParams['date'] = $this->apiClient->toPathValue($DateTime);
    2123         }
    2124         if($name !== null) {
    2125           $queryParams['name'] = $this->apiClient->toPathValue($name);
    2126         }
    2127         if($userId !== null) {
    2128             $resourcePath = str_replace("{" . "userId" . "}",
    2129                                         $userId, $resourcePath);
    2130         }
    2131         //make the API Call
    2132       if (! isset($body)) {
    2133         $body = null;
    2134       }
    2135       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2136                                               $queryParams, $body, $headerParams);
    2137       if(! $response){
    2138         return null;
    2139       }
    2140 
    2141       $responseObject = $this->apiClient->deserialize($response,
    2142                                                         'SignatureFormsResponse');
    2143       return $responseObject;
    2144       }
    2145   /**
    2146      * GetSignatureFormResources
    2147      * Get form resources
    2148    * userId, string: User GUID (required)
    2149    * statusIds, string: Form status identifier - comma separated list (required)
    2150    * @return SignatureFormResourcesResponse
    2151      */
    2152 
    2153    public function GetSignatureFormResources($userId, $statusIds) {
    2154       if( $userId === null || $statusIds === null ) {
    2155         throw new ApiException("missing required parameters", 400);
    2156       }
    2157       //parse inputs
    2158       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/resources?statusIds={statusIds}");
    2159       $pos = strpos($resourcePath, "?");
    2160       if($pos !== false){
    2161         $resourcePath = substr($resourcePath, 0, $pos);
    2162       }
    2163       $resourcePath = str_replace("{format}", "json", $resourcePath);
    2164       $method = "GET";
    2165       $queryParams = array();
    2166       $headerParams = array();
    2167 
    2168       if($statusIds !== null) {
    2169           $queryParams['statusIds'] = $this->apiClient->toPathValue($statusIds);
    2170         }
    2171         if($userId !== null) {
    2172             $resourcePath = str_replace("{" . "userId" . "}",
    2173                                         $userId, $resourcePath);
    2174         }
    2175         //make the API Call
    2176       if (! isset($body)) {
    2177         $body = null;
    2178       }
    2179       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2180                                               $queryParams, $body, $headerParams);
    2181       if(! $response){
    2182         return null;
    2183       }
    2184 
    2185       $responseObject = $this->apiClient->deserialize($response,
    2186                                                         'SignatureFormResourcesResponse');
    2187       return $responseObject;
    2188       }
    2189   /**
    2190      * GetSignedFormDocuments
    2191      * Get signed form documents
    2192    * userId, string: User GUID (required)
    2193    * formGuid, string: Form GUID (required)
    2194    * @return stream
    2195      */
    2196 
    2197    public function GetSignedFormDocuments($userId, $formGuid, FileStream $outFileStream) {
    2198       if( $userId === null || $formGuid === null ) {
    2199         throw new ApiException("missing required parameters", 400);
    2200       }
    2201       //parse inputs
    2202       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents/get");
    2203       $resourcePath = str_replace("{format}", "json", $resourcePath);
    2204       $method = "GET";
    2205       $queryParams = array();
    2206       $headerParams = array();
    2207 
    2208       if($userId !== null) {
    2209             $resourcePath = str_replace("{" . "userId" . "}",
    2210                                         $userId, $resourcePath);
    2211         }
    2212         if($formGuid !== null) {
    2213             $resourcePath = str_replace("{" . "formGuid" . "}",
    2214                                         $formGuid, $resourcePath);
    2215         }
    2216         //make the API Call
    2217       if (! isset($body)) {
    2218         $body = null;
    2219       }
    2220       return $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2221                                               $queryParams, $body, $headerParams, $outFileStream);
    2222       }
    2223   /**
    2224      * RenameSignatureFormDocument
    2225      * Rename signature form document
    2226    * userId, string: User GUID (required)
    2227    * formGuid, string: Form GUID (required)
    2228    * documentGuid, string: Form Document GUID (required)
    2229    * newName, string: New name of the document (optional)
    2230    * @return SignatureFormDocumentResponse
    2231      */
    2232 
    2233    public function RenameSignatureFormDocument($userId, $formGuid, $documentGuid, $newName=null) {
    2234       if( $userId === null || $formGuid === null || $documentGuid === null ) {
    2235         throw new ApiException("missing required parameters", 400);
    2236       }
    2237       //parse inputs
    2238       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/document/{documentGuid}?newName={newName}");
    2239       $pos = strpos($resourcePath, "?");
    2240       if($pos !== false){
    2241         $resourcePath = substr($resourcePath, 0, $pos);
    2242       }
    2243       $resourcePath = str_replace("{format}", "json", $resourcePath);
    2244       $method = "PUT";
    2245       $queryParams = array();
    2246       $headerParams = array();
    2247 
    2248       if($newName !== null) {
    2249           $queryParams['newName'] = $this->apiClient->toPathValue($newName);
    2250         }
    2251         if($userId !== null) {
    2252             $resourcePath = str_replace("{" . "userId" . "}",
    2253                                         $userId, $resourcePath);
    2254         }
    2255         if($formGuid !== null) {
    2256             $resourcePath = str_replace("{" . "formGuid" . "}",
    2257                                         $formGuid, $resourcePath);
    2258         }
    2259         if($documentGuid !== null) {
    2260             $resourcePath = str_replace("{" . "documentGuid" . "}",
    2261                                         $documentGuid, $resourcePath);
    2262         }
    2263         //make the API Call
    2264       if (! isset($body)) {
    2265         $body = null;
    2266       }
    2267       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2268                                               $queryParams, $body, $headerParams);
    2269       if(! $response){
    2270         return null;
    2271       }
    2272 
    2273       $responseObject = $this->apiClient->deserialize($response,
    2274                                                         'SignatureFormDocumentResponse');
    2275       return $responseObject;
    2276       }
    2277   /**
    2278      * ModifySignatureFormDocument
    2279      * Modify signature form document
    2280    * userId, string: User GUID (required)
    2281    * formGuid, string: Form GUID (required)
    2282    * documentGuid, string: Form Document GUID (required)
    2283    * body, SignatureFormDocumentSettingsInfo: Settings of the document (optional)
    2284    * @return SignatureFormDocumentResponse
    2285      */
    2286 
    2287    public function ModifySignatureFormDocument($userId, $formGuid, $documentGuid, $body=null) {
    2288       if( $userId === null || $formGuid === null || $documentGuid === null ) {
    2289         throw new ApiException("missing required parameters", 400);
    2290       }
    2291       //parse inputs
    2292       $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/document/{documentGuid}");
    2293       $resourcePath = str_replace("{format}", "json", $resourcePath);
    2294       $method = "PUT";
    2295       $queryParams = array();
    2296       $headerParams = array();
    2297 
    2298       if($userId !== null) {
    2299             $resourcePath = str_replace("{" . "userId" . "}",
    2300                                         $userId, $resourcePath);
    2301         }
    2302         if($formGuid !== null) {
    2303             $resourcePath = str_replace("{" . "formGuid" . "}",
    2304                                         $formGuid, $resourcePath);
    2305         }
    2306         if($documentGuid !== null) {
    2307             $resourcePath = str_replace("{" . "documentGuid" . "}",
    2308                                         $documentGuid, $resourcePath);
    2309         }
    2310         //make the API Call
    2311       if (! isset($body)) {
    2312         $body = null;
    2313       }
    2314       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2315                                               $queryParams, $body, $headerParams);
    2316       if(! $response){
    2317         return null;
    2318       }
    2319 
    2320       $responseObject = $this->apiClient->deserialize($response,
    2321                                                         'SignatureFormDocumentResponse');
    2322       return $responseObject;
    2323       }
    2324   /**
    2325      * GetFieldsList
    2326      * Get signature fields
    2327    * userId, string: User GUID (required)
    2328    * fieldGuid, string: Filter fields by id (optional)
    2329    * @return SignatureFieldsResponse
    2330      */
    2331 
    2332    public function GetFieldsList($userId, $fieldGuid=null) {
    2333       if( $userId === null ) {
    2334         throw new ApiException("missing required parameters", 400);
    2335       }
    2336       //parse inputs
    2337       $resourcePath = str_replace("*", "", "/signature/{userId}/fields?id={fieldGuid}");
    2338       $pos = strpos($resourcePath, "?");
    2339       if($pos !== false){
    2340         $resourcePath = substr($resourcePath, 0, $pos);
    2341       }
    2342       $resourcePath = str_replace("{format}", "json", $resourcePath);
    2343       $method = "GET";
    2344       $queryParams = array();
    2345       $headerParams = array();
    2346 
    2347       if($fieldGuid !== null) {
    2348           $queryParams['id'] = $this->apiClient->toPathValue($fieldGuid);
    2349         }
    2350         if($userId !== null) {
    2351             $resourcePath = str_replace("{" . "userId" . "}",
    2352                                         $userId, $resourcePath);
    2353         }
    2354         //make the API Call
    2355       if (! isset($body)) {
    2356         $body = null;
    2357       }
    2358       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2359                                               $queryParams, $body, $headerParams);
    2360       if(! $response){
    2361         return null;
    2362       }
    2363 
    2364       $responseObject = $this->apiClient->deserialize($response,
    2365                                                         'SignatureFieldsResponse');
    2366       return $responseObject;
    2367       }
    2368   /**
    2369      * CreateSignatureField
    2370      * Create signature field
    2371    * userId, string: User GUID (required)
    2372    * body, SignatureFieldSettingsInfo: Settings of the new field (optional)
    2373    * @return SignatureFieldResponse
    2374      */
    2375 
    2376    public function CreateSignatureField($userId, $body=null) {
    2377       if( $userId === null ) {
    2378         throw new ApiException("missing required parameters", 400);
    2379       }
    2380       //parse inputs
    2381       $resourcePath = str_replace("*", "", "/signature/{userId}/field");
    2382       $resourcePath = str_replace("{format}", "json", $resourcePath);
    2383       $method = "POST";
    2384       $queryParams = array();
    2385       $headerParams = array();
    2386 
    2387       if($userId !== null) {
    2388             $resourcePath = str_replace("{" . "userId" . "}",
    2389                                         $userId, $resourcePath);
    2390         }
    2391         //make the API Call
    2392       if (! isset($body)) {
    2393         $body = null;
    2394       }
    2395       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2396                                               $queryParams, $body, $headerParams);
    2397       if(! $response){
    2398         return null;
    2399       }
    2400 
    2401       $responseObject = $this->apiClient->deserialize($response,
    2402                                                         'SignatureFieldResponse');
    2403       return $responseObject;
    2404       }
    2405   /**
    2406      * ModifySignatureField
    2407      * Modify signature field
    2408    * userId, string: User GUID (required)
    2409    * fieldGuid, string: Field GUID (required)
    2410    * body, SignatureFieldSettingsInfo: Settings of the field (optional)
    2411    * @return SignatureFieldResponse
    2412      */
    2413 
    2414    public function ModifySignatureField($userId, $fieldGuid, $body=null) {
    2415       if( $userId === null || $fieldGuid === null ) {
    2416         throw new ApiException("missing required parameters", 400);
    2417       }
    2418       //parse inputs
    2419       $resourcePath = str_replace("*", "", "/signature/{userId}/fields/{fieldGuid}");
    2420       $resourcePath = str_replace("{format}", "json", $resourcePath);
    2421       $method = "POST";
    2422       $queryParams = array();
    2423       $headerParams = array();
    2424 
    2425       if($userId !== null) {
    2426             $resourcePath = str_replace("{" . "userId" . "}",
    2427                                         $userId, $resourcePath);
    2428         }
    2429         if($fieldGuid !== null) {
    2430             $resourcePath = str_replace("{" . "fieldGuid" . "}",
    2431                                         $fieldGuid, $resourcePath);
    2432         }
    2433         //make the API Call
    2434       if (! isset($body)) {
    2435         $body = null;
    2436       }
    2437       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2438                                               $queryParams, $body, $headerParams);
    2439       if(! $response){
    2440         return null;
    2441       }
    2442 
    2443       $responseObject = $this->apiClient->deserialize($response,
    2444                                                         'SignatureFieldResponse');
    2445       return $responseObject;
    2446       }
    2447   /**
    2448      * DeleteSignatureField
    2449      * Delete signature field
    2450    * userId, string: User GUID (required)
    2451    * fieldGuid, string: Field GUID (required)
    2452    * @return SignatureStatusResponse
    2453      */
    2454 
    2455    public function DeleteSignatureField($userId, $fieldGuid) {
    2456       if( $userId === null || $fieldGuid === null ) {
    2457         throw new ApiException("missing required parameters", 400);
    2458       }
    2459       //parse inputs
    2460       $resourcePath = str_replace("*", "", "/signature/{userId}/fields/{fieldGuid}");
    2461       $resourcePath = str_replace("{format}", "json", $resourcePath);
    2462       $method = "DELETE";
    2463       $queryParams = array();
    2464       $headerParams = array();
    2465 
    2466       if($userId !== null) {
    2467             $resourcePath = str_replace("{" . "userId" . "}",
    2468                                         $userId, $resourcePath);
    2469         }
    2470         if($fieldGuid !== null) {
    2471             $resourcePath = str_replace("{" . "fieldGuid" . "}",
    2472                                         $fieldGuid, $resourcePath);
    2473         }
    2474         //make the API Call
    2475       if (! isset($body)) {
    2476         $body = null;
    2477       }
    2478       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2479                                               $queryParams, $body, $headerParams);
    2480       if(! $response){
    2481         return null;
    2482       }
    2483 
    2484       $responseObject = $this->apiClient->deserialize($response,
    2485                                                         'SignatureStatusResponse');
    2486       return $responseObject;
    2487       }
    2488   /**
    24891156     * GetContacts
    24901157     * Get contacts
    … …  
    27081375      }
    27091376  /**
    2710      * GetRolesList
    2711      * Get signature roles
    2712    * userId, string: User GUID (required)
    2713    * roleGuid, string: Filter roles by GUID (optional)
    2714    * @return SignatureRolesResponse
    2715      */
    2716 
    2717    public function GetRolesList($userId, $roleGuid=null) {
    2718       if( $userId === null ) {
    2719         throw new ApiException("missing required parameters", 400);
    2720       }
    2721       //parse inputs
    2722       $resourcePath = str_replace("*", "", "/signature/{userId}/roles?id={roleGuid}");
    2723       $pos = strpos($resourcePath, "?");
    2724       if($pos !== false){
    2725         $resourcePath = substr($resourcePath, 0, $pos);
    2726       }
    2727       $resourcePath = str_replace("{format}", "json", $resourcePath);
    2728       $method = "GET";
    2729       $queryParams = array();
    2730       $headerParams = array();
    2731 
    2732       if($roleGuid !== null) {
    2733           $queryParams['id'] = $this->apiClient->toPathValue($roleGuid);
    2734         }
    2735         if($userId !== null) {
    2736             $resourcePath = str_replace("{" . "userId" . "}",
    2737                                         $userId, $resourcePath);
    2738         }
    2739         //make the API Call
    2740       if (! isset($body)) {
    2741         $body = null;
    2742       }
    2743       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2744                                               $queryParams, $body, $headerParams);
    2745       if(! $response){
    2746         return null;
    2747       }
    2748 
    2749       $responseObject = $this->apiClient->deserialize($response,
    2750                                                         'SignatureRolesResponse');
    2751       return $responseObject;
    2752       }
    2753   /**
    27541377     * AddContactIntegration
    27551378     * Add Contact Integration Authorization
    … …  
    27891412      }
    27901413  /**
    2791      * CreateSignature
    2792      * Create user signature
    2793    * userId, string: User GUID (required)
    2794    * name, string: Signature name (required)
    2795    * body, SignatureSignatureSettingsInfo: Settings of the signature (optional)
    2796    * @return SignatureSignatureResponse
    2797      */
    2798 
    2799    public function CreateSignature($userId, $name, $body=null) {
    2800       if( $userId === null || $name === null ) {
    2801         throw new ApiException("missing required parameters", 400);
    2802       }
    2803       //parse inputs
    2804       $resourcePath = str_replace("*", "", "/signature/{userId}/signature?name={name}");
    2805       $pos = strpos($resourcePath, "?");
    2806       if($pos !== false){
    2807         $resourcePath = substr($resourcePath, 0, $pos);
    2808       }
    2809       $resourcePath = str_replace("{format}", "json", $resourcePath);
     1414     * SignDocument
     1415     * Sign document
     1416   * userId, string: User GUID (required)
     1417   * body, SignatureSignDocumentSettingsInfo: Settings of the signing document (optional)
     1418   * @return SignatureSignDocumentResponse
     1419     */
     1420
     1421   public function SignDocument($userId, $body=null) {
     1422      if( $userId === null ) {
     1423        throw new ApiException("missing required parameters", 400);
     1424      }
     1425      //parse inputs
     1426      $resourcePath = str_replace("*", "", "/signature/{userId}/sign");
     1427      $resourcePath = str_replace("{format}", "json", $resourcePath);
    28101428      $method = "POST";
    28111429      $queryParams = array();
    28121430      $headerParams = array();
    28131431
    2814       if($name !== null) {
    2815           $queryParams['name'] = $this->apiClient->toPathValue($name);
    2816         }
    2817         if($userId !== null) {
    2818             $resourcePath = str_replace("{" . "userId" . "}",
    2819                                         $userId, $resourcePath);
    2820         }
    2821         //make the API Call
    2822       if (! isset($body)) {
    2823         $body = null;
    2824       }
    2825       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2826                                               $queryParams, $body, $headerParams);
    2827       if(! $response){
    2828         return null;
    2829       }
    2830 
    2831       $responseObject = $this->apiClient->deserialize($response,
    2832                                                         'SignatureSignatureResponse');
    2833       return $responseObject;
    2834       }
    2835   /**
    2836      * DeleteSignature
    2837      * Delete user signature
    2838    * userId, string: User GUID (required)
    2839    * signatureGuid, string: Signature GUID (required)
    2840    * @return SignatureStatusResponse
    2841      */
    2842 
    2843    public function DeleteSignature($userId, $signatureGuid) {
    2844       if( $userId === null || $signatureGuid === null ) {
    2845         throw new ApiException("missing required parameters", 400);
    2846       }
    2847       //parse inputs
    2848       $resourcePath = str_replace("*", "", "/signature/{userId}/signatures/{signatureGuid}");
    2849       $resourcePath = str_replace("{format}", "json", $resourcePath);
    2850       $method = "DELETE";
    2851       $queryParams = array();
    2852       $headerParams = array();
    2853 
    2854       if($userId !== null) {
    2855             $resourcePath = str_replace("{" . "userId" . "}",
    2856                                         $userId, $resourcePath);
    2857         }
    2858         if($signatureGuid !== null) {
    2859             $resourcePath = str_replace("{" . "signatureGuid" . "}",
    2860                                         $signatureGuid, $resourcePath);
    2861         }
    2862         //make the API Call
    2863       if (! isset($body)) {
    2864         $body = null;
    2865       }
    2866       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2867                                               $queryParams, $body, $headerParams);
    2868       if(! $response){
    2869         return null;
    2870       }
    2871 
    2872       $responseObject = $this->apiClient->deserialize($response,
    2873                                                         'SignatureStatusResponse');
    2874       return $responseObject;
    2875       }
    2876   /**
    2877      * GetSignatures
    2878      * Get user signatures
    2879    * userId, string: User GUID (required)
    2880    * page, int: Show records for page number (optional)
    2881    * records, int: Show records count (optional)
    2882    * name, string: Filter by signature name (optional)
    2883    * @return SignatureSignaturesResponse
    2884      */
    2885 
    2886    public function GetSignatures($userId, $page=null, $records=null, $name=null) {
    2887       if( $userId === null ) {
    2888         throw new ApiException("missing required parameters", 400);
    2889       }
    2890       //parse inputs
    2891       $resourcePath = str_replace("*", "", "/signature/{userId}/signatures?records={records}&page={page}&name={name}");
    2892       $pos = strpos($resourcePath, "?");
    2893       if($pos !== false){
    2894         $resourcePath = substr($resourcePath, 0, $pos);
    2895       }
    2896       $resourcePath = str_replace("{format}", "json", $resourcePath);
     1432      if($userId !== null) {
     1433            $resourcePath = str_replace("{" . "userId" . "}",
     1434                                        $userId, $resourcePath);
     1435        }
     1436        //make the API Call
     1437      if (! isset($body)) {
     1438        $body = null;
     1439      }
     1440      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     1441                                              $queryParams, $body, $headerParams);
     1442      if(! $response){
     1443        return null;
     1444      }
     1445
     1446      $responseObject = $this->apiClient->deserialize($response,
     1447                                                        'SignatureSignDocumentResponse');
     1448      return $responseObject;
     1449      }
     1450  /**
     1451     * GetSignDocumentStatus
     1452     * Get sign documents status
     1453   * userId, string: User GUID (required)
     1454   * jobGuid, string: Job GUID (required)
     1455   * @return SignatureSignDocumentStatusResponse
     1456     */
     1457
     1458   public function GetSignDocumentStatus($userId, $jobGuid) {
     1459      if( $userId === null || $jobGuid === null ) {
     1460        throw new ApiException("missing required parameters", 400);
     1461      }
     1462      //parse inputs
     1463      $resourcePath = str_replace("*", "", "/signature/{userId}/documents/{jobGuid}/status");
     1464      $resourcePath = str_replace("{format}", "json", $resourcePath);
    28971465      $method = "GET";
    28981466      $queryParams = array();
    28991467      $headerParams = array();
    29001468
    2901       if($page !== null) {
    2902           $queryParams['page'] = $this->apiClient->toPathValue($page);
    2903         }
    2904         if($records !== null) {
    2905           $queryParams['records'] = $this->apiClient->toPathValue($records);
    2906         }
    2907         if($name !== null) {
    2908           $queryParams['name'] = $this->apiClient->toPathValue($name);
    2909         }
    2910         if($userId !== null) {
    2911             $resourcePath = str_replace("{" . "userId" . "}",
    2912                                         $userId, $resourcePath);
    2913         }
    2914         //make the API Call
    2915       if (! isset($body)) {
    2916         $body = null;
    2917       }
    2918       $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
    2919                                               $queryParams, $body, $headerParams);
    2920       if(! $response){
    2921         return null;
    2922       }
    2923 
    2924       $responseObject = $this->apiClient->deserialize($response,
    2925                                                         'SignatureSignaturesResponse');
     1469      if($userId !== null) {
     1470            $resourcePath = str_replace("{" . "userId" . "}",
     1471                                        $userId, $resourcePath);
     1472        }
     1473        if($jobGuid !== null) {
     1474            $resourcePath = str_replace("{" . "jobGuid" . "}",
     1475                                        $jobGuid, $resourcePath);
     1476        }
     1477        //make the API Call
     1478      if (! isset($body)) {
     1479        $body = null;
     1480      }
     1481      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     1482                                              $queryParams, $body, $headerParams);
     1483      if(! $response){
     1484        return null;
     1485      }
     1486
     1487      $responseObject = $this->apiClient->deserialize($response,
     1488                                                        'SignatureSignDocumentStatusResponse');
    29261489      return $responseObject;
    29271490      }
    … …  
    37292292   * envelopeGuid, string: Envelope GUID (required)
    37302293   * documentGuid, string: Document GUID (required)
     2294   * recipientGuid, string: Recipient GUID (required)
    37312295   * fieldGuid, string: Field GUID (required)
    37322296   * body, SignatureEnvelopeFieldSettingsInfo: Settings of the field (optional)
    … …  
    37342298     */
    37352299
    3736    public function ModifySignatureEnvelopeField($userId, $envelopeGuid, $documentGuid, $fieldGuid, $body=null) {
    3737       if( $userId === null || $envelopeGuid === null || $documentGuid === null || $fieldGuid === null ) {
    3738         throw new ApiException("missing required parameters", 400);
    3739       }
    3740       //parse inputs
    3741       $resourcePath = str_replace("*", "", "/signature/{userId}/envelopes/{envelopeGuid}/documents/{documentGuid}/field/{fieldGuid}");
     2300   public function ModifySignatureEnvelopeField($userId, $envelopeGuid, $documentGuid, $recipientGuid, $fieldGuid, $body=null) {
     2301      if( $userId === null || $envelopeGuid === null || $documentGuid === null || $recipientGuid === null || $fieldGuid === null ) {
     2302        throw new ApiException("missing required parameters", 400);
     2303      }
     2304      //parse inputs
     2305      $resourcePath = str_replace("*", "", "/signature/{userId}/envelopes/{envelopeGuid}/documents/{documentGuid}/recipientGuid/{recipientGuid}/field/{fieldGuid}");
    37422306      $resourcePath = str_replace("{format}", "json", $resourcePath);
    37432307      $method = "PUT";
    … …  
    37562320            $resourcePath = str_replace("{" . "documentGuid" . "}",
    37572321                                        $documentGuid, $resourcePath);
     2322        }
     2323        if($recipientGuid !== null) {
     2324            $resourcePath = str_replace("{" . "recipientGuid" . "}",
     2325                                        $recipientGuid, $resourcePath);
    37582326        }
    37592327        if($fieldGuid !== null) {
    … …  
    43212889   * envelopeGuid, string: Envelope GUID (required)
    43222890   * recipientGuid, string: Recipient GUID (required)
     2891   * body, SignatureSignEnvelopeSettingsInfo: Sign settings (optional)
    43232892   * @return SignatureStatusResponse
    43242893     */
    43252894
    4326    public function SignEnvelope($userId, $envelopeGuid, $recipientGuid) {
     2895   public function SignEnvelope($userId, $envelopeGuid, $recipientGuid, $body=null) {
    43272896      if( $userId === null || $envelopeGuid === null || $recipientGuid === null ) {
    43282897        throw new ApiException("missing required parameters", 400);
    … …  
    43722941   * DateTime, string: Filter envelopes by date (optional)
    43732942   * name, string: Filter envelopes by name (optional)
     2943   * tag, string: Filter envelopes by tag (optional)
    43742944   * @return SignatureEnvelopesResponse
    43752945     */
    43762946
    4377    public function GetSignatureEnvelopes($userId, $statusId=null, $page=null, $records=null, $originalDocumentMD5=null, $recipientEmail=null, $DateTime=null, $name=null) {
     2947   public function GetSignatureEnvelopes($userId, $statusId=null, $page=null, $records=null, $originalDocumentMD5=null, $recipientEmail=null, $DateTime=null, $name=null, $tag=null) {
    43782948      if( $userId === null ) {
    43792949        throw new ApiException("missing required parameters", 400);
    43802950      }
    43812951      //parse inputs
    4382       $resourcePath = str_replace("*", "", "/signature/{userId}/envelopes?statusId={statusId}&records={records}&page={page}&document={originalDocumentMD5}&recipient={recipientEmail}&date={date}&name={name}");
     2952      $resourcePath = str_replace("*", "", "/signature/{userId}/envelopes?statusId={statusId}&records={records}&page={page}&document={originalDocumentMD5}&recipient={recipientEmail}&date={date}&name={name}&tag={tag}");
    43832953      $pos = strpos($resourcePath, "?");
    43842954      if($pos !== false){
    … …  
    44102980        if($name !== null) {
    44112981          $queryParams['name'] = $this->apiClient->toPathValue($name);
     2982        }
     2983        if($tag !== null) {
     2984          $queryParams['tag'] = $this->apiClient->toPathValue($tag);
    44122985        }
    44132986        if($userId !== null) {
    … …  
    47773350      }
    47783351  /**
     3352     * ResendSignatureEnvelopeEmailNotification
     3353     * Resend envelope email notification
     3354   * userId, string: User GUID (required)
     3355   * envelopeGuid, string: Envelope GUID (required)
     3356   * @return SignatureStatusResponse
     3357     */
     3358
     3359   public function ResendSignatureEnvelopeEmailNotification($userId, $envelopeGuid) {
     3360      if( $userId === null || $envelopeGuid === null ) {
     3361        throw new ApiException("missing required parameters", 400);
     3362      }
     3363      //parse inputs
     3364      $resourcePath = str_replace("*", "", "/signature/{userId}/envelopes/{envelopeGuid}/resend-notification");
     3365      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3366      $method = "PUT";
     3367      $queryParams = array();
     3368      $headerParams = array();
     3369
     3370      if($userId !== null) {
     3371            $resourcePath = str_replace("{" . "userId" . "}",
     3372                                        $userId, $resourcePath);
     3373        }
     3374        if($envelopeGuid !== null) {
     3375            $resourcePath = str_replace("{" . "envelopeGuid" . "}",
     3376                                        $envelopeGuid, $resourcePath);
     3377        }
     3378        //make the API Call
     3379      if (! isset($body)) {
     3380        $body = null;
     3381      }
     3382      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3383                                              $queryParams, $body, $headerParams);
     3384      if(! $response){
     3385        return null;
     3386      }
     3387
     3388      $responseObject = $this->apiClient->deserialize($response,
     3389                                                        'SignatureStatusResponse');
     3390      return $responseObject;
     3391      }
     3392  /**
     3393     * GetFieldsList
     3394     * Get signature fields
     3395   * userId, string: User GUID (required)
     3396   * fieldGuid, string: Filter fields by id (optional)
     3397   * @return SignatureFieldsResponse
     3398     */
     3399
     3400   public function GetFieldsList($userId, $fieldGuid=null) {
     3401      if( $userId === null ) {
     3402        throw new ApiException("missing required parameters", 400);
     3403      }
     3404      //parse inputs
     3405      $resourcePath = str_replace("*", "", "/signature/{userId}/fields?id={fieldGuid}");
     3406      $pos = strpos($resourcePath, "?");
     3407      if($pos !== false){
     3408        $resourcePath = substr($resourcePath, 0, $pos);
     3409      }
     3410      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3411      $method = "GET";
     3412      $queryParams = array();
     3413      $headerParams = array();
     3414
     3415      if($fieldGuid !== null) {
     3416          $queryParams['id'] = $this->apiClient->toPathValue($fieldGuid);
     3417        }
     3418        if($userId !== null) {
     3419            $resourcePath = str_replace("{" . "userId" . "}",
     3420                                        $userId, $resourcePath);
     3421        }
     3422        //make the API Call
     3423      if (! isset($body)) {
     3424        $body = null;
     3425      }
     3426      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3427                                              $queryParams, $body, $headerParams);
     3428      if(! $response){
     3429        return null;
     3430      }
     3431
     3432      $responseObject = $this->apiClient->deserialize($response,
     3433                                                        'SignatureFieldsResponse');
     3434      return $responseObject;
     3435      }
     3436  /**
     3437     * CreateSignatureField
     3438     * Create signature field
     3439   * userId, string: User GUID (required)
     3440   * body, SignatureFieldSettingsInfo: Settings of the new field (optional)
     3441   * @return SignatureFieldResponse
     3442     */
     3443
     3444   public function CreateSignatureField($userId, $body=null) {
     3445      if( $userId === null ) {
     3446        throw new ApiException("missing required parameters", 400);
     3447      }
     3448      //parse inputs
     3449      $resourcePath = str_replace("*", "", "/signature/{userId}/field");
     3450      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3451      $method = "POST";
     3452      $queryParams = array();
     3453      $headerParams = array();
     3454
     3455      if($userId !== null) {
     3456            $resourcePath = str_replace("{" . "userId" . "}",
     3457                                        $userId, $resourcePath);
     3458        }
     3459        //make the API Call
     3460      if (! isset($body)) {
     3461        $body = null;
     3462      }
     3463      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3464                                              $queryParams, $body, $headerParams);
     3465      if(! $response){
     3466        return null;
     3467      }
     3468
     3469      $responseObject = $this->apiClient->deserialize($response,
     3470                                                        'SignatureFieldResponse');
     3471      return $responseObject;
     3472      }
     3473  /**
     3474     * ModifySignatureField
     3475     * Modify signature field
     3476   * userId, string: User GUID (required)
     3477   * fieldGuid, string: Field GUID (required)
     3478   * body, SignatureFieldSettingsInfo: Settings of the field (optional)
     3479   * @return SignatureFieldResponse
     3480     */
     3481
     3482   public function ModifySignatureField($userId, $fieldGuid, $body=null) {
     3483      if( $userId === null || $fieldGuid === null ) {
     3484        throw new ApiException("missing required parameters", 400);
     3485      }
     3486      //parse inputs
     3487      $resourcePath = str_replace("*", "", "/signature/{userId}/fields/{fieldGuid}");
     3488      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3489      $method = "POST";
     3490      $queryParams = array();
     3491      $headerParams = array();
     3492
     3493      if($userId !== null) {
     3494            $resourcePath = str_replace("{" . "userId" . "}",
     3495                                        $userId, $resourcePath);
     3496        }
     3497        if($fieldGuid !== null) {
     3498            $resourcePath = str_replace("{" . "fieldGuid" . "}",
     3499                                        $fieldGuid, $resourcePath);
     3500        }
     3501        //make the API Call
     3502      if (! isset($body)) {
     3503        $body = null;
     3504      }
     3505      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3506                                              $queryParams, $body, $headerParams);
     3507      if(! $response){
     3508        return null;
     3509      }
     3510
     3511      $responseObject = $this->apiClient->deserialize($response,
     3512                                                        'SignatureFieldResponse');
     3513      return $responseObject;
     3514      }
     3515  /**
     3516     * DeleteSignatureField
     3517     * Delete signature field
     3518   * userId, string: User GUID (required)
     3519   * fieldGuid, string: Field GUID (required)
     3520   * @return SignatureStatusResponse
     3521     */
     3522
     3523   public function DeleteSignatureField($userId, $fieldGuid) {
     3524      if( $userId === null || $fieldGuid === null ) {
     3525        throw new ApiException("missing required parameters", 400);
     3526      }
     3527      //parse inputs
     3528      $resourcePath = str_replace("*", "", "/signature/{userId}/fields/{fieldGuid}");
     3529      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3530      $method = "DELETE";
     3531      $queryParams = array();
     3532      $headerParams = array();
     3533
     3534      if($userId !== null) {
     3535            $resourcePath = str_replace("{" . "userId" . "}",
     3536                                        $userId, $resourcePath);
     3537        }
     3538        if($fieldGuid !== null) {
     3539            $resourcePath = str_replace("{" . "fieldGuid" . "}",
     3540                                        $fieldGuid, $resourcePath);
     3541        }
     3542        //make the API Call
     3543      if (! isset($body)) {
     3544        $body = null;
     3545      }
     3546      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3547                                              $queryParams, $body, $headerParams);
     3548      if(! $response){
     3549        return null;
     3550      }
     3551
     3552      $responseObject = $this->apiClient->deserialize($response,
     3553                                                        'SignatureStatusResponse');
     3554      return $responseObject;
     3555      }
     3556  /**
     3557     * ArchiveSignatureForm
     3558     * Archive signature form
     3559   * userId, string: User GUID (required)
     3560   * formGuid, string: Form GUID (required)
     3561   * @return SignatureStatusResponse
     3562     */
     3563
     3564   public function ArchiveSignatureForm($userId, $formGuid) {
     3565      if( $userId === null || $formGuid === null ) {
     3566        throw new ApiException("missing required parameters", 400);
     3567      }
     3568      //parse inputs
     3569      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/archive");
     3570      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3571      $method = "PUT";
     3572      $queryParams = array();
     3573      $headerParams = array();
     3574
     3575      if($userId !== null) {
     3576            $resourcePath = str_replace("{" . "userId" . "}",
     3577                                        $userId, $resourcePath);
     3578        }
     3579        if($formGuid !== null) {
     3580            $resourcePath = str_replace("{" . "formGuid" . "}",
     3581                                        $formGuid, $resourcePath);
     3582        }
     3583        //make the API Call
     3584      if (! isset($body)) {
     3585        $body = null;
     3586      }
     3587      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3588                                              $queryParams, $body, $headerParams);
     3589      if(! $response){
     3590        return null;
     3591      }
     3592
     3593      $responseObject = $this->apiClient->deserialize($response,
     3594                                                        'SignatureStatusResponse');
     3595      return $responseObject;
     3596      }
     3597  /**
     3598     * CompleteSignatureForm
     3599     * Complete signature form
     3600   * userId, string: User GUID (required)
     3601   * formGuid, string: Form GUID (required)
     3602   * @return SignatureStatusResponse
     3603     */
     3604
     3605   public function CompleteSignatureForm($userId, $formGuid) {
     3606      if( $userId === null || $formGuid === null ) {
     3607        throw new ApiException("missing required parameters", 400);
     3608      }
     3609      //parse inputs
     3610      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/complete");
     3611      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3612      $method = "PUT";
     3613      $queryParams = array();
     3614      $headerParams = array();
     3615
     3616      if($userId !== null) {
     3617            $resourcePath = str_replace("{" . "userId" . "}",
     3618                                        $userId, $resourcePath);
     3619        }
     3620        if($formGuid !== null) {
     3621            $resourcePath = str_replace("{" . "formGuid" . "}",
     3622                                        $formGuid, $resourcePath);
     3623        }
     3624        //make the API Call
     3625      if (! isset($body)) {
     3626        $body = null;
     3627      }
     3628      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3629                                              $queryParams, $body, $headerParams);
     3630      if(! $response){
     3631        return null;
     3632      }
     3633
     3634      $responseObject = $this->apiClient->deserialize($response,
     3635                                                        'SignatureStatusResponse');
     3636      return $responseObject;
     3637      }
     3638  /**
     3639     * CreateSignatureForm
     3640     * Create signature form
     3641   * userId, string: User GUID (required)
     3642   * name, string: Form name (optional)
     3643   * templateGuid, string: A templateGuid of the template which will be used to created the new form (optional)
     3644   * assemblyGuid, string: A guid of the assembly which will be used to created the new form (optional)
     3645   * formGuid, string: A formGuid of the form which will be used to created the new form (optional)
     3646   * body, SignatureFormSettingsInfo: Settings of the new form (optional)
     3647   * @return SignatureFormResponse
     3648     */
     3649
     3650   public function CreateSignatureForm($userId, $name=null, $templateGuid=null, $assemblyGuid=null, $formGuid=null, $body=null) {
     3651      if( $userId === null ) {
     3652        throw new ApiException("missing required parameters", 400);
     3653      }
     3654      //parse inputs
     3655      $resourcePath = str_replace("*", "", "/signature/{userId}/form?name={name}&templateId={templateGuid}&assemblyId={assemblyGuid}&formId={formGuid}");
     3656      $pos = strpos($resourcePath, "?");
     3657      if($pos !== false){
     3658        $resourcePath = substr($resourcePath, 0, $pos);
     3659      }
     3660      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3661      $method = "POST";
     3662      $queryParams = array();
     3663      $headerParams = array();
     3664
     3665      if($name !== null) {
     3666          $queryParams['name'] = $this->apiClient->toPathValue($name);
     3667        }
     3668        if($templateGuid !== null) {
     3669          $queryParams['templateId'] = $this->apiClient->toPathValue($templateGuid);
     3670        }
     3671        if($assemblyGuid !== null) {
     3672          $queryParams['assemblyId'] = $this->apiClient->toPathValue($assemblyGuid);
     3673        }
     3674        if($formGuid !== null) {
     3675          $queryParams['formId'] = $this->apiClient->toPathValue($formGuid);
     3676        }
     3677        if($userId !== null) {
     3678            $resourcePath = str_replace("{" . "userId" . "}",
     3679                                        $userId, $resourcePath);
     3680        }
     3681        //make the API Call
     3682      if (! isset($body)) {
     3683        $body = null;
     3684      }
     3685      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3686                                              $queryParams, $body, $headerParams);
     3687      if(! $response){
     3688        return null;
     3689      }
     3690
     3691      $responseObject = $this->apiClient->deserialize($response,
     3692                                                        'SignatureFormResponse');
     3693      return $responseObject;
     3694      }
     3695  /**
     3696     * DeleteSignatureForm
     3697     * Delete signature form
     3698   * userId, string: User GUID (required)
     3699   * formGuid, string: Form GUID (required)
     3700   * @return SignatureStatusResponse
     3701     */
     3702
     3703   public function DeleteSignatureForm($userId, $formGuid) {
     3704      if( $userId === null || $formGuid === null ) {
     3705        throw new ApiException("missing required parameters", 400);
     3706      }
     3707      //parse inputs
     3708      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}");
     3709      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3710      $method = "DELETE";
     3711      $queryParams = array();
     3712      $headerParams = array();
     3713
     3714      if($userId !== null) {
     3715            $resourcePath = str_replace("{" . "userId" . "}",
     3716                                        $userId, $resourcePath);
     3717        }
     3718        if($formGuid !== null) {
     3719            $resourcePath = str_replace("{" . "formGuid" . "}",
     3720                                        $formGuid, $resourcePath);
     3721        }
     3722        //make the API Call
     3723      if (! isset($body)) {
     3724        $body = null;
     3725      }
     3726      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3727                                              $queryParams, $body, $headerParams);
     3728      if(! $response){
     3729        return null;
     3730      }
     3731
     3732      $responseObject = $this->apiClient->deserialize($response,
     3733                                                        'SignatureStatusResponse');
     3734      return $responseObject;
     3735      }
     3736  /**
     3737     * AddSignatureFormDocument
     3738     * Add document in form
     3739   * userId, string: User GUID (required)
     3740   * formGuid, string: Form GUID (required)
     3741   * documentGuid, string: Document GUID (required)
     3742   * order, int: Document order (optional)
     3743   * parseFields, bool: Try to parse fields in document (optional)
     3744   * @return SignatureFormDocumentResponse
     3745     */
     3746
     3747   public function AddSignatureFormDocument($userId, $formGuid, $documentGuid, $order=null, $parseFields=null) {
     3748      if( $userId === null || $formGuid === null || $documentGuid === null ) {
     3749        throw new ApiException("missing required parameters", 400);
     3750      }
     3751      //parse inputs
     3752      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/document/{documentGuid}?parseFields={parseFields}&order={order}");
     3753      $pos = strpos($resourcePath, "?");
     3754      if($pos !== false){
     3755        $resourcePath = substr($resourcePath, 0, $pos);
     3756      }
     3757      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3758      $method = "POST";
     3759      $queryParams = array();
     3760      $headerParams = array();
     3761
     3762      if($order !== null) {
     3763          $queryParams['order'] = $this->apiClient->toPathValue($order);
     3764        }
     3765        if($parseFields !== null) {
     3766          $queryParams['parseFields'] = $this->apiClient->toPathValue($parseFields);
     3767        }
     3768        if($userId !== null) {
     3769            $resourcePath = str_replace("{" . "userId" . "}",
     3770                                        $userId, $resourcePath);
     3771        }
     3772        if($formGuid !== null) {
     3773            $resourcePath = str_replace("{" . "formGuid" . "}",
     3774                                        $formGuid, $resourcePath);
     3775        }
     3776        if($documentGuid !== null) {
     3777            $resourcePath = str_replace("{" . "documentGuid" . "}",
     3778                                        $documentGuid, $resourcePath);
     3779        }
     3780        //make the API Call
     3781      if (! isset($body)) {
     3782        $body = null;
     3783      }
     3784      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3785                                              $queryParams, $body, $headerParams);
     3786      if(! $response){
     3787        return null;
     3788      }
     3789
     3790      $responseObject = $this->apiClient->deserialize($response,
     3791                                                        'SignatureFormDocumentResponse');
     3792      return $responseObject;
     3793      }
     3794  /**
     3795     * DeleteSignatureFormDocument
     3796     * Delete document from form
     3797   * userId, string: User GUID (required)
     3798   * formGuid, string: Form GUID (required)
     3799   * documentGuid, string: Document GUID (required)
     3800   * @return SignatureStatusResponse
     3801     */
     3802
     3803   public function DeleteSignatureFormDocument($userId, $formGuid, $documentGuid) {
     3804      if( $userId === null || $formGuid === null || $documentGuid === null ) {
     3805        throw new ApiException("missing required parameters", 400);
     3806      }
     3807      //parse inputs
     3808      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents/{documentGuid}");
     3809      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3810      $method = "DELETE";
     3811      $queryParams = array();
     3812      $headerParams = array();
     3813
     3814      if($userId !== null) {
     3815            $resourcePath = str_replace("{" . "userId" . "}",
     3816                                        $userId, $resourcePath);
     3817        }
     3818        if($formGuid !== null) {
     3819            $resourcePath = str_replace("{" . "formGuid" . "}",
     3820                                        $formGuid, $resourcePath);
     3821        }
     3822        if($documentGuid !== null) {
     3823            $resourcePath = str_replace("{" . "documentGuid" . "}",
     3824                                        $documentGuid, $resourcePath);
     3825        }
     3826        //make the API Call
     3827      if (! isset($body)) {
     3828        $body = null;
     3829      }
     3830      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3831                                              $queryParams, $body, $headerParams);
     3832      if(! $response){
     3833        return null;
     3834      }
     3835
     3836      $responseObject = $this->apiClient->deserialize($response,
     3837                                                        'SignatureStatusResponse');
     3838      return $responseObject;
     3839      }
     3840  /**
     3841     * GetSignatureFormDocuments
     3842     * Get documents in form
     3843   * userId, string: User GUID (required)
     3844   * formGuid, string: Form GUID (required)
     3845   * @return SignatureFormDocumentsResponse
     3846     */
     3847
     3848   public function GetSignatureFormDocuments($userId, $formGuid) {
     3849      if( $userId === null || $formGuid === null ) {
     3850        throw new ApiException("missing required parameters", 400);
     3851      }
     3852      //parse inputs
     3853      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents");
     3854      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3855      $method = "GET";
     3856      $queryParams = array();
     3857      $headerParams = array();
     3858
     3859      if($userId !== null) {
     3860            $resourcePath = str_replace("{" . "userId" . "}",
     3861                                        $userId, $resourcePath);
     3862        }
     3863        if($formGuid !== null) {
     3864            $resourcePath = str_replace("{" . "formGuid" . "}",
     3865                                        $formGuid, $resourcePath);
     3866        }
     3867        //make the API Call
     3868      if (! isset($body)) {
     3869        $body = null;
     3870      }
     3871      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3872                                              $queryParams, $body, $headerParams);
     3873      if(! $response){
     3874        return null;
     3875      }
     3876
     3877      $responseObject = $this->apiClient->deserialize($response,
     3878                                                        'SignatureFormDocumentsResponse');
     3879      return $responseObject;
     3880      }
     3881  /**
     3882     * AddSignatureFormField
     3883     * Add signature field for document in form
     3884   * userId, string: User GUID (required)
     3885   * formGuid, string: Form GUID (required)
     3886   * documentGuid, string: Document GUID (required)
     3887   * fieldGuid, string: Field GUID (required)
     3888   * body, SignatureFormFieldSettingsInfo: Settings of the field (optional)
     3889   * @return SignatureFormFieldResponse
     3890     */
     3891
     3892   public function AddSignatureFormField($userId, $formGuid, $documentGuid, $fieldGuid, $body=null) {
     3893      if( $userId === null || $formGuid === null || $documentGuid === null || $fieldGuid === null ) {
     3894        throw new ApiException("missing required parameters", 400);
     3895      }
     3896      //parse inputs
     3897      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents/{documentGuid}/field/{fieldGuid}");
     3898      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3899      $method = "POST";
     3900      $queryParams = array();
     3901      $headerParams = array();
     3902
     3903      if($userId !== null) {
     3904            $resourcePath = str_replace("{" . "userId" . "}",
     3905                                        $userId, $resourcePath);
     3906        }
     3907        if($formGuid !== null) {
     3908            $resourcePath = str_replace("{" . "formGuid" . "}",
     3909                                        $formGuid, $resourcePath);
     3910        }
     3911        if($documentGuid !== null) {
     3912            $resourcePath = str_replace("{" . "documentGuid" . "}",
     3913                                        $documentGuid, $resourcePath);
     3914        }
     3915        if($fieldGuid !== null) {
     3916            $resourcePath = str_replace("{" . "fieldGuid" . "}",
     3917                                        $fieldGuid, $resourcePath);
     3918        }
     3919        //make the API Call
     3920      if (! isset($body)) {
     3921        $body = null;
     3922      }
     3923      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3924                                              $queryParams, $body, $headerParams);
     3925      if(! $response){
     3926        return null;
     3927      }
     3928
     3929      $responseObject = $this->apiClient->deserialize($response,
     3930                                                        'SignatureFormFieldResponse');
     3931      return $responseObject;
     3932      }
     3933  /**
     3934     * ModifySignatureFormFieldLocation
     3935     * Modify signature form field location
     3936   * userId, string: User GUID (required)
     3937   * formGuid, string: Form GUID (required)
     3938   * documentGuid, string: Document GUID (required)
     3939   * fieldGuid, string: Field GUID (required)
     3940   * locationGuid, string: Field location GUID (required)
     3941   * body, SignatureFormFieldLocationSettingsInfo: Settings of the field location (optional)
     3942   * @return SignatureFormFieldResponse
     3943     */
     3944
     3945   public function ModifySignatureFormFieldLocation($userId, $formGuid, $documentGuid, $fieldGuid, $locationGuid, $body=null) {
     3946      if( $userId === null || $formGuid === null || $documentGuid === null || $fieldGuid === null || $locationGuid === null ) {
     3947        throw new ApiException("missing required parameters", 400);
     3948      }
     3949      //parse inputs
     3950      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents/{documentGuid}/fields/{fieldGuid}/locations/{locationGuid}");
     3951      $resourcePath = str_replace("{format}", "json", $resourcePath);
     3952      $method = "PUT";
     3953      $queryParams = array();
     3954      $headerParams = array();
     3955
     3956      if($userId !== null) {
     3957            $resourcePath = str_replace("{" . "userId" . "}",
     3958                                        $userId, $resourcePath);
     3959        }
     3960        if($formGuid !== null) {
     3961            $resourcePath = str_replace("{" . "formGuid" . "}",
     3962                                        $formGuid, $resourcePath);
     3963        }
     3964        if($documentGuid !== null) {
     3965            $resourcePath = str_replace("{" . "documentGuid" . "}",
     3966                                        $documentGuid, $resourcePath);
     3967        }
     3968        if($fieldGuid !== null) {
     3969            $resourcePath = str_replace("{" . "fieldGuid" . "}",
     3970                                        $fieldGuid, $resourcePath);
     3971        }
     3972        if($locationGuid !== null) {
     3973            $resourcePath = str_replace("{" . "locationGuid" . "}",
     3974                                        $locationGuid, $resourcePath);
     3975        }
     3976        //make the API Call
     3977      if (! isset($body)) {
     3978        $body = null;
     3979      }
     3980      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     3981                                              $queryParams, $body, $headerParams);
     3982      if(! $response){
     3983        return null;
     3984      }
     3985
     3986      $responseObject = $this->apiClient->deserialize($response,
     3987                                                        'SignatureFormFieldResponse');
     3988      return $responseObject;
     3989      }
     3990  /**
     3991     * DeleteSignatureFormFieldLocation
     3992     * Remove signature form field location
     3993   * userId, string: User GUID (required)
     3994   * formGuid, string: Form GUID (required)
     3995   * fieldGuid, string: Field GUID (required)
     3996   * locationGuid, string: Field location GUID (required)
     3997   * @return SignatureStatusResponse
     3998     */
     3999
     4000   public function DeleteSignatureFormFieldLocation($userId, $formGuid, $fieldGuid, $locationGuid) {
     4001      if( $userId === null || $formGuid === null || $fieldGuid === null || $locationGuid === null ) {
     4002        throw new ApiException("missing required parameters", 400);
     4003      }
     4004      //parse inputs
     4005      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/fields/{fieldGuid}/locations/{locationGuid}");
     4006      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4007      $method = "DELETE";
     4008      $queryParams = array();
     4009      $headerParams = array();
     4010
     4011      if($userId !== null) {
     4012            $resourcePath = str_replace("{" . "userId" . "}",
     4013                                        $userId, $resourcePath);
     4014        }
     4015        if($formGuid !== null) {
     4016            $resourcePath = str_replace("{" . "formGuid" . "}",
     4017                                        $formGuid, $resourcePath);
     4018        }
     4019        if($fieldGuid !== null) {
     4020            $resourcePath = str_replace("{" . "fieldGuid" . "}",
     4021                                        $fieldGuid, $resourcePath);
     4022        }
     4023        if($locationGuid !== null) {
     4024            $resourcePath = str_replace("{" . "locationGuid" . "}",
     4025                                        $locationGuid, $resourcePath);
     4026        }
     4027        //make the API Call
     4028      if (! isset($body)) {
     4029        $body = null;
     4030      }
     4031      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4032                                              $queryParams, $body, $headerParams);
     4033      if(! $response){
     4034        return null;
     4035      }
     4036
     4037      $responseObject = $this->apiClient->deserialize($response,
     4038                                                        'SignatureStatusResponse');
     4039      return $responseObject;
     4040      }
     4041  /**
     4042     * ModifySignatureFormField
     4043     * Modify signature form field
     4044   * userId, string: User GUID (required)
     4045   * formGuid, string: Form GUID (required)
     4046   * documentGuid, string: Document GUID (required)
     4047   * fieldGuid, string: Field GUID (required)
     4048   * body, SignatureFormFieldSettingsInfo: Settings of the field (optional)
     4049   * @return SignatureFormFieldResponse
     4050     */
     4051
     4052   public function ModifySignatureFormField($userId, $formGuid, $documentGuid, $fieldGuid, $body=null) {
     4053      if( $userId === null || $formGuid === null || $documentGuid === null || $fieldGuid === null ) {
     4054        throw new ApiException("missing required parameters", 400);
     4055      }
     4056      //parse inputs
     4057      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents/{documentGuid}/field/{fieldGuid}");
     4058      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4059      $method = "PUT";
     4060      $queryParams = array();
     4061      $headerParams = array();
     4062
     4063      if($userId !== null) {
     4064            $resourcePath = str_replace("{" . "userId" . "}",
     4065                                        $userId, $resourcePath);
     4066        }
     4067        if($formGuid !== null) {
     4068            $resourcePath = str_replace("{" . "formGuid" . "}",
     4069                                        $formGuid, $resourcePath);
     4070        }
     4071        if($documentGuid !== null) {
     4072            $resourcePath = str_replace("{" . "documentGuid" . "}",
     4073                                        $documentGuid, $resourcePath);
     4074        }
     4075        if($fieldGuid !== null) {
     4076            $resourcePath = str_replace("{" . "fieldGuid" . "}",
     4077                                        $fieldGuid, $resourcePath);
     4078        }
     4079        //make the API Call
     4080      if (! isset($body)) {
     4081        $body = null;
     4082      }
     4083      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4084                                              $queryParams, $body, $headerParams);
     4085      if(! $response){
     4086        return null;
     4087      }
     4088
     4089      $responseObject = $this->apiClient->deserialize($response,
     4090                                                        'SignatureFormFieldResponse');
     4091      return $responseObject;
     4092      }
     4093  /**
     4094     * DeleteSignatureFormField
     4095     * Delete signature form field
     4096   * userId, string: User GUID (required)
     4097   * formGuid, string: Form GUID (required)
     4098   * fieldGuid, string: Field GUID (required)
     4099   * @return SignatureStatusResponse
     4100     */
     4101
     4102   public function DeleteSignatureFormField($userId, $formGuid, $fieldGuid) {
     4103      if( $userId === null || $formGuid === null || $fieldGuid === null ) {
     4104        throw new ApiException("missing required parameters", 400);
     4105      }
     4106      //parse inputs
     4107      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/fields/{fieldGuid}");
     4108      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4109      $method = "DELETE";
     4110      $queryParams = array();
     4111      $headerParams = array();
     4112
     4113      if($userId !== null) {
     4114            $resourcePath = str_replace("{" . "userId" . "}",
     4115                                        $userId, $resourcePath);
     4116        }
     4117        if($formGuid !== null) {
     4118            $resourcePath = str_replace("{" . "formGuid" . "}",
     4119                                        $formGuid, $resourcePath);
     4120        }
     4121        if($fieldGuid !== null) {
     4122            $resourcePath = str_replace("{" . "fieldGuid" . "}",
     4123                                        $fieldGuid, $resourcePath);
     4124        }
     4125        //make the API Call
     4126      if (! isset($body)) {
     4127        $body = null;
     4128      }
     4129      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4130                                              $queryParams, $body, $headerParams);
     4131      if(! $response){
     4132        return null;
     4133      }
     4134
     4135      $responseObject = $this->apiClient->deserialize($response,
     4136                                                        'SignatureStatusResponse');
     4137      return $responseObject;
     4138      }
     4139  /**
     4140     * GetSignatureFormFields
     4141     * Get form fields for document in form per participant
     4142   * userId, string: User GUID (required)
     4143   * formGuid, string: Form GUID (required)
     4144   * fieldGuid, string: Field GUID (optional)
     4145   * @return SignatureFormFieldsResponse
     4146     */
     4147
     4148   public function GetSignatureFormFields($userId, $formGuid, $fieldGuid=null) {
     4149      if( $userId === null || $formGuid === null ) {
     4150        throw new ApiException("missing required parameters", 400);
     4151      }
     4152      //parse inputs
     4153      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/fields?field={fieldGuid}");
     4154      $pos = strpos($resourcePath, "?");
     4155      if($pos !== false){
     4156        $resourcePath = substr($resourcePath, 0, $pos);
     4157      }
     4158      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4159      $method = "GET";
     4160      $queryParams = array();
     4161      $headerParams = array();
     4162
     4163      if($fieldGuid !== null) {
     4164          $queryParams['field'] = $this->apiClient->toPathValue($fieldGuid);
     4165        }
     4166        if($userId !== null) {
     4167            $resourcePath = str_replace("{" . "userId" . "}",
     4168                                        $userId, $resourcePath);
     4169        }
     4170        if($formGuid !== null) {
     4171            $resourcePath = str_replace("{" . "formGuid" . "}",
     4172                                        $formGuid, $resourcePath);
     4173        }
     4174        //make the API Call
     4175      if (! isset($body)) {
     4176        $body = null;
     4177      }
     4178      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4179                                              $queryParams, $body, $headerParams);
     4180      if(! $response){
     4181        return null;
     4182      }
     4183
     4184      $responseObject = $this->apiClient->deserialize($response,
     4185                                                        'SignatureFormFieldsResponse');
     4186      return $responseObject;
     4187      }
     4188  /**
     4189     * GetSignatureFormDocumentFields
     4190     * Get form fields for document in form per participant
     4191   * userId, string: User GUID (required)
     4192   * formGuid, string: Form GUID (required)
     4193   * documentGuid, string: Document GUID (required)
     4194   * fieldGuid, string: Field GUID (optional)
     4195   * @return SignatureFormFieldsResponse
     4196     */
     4197
     4198   public function GetSignatureFormDocumentFields($userId, $formGuid, $documentGuid, $fieldGuid=null) {
     4199      if( $userId === null || $formGuid === null || $documentGuid === null ) {
     4200        throw new ApiException("missing required parameters", 400);
     4201      }
     4202      //parse inputs
     4203      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents/{documentGuid}/fields?field={fieldGuid}");
     4204      $pos = strpos($resourcePath, "?");
     4205      if($pos !== false){
     4206        $resourcePath = substr($resourcePath, 0, $pos);
     4207      }
     4208      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4209      $method = "GET";
     4210      $queryParams = array();
     4211      $headerParams = array();
     4212
     4213      if($fieldGuid !== null) {
     4214          $queryParams['field'] = $this->apiClient->toPathValue($fieldGuid);
     4215        }
     4216        if($userId !== null) {
     4217            $resourcePath = str_replace("{" . "userId" . "}",
     4218                                        $userId, $resourcePath);
     4219        }
     4220        if($formGuid !== null) {
     4221            $resourcePath = str_replace("{" . "formGuid" . "}",
     4222                                        $formGuid, $resourcePath);
     4223        }
     4224        if($documentGuid !== null) {
     4225            $resourcePath = str_replace("{" . "documentGuid" . "}",
     4226                                        $documentGuid, $resourcePath);
     4227        }
     4228        //make the API Call
     4229      if (! isset($body)) {
     4230        $body = null;
     4231      }
     4232      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4233                                              $queryParams, $body, $headerParams);
     4234      if(! $response){
     4235        return null;
     4236      }
     4237
     4238      $responseObject = $this->apiClient->deserialize($response,
     4239                                                        'SignatureFormFieldsResponse');
     4240      return $responseObject;
     4241      }
     4242  /**
     4243     * GetSignatureForm
     4244     * Get signature form
     4245   * userId, string: User GUID (required)
     4246   * formGuid, string: Form GUID (required)
     4247   * @return SignatureFormResponse
     4248     */
     4249
     4250   public function GetSignatureForm($userId, $formGuid) {
     4251      if( $userId === null || $formGuid === null ) {
     4252        throw new ApiException("missing required parameters", 400);
     4253      }
     4254      //parse inputs
     4255      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}");
     4256      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4257      $method = "GET";
     4258      $queryParams = array();
     4259      $headerParams = array();
     4260
     4261      if($userId !== null) {
     4262            $resourcePath = str_replace("{" . "userId" . "}",
     4263                                        $userId, $resourcePath);
     4264        }
     4265        if($formGuid !== null) {
     4266            $resourcePath = str_replace("{" . "formGuid" . "}",
     4267                                        $formGuid, $resourcePath);
     4268        }
     4269        //make the API Call
     4270      if (! isset($body)) {
     4271        $body = null;
     4272      }
     4273      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4274                                              $queryParams, $body, $headerParams);
     4275      if(! $response){
     4276        return null;
     4277      }
     4278
     4279      $responseObject = $this->apiClient->deserialize($response,
     4280                                                        'SignatureFormResponse');
     4281      return $responseObject;
     4282      }
     4283  /**
     4284     * ModifySignatureForm
     4285     * Modify signature form
     4286   * userId, string: User GUID (required)
     4287   * formGuid, string: Form GUID (required)
     4288   * body, SignatureFormSettingsInfo: Settings of the form (optional)
     4289   * @return SignatureFormResponse
     4290     */
     4291
     4292   public function ModifySignatureForm($userId, $formGuid, $body=null) {
     4293      if( $userId === null || $formGuid === null ) {
     4294        throw new ApiException("missing required parameters", 400);
     4295      }
     4296      //parse inputs
     4297      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}");
     4298      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4299      $method = "POST";
     4300      $queryParams = array();
     4301      $headerParams = array();
     4302
     4303      if($userId !== null) {
     4304            $resourcePath = str_replace("{" . "userId" . "}",
     4305                                        $userId, $resourcePath);
     4306        }
     4307        if($formGuid !== null) {
     4308            $resourcePath = str_replace("{" . "formGuid" . "}",
     4309                                        $formGuid, $resourcePath);
     4310        }
     4311        //make the API Call
     4312      if (! isset($body)) {
     4313        $body = null;
     4314      }
     4315      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4316                                              $queryParams, $body, $headerParams);
     4317      if(! $response){
     4318        return null;
     4319      }
     4320
     4321      $responseObject = $this->apiClient->deserialize($response,
     4322                                                        'SignatureFormResponse');
     4323      return $responseObject;
     4324      }
     4325  /**
     4326     * PublishSignatureForm
     4327     * Publish signature form
     4328   * userId, string: User GUID (required)
     4329   * formGuid, string: Form GUID (required)
     4330   * body, WebhookInfo: Webhook Callback Url (optional)
     4331   * @return SignatureStatusResponse
     4332     */
     4333
     4334   public function PublishSignatureForm($userId, $formGuid, $body=null) {
     4335      if( $userId === null || $formGuid === null ) {
     4336        throw new ApiException("missing required parameters", 400);
     4337      }
     4338      //parse inputs
     4339      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/publish");
     4340      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4341      $method = "PUT";
     4342      $queryParams = array();
     4343      $headerParams = array();
     4344
     4345      if($userId !== null) {
     4346            $resourcePath = str_replace("{" . "userId" . "}",
     4347                                        $userId, $resourcePath);
     4348        }
     4349        if($formGuid !== null) {
     4350            $resourcePath = str_replace("{" . "formGuid" . "}",
     4351                                        $formGuid, $resourcePath);
     4352        }
     4353        //make the API Call
     4354      if (! isset($body)) {
     4355        $body = null;
     4356      }
     4357      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4358                                              $queryParams, $body, $headerParams);
     4359      if(! $response){
     4360        return null;
     4361      }
     4362
     4363      $responseObject = $this->apiClient->deserialize($response,
     4364                                                        'SignatureStatusResponse');
     4365      return $responseObject;
     4366      }
     4367  /**
     4368     * RenameSignatureForm
     4369     * Rename signature form
     4370   * userId, string: User GUID (required)
     4371   * formGuid, string: Form GUID (required)
     4372   * name, string: New form name (required)
     4373   * @return SignatureFormResponse
     4374     */
     4375
     4376   public function RenameSignatureForm($userId, $formGuid, $name) {
     4377      if( $userId === null || $formGuid === null || $name === null ) {
     4378        throw new ApiException("missing required parameters", 400);
     4379      }
     4380      //parse inputs
     4381      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}?new_name={name}");
     4382      $pos = strpos($resourcePath, "?");
     4383      if($pos !== false){
     4384        $resourcePath = substr($resourcePath, 0, $pos);
     4385      }
     4386      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4387      $method = "PUT";
     4388      $queryParams = array();
     4389      $headerParams = array();
     4390
     4391      if($name !== null) {
     4392          $queryParams['new_name'] = $this->apiClient->toPathValue($name);
     4393        }
     4394        if($userId !== null) {
     4395            $resourcePath = str_replace("{" . "userId" . "}",
     4396                                        $userId, $resourcePath);
     4397        }
     4398        if($formGuid !== null) {
     4399            $resourcePath = str_replace("{" . "formGuid" . "}",
     4400                                        $formGuid, $resourcePath);
     4401        }
     4402        //make the API Call
     4403      if (! isset($body)) {
     4404        $body = null;
     4405      }
     4406      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4407                                              $queryParams, $body, $headerParams);
     4408      if(! $response){
     4409        return null;
     4410      }
     4411
     4412      $responseObject = $this->apiClient->deserialize($response,
     4413                                                        'SignatureFormResponse');
     4414      return $responseObject;
     4415      }
     4416  /**
     4417     * UpdateSignatureFormFromTemplate
     4418     * Add signature form fields from template
     4419   * userId, string: User GUID (required)
     4420   * formGuid, string: Form GUID (required)
     4421   * templateGuid, string: Template GUID (required)
     4422   * @return SignatureFormResponse
     4423     */
     4424
     4425   public function UpdateSignatureFormFromTemplate($userId, $formGuid, $templateGuid) {
     4426      if( $userId === null || $formGuid === null || $templateGuid === null ) {
     4427        throw new ApiException("missing required parameters", 400);
     4428      }
     4429      //parse inputs
     4430      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/templates/{templateGuid}");
     4431      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4432      $method = "POST";
     4433      $queryParams = array();
     4434      $headerParams = array();
     4435
     4436      if($userId !== null) {
     4437            $resourcePath = str_replace("{" . "userId" . "}",
     4438                                        $userId, $resourcePath);
     4439        }
     4440        if($formGuid !== null) {
     4441            $resourcePath = str_replace("{" . "formGuid" . "}",
     4442                                        $formGuid, $resourcePath);
     4443        }
     4444        if($templateGuid !== null) {
     4445            $resourcePath = str_replace("{" . "templateGuid" . "}",
     4446                                        $templateGuid, $resourcePath);
     4447        }
     4448        //make the API Call
     4449      if (! isset($body)) {
     4450        $body = null;
     4451      }
     4452      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4453                                              $queryParams, $body, $headerParams);
     4454      if(! $response){
     4455        return null;
     4456      }
     4457
     4458      $responseObject = $this->apiClient->deserialize($response,
     4459                                                        'SignatureFormResponse');
     4460      return $responseObject;
     4461      }
     4462  /**
     4463     * GetSignatureForms
     4464     * Get signature forms
     4465   * userId, string: User GUID (required)
     4466   * statusId, int: Filter forms by statusId (optional)
     4467   * page, int: Show records for page number (optional)
     4468   * records, int: Show records count (optional)
     4469   * originalDocumentMD5, string: Filter forms by original document MD5 (optional)
     4470   * DateTime, string: Filter forms by date (optional)
     4471   * name, string: Filter forms by name (optional)
     4472   * tag, string: Filter forms by tag (optional)
     4473   * @return SignatureFormsResponse
     4474     */
     4475
     4476   public function GetSignatureForms($userId, $statusId=null, $page=null, $records=null, $originalDocumentMD5=null, $DateTime=null, $name=null, $tag=null) {
     4477      if( $userId === null ) {
     4478        throw new ApiException("missing required parameters", 400);
     4479      }
     4480      //parse inputs
     4481      $resourcePath = str_replace("*", "", "/signature/{userId}/forms?statusId={statusId}&records={records}&page={page}&document={originalDocumentMD5}&date={date}&name={name}&tag={tag}");
     4482      $pos = strpos($resourcePath, "?");
     4483      if($pos !== false){
     4484        $resourcePath = substr($resourcePath, 0, $pos);
     4485      }
     4486      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4487      $method = "GET";
     4488      $queryParams = array();
     4489      $headerParams = array();
     4490
     4491      if($statusId !== null) {
     4492          $queryParams['statusId'] = $this->apiClient->toPathValue($statusId);
     4493        }
     4494        if($page !== null) {
     4495          $queryParams['page'] = $this->apiClient->toPathValue($page);
     4496        }
     4497        if($records !== null) {
     4498          $queryParams['records'] = $this->apiClient->toPathValue($records);
     4499        }
     4500        if($originalDocumentMD5 !== null) {
     4501          $queryParams['document'] = $this->apiClient->toPathValue($originalDocumentMD5);
     4502        }
     4503        if($DateTime !== null) {
     4504          $queryParams['date'] = $this->apiClient->toPathValue($DateTime);
     4505        }
     4506        if($name !== null) {
     4507          $queryParams['name'] = $this->apiClient->toPathValue($name);
     4508        }
     4509        if($tag !== null) {
     4510          $queryParams['tag'] = $this->apiClient->toPathValue($tag);
     4511        }
     4512        if($userId !== null) {
     4513            $resourcePath = str_replace("{" . "userId" . "}",
     4514                                        $userId, $resourcePath);
     4515        }
     4516        //make the API Call
     4517      if (! isset($body)) {
     4518        $body = null;
     4519      }
     4520      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4521                                              $queryParams, $body, $headerParams);
     4522      if(! $response){
     4523        return null;
     4524      }
     4525
     4526      $responseObject = $this->apiClient->deserialize($response,
     4527                                                        'SignatureFormsResponse');
     4528      return $responseObject;
     4529      }
     4530  /**
     4531     * GetSignatureFormResources
     4532     * Get form resources
     4533   * userId, string: User GUID (required)
     4534   * statusIds, string: Form status identifier - comma separated list (required)
     4535   * @return SignatureFormResourcesResponse
     4536     */
     4537
     4538   public function GetSignatureFormResources($userId, $statusIds) {
     4539      if( $userId === null || $statusIds === null ) {
     4540        throw new ApiException("missing required parameters", 400);
     4541      }
     4542      //parse inputs
     4543      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/resources?statusIds={statusIds}");
     4544      $pos = strpos($resourcePath, "?");
     4545      if($pos !== false){
     4546        $resourcePath = substr($resourcePath, 0, $pos);
     4547      }
     4548      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4549      $method = "GET";
     4550      $queryParams = array();
     4551      $headerParams = array();
     4552
     4553      if($statusIds !== null) {
     4554          $queryParams['statusIds'] = $this->apiClient->toPathValue($statusIds);
     4555        }
     4556        if($userId !== null) {
     4557            $resourcePath = str_replace("{" . "userId" . "}",
     4558                                        $userId, $resourcePath);
     4559        }
     4560        //make the API Call
     4561      if (! isset($body)) {
     4562        $body = null;
     4563      }
     4564      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4565                                              $queryParams, $body, $headerParams);
     4566      if(! $response){
     4567        return null;
     4568      }
     4569
     4570      $responseObject = $this->apiClient->deserialize($response,
     4571                                                        'SignatureFormResourcesResponse');
     4572      return $responseObject;
     4573      }
     4574  /**
     4575     * GetSignedFormDocuments
     4576     * Get signed form documents
     4577   * userId, string: User GUID (required)
     4578   * formGuid, string: Form GUID (required)
     4579   * @return stream
     4580     */
     4581
     4582   public function GetSignedFormDocuments($userId, $formGuid, FileStream $outFileStream) {
     4583      if( $userId === null || $formGuid === null ) {
     4584        throw new ApiException("missing required parameters", 400);
     4585      }
     4586      //parse inputs
     4587      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/documents/get");
     4588      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4589      $method = "GET";
     4590      $queryParams = array();
     4591      $headerParams = array();
     4592
     4593      if($userId !== null) {
     4594            $resourcePath = str_replace("{" . "userId" . "}",
     4595                                        $userId, $resourcePath);
     4596        }
     4597        if($formGuid !== null) {
     4598            $resourcePath = str_replace("{" . "formGuid" . "}",
     4599                                        $formGuid, $resourcePath);
     4600        }
     4601        //make the API Call
     4602      if (! isset($body)) {
     4603        $body = null;
     4604      }
     4605      return $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4606                                              $queryParams, $body, $headerParams, $outFileStream);
     4607      }
     4608  /**
     4609     * RenameSignatureFormDocument
     4610     * Rename signature form document
     4611   * userId, string: User GUID (required)
     4612   * formGuid, string: Form GUID (required)
     4613   * documentGuid, string: Form Document GUID (required)
     4614   * newName, string: New name of the document (optional)
     4615   * @return SignatureFormDocumentResponse
     4616     */
     4617
     4618   public function RenameSignatureFormDocument($userId, $formGuid, $documentGuid, $newName=null) {
     4619      if( $userId === null || $formGuid === null || $documentGuid === null ) {
     4620        throw new ApiException("missing required parameters", 400);
     4621      }
     4622      //parse inputs
     4623      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/document/{documentGuid}?newName={newName}");
     4624      $pos = strpos($resourcePath, "?");
     4625      if($pos !== false){
     4626        $resourcePath = substr($resourcePath, 0, $pos);
     4627      }
     4628      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4629      $method = "PUT";
     4630      $queryParams = array();
     4631      $headerParams = array();
     4632
     4633      if($newName !== null) {
     4634          $queryParams['newName'] = $this->apiClient->toPathValue($newName);
     4635        }
     4636        if($userId !== null) {
     4637            $resourcePath = str_replace("{" . "userId" . "}",
     4638                                        $userId, $resourcePath);
     4639        }
     4640        if($formGuid !== null) {
     4641            $resourcePath = str_replace("{" . "formGuid" . "}",
     4642                                        $formGuid, $resourcePath);
     4643        }
     4644        if($documentGuid !== null) {
     4645            $resourcePath = str_replace("{" . "documentGuid" . "}",
     4646                                        $documentGuid, $resourcePath);
     4647        }
     4648        //make the API Call
     4649      if (! isset($body)) {
     4650        $body = null;
     4651      }
     4652      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4653                                              $queryParams, $body, $headerParams);
     4654      if(! $response){
     4655        return null;
     4656      }
     4657
     4658      $responseObject = $this->apiClient->deserialize($response,
     4659                                                        'SignatureFormDocumentResponse');
     4660      return $responseObject;
     4661      }
     4662  /**
     4663     * ModifySignatureFormDocument
     4664     * Modify signature form document
     4665   * userId, string: User GUID (required)
     4666   * formGuid, string: Form GUID (required)
     4667   * documentGuid, string: Form Document GUID (required)
     4668   * body, SignatureFormDocumentSettingsInfo: Settings of the document (optional)
     4669   * @return SignatureFormDocumentResponse
     4670     */
     4671
     4672   public function ModifySignatureFormDocument($userId, $formGuid, $documentGuid, $body=null) {
     4673      if( $userId === null || $formGuid === null || $documentGuid === null ) {
     4674        throw new ApiException("missing required parameters", 400);
     4675      }
     4676      //parse inputs
     4677      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/document/{documentGuid}");
     4678      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4679      $method = "PUT";
     4680      $queryParams = array();
     4681      $headerParams = array();
     4682
     4683      if($userId !== null) {
     4684            $resourcePath = str_replace("{" . "userId" . "}",
     4685                                        $userId, $resourcePath);
     4686        }
     4687        if($formGuid !== null) {
     4688            $resourcePath = str_replace("{" . "formGuid" . "}",
     4689                                        $formGuid, $resourcePath);
     4690        }
     4691        if($documentGuid !== null) {
     4692            $resourcePath = str_replace("{" . "documentGuid" . "}",
     4693                                        $documentGuid, $resourcePath);
     4694        }
     4695        //make the API Call
     4696      if (! isset($body)) {
     4697        $body = null;
     4698      }
     4699      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4700                                              $queryParams, $body, $headerParams);
     4701      if(! $response){
     4702        return null;
     4703      }
     4704
     4705      $responseObject = $this->apiClient->deserialize($response,
     4706                                                        'SignatureFormDocumentResponse');
     4707      return $responseObject;
     4708      }
     4709  /**
     4710     * GetFormAuditLogs
     4711     * Get form audit logs
     4712   * userId, string: User GUID (required)
     4713   * formGuid, string: Form GUID (required)
     4714   * @return SignatureFormAuditLogsResponse
     4715     */
     4716
     4717   public function GetFormAuditLogs($userId, $formGuid) {
     4718      if( $userId === null || $formGuid === null ) {
     4719        throw new ApiException("missing required parameters", 400);
     4720      }
     4721      //parse inputs
     4722      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/logs");
     4723      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4724      $method = "GET";
     4725      $queryParams = array();
     4726      $headerParams = array();
     4727
     4728      if($userId !== null) {
     4729            $resourcePath = str_replace("{" . "userId" . "}",
     4730                                        $userId, $resourcePath);
     4731        }
     4732        if($formGuid !== null) {
     4733            $resourcePath = str_replace("{" . "formGuid" . "}",
     4734                                        $formGuid, $resourcePath);
     4735        }
     4736        //make the API Call
     4737      if (! isset($body)) {
     4738        $body = null;
     4739      }
     4740      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4741                                              $queryParams, $body, $headerParams);
     4742      if(! $response){
     4743        return null;
     4744      }
     4745
     4746      $responseObject = $this->apiClient->deserialize($response,
     4747                                                        'SignatureFormAuditLogsResponse');
     4748      return $responseObject;
     4749      }
     4750  /**
     4751     * GetSignatureFormParticipants
     4752     * Get form participants
     4753   * userId, string: User GUID (required)
     4754   * formGuid, string: Form GUID (required)
     4755   * @return SignatureFormParticipantsResponse
     4756     */
     4757
     4758   public function GetSignatureFormParticipants($userId, $formGuid) {
     4759      if( $userId === null || $formGuid === null ) {
     4760        throw new ApiException("missing required parameters", 400);
     4761      }
     4762      //parse inputs
     4763      $resourcePath = str_replace("*", "", "/signature/{userId}/forms/{formGuid}/participants");
     4764      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4765      $method = "GET";
     4766      $queryParams = array();
     4767      $headerParams = array();
     4768
     4769      if($userId !== null) {
     4770            $resourcePath = str_replace("{" . "userId" . "}",
     4771                                        $userId, $resourcePath);
     4772        }
     4773        if($formGuid !== null) {
     4774            $resourcePath = str_replace("{" . "formGuid" . "}",
     4775                                        $formGuid, $resourcePath);
     4776        }
     4777        //make the API Call
     4778      if (! isset($body)) {
     4779        $body = null;
     4780      }
     4781      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4782                                              $queryParams, $body, $headerParams);
     4783      if(! $response){
     4784        return null;
     4785      }
     4786
     4787      $responseObject = $this->apiClient->deserialize($response,
     4788                                                        'SignatureFormParticipantsResponse');
     4789      return $responseObject;
     4790      }
     4791  /**
    47794792     * GetSignaturePredefinedLists
    47804793     * Get user predefined lists
    … …  
    48884901      $responseObject = $this->apiClient->deserialize($response,
    48894902                                                        'SignaturePredefinedListsResponse');
     4903      return $responseObject;
     4904      }
     4905  /**
     4906     * GetRolesList
     4907     * Get signature roles
     4908   * userId, string: User GUID (required)
     4909   * roleGuid, string: Filter roles by GUID (optional)
     4910   * @return SignatureRolesResponse
     4911     */
     4912
     4913   public function GetRolesList($userId, $roleGuid=null) {
     4914      if( $userId === null ) {
     4915        throw new ApiException("missing required parameters", 400);
     4916      }
     4917      //parse inputs
     4918      $resourcePath = str_replace("*", "", "/signature/{userId}/roles?id={roleGuid}");
     4919      $pos = strpos($resourcePath, "?");
     4920      if($pos !== false){
     4921        $resourcePath = substr($resourcePath, 0, $pos);
     4922      }
     4923      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4924      $method = "GET";
     4925      $queryParams = array();
     4926      $headerParams = array();
     4927
     4928      if($roleGuid !== null) {
     4929          $queryParams['id'] = $this->apiClient->toPathValue($roleGuid);
     4930        }
     4931        if($userId !== null) {
     4932            $resourcePath = str_replace("{" . "userId" . "}",
     4933                                        $userId, $resourcePath);
     4934        }
     4935        //make the API Call
     4936      if (! isset($body)) {
     4937        $body = null;
     4938      }
     4939      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4940                                              $queryParams, $body, $headerParams);
     4941      if(! $response){
     4942        return null;
     4943      }
     4944
     4945      $responseObject = $this->apiClient->deserialize($response,
     4946                                                        'SignatureRolesResponse');
     4947      return $responseObject;
     4948      }
     4949  /**
     4950     * GetUserEmailTemplate
     4951     * Get user email template
     4952   * userId, string: User GUID (required)
     4953   * templateType, int: Template type (required)
     4954   * @return stream
     4955     */
     4956
     4957   public function GetUserEmailTemplate($userId, $templateType, FileStream $outFileStream) {
     4958      if( $userId === null || $templateType === null ) {
     4959        throw new ApiException("missing required parameters", 400);
     4960      }
     4961      //parse inputs
     4962      $resourcePath = str_replace("*", "", "/signature/{userId}/email-template/{templateType}");
     4963      $resourcePath = str_replace("{format}", "json", $resourcePath);
     4964      $method = "GET";
     4965      $queryParams = array();
     4966      $headerParams = array();
     4967
     4968      if($userId !== null) {
     4969            $resourcePath = str_replace("{" . "userId" . "}",
     4970                                        $userId, $resourcePath);
     4971        }
     4972        if($templateType !== null) {
     4973            $resourcePath = str_replace("{" . "templateType" . "}",
     4974                                        $templateType, $resourcePath);
     4975        }
     4976        //make the API Call
     4977      if (! isset($body)) {
     4978        $body = null;
     4979      }
     4980      return $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     4981                                              $queryParams, $body, $headerParams, $outFileStream);
     4982      }
     4983  /**
     4984     * CreateSignature
     4985     * Create user signature
     4986   * userId, string: User GUID (required)
     4987   * name, string: Signature name (required)
     4988   * body, SignatureSignatureSettingsInfo: Settings of the signature (optional)
     4989   * @return SignatureSignatureResponse
     4990     */
     4991
     4992   public function CreateSignature($userId, $name, $body=null) {
     4993      if( $userId === null || $name === null ) {
     4994        throw new ApiException("missing required parameters", 400);
     4995      }
     4996      //parse inputs
     4997      $resourcePath = str_replace("*", "", "/signature/{userId}/signature?name={name}");
     4998      $pos = strpos($resourcePath, "?");
     4999      if($pos !== false){
     5000        $resourcePath = substr($resourcePath, 0, $pos);
     5001      }
     5002      $resourcePath = str_replace("{format}", "json", $resourcePath);
     5003      $method = "POST";
     5004      $queryParams = array();
     5005      $headerParams = array();
     5006
     5007      if($name !== null) {
     5008          $queryParams['name'] = $this->apiClient->toPathValue($name);
     5009        }
     5010        if($userId !== null) {
     5011            $resourcePath = str_replace("{" . "userId" . "}",
     5012                                        $userId, $resourcePath);
     5013        }
     5014        //make the API Call
     5015      if (! isset($body)) {
     5016        $body = null;
     5017      }
     5018      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     5019                                              $queryParams, $body, $headerParams);
     5020      if(! $response){
     5021        return null;
     5022      }
     5023
     5024      $responseObject = $this->apiClient->deserialize($response,
     5025                                                        'SignatureSignatureResponse');
     5026      return $responseObject;
     5027      }
     5028  /**
     5029     * DeleteSignature
     5030     * Delete user signature
     5031   * userId, string: User GUID (required)
     5032   * signatureGuid, string: Signature GUID (required)
     5033   * @return SignatureStatusResponse
     5034     */
     5035
     5036   public function DeleteSignature($userId, $signatureGuid) {
     5037      if( $userId === null || $signatureGuid === null ) {
     5038        throw new ApiException("missing required parameters", 400);
     5039      }
     5040      //parse inputs
     5041      $resourcePath = str_replace("*", "", "/signature/{userId}/signatures/{signatureGuid}");
     5042      $resourcePath = str_replace("{format}", "json", $resourcePath);
     5043      $method = "DELETE";
     5044      $queryParams = array();
     5045      $headerParams = array();
     5046
     5047      if($userId !== null) {
     5048            $resourcePath = str_replace("{" . "userId" . "}",
     5049                                        $userId, $resourcePath);
     5050        }
     5051        if($signatureGuid !== null) {
     5052            $resourcePath = str_replace("{" . "signatureGuid" . "}",
     5053                                        $signatureGuid, $resourcePath);
     5054        }
     5055        //make the API Call
     5056      if (! isset($body)) {
     5057        $body = null;
     5058      }
     5059      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     5060                                              $queryParams, $body, $headerParams);
     5061      if(! $response){
     5062        return null;
     5063      }
     5064
     5065      $responseObject = $this->apiClient->deserialize($response,
     5066                                                        'SignatureStatusResponse');
     5067      return $responseObject;
     5068      }
     5069  /**
     5070     * GetSignatures
     5071     * Get user signatures
     5072   * userId, string: User GUID (required)
     5073   * page, int: Show records for page number (optional)
     5074   * records, int: Show records count (optional)
     5075   * name, string: Filter by signature name (optional)
     5076   * @return SignatureSignaturesResponse
     5077     */
     5078
     5079   public function GetSignatures($userId, $page=null, $records=null, $name=null) {
     5080      if( $userId === null ) {
     5081        throw new ApiException("missing required parameters", 400);
     5082      }
     5083      //parse inputs
     5084      $resourcePath = str_replace("*", "", "/signature/{userId}/signatures?records={records}&page={page}&name={name}");
     5085      $pos = strpos($resourcePath, "?");
     5086      if($pos !== false){
     5087        $resourcePath = substr($resourcePath, 0, $pos);
     5088      }
     5089      $resourcePath = str_replace("{format}", "json", $resourcePath);
     5090      $method = "GET";
     5091      $queryParams = array();
     5092      $headerParams = array();
     5093
     5094      if($page !== null) {
     5095          $queryParams['page'] = $this->apiClient->toPathValue($page);
     5096        }
     5097        if($records !== null) {
     5098          $queryParams['records'] = $this->apiClient->toPathValue($records);
     5099        }
     5100        if($name !== null) {
     5101          $queryParams['name'] = $this->apiClient->toPathValue($name);
     5102        }
     5103        if($userId !== null) {
     5104            $resourcePath = str_replace("{" . "userId" . "}",
     5105                                        $userId, $resourcePath);
     5106        }
     5107        //make the API Call
     5108      if (! isset($body)) {
     5109        $body = null;
     5110      }
     5111      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     5112                                              $queryParams, $body, $headerParams);
     5113      if(! $response){
     5114        return null;
     5115      }
     5116
     5117      $responseObject = $this->apiClient->deserialize($response,
     5118                                                        'SignatureSignaturesResponse');
    48905119      return $responseObject;
    48915120      }
    … …  
    49475176   * envelopeGuid, string: Envelope GUID (required)
    49485177   * recipientGuid, string: Recipient GUID (required)
     5178   * body, SignatureSignEnvelopeSettingsInfo: Sign settings (optional)
    49495179   * @return SignatureStatusResponse
    49505180     */
    49515181
    4952    public function PublicSignEnvelope($envelopeGuid, $recipientGuid) {
     5182   public function PublicSignEnvelope($envelopeGuid, $recipientGuid, $body=null) {
    49535183      if( $envelopeGuid === null || $recipientGuid === null ) {
    49545184        throw new ApiException("missing required parameters", 400);
    … …  
    52865516   * participantName, string: Participant Name (required)
    52875517   * authSignature, string: Authentication signature (required)
     5518   * authData, stream: Base64 encoded Signer Image (optional)
     5519   * body, SignatureSignFormSettingsInfo: Sign settings (optional)
    52885520   * @return SignatureStatusResponse
    52895521     */
    52905522
    5291    public function PublicSignForm($formGuid, $participantGuid, $participantName, $authSignature) {
     5523   public function PublicSignForm($formGuid, $participantGuid, $participantName, $authSignature, $authData=null, $body=null) {
    52925524      if( $formGuid === null || $participantGuid === null || $participantName === null || $authSignature === null ) {
    52935525        throw new ApiException("missing required parameters", 400);
    52945526      }
    52955527      //parse inputs
    5296       $resourcePath = str_replace("*", "", "/signature/public/forms/{formGuid}/participant/{participantGuid}/sign?name={participantName}&participantAuthSignature={authSignature}");
     5528      $resourcePath = str_replace("*", "", "/signature/public/forms/{formGuid}/participant/{participantGuid}/sign?name={participantName}&participantAuthSignature={authSignature}&authData={authData}&signatureSignFormSettingsInfo={signatureSignFormSettingsInfo}");
    52975529      $pos = strpos($resourcePath, "?");
    52985530      if($pos !== false){
    … …  
    53095541        if($authSignature !== null) {
    53105542          $queryParams['participantAuthSignature'] = $this->apiClient->toPathValue($authSignature);
     5543        }
     5544        if($authData !== null) {
     5545          $queryParams['authData'] = $this->apiClient->toPathValue($authData);
    53115546        }
    53125547        if($formGuid !== null) {
    … …  
    56695904      }
    56705905  /**
     5906     * PublicModifyFormParticipant
     5907     * Update Form Participant
     5908   * formGuid, string: Form GUID (required)
     5909   * participantGuid, string: Participant GUID (required)
     5910   * participantEmail, string: Participant Email to be set (required)
     5911   * @return SignatureFormParticipantResponse
     5912     */
     5913
     5914   public function PublicModifyFormParticipant($formGuid, $participantGuid, $participantEmail) {
     5915      if( $formGuid === null || $participantGuid === null || $participantEmail === null ) {
     5916        throw new ApiException("missing required parameters", 400);
     5917      }
     5918      //parse inputs
     5919      $resourcePath = str_replace("*", "", "/signature/public/forms/{formGuid}/participant/{participantGuid}?email={participantEmail}");
     5920      $pos = strpos($resourcePath, "?");
     5921      if($pos !== false){
     5922        $resourcePath = substr($resourcePath, 0, $pos);
     5923      }
     5924      $resourcePath = str_replace("{format}", "json", $resourcePath);
     5925      $method = "PUT";
     5926      $queryParams = array();
     5927      $headerParams = array();
     5928
     5929      if($participantEmail !== null) {
     5930          $queryParams['email'] = $this->apiClient->toPathValue($participantEmail);
     5931        }
     5932        if($formGuid !== null) {
     5933            $resourcePath = str_replace("{" . "formGuid" . "}",
     5934                                        $formGuid, $resourcePath);
     5935        }
     5936        if($participantGuid !== null) {
     5937            $resourcePath = str_replace("{" . "participantGuid" . "}",
     5938                                        $participantGuid, $resourcePath);
     5939        }
     5940        //make the API Call
     5941      if (! isset($body)) {
     5942        $body = null;
     5943      }
     5944      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     5945                                              $queryParams, $body, $headerParams);
     5946      if(! $response){
     5947        return null;
     5948      }
     5949
     5950      $responseObject = $this->apiClient->deserialize($response,
     5951                                                        'SignatureFormParticipantResponse');
     5952      return $responseObject;
     5953      }
     5954  /**
     5955     * PublicValidateFormParticipant
     5956     * Validate Particpiant Identity
     5957   * formGuid, string: Form GUID (required)
     5958   * participantGuid, string: Participant GUID (required)
     5959   * validationCode, string: Code to be validated (required)
     5960   * @return SignatureStatusResponse
     5961     */
     5962
     5963   public function PublicValidateFormParticipant($formGuid, $participantGuid, $validationCode) {
     5964      if( $formGuid === null || $participantGuid === null || $validationCode === null ) {
     5965        throw new ApiException("missing required parameters", 400);
     5966      }
     5967      //parse inputs
     5968      $resourcePath = str_replace("*", "", "/signature/public/forms/{formGuid}/participant/{participantGuid}/validationCode/{validationCode}");
     5969      $resourcePath = str_replace("{format}", "json", $resourcePath);
     5970      $method = "GET";
     5971      $queryParams = array();
     5972      $headerParams = array();
     5973
     5974      if($formGuid !== null) {
     5975            $resourcePath = str_replace("{" . "formGuid" . "}",
     5976                                        $formGuid, $resourcePath);
     5977        }
     5978        if($participantGuid !== null) {
     5979            $resourcePath = str_replace("{" . "participantGuid" . "}",
     5980                                        $participantGuid, $resourcePath);
     5981        }
     5982        if($validationCode !== null) {
     5983            $resourcePath = str_replace("{" . "validationCode" . "}",
     5984                                        $validationCode, $resourcePath);
     5985        }
     5986        //make the API Call
     5987      if (! isset($body)) {
     5988        $body = null;
     5989      }
     5990      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     5991                                              $queryParams, $body, $headerParams);
     5992      if(! $response){
     5993        return null;
     5994      }
     5995
     5996      $responseObject = $this->apiClient->deserialize($response,
     5997                                                        'SignatureStatusResponse');
     5998      return $responseObject;
     5999      }
     6000  /**
     6001     * PublicFormParticipantResentValidationCode
     6002     * Request validation code email
     6003   * formGuid, string: Form GUID (required)
     6004   * participantGuid, string: Participant GUID (required)
     6005   * @return SignatureStatusResponse
     6006     */
     6007
     6008   public function PublicFormParticipantResentValidationCode($formGuid, $participantGuid) {
     6009      if( $formGuid === null || $participantGuid === null ) {
     6010        throw new ApiException("missing required parameters", 400);
     6011      }
     6012      //parse inputs
     6013      $resourcePath = str_replace("*", "", "/signature/public/forms/{formGuid}/participant/{participantGuid}/validationCode/resent");
     6014      $resourcePath = str_replace("{format}", "json", $resourcePath);
     6015      $method = "GET";
     6016      $queryParams = array();
     6017      $headerParams = array();
     6018
     6019      if($formGuid !== null) {
     6020            $resourcePath = str_replace("{" . "formGuid" . "}",
     6021                                        $formGuid, $resourcePath);
     6022        }
     6023        if($participantGuid !== null) {
     6024            $resourcePath = str_replace("{" . "participantGuid" . "}",
     6025                                        $participantGuid, $resourcePath);
     6026        }
     6027        //make the API Call
     6028      if (! isset($body)) {
     6029        $body = null;
     6030      }
     6031      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     6032                                              $queryParams, $body, $headerParams);
     6033      if(! $response){
     6034        return null;
     6035      }
     6036
     6037      $responseObject = $this->apiClient->deserialize($response,
     6038                                                        'SignatureStatusResponse');
     6039      return $responseObject;
     6040      }
     6041  /**
    56716042     * GetSignatureEnvelopeFieldData
    56726043     * Get signed envelope field data
    … …  
    57076078                                              $queryParams, $body, $headerParams, $outFileStream);
    57086079      }
     6080  /**
     6081     * PublicGetDefaultEmailTemplate
     6082     * Get default email template
     6083   * templateType, int: Template type (required)
     6084   * @return stream
     6085     */
     6086
     6087   public function PublicGetDefaultEmailTemplate($templateType, FileStream $outFileStream) {
     6088      if( $templateType === null ) {
     6089        throw new ApiException("missing required parameters", 400);
     6090      }
     6091      //parse inputs
     6092      $resourcePath = str_replace("*", "", "/signature/public/email-template/{templateType}/default");
     6093      $resourcePath = str_replace("{format}", "json", $resourcePath);
     6094      $method = "GET";
     6095      $queryParams = array();
     6096      $headerParams = array();
     6097
     6098      if($templateType !== null) {
     6099            $resourcePath = str_replace("{" . "templateType" . "}",
     6100                                        $templateType, $resourcePath);
     6101        }
     6102        //make the API Call
     6103      if (! isset($body)) {
     6104        $body = null;
     6105      }
     6106      return $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     6107                                              $queryParams, $body, $headerParams, $outFileStream);
     6108      }
    57096109 
    57106110}

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/StorageApi.php

    r885602 r1123003  
    270270   * description, string: Description (optional)
    271271   * callbackUrl, string: Callback url (optional)
     272   * overrideMode, int: Override mode (optional)
    272273   * body, stream: Stream (required)
    273274   * @return UploadResponse
    274275     */
    275276
    276    public function Upload($userId, $path, $description=null, $callbackUrl=null, $body) {
     277   public function Upload($userId, $path, $description=null, $callbackUrl=null, $overrideMode=null, $body) {
    277278      if( $userId === null || $path === null || $body === null ) {
    278279        throw new ApiException("missing required parameters", 400);
    279280      }
    280281      //parse inputs
    281       $resourcePath = str_replace("*", "", "/storage/{userId}/folders/{*path}?description={description}&callbackUrl={callbackUrl}");
     282      $resourcePath = str_replace("*", "", "/storage/{userId}/folders/{*path}?description={description}&callbackUrl={callbackUrl}&overrideMode={overrideMode}");
    282283      $pos = strpos($resourcePath, "?");
    283284      if($pos !== false){
    … …  
    294295        if($callbackUrl !== null) {
    295296          $queryParams['callbackUrl'] = $this->apiClient->toPathValue($callbackUrl);
     297        }
     298        if($overrideMode !== null) {
     299          $queryParams['overrideMode'] = $this->apiClient->toPathValue($overrideMode);
    296300        }
    297301        if($userId !== null) {

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/SystemApi.php

    r885602 r1123003  
    8787      }
    8888  /**
     89     * SimulateAssessForPaymentPlan
     90     * Simulate Assess For Payment Plan
     91   * userId, string: User GUID (required)
     92   * discountCode, string: Discount Code (optional)
     93   * paymentPlanId, string: Payment PlanId on the payment service (optional)
     94   * @return GetInvoicesResponse
     95     */
     96
     97   public function SimulateAssessForPaymentPlan($userId, $discountCode=null, $paymentPlanId=null) {
     98      if( $userId === null || $discountCode === null || $paymentPlanId === null ) {
     99        throw new ApiException("missing required parameters", 400);
     100      }
     101      //parse inputs
     102      $resourcePath = str_replace("*", "", "/system/{userId}/paymentPlans/{paymentPlanId}/discounts/{discountCode}");
     103      $resourcePath = str_replace("{format}", "json", $resourcePath);
     104      $method = "GET";
     105      $queryParams = array();
     106      $headerParams = array();
     107
     108      if($userId !== null) {
     109            $resourcePath = str_replace("{" . "userId" . "}",
     110                                        $userId, $resourcePath);
     111        }
     112        if($discountCode !== null) {
     113            $resourcePath = str_replace("{" . "discountCode" . "}",
     114                                        $discountCode, $resourcePath);
     115        }
     116        if($paymentPlanId !== null) {
     117            $resourcePath = str_replace("{" . "paymentPlanId" . "}",
     118                                        $paymentPlanId, $resourcePath);
     119        }
     120        //make the API Call
     121      if (! isset($body)) {
     122        $body = null;
     123      }
     124      $response = $this->apiClient->callAPI($this->basePath, $resourcePath, $method,
     125                                              $queryParams, $body, $headerParams);
     126      if(! $response){
     127        return null;
     128      }
     129
     130      $responseObject = $this->apiClient->deserialize($response,
     131                                                        'GetInvoicesResponse');
     132      return $responseObject;
     133      }
     134  /**
    89135     * GetUserPlan
    90136     * Get user plan

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/AnnotationInfo.php

    r885602 r1123003  
    2727      'guid' => 'string',
    2828      'documentGuid' => 'string',
     29      'text' => 'string',
     30      'layerId' => 'string',
    2931      'sessionGuid' => 'string',
    3032      'creatorGuid' => 'string',
     33      'creatorName' => 'string',
     34      'creatorEmail' => 'string',
    3135      'box' => 'Rectangle',
    3236      'pageNumber' => 'int',
    … …  
    3943      'createdOn' => 'string',
    4044      'fontColor' => 'int',
     45      'penColor' => 'int',
     46      'penWidth' => 'int',
     47      'penStyle' => 'int',
     48      'backgroundColor' => 'int',
    4149      'fieldText' => 'string',
    4250      'fontFamily' => 'string',
    … …  
    4755  public $guid; // string
    4856  public $documentGuid; // string
     57  public $text; // string
     58  public $layerId; // string
    4959  public $sessionGuid; // string
    5060  public $creatorGuid; // string
     61  public $creatorName; // string
     62  public $creatorEmail; // string
    5163  public $box; // Rectangle
    5264  public $pageNumber; // int
    … …  
    5971  public $createdOn; // string
    6072  public $fontColor; // int
     73  public $penColor; // int
     74  public $penWidth; // int
     75  public $penStyle; // int
     76  public $backgroundColor; // int
    6177  public $fieldText; // string
    6278  public $fontFamily; // string

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/AnnotationReplyInfo.php

    r885602 r1123003  
    2828      'userGuid' => 'string',
    2929      'userName' => 'string',
     30      'userEmail' => 'string',
    3031      'text' => 'string',
    3132      'repliedOn' => 'string',
    … …  
    3839  public $userGuid; // string
    3940  public $userName; // string
     41  public $userEmail; // string
    4042  public $text; // string
    4143  public $repliedOn; // string

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/AnnotationReviewerRights.php

    r909008 r1123003  
    2828      'CanAnnotate' => 'int',
    2929      'CanDownload' => 'int',
    30       'CanExport' => 'int',
    31       'CanDelete' => 'int',
    32       'All' => 'int'
     30      'CanExport' => 'int'
    3331
    3432    );
    … …  
    3836  public $CanDownload; // int
    3937  public $CanExport; // int
    40   public $CanDelete; // int
    41   public $All; // int
    4238  }
    4339

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/CreateAnnotationResult.php

    r885602 r1123003  
    3131      'sessionGuid' => 'string',
    3232      'access' => 'string',
     33      'type' => 'string',
    3334      'serverTime' => 'string'
    3435
    … …  
    4142  public $sessionGuid; // string
    4243  public $access; // string
     44  public $type; // string
    4345  public $serverTime; // string
    4446  }

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/DatasourceField.php

    r885602 r1123003  
    2929      'contentType' => 'string',
    3030      'type' => 'string',
    31       'nested_fields' => 'array[DatasourceField]'
     31      'nested_fields' => 'array[DatasourceField]',
     32      'regionName' => 'string',
     33      'dimension' => 'Dimension'
    3234
    3335    );
    … …  
    3840  public $type; // string
    3941  public $nested_fields; // array[DatasourceField]
     42  public $regionName; // string
     43  public $dimension; // Dimension
    4044  }
    4145

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/GetAccountResult.php

    r798541 r1123003  
    2525
    2626  static $swaggerTypes = array(
     27      'max_file_size' => 'string',
    2728      'max_users' => 'int',
    2829      'users' => 'array[UserInfo]'
    … …  
    3031    );
    3132
     33  public $max_file_size; // string
    3234  public $max_users; // int
    3335  public $users; // array[UserInfo]

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/GetDocumentInfoResult.php

    r798541 r1123003  
    2525
    2626  static $swaggerTypes = array(
     27      'type' => 'string',
     28      'url' => 'string',
    2729      'page_count' => 'int',
    2830      'views_count' => 'int',
    … …  
    3335    );
    3436
     37  public $type; // string
     38  public $url; // string
    3539  public $page_count; // int
    3640  public $views_count; // int

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/GetDocumentQuestionnairesResult.php

    r798541 r1123003  
    2626  static $swaggerTypes = array(
    2727      'document_id' => 'float',
    28       'questionnaires' => 'array[QuestionnaireInfo]'
     28      'questionnaires' => 'array[QuestionnaireInfo]',
     29      'totalCount' => 'int'
    2930
    3031    );
    … …  
    3233  public $document_id; // float
    3334  public $questionnaires; // array[QuestionnaireInfo]
     35  public $totalCount; // int
    3436  }
    3537

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/GetJobResult.php

    r798541 r1123003  
    3737      'guid' => 'string',
    3838      'name' => 'string',
    39       'callback_url' => 'string'
     39      'callback_url' => 'string',
     40      'type' => 'string'
    4041
    4142    );
    … …  
    5455  public $name; // string
    5556  public $callback_url; // string
     57  public $type; // string
    5658  }
    5759

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/GetQuestionnairesResult.php

    r798541 r1123003  
    2525
    2626  static $swaggerTypes = array(
    27       'questionnaires' => 'array[QuestionnaireInfo]'
     27      'questionnaires' => 'array[QuestionnaireInfo]',
     28      'totalCount' => 'int'
    2829
    2930    );
    3031
    3132  public $questionnaires; // array[QuestionnaireInfo]
     33  public $totalCount; // int
    3234  }
    3335

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/JobInfo.php

    r798541 r1123003  
    3737      'guid' => 'string',
    3838      'name' => 'string',
    39       'callback_url' => 'string'
     39      'callback_url' => 'string',
     40      'type' => 'string'
    4041
    4142    );
    … …  
    5455  public $name; // string
    5556  public $callback_url; // string
     57  public $type; // string
    5658  }
    5759

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/PublicSignatureSignDocumentSignerSettingsInfo.php

    r885602 r1123003  
    2828      'waterMarkImage' => 'string',
    2929      'name' => 'string',
     30      'email' => 'string',
    3031      'top' => 'float',
    3132      'left' => 'float',
    … …  
    3435      'placeSignatureOn' => 'string',
    3536      'data' => 'string',
    36       'fields' => 'array[SignatureDocumentFieldInfo]'
     37      'fields' => 'array[SignatureSignFieldSettingsInfo]'
    3738
    3839    );
    … …  
    4142  public $waterMarkImage; // string
    4243  public $name; // string
     44  public $email; // string
    4345  public $top; // float
    4446  public $left; // float
    … …  
    4749  public $placeSignatureOn; // string
    4850  public $data; // string
    49   public $fields; // array[SignatureDocumentFieldInfo]
     51  public $fields; // array[SignatureSignFieldSettingsInfo]
    5052  }
    5153

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/QuestionInfo.php

    r885602 r1123003  
    3535      'acceptableValues' => 'array[string]',
    3636      'max_length' => 'int',
    37       'rect' => 'Rectangle'
     37      'rect' => 'Rectangle',
     38      'regionName' => 'string',
     39      'hint' => 'string',
     40      'dimension' => 'FieldDimension'
    3841
    3942    );
    … …  
    5053  public $max_length; // int
    5154  public $rect; // Rectangle
     55  public $regionName; // string
     56  public $hint; // string
     57  public $dimension; // FieldDimension
    5258  }
    5359

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureEnvelopeFieldInfo.php

    r885602 r1123003  
    4343      'guidanceText' => 'string',
    4444      'groupName' => 'string',
    45       'settings' => 'string'
     45      'settings' => 'string',
     46      'lockDuringSign' => 'bool'
    4647
    4748    );
    … …  
    6667  public $groupName; // string
    6768  public $settings; // string
     69  public $lockDuringSign; // bool
    6870  }
    6971

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureEnvelopeFieldSettingsInfo.php

    r885602 r1123003  
    5050      'settings' => 'string',
    5151      'pageWidth' => 'int',
    52       'pageHeight' => 'int'
     52      'pageHeight' => 'int',
     53      'lockDuringSign' => 'bool'
    5354
    5455    );
    … …  
    8081  public $pageWidth; // int
    8182  public $pageHeight; // int
     83  public $lockDuringSign; // bool
    8284  }
    8385

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureEnvelopeInfo.php

    r798541 r1123003  
    4848      'canBeCommented' => 'bool',
    4949      'inPersonSign' => 'bool',
    50       'ownerName' => 'string'
     50      'ownerName' => 'string',
     51      'enableTypedSignature' => 'bool',
     52      'enableUploadedSignature' => 'bool',
     53      'requireUserAuthForSign' => 'bool',
     54      'requestUserAuthByPhoto' => 'bool',
     55      'showRecipientCommentInSignedDocument' => 'bool',
     56      'tags' => 'string'
    5157
    5258    );
    … …  
    7682  public $inPersonSign; // bool
    7783  public $ownerName; // string
     84  public $enableTypedSignature; // bool
     85  public $enableUploadedSignature; // bool
     86  public $requireUserAuthForSign; // bool
     87  public $requestUserAuthByPhoto; // bool
     88  public $showRecipientCommentInSignedDocument; // bool
     89  public $tags; // string
    7890  }
    7991

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureEnvelopeRecipientInfo.php

    r798541 r1123003  
    4040      'signatureLocation' => 'string',
    4141      'signatureBrowser' => 'string',
    42       'embedUrl' => 'string'
     42      'embedUrl' => 'string',
     43      'comment' => 'string'
    4344
    4445    );
    … …  
    6061  public $signatureBrowser; // string
    6162  public $embedUrl; // string
     63  public $comment; // string
    6264  }
    6365

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureEnvelopeResourcesResult.php

    r798541 r1123003  
    2727      'documents' => 'array[SignatureEnvelopeDocumentInfo]',
    2828      'recipients' => 'array[SignatureEnvelopeRecipientInfo]',
    29       'dates' => 'array[string]'
     29      'dates' => 'array[string]',
     30      'tags' => 'array[string]'
    3031
    3132    );
    … …  
    3435  public $recipients; // array[SignatureEnvelopeRecipientInfo]
    3536  public $dates; // array[string]
     37  public $tags; // array[string]
    3638  }
    3739

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureEnvelopeSettingsInfo.php

    r798541 r1123003  
    3838      'includeViewLink' => 'bool',
    3939      'canBeCommented' => 'bool',
    40       'inPersonSign' => 'bool'
     40      'inPersonSign' => 'bool',
     41      'enableTypedSignature' => 'bool',
     42      'enableUploadedSignature' => 'bool',
     43      'requireUserAuthForSign' => 'bool',
     44      'requestUserAuthByPhoto' => 'bool',
     45      'showRecipientCommentInSignedDocument' => 'bool',
     46      'tags' => 'string'
    4147
    4248    );
    … …  
    5662  public $canBeCommented; // bool
    5763  public $inPersonSign; // bool
     64  public $enableTypedSignature; // bool
     65  public $enableUploadedSignature; // bool
     66  public $requireUserAuthForSign; // bool
     67  public $requestUserAuthByPhoto; // bool
     68  public $showRecipientCommentInSignedDocument; // bool
     69  public $tags; // string
    5870  }
    5971

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureFormInfo.php

    r885602 r1123003  
    4242      'notifyOwnerOnSign' => 'bool',
    4343      'attachSignedDocument' => 'bool',
    44       'notifyOtherOnSign' => 'string'
     44      'notifyOtherOnSign' => 'string',
     45      'canParticipantPrintForm' => 'bool',
     46      'requireUserAuthForSign' => 'bool',
     47      'requestUserAuthByPhoto' => 'bool',
     48      'enableTypedSignature' => 'bool',
     49      'enableUploadedSignature' => 'bool',
     50      'requireUserIdentityValidation' => 'bool',
     51      'canBeCommented' => 'bool',
     52      'showParticipantCommentInSignedDocument' => 'bool',
     53      'tags' => 'string',
     54      'parseFields' => 'bool'
    4555
    4656    );
    … …  
    6474  public $attachSignedDocument; // bool
    6575  public $notifyOtherOnSign; // string
     76  public $canParticipantPrintForm; // bool
     77  public $requireUserAuthForSign; // bool
     78  public $requestUserAuthByPhoto; // bool
     79  public $enableTypedSignature; // bool
     80  public $enableUploadedSignature; // bool
     81  public $requireUserIdentityValidation; // bool
     82  public $canBeCommented; // bool
     83  public $showParticipantCommentInSignedDocument; // bool
     84  public $tags; // string
     85  public $parseFields; // bool
    6686  }
    6787

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureFormParticipantInfo.php

    r798541 r1123003  
    2626  static $swaggerTypes = array(
    2727      'id' => 'string',
    28       'documentGuid' => 'string',
     28      'signedDocuments' => 'array[SignatureFormParticipantSignedDocumentInfo]',
    2929      'fillDateTime' => 'string',
    30       'status' => 'int'
     30      'status' => 'int',
     31      'email' => 'string',
     32      'comment' => 'string',
     33      'name' => 'string'
    3134
    3235    );
    3336
    3437  public $id; // string
    35   public $documentGuid; // string
     38  public $signedDocuments; // array[SignatureFormParticipantSignedDocumentInfo]
    3639  public $fillDateTime; // string
    3740  public $status; // int
     41  public $email; // string
     42  public $comment; // string
     43  public $name; // string
    3844  }
    3945

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureFormResourcesResult.php

    r798541 r1123003  
    2626  static $swaggerTypes = array(
    2727      'documents' => 'array[SignatureFormDocumentInfo]',
    28       'dates' => 'array[string]'
     28      'dates' => 'array[string]',
     29      'tags' => 'array[string]'
    2930
    3031    );
    … …  
    3233  public $documents; // array[SignatureFormDocumentInfo]
    3334  public $dates; // array[string]
     35  public $tags; // array[string]
    3436  }
    3537

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureFormSettingsInfo.php

    r885602 r1123003  
    3030      'waterMarkText' => 'string',
    3131      'waterMarkImage' => 'string',
    32       'notifyOwnerOnSign ' => 'bool',
     32      'notifyOwnerOnSign' => 'bool',
    3333      'attachSignedDocument' => 'bool',
    34       'notifyOtherOnSign ' => 'string'
     34      'notifyOtherOnSign' => 'string',
     35      'canParticipantPrintForm' => 'bool',
     36      'requireUserAuthForSign' => 'bool',
     37      'requestUserAuthByPhoto' => 'bool',
     38      'enableTypedSignature' => 'bool',
     39      'enableUploadedSignature' => 'bool',
     40      'requireUserIdentityValidation' => 'bool',
     41      'canBeCommented' => 'bool',
     42      'showParticipantCommentInSignedDocument' => 'bool',
     43      'tags' => 'string'
    3544
    3645    );
    … …  
    4150  public $waterMarkText; // string
    4251  public $waterMarkImage; // string
    43   public $notifyOwnerOnSign ; // bool
     52  public $notifyOwnerOnSign; // bool
    4453  public $attachSignedDocument; // bool
    45   public $notifyOtherOnSign ; // string
     54  public $notifyOtherOnSign; // string
     55  public $canParticipantPrintForm; // bool
     56  public $requireUserAuthForSign; // bool
     57  public $requestUserAuthByPhoto; // bool
     58  public $enableTypedSignature; // bool
     59  public $enableUploadedSignature; // bool
     60  public $requireUserIdentityValidation; // bool
     61  public $canBeCommented; // bool
     62  public $showParticipantCommentInSignedDocument; // bool
     63  public $tags; // string
    4664  }
    4765

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureSignDocumentSignerSettingsInfo.php

    r885602 r1123003  
    2626  static $swaggerTypes = array(
    2727      'name' => 'string',
     28      'email' => 'string',
    2829      'top' => 'float',
    2930      'left' => 'float',
    … …  
    3233      'placeSignatureOn' => 'string',
    3334      'data' => 'string',
    34       'fields' => 'array[SignatureFieldInfo]'
     35      'fields' => 'array[SignatureSignFieldSettingsInfo]'
    3536
    3637    );
    3738
    3839  public $name; // string
     40  public $email; // string
    3941  public $top; // float
    4042  public $left; // float
    … …  
    4345  public $placeSignatureOn; // string
    4446  public $data; // string
    45   public $fields; // array[SignatureFieldInfo]
     47  public $fields; // array[SignatureSignFieldSettingsInfo]
    4648  }
    4749

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureTemplateInfo.php

    r798541 r1123003  
    4040      'waterMarkText' => 'string',
    4141      'waterMarkImage' => 'string',
    42       'fieldsCount' => 'float'
     42      'fieldsCount' => 'float',
     43      'enableTypedSignature' => 'bool',
     44      'enableUploadedSignature' => 'bool',
     45      'tags' => 'string'
    4346
    4447    );
    … …  
    6063  public $waterMarkImage; // string
    6164  public $fieldsCount; // float
     65  public $enableTypedSignature; // bool
     66  public $enableUploadedSignature; // bool
     67  public $tags; // string
    6268  }
    6369

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureTemplateResourcesResult.php

    r798541 r1123003  
    2626  static $swaggerTypes = array(
    2727      'documents' => 'array[SignatureTemplateDocumentInfo]',
    28       'recipients' => 'array[SignatureTemplateRecipientInfo]'
     28      'recipients' => 'array[SignatureTemplateRecipientInfo]',
     29      'tags' => 'array[string]'
    2930
    3031    );
    … …  
    3233  public $documents; // array[SignatureTemplateDocumentInfo]
    3334  public $recipients; // array[SignatureTemplateRecipientInfo]
     35  public $tags; // array[string]
    3436  }
    3537

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureTemplateSettingsInfo.php

    r798541 r1123003  
    3333      'emailBody' => 'string',
    3434      'waterMarkText' => 'string',
    35       'waterMarkImage' => 'string'
     35      'waterMarkImage' => 'string',
     36      'enableTypedSignature' => 'bool',
     37      'enableUploadedSignature' => 'bool',
     38      'tags' => 'string'
    3639
    3740    );
    … …  
    4649  public $waterMarkText; // string
    4750  public $waterMarkImage; // string
     51  public $enableTypedSignature; // bool
     52  public $enableUploadedSignature; // bool
     53  public $tags; // string
    4854  }
    4955

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/SignatureVerifyDocumentResult.php

    r798541 r1123003  
    2828      'datesSigned' => 'array[string]',
    2929      'references' => 'array[string]',
    30       'recipients' => 'array[SignatureEnvelopeRecipientInfo]'
     30      'recipients' => 'array[SignatureSignerInfo]'
    3131
    3232    );
    … …  
    3535  public $datesSigned; // array[string]
    3636  public $references; // array[string]
    37   public $recipients; // array[SignatureEnvelopeRecipientInfo]
     37  public $recipients; // array[SignatureSignerInfo]
    3838  }
    3939

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/StorageProviderInfo.php

    r798541 r1123003  
    3434      'isPrimary' => 'bool',
    3535      'serviceHost' => 'string',
    36       'syncOptions' => 'string'
     36      'syncOptions' => 'string',
     37      'altPublicKey' => 'string',
     38      'altPrivateKey' => 'string',
     39      'interoperable' => 'bool'
    3740
    3841    );
    … …  
    4851  public $serviceHost; // string
    4952  public $syncOptions; // string
     53  public $altPublicKey; // string
     54  public $altPrivateKey; // string
     55  public $interoperable; // bool
    5056  }
    5157

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/TemplateField.php

    r885602 r1123003  
    3232      'mandatory' => 'bool',
    3333      'fieldtype' => 'string',
    34       'acceptableValues' => 'array[string]'
     34      'acceptableValues' => 'array[string]',
     35      'selectionPosition' => 'int',
     36      'selectionLength' => 'int',
     37      'isTableStartMarker' => 'bool',
     38      'isTableEndMarker' => 'bool',
     39      'regionName' => 'string'
    3540
    3641    );
    … …  
    4449  public $fieldtype; // string
    4550  public $acceptableValues; // array[string]
     51  public $selectionPosition; // int
     52  public $selectionLength; // int
     53  public $isTableStartMarker; // bool
     54  public $isTableEndMarker; // bool
     55  public $regionName; // string
    4656  }
    4757

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/TemplateInfo.php

    r885602 r1123003  
    2929      'size' => 'string',
    3030      'fileType' => 'string',
     31      'docType' => 'string',
     32      'dependent_questionnaires_count' => 'int',
    3133      'upload_time' => 'string',
    3234      'id' => 'float',
    … …  
    3941  public $size; // string
    4042  public $fileType; // string
     43  public $docType; // string
     44  public $dependent_questionnaires_count; // int
    4145  public $upload_time; // string
    4246  public $id; // float

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/UserInfo.php

    r885602 r1123003  
    6565      'is_typewriter_annotation_button_enabled' => 'bool',
    6666      'is_watermark_annotation_button_enabled' => 'bool',
     67      'is_text_replacement_annotation_button_enabled' => 'bool',
     68      'is_arrow_annotation_button_enabled' => 'bool',
     69      'is_text_redaction_annotation_button_enabled' => 'bool',
     70      'is_resource_redaction_annotation_button_enabled' => 'bool',
     71      'is_text_underline_annotation_button_enabled' => 'bool',
     72      'is_distance_annotation_button_enabled' => 'bool',
    6773      'is_annotation_document_name_shown' => 'bool',
    6874      'annotation_navigation_icons' => 'array[int]',
    … …  
    8894      'signature_color' => 'string',
    8995      'signature_save_field_changes_automatically' => 'bool',
     96      'signature_use_custom_email_templates' => 'bool',
     97      'signature_envelope_sent_owner_template' => 'string',
     98      'signature_envelope_sent_other_template' => 'string',
     99      'signature_envelope_completed_template' => 'string',
     100      'signature_envelope_signed_template' => 'string',
     101      'signature_envelope_declined_template' => 'string',
     102      'signature_envelope_failed_template' => 'string',
     103      'signature_envelope_cancelled_template' => 'string',
     104      'signature_envelope_expired_template' => 'string',
     105      'signature_envelope_step_expired_template' => 'string',
     106      'signature_envelope_recipient_reminder_template' => 'string',
     107      'signature_form_signed_template' => 'string',
     108      'signature_form_require_user_auth_for_sign' => 'bool',
     109      'signature_form_request_user_auth_by_photo' => 'bool',
     110      'signature_form_require_user_identity_validation' => 'bool',
     111      'signature_envelope_require_user_auth_for_sign' => 'bool',
     112      'signature_envelope_request_user_auth_by_photo' => 'bool',
     113      'signature_enable_uploaded_signature' => 'bool',
     114      'signature_enable_typed_signature' => 'bool',
     115      'signature_enable_envelope_comment' => 'bool',
     116      'signature_enable_form_comment' => 'bool',
     117      'can_participan_download_form' => 'bool',
     118      'can_participant_print_form' => 'bool',
     119      'notify_form_owner_on_sign' => 'bool',
     120      'attach_signed_form_document' => 'bool',
     121      'show_participant_comment_in_signed_document' => 'bool',
     122      'forms_notify_other_on_sign' => 'string',
     123      'form_document_parse_fields' => 'bool',
    90124      'id' => 'string',
    91125      'guid' => 'string',
    … …  
    134168  public $is_typewriter_annotation_button_enabled; // bool
    135169  public $is_watermark_annotation_button_enabled; // bool
     170  public $is_text_replacement_annotation_button_enabled; // bool
     171  public $is_arrow_annotation_button_enabled; // bool
     172  public $is_text_redaction_annotation_button_enabled; // bool
     173  public $is_resource_redaction_annotation_button_enabled; // bool
     174  public $is_text_underline_annotation_button_enabled; // bool
     175  public $is_distance_annotation_button_enabled; // bool
    136176  public $is_annotation_document_name_shown; // bool
    137177  public $annotation_navigation_icons; // array[int]
    … …  
    157197  public $signature_color; // string
    158198  public $signature_save_field_changes_automatically; // bool
     199  public $signature_use_custom_email_templates; // bool
     200  public $signature_envelope_sent_owner_template; // string
     201  public $signature_envelope_sent_other_template; // string
     202  public $signature_envelope_completed_template; // string
     203  public $signature_envelope_signed_template; // string
     204  public $signature_envelope_declined_template; // string
     205  public $signature_envelope_failed_template; // string
     206  public $signature_envelope_cancelled_template; // string
     207  public $signature_envelope_expired_template; // string
     208  public $signature_envelope_step_expired_template; // string
     209  public $signature_envelope_recipient_reminder_template; // string
     210  public $signature_form_signed_template; // string
     211  public $signature_form_require_user_auth_for_sign; // bool
     212  public $signature_form_request_user_auth_by_photo; // bool
     213  public $signature_form_require_user_identity_validation; // bool
     214  public $signature_envelope_require_user_auth_for_sign; // bool
     215  public $signature_envelope_request_user_auth_by_photo; // bool
     216  public $signature_enable_uploaded_signature; // bool
     217  public $signature_enable_typed_signature; // bool
     218  public $signature_enable_envelope_comment; // bool
     219  public $signature_enable_form_comment; // bool
     220  public $can_participan_download_form; // bool
     221  public $can_participant_print_form; // bool
     222  public $notify_form_owner_on_sign; // bool
     223  public $attach_signed_form_document; // bool
     224  public $show_participant_comment_in_signed_document; // bool
     225  public $forms_notify_other_on_sign; // string
     226  public $form_document_parse_fields; // bool
    159227  public $id; // string
    160228  public $guid; // string

  • groupdocs-documents-annotation/trunk/tree_annotation/lib/groupdocs-php/models/ViewDocumentResult.php

    r885602 r1123003  
    3939      'pdfPrintUrl' => 'string',
    4040      'htmlPrintUrl' => 'string',
     41      'documentDescription' => 'string',
    4142      'id' => 'float',
    4243      'guid' => 'string'
    … …  
    5859  public $pdfPrintUrl; // string
    5960  public $htmlPrintUrl; // string
     61  public $documentDescription; // string
    6062  public $id; // float
    6163  public $guid; // string
Note: See TracChangeset for help on using the changeset viewer.