import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DocumentLocationsApi;

import java.io.File;
import java.util.*;

public class DocumentLocationsApiExample {

    public static void main(String[] args) {
        
        DocumentLocationsApi apiInstance = new DocumentLocationsApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        DocumentLocationForCreationDTO body = ; // DocumentLocationForCreationDTO | 
        try {
            apiInstance.v1FolderIdDocumentsDocumentIdPost(folderId, documentId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentLocationsApi#v1FolderIdDocumentsDocumentIdPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DocumentLocationsApi;

public class DocumentLocationsApiExample {

    public static void main(String[] args) {
        DocumentLocationsApi apiInstance = new DocumentLocationsApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        DocumentLocationForCreationDTO body = ; // DocumentLocationForCreationDTO | 
        try {
            apiInstance.v1FolderIdDocumentsDocumentIdPost(folderId, documentId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentLocationsApi#v1FolderIdDocumentsDocumentIdPost");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
String *documentId = documentId_example; // 
DocumentLocationForCreationDTO *body = ; //  (optional)

DocumentLocationsApi *apiInstance = [[DocumentLocationsApi alloc] init];

// Creates a new document.
[apiInstance v1FolderIdDocumentsDocumentIdPostWith:folderId
    documentId:documentId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.DocumentLocationsApi()
var folderId = folderId_example; // {{String}} 
var documentId = documentId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdDocumentsDocumentIdPost(folderIddocumentId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdDocumentsDocumentIdPostExample
    {
        public void main()
        {

            var apiInstance = new DocumentLocationsApi();
            var folderId = folderId_example;  // String | 
            var documentId = documentId_example;  // String | 
            var body = new DocumentLocationForCreationDTO(); // DocumentLocationForCreationDTO |  (optional) 

            try
            {
                // Creates a new document.
                apiInstance.v1FolderIdDocumentsDocumentIdPost(folderId, documentId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DocumentLocationsApi.v1FolderIdDocumentsDocumentIdPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDocumentLocationsApi();
$folderId = folderId_example; // String | 
$documentId = documentId_example; // String | 
$body = ; // DocumentLocationForCreationDTO | 

try {
    $api_instance->v1FolderIdDocumentsDocumentIdPost($folderId, $documentId, $body);
} catch (Exception $e) {
    echo 'Exception when calling DocumentLocationsApi->v1FolderIdDocumentsDocumentIdPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DocumentLocationsApi;

my $api_instance = WWW::SwaggerClient::DocumentLocationsApi->new();
my $folderId = folderId_example; # String | 
my $documentId = documentId_example; # String | 
my $body = WWW::SwaggerClient::Object::DocumentLocationForCreationDTO->new(); # DocumentLocationForCreationDTO | 

eval { 
    $api_instance->v1FolderIdDocumentsDocumentIdPost(folderId => $folderId, documentId => $documentId, body => $body);
};
if ($@) {
    warn "Exception when calling DocumentLocationsApi->v1FolderIdDocumentsDocumentIdPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DocumentLocationsApi()
folderId = folderId_example # String | 
documentId = documentId_example # String | 
body =  # DocumentLocationForCreationDTO |  (optional)

try: 
    # Creates a new document.
    api_instance.v1_folder_id_documents_document_id_post(folderId, documentId, body=body)
except ApiException as e:
    print("Exception when calling DocumentLocationsApi->v1FolderIdDocumentsDocumentIdPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DocumentsApi;

import java.io.File;
import java.util.*;

public class DocumentsApiExample {

    public static void main(String[] args) {
        
        DocumentsApi apiInstance = new DocumentsApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        try {
            apiInstance.v1FolderIdDocumentsDocumentIdContentHashGet(folderId, documentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#v1FolderIdDocumentsDocumentIdContentHashGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DocumentsApi;

public class DocumentsApiExample {

    public static void main(String[] args) {
        DocumentsApi apiInstance = new DocumentsApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        try {
            apiInstance.v1FolderIdDocumentsDocumentIdContentHashGet(folderId, documentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#v1FolderIdDocumentsDocumentIdContentHashGet");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
String *documentId = documentId_example; // 

DocumentsApi *apiInstance = [[DocumentsApi alloc] init];

// Retrieves a document containing a particular hash.
[apiInstance v1FolderIdDocumentsDocumentIdContentHashGetWith:folderId
    documentId:documentId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.DocumentsApi()
var folderId = folderId_example; // {{String}} 
var documentId = documentId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdDocumentsDocumentIdContentHashGet(folderId, documentId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdDocumentsDocumentIdContentHashGetExample
    {
        public void main()
        {

            var apiInstance = new DocumentsApi();
            var folderId = folderId_example;  // String | 
            var documentId = documentId_example;  // String | 

            try
            {
                // Retrieves a document containing a particular hash.
                apiInstance.v1FolderIdDocumentsDocumentIdContentHashGet(folderId, documentId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DocumentsApi.v1FolderIdDocumentsDocumentIdContentHashGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDocumentsApi();
$folderId = folderId_example; // String | 
$documentId = documentId_example; // String | 

try {
    $api_instance->v1FolderIdDocumentsDocumentIdContentHashGet($folderId, $documentId);
} catch (Exception $e) {
    echo 'Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdContentHashGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DocumentsApi;

my $api_instance = WWW::SwaggerClient::DocumentsApi->new();
my $folderId = folderId_example; # String | 
my $documentId = documentId_example; # String | 

eval { 
    $api_instance->v1FolderIdDocumentsDocumentIdContentHashGet(folderId => $folderId, documentId => $documentId);
};
if ($@) {
    warn "Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdContentHashGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DocumentsApi()
folderId = folderId_example # String | 
documentId = documentId_example # String | 

try: 
    # Retrieves a document containing a particular hash.
    api_instance.v1_folder_id_documents_document_id_content_hash_get(folderId, documentId)
except ApiException as e:
    print("Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdContentHashGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DocumentsApi;

import java.io.File;
import java.util.*;

public class DocumentsApiExample {

    public static void main(String[] args) {
        
        DocumentsApi apiInstance = new DocumentsApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        try {
            apiInstance.v1FolderIdDocumentsDocumentIdContentSignedGet(folderId, documentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#v1FolderIdDocumentsDocumentIdContentSignedGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DocumentsApi;

public class DocumentsApiExample {

    public static void main(String[] args) {
        DocumentsApi apiInstance = new DocumentsApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        try {
            apiInstance.v1FolderIdDocumentsDocumentIdContentSignedGet(folderId, documentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#v1FolderIdDocumentsDocumentIdContentSignedGet");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
String *documentId = documentId_example; // 

DocumentsApi *apiInstance = [[DocumentsApi alloc] init];

// Retrieves a particular signed document.
[apiInstance v1FolderIdDocumentsDocumentIdContentSignedGetWith:folderId
    documentId:documentId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.DocumentsApi()
var folderId = folderId_example; // {{String}} 
var documentId = documentId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdDocumentsDocumentIdContentSignedGet(folderId, documentId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdDocumentsDocumentIdContentSignedGetExample
    {
        public void main()
        {

            var apiInstance = new DocumentsApi();
            var folderId = folderId_example;  // String | 
            var documentId = documentId_example;  // String | 

            try
            {
                // Retrieves a particular signed document.
                apiInstance.v1FolderIdDocumentsDocumentIdContentSignedGet(folderId, documentId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DocumentsApi.v1FolderIdDocumentsDocumentIdContentSignedGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDocumentsApi();
$folderId = folderId_example; // String | 
$documentId = documentId_example; // String | 

try {
    $api_instance->v1FolderIdDocumentsDocumentIdContentSignedGet($folderId, $documentId);
} catch (Exception $e) {
    echo 'Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdContentSignedGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DocumentsApi;

my $api_instance = WWW::SwaggerClient::DocumentsApi->new();
my $folderId = folderId_example; # String | 
my $documentId = documentId_example; # String | 

eval { 
    $api_instance->v1FolderIdDocumentsDocumentIdContentSignedGet(folderId => $folderId, documentId => $documentId);
};
if ($@) {
    warn "Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdContentSignedGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DocumentsApi()
folderId = folderId_example # String | 
documentId = documentId_example # String | 

try: 
    # Retrieves a particular signed document.
    api_instance.v1_folder_id_documents_document_id_content_signed_get(folderId, documentId)
except ApiException as e:
    print("Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdContentSignedGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DocumentsApi;

import java.io.File;
import java.util.*;

public class DocumentsApiExample {

    public static void main(String[] args) {
        
        DocumentsApi apiInstance = new DocumentsApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        try {
            apiInstance.v1FolderIdDocumentsDocumentIdDelete(folderId, documentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#v1FolderIdDocumentsDocumentIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DocumentsApi;

public class DocumentsApiExample {

    public static void main(String[] args) {
        DocumentsApi apiInstance = new DocumentsApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        try {
            apiInstance.v1FolderIdDocumentsDocumentIdDelete(folderId, documentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#v1FolderIdDocumentsDocumentIdDelete");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
String *documentId = documentId_example; // 

DocumentsApi *apiInstance = [[DocumentsApi alloc] init];

// Deletes a document.
[apiInstance v1FolderIdDocumentsDocumentIdDeleteWith:folderId
    documentId:documentId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.DocumentsApi()
var folderId = folderId_example; // {{String}} 
var documentId = documentId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdDocumentsDocumentIdDelete(folderId, documentId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdDocumentsDocumentIdDeleteExample
    {
        public void main()
        {

            var apiInstance = new DocumentsApi();
            var folderId = folderId_example;  // String | 
            var documentId = documentId_example;  // String | 

            try
            {
                // Deletes a document.
                apiInstance.v1FolderIdDocumentsDocumentIdDelete(folderId, documentId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DocumentsApi.v1FolderIdDocumentsDocumentIdDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDocumentsApi();
$folderId = folderId_example; // String | 
$documentId = documentId_example; // String | 

try {
    $api_instance->v1FolderIdDocumentsDocumentIdDelete($folderId, $documentId);
} catch (Exception $e) {
    echo 'Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DocumentsApi;

my $api_instance = WWW::SwaggerClient::DocumentsApi->new();
my $folderId = folderId_example; # String | 
my $documentId = documentId_example; # String | 

eval { 
    $api_instance->v1FolderIdDocumentsDocumentIdDelete(folderId => $folderId, documentId => $documentId);
};
if ($@) {
    warn "Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DocumentsApi()
folderId = folderId_example # String | 
documentId = documentId_example # String | 

try: 
    # Deletes a document.
    api_instance.v1_folder_id_documents_document_id_delete(folderId, documentId)
except ApiException as e:
    print("Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DocumentsApi;

import java.io.File;
import java.util.*;

public class DocumentsApiExample {

    public static void main(String[] args) {
        
        DocumentsApi apiInstance = new DocumentsApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        try {
            apiInstance.v1FolderIdDocumentsDocumentIdGet(folderId, documentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#v1FolderIdDocumentsDocumentIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DocumentsApi;

public class DocumentsApiExample {

    public static void main(String[] args) {
        DocumentsApi apiInstance = new DocumentsApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        try {
            apiInstance.v1FolderIdDocumentsDocumentIdGet(folderId, documentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#v1FolderIdDocumentsDocumentIdGet");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
String *documentId = documentId_example; // 

DocumentsApi *apiInstance = [[DocumentsApi alloc] init];

// Retrieves a document.
[apiInstance v1FolderIdDocumentsDocumentIdGetWith:folderId
    documentId:documentId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.DocumentsApi()
var folderId = folderId_example; // {{String}} 
var documentId = documentId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdDocumentsDocumentIdGet(folderId, documentId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdDocumentsDocumentIdGetExample
    {
        public void main()
        {

            var apiInstance = new DocumentsApi();
            var folderId = folderId_example;  // String | 
            var documentId = documentId_example;  // String | 

            try
            {
                // Retrieves a document.
                apiInstance.v1FolderIdDocumentsDocumentIdGet(folderId, documentId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DocumentsApi.v1FolderIdDocumentsDocumentIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDocumentsApi();
$folderId = folderId_example; // String | 
$documentId = documentId_example; // String | 

try {
    $api_instance->v1FolderIdDocumentsDocumentIdGet($folderId, $documentId);
} catch (Exception $e) {
    echo 'Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DocumentsApi;

my $api_instance = WWW::SwaggerClient::DocumentsApi->new();
my $folderId = folderId_example; # String | 
my $documentId = documentId_example; # String | 

eval { 
    $api_instance->v1FolderIdDocumentsDocumentIdGet(folderId => $folderId, documentId => $documentId);
};
if ($@) {
    warn "Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DocumentsApi()
folderId = folderId_example # String | 
documentId = documentId_example # String | 

try: 
    # Retrieves a document.
    api_instance.v1_folder_id_documents_document_id_get(folderId, documentId)
except ApiException as e:
    print("Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DocumentsApi;

import java.io.File;
import java.util.*;

public class DocumentsApiExample {

    public static void main(String[] args) {
        
        DocumentsApi apiInstance = new DocumentsApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        DocumentForUpdateDTOJsonPatchDocument body = ; // DocumentForUpdateDTOJsonPatchDocument | 
        try {
            apiInstance.v1FolderIdDocumentsDocumentIdPatch(folderId, documentId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#v1FolderIdDocumentsDocumentIdPatch");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DocumentsApi;

public class DocumentsApiExample {

    public static void main(String[] args) {
        DocumentsApi apiInstance = new DocumentsApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        DocumentForUpdateDTOJsonPatchDocument body = ; // DocumentForUpdateDTOJsonPatchDocument | 
        try {
            apiInstance.v1FolderIdDocumentsDocumentIdPatch(folderId, documentId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#v1FolderIdDocumentsDocumentIdPatch");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
String *documentId = documentId_example; // 
DocumentForUpdateDTOJsonPatchDocument *body = ; //  (optional)

DocumentsApi *apiInstance = [[DocumentsApi alloc] init];

// Replaces a document.
[apiInstance v1FolderIdDocumentsDocumentIdPatchWith:folderId
    documentId:documentId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.DocumentsApi()
var folderId = folderId_example; // {{String}} 
var documentId = documentId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdDocumentsDocumentIdPatch(folderIddocumentId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdDocumentsDocumentIdPatchExample
    {
        public void main()
        {

            var apiInstance = new DocumentsApi();
            var folderId = folderId_example;  // String | 
            var documentId = documentId_example;  // String | 
            var body = new DocumentForUpdateDTOJsonPatchDocument(); // DocumentForUpdateDTOJsonPatchDocument |  (optional) 

            try
            {
                // Replaces a document.
                apiInstance.v1FolderIdDocumentsDocumentIdPatch(folderId, documentId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DocumentsApi.v1FolderIdDocumentsDocumentIdPatch: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDocumentsApi();
$folderId = folderId_example; // String | 
$documentId = documentId_example; // String | 
$body = ; // DocumentForUpdateDTOJsonPatchDocument | 

try {
    $api_instance->v1FolderIdDocumentsDocumentIdPatch($folderId, $documentId, $body);
} catch (Exception $e) {
    echo 'Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdPatch: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DocumentsApi;

my $api_instance = WWW::SwaggerClient::DocumentsApi->new();
my $folderId = folderId_example; # String | 
my $documentId = documentId_example; # String | 
my $body = WWW::SwaggerClient::Object::DocumentForUpdateDTOJsonPatchDocument->new(); # DocumentForUpdateDTOJsonPatchDocument | 

eval { 
    $api_instance->v1FolderIdDocumentsDocumentIdPatch(folderId => $folderId, documentId => $documentId, body => $body);
};
if ($@) {
    warn "Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdPatch: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DocumentsApi()
folderId = folderId_example # String | 
documentId = documentId_example # String | 
body =  # DocumentForUpdateDTOJsonPatchDocument |  (optional)

try: 
    # Replaces a document.
    api_instance.v1_folder_id_documents_document_id_patch(folderId, documentId, body=body)
except ApiException as e:
    print("Exception when calling DocumentsApi->v1FolderIdDocumentsDocumentIdPatch: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.DocumentsApi;

import java.io.File;
import java.util.*;

public class DocumentsApiExample {

    public static void main(String[] args) {
        
        DocumentsApi apiInstance = new DocumentsApi();
        String folderId = folderId_example; // String | 
        DocumentForCreationDTO body = ; // DocumentForCreationDTO | 
        try {
            apiInstance.v1FolderIdDocumentsPost(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#v1FolderIdDocumentsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.DocumentsApi;

public class DocumentsApiExample {

    public static void main(String[] args) {
        DocumentsApi apiInstance = new DocumentsApi();
        String folderId = folderId_example; // String | 
        DocumentForCreationDTO body = ; // DocumentForCreationDTO | 
        try {
            apiInstance.v1FolderIdDocumentsPost(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling DocumentsApi#v1FolderIdDocumentsPost");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
DocumentForCreationDTO *body = ; //  (optional)

DocumentsApi *apiInstance = [[DocumentsApi alloc] init];

// Creates one or more new documents.
[apiInstance v1FolderIdDocumentsPostWith:folderId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.DocumentsApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdDocumentsPost(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdDocumentsPostExample
    {
        public void main()
        {

            var apiInstance = new DocumentsApi();
            var folderId = folderId_example;  // String | 
            var body = new DocumentForCreationDTO(); // DocumentForCreationDTO |  (optional) 

            try
            {
                // Creates one or more new documents.
                apiInstance.v1FolderIdDocumentsPost(folderId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling DocumentsApi.v1FolderIdDocumentsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiDocumentsApi();
$folderId = folderId_example; // String | 
$body = ; // DocumentForCreationDTO | 

try {
    $api_instance->v1FolderIdDocumentsPost($folderId, $body);
} catch (Exception $e) {
    echo 'Exception when calling DocumentsApi->v1FolderIdDocumentsPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::DocumentsApi;

my $api_instance = WWW::SwaggerClient::DocumentsApi->new();
my $folderId = folderId_example; # String | 
my $body = WWW::SwaggerClient::Object::DocumentForCreationDTO->new(); # DocumentForCreationDTO | 

eval { 
    $api_instance->v1FolderIdDocumentsPost(folderId => $folderId, body => $body);
};
if ($@) {
    warn "Exception when calling DocumentsApi->v1FolderIdDocumentsPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.DocumentsApi()
folderId = folderId_example # String | 
body =  # DocumentForCreationDTO |  (optional)

try: 
    # Creates one or more new documents.
    api_instance.v1_folder_id_documents_post(folderId, body=body)
except ApiException as e:
    print("Exception when calling DocumentsApi->v1FolderIdDocumentsPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FoldersApi;

import java.io.File;
import java.util.*;

public class FoldersApiExample {

    public static void main(String[] args) {
        
        FoldersApi apiInstance = new FoldersApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FoldersFolderIdContentGet(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling FoldersApi#v1FoldersFolderIdContentGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FoldersApi;

public class FoldersApiExample {

    public static void main(String[] args) {
        FoldersApi apiInstance = new FoldersApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FoldersFolderIdContentGet(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling FoldersApi#v1FoldersFolderIdContentGet");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 

FoldersApi *apiInstance = [[FoldersApi alloc] init];

// Retrieves content from a particular folder.
[apiInstance v1FoldersFolderIdContentGetWith:folderId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.FoldersApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FoldersFolderIdContentGet(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FoldersFolderIdContentGetExample
    {
        public void main()
        {

            var apiInstance = new FoldersApi();
            var folderId = folderId_example;  // String | 

            try
            {
                // Retrieves content from a particular folder.
                apiInstance.v1FoldersFolderIdContentGet(folderId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FoldersApi.v1FoldersFolderIdContentGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFoldersApi();
$folderId = folderId_example; // String | 

try {
    $api_instance->v1FoldersFolderIdContentGet($folderId);
} catch (Exception $e) {
    echo 'Exception when calling FoldersApi->v1FoldersFolderIdContentGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FoldersApi;

my $api_instance = WWW::SwaggerClient::FoldersApi->new();
my $folderId = folderId_example; # String | 

eval { 
    $api_instance->v1FoldersFolderIdContentGet(folderId => $folderId);
};
if ($@) {
    warn "Exception when calling FoldersApi->v1FoldersFolderIdContentGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FoldersApi()
folderId = folderId_example # String | 

try: 
    # Retrieves content from a particular folder.
    api_instance.v1_folders_folder_id_content_get(folderId)
except ApiException as e:
    print("Exception when calling FoldersApi->v1FoldersFolderIdContentGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FoldersApi;

import java.io.File;
import java.util.*;

public class FoldersApiExample {

    public static void main(String[] args) {
        
        FoldersApi apiInstance = new FoldersApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FoldersFolderIdDelete(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling FoldersApi#v1FoldersFolderIdDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FoldersApi;

public class FoldersApiExample {

    public static void main(String[] args) {
        FoldersApi apiInstance = new FoldersApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FoldersFolderIdDelete(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling FoldersApi#v1FoldersFolderIdDelete");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 

FoldersApi *apiInstance = [[FoldersApi alloc] init];

// Deletes a particular folder.
[apiInstance v1FoldersFolderIdDeleteWith:folderId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.FoldersApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FoldersFolderIdDelete(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FoldersFolderIdDeleteExample
    {
        public void main()
        {

            var apiInstance = new FoldersApi();
            var folderId = folderId_example;  // String | 

            try
            {
                // Deletes a particular folder.
                apiInstance.v1FoldersFolderIdDelete(folderId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FoldersApi.v1FoldersFolderIdDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFoldersApi();
$folderId = folderId_example; // String | 

try {
    $api_instance->v1FoldersFolderIdDelete($folderId);
} catch (Exception $e) {
    echo 'Exception when calling FoldersApi->v1FoldersFolderIdDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FoldersApi;

my $api_instance = WWW::SwaggerClient::FoldersApi->new();
my $folderId = folderId_example; # String | 

eval { 
    $api_instance->v1FoldersFolderIdDelete(folderId => $folderId);
};
if ($@) {
    warn "Exception when calling FoldersApi->v1FoldersFolderIdDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FoldersApi()
folderId = folderId_example # String | 

try: 
    # Deletes a particular folder.
    api_instance.v1_folders_folder_id_delete(folderId)
except ApiException as e:
    print("Exception when calling FoldersApi->v1FoldersFolderIdDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FoldersApi;

import java.io.File;
import java.util.*;

public class FoldersApiExample {

    public static void main(String[] args) {
        
        FoldersApi apiInstance = new FoldersApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FoldersFolderIdGet(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling FoldersApi#v1FoldersFolderIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FoldersApi;

public class FoldersApiExample {

    public static void main(String[] args) {
        FoldersApi apiInstance = new FoldersApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FoldersFolderIdGet(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling FoldersApi#v1FoldersFolderIdGet");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 

FoldersApi *apiInstance = [[FoldersApi alloc] init];

// Retrieves a particular folder.
[apiInstance v1FoldersFolderIdGetWith:folderId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.FoldersApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FoldersFolderIdGet(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FoldersFolderIdGetExample
    {
        public void main()
        {

            var apiInstance = new FoldersApi();
            var folderId = folderId_example;  // String | 

            try
            {
                // Retrieves a particular folder.
                apiInstance.v1FoldersFolderIdGet(folderId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FoldersApi.v1FoldersFolderIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFoldersApi();
$folderId = folderId_example; // String | 

try {
    $api_instance->v1FoldersFolderIdGet($folderId);
} catch (Exception $e) {
    echo 'Exception when calling FoldersApi->v1FoldersFolderIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FoldersApi;

my $api_instance = WWW::SwaggerClient::FoldersApi->new();
my $folderId = folderId_example; # String | 

eval { 
    $api_instance->v1FoldersFolderIdGet(folderId => $folderId);
};
if ($@) {
    warn "Exception when calling FoldersApi->v1FoldersFolderIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FoldersApi()
folderId = folderId_example # String | 

try: 
    # Retrieves a particular folder.
    api_instance.v1_folders_folder_id_get(folderId)
except ApiException as e:
    print("Exception when calling FoldersApi->v1FoldersFolderIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FoldersApi;

import java.io.File;
import java.util.*;

public class FoldersApiExample {

    public static void main(String[] args) {
        
        FoldersApi apiInstance = new FoldersApi();
        String folderId = folderId_example; // String | 
        FolderForUpdateDTOJsonPatchDocument body = ; // FolderForUpdateDTOJsonPatchDocument | 
        try {
            apiInstance.v1FoldersFolderIdPatch(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FoldersApi#v1FoldersFolderIdPatch");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FoldersApi;

public class FoldersApiExample {

    public static void main(String[] args) {
        FoldersApi apiInstance = new FoldersApi();
        String folderId = folderId_example; // String | 
        FolderForUpdateDTOJsonPatchDocument body = ; // FolderForUpdateDTOJsonPatchDocument | 
        try {
            apiInstance.v1FoldersFolderIdPatch(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FoldersApi#v1FoldersFolderIdPatch");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
FolderForUpdateDTOJsonPatchDocument *body = ; //  (optional)

FoldersApi *apiInstance = [[FoldersApi alloc] init];

// Replaces a particular folder.
[apiInstance v1FoldersFolderIdPatchWith:folderId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.FoldersApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FoldersFolderIdPatch(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FoldersFolderIdPatchExample
    {
        public void main()
        {

            var apiInstance = new FoldersApi();
            var folderId = folderId_example;  // String | 
            var body = new FolderForUpdateDTOJsonPatchDocument(); // FolderForUpdateDTOJsonPatchDocument |  (optional) 

            try
            {
                // Replaces a particular folder.
                apiInstance.v1FoldersFolderIdPatch(folderId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FoldersApi.v1FoldersFolderIdPatch: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFoldersApi();
$folderId = folderId_example; // String | 
$body = ; // FolderForUpdateDTOJsonPatchDocument | 

try {
    $api_instance->v1FoldersFolderIdPatch($folderId, $body);
} catch (Exception $e) {
    echo 'Exception when calling FoldersApi->v1FoldersFolderIdPatch: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FoldersApi;

my $api_instance = WWW::SwaggerClient::FoldersApi->new();
my $folderId = folderId_example; # String | 
my $body = WWW::SwaggerClient::Object::FolderForUpdateDTOJsonPatchDocument->new(); # FolderForUpdateDTOJsonPatchDocument | 

eval { 
    $api_instance->v1FoldersFolderIdPatch(folderId => $folderId, body => $body);
};
if ($@) {
    warn "Exception when calling FoldersApi->v1FoldersFolderIdPatch: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FoldersApi()
folderId = folderId_example # String | 
body =  # FolderForUpdateDTOJsonPatchDocument |  (optional)

try: 
    # Replaces a particular folder.
    api_instance.v1_folders_folder_id_patch(folderId, body=body)
except ApiException as e:
    print("Exception when calling FoldersApi->v1FoldersFolderIdPatch: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FoldersApi;

import java.io.File;
import java.util.*;

public class FoldersApiExample {

    public static void main(String[] args) {
        
        FoldersApi apiInstance = new FoldersApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        try {
            apiInstance.v1FoldersFolderIdSummaryDocumentIdGet(folderId, documentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling FoldersApi#v1FoldersFolderIdSummaryDocumentIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FoldersApi;

public class FoldersApiExample {

    public static void main(String[] args) {
        FoldersApi apiInstance = new FoldersApi();
        String folderId = folderId_example; // String | 
        String documentId = documentId_example; // String | 
        try {
            apiInstance.v1FoldersFolderIdSummaryDocumentIdGet(folderId, documentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling FoldersApi#v1FoldersFolderIdSummaryDocumentIdGet");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
String *documentId = documentId_example; // 

FoldersApi *apiInstance = [[FoldersApi alloc] init];

// Retrieves a particular document from a given folder.
[apiInstance v1FoldersFolderIdSummaryDocumentIdGetWith:folderId
    documentId:documentId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.FoldersApi()
var folderId = folderId_example; // {{String}} 
var documentId = documentId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FoldersFolderIdSummaryDocumentIdGet(folderId, documentId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FoldersFolderIdSummaryDocumentIdGetExample
    {
        public void main()
        {

            var apiInstance = new FoldersApi();
            var folderId = folderId_example;  // String | 
            var documentId = documentId_example;  // String | 

            try
            {
                // Retrieves a particular document from a given folder.
                apiInstance.v1FoldersFolderIdSummaryDocumentIdGet(folderId, documentId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FoldersApi.v1FoldersFolderIdSummaryDocumentIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFoldersApi();
$folderId = folderId_example; // String | 
$documentId = documentId_example; // String | 

try {
    $api_instance->v1FoldersFolderIdSummaryDocumentIdGet($folderId, $documentId);
} catch (Exception $e) {
    echo 'Exception when calling FoldersApi->v1FoldersFolderIdSummaryDocumentIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FoldersApi;

my $api_instance = WWW::SwaggerClient::FoldersApi->new();
my $folderId = folderId_example; # String | 
my $documentId = documentId_example; # String | 

eval { 
    $api_instance->v1FoldersFolderIdSummaryDocumentIdGet(folderId => $folderId, documentId => $documentId);
};
if ($@) {
    warn "Exception when calling FoldersApi->v1FoldersFolderIdSummaryDocumentIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FoldersApi()
folderId = folderId_example # String | 
documentId = documentId_example # String | 

try: 
    # Retrieves a particular document from a given folder.
    api_instance.v1_folders_folder_id_summary_document_id_get(folderId, documentId)
except ApiException as e:
    print("Exception when calling FoldersApi->v1FoldersFolderIdSummaryDocumentIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.FoldersApi;

import java.io.File;
import java.util.*;

public class FoldersApiExample {

    public static void main(String[] args) {
        
        FoldersApi apiInstance = new FoldersApi();
        FolderForCreationDTO body = ; // FolderForCreationDTO | 
        try {
            apiInstance.v1FoldersPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FoldersApi#v1FoldersPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.FoldersApi;

public class FoldersApiExample {

    public static void main(String[] args) {
        FoldersApi apiInstance = new FoldersApi();
        FolderForCreationDTO body = ; // FolderForCreationDTO | 
        try {
            apiInstance.v1FoldersPost(body);
        } catch (ApiException e) {
            System.err.println("Exception when calling FoldersApi#v1FoldersPost");
            e.printStackTrace();
        }
    }
}

FolderForCreationDTO *body = ; //  (optional)

FoldersApi *apiInstance = [[FoldersApi alloc] init];

// Creates a new folder.
[apiInstance v1FoldersPostWith:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.FoldersApi()

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FoldersPost(, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FoldersPostExample
    {
        public void main()
        {

            var apiInstance = new FoldersApi();
            var body = new FolderForCreationDTO(); // FolderForCreationDTO |  (optional) 

            try
            {
                // Creates a new folder.
                apiInstance.v1FoldersPost(body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling FoldersApi.v1FoldersPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiFoldersApi();
$body = ; // FolderForCreationDTO | 

try {
    $api_instance->v1FoldersPost($body);
} catch (Exception $e) {
    echo 'Exception when calling FoldersApi->v1FoldersPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::FoldersApi;

my $api_instance = WWW::SwaggerClient::FoldersApi->new();
my $body = WWW::SwaggerClient::Object::FolderForCreationDTO->new(); # FolderForCreationDTO | 

eval { 
    $api_instance->v1FoldersPost(body => $body);
};
if ($@) {
    warn "Exception when calling FoldersApi->v1FoldersPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.FoldersApi()
body =  # FolderForCreationDTO |  (optional)

try: 
    # Creates a new folder.
    api_instance.v1_folders_post(body=body)
except ApiException as e:
    print("Exception when calling FoldersApi->v1FoldersPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.InvitesApi;

import java.io.File;
import java.util.*;

public class InvitesApiExample {

    public static void main(String[] args) {
        
        InvitesApi apiInstance = new InvitesApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FolderIdInvitesPost(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InvitesApi#v1FolderIdInvitesPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.InvitesApi;

public class InvitesApiExample {

    public static void main(String[] args) {
        InvitesApi apiInstance = new InvitesApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FolderIdInvitesPost(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling InvitesApi#v1FolderIdInvitesPost");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 

InvitesApi *apiInstance = [[InvitesApi alloc] init];

// Creates new invites within a given folder.
[apiInstance v1FolderIdInvitesPostWith:folderId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.InvitesApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdInvitesPost(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdInvitesPostExample
    {
        public void main()
        {

            var apiInstance = new InvitesApi();
            var folderId = folderId_example;  // String | 

            try
            {
                // Creates new invites within a given folder.
                apiInstance.v1FolderIdInvitesPost(folderId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling InvitesApi.v1FolderIdInvitesPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiInvitesApi();
$folderId = folderId_example; // String | 

try {
    $api_instance->v1FolderIdInvitesPost($folderId);
} catch (Exception $e) {
    echo 'Exception when calling InvitesApi->v1FolderIdInvitesPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::InvitesApi;

my $api_instance = WWW::SwaggerClient::InvitesApi->new();
my $folderId = folderId_example; # String | 

eval { 
    $api_instance->v1FolderIdInvitesPost(folderId => $folderId);
};
if ($@) {
    warn "Exception when calling InvitesApi->v1FolderIdInvitesPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.InvitesApi()
folderId = folderId_example # String | 

try: 
    # Creates new invites within a given folder.
    api_instance.v1_folder_id_invites_post(folderId)
except ApiException as e:
    print("Exception when calling InvitesApi->v1FolderIdInvitesPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.LinksApi;

import java.io.File;
import java.util.*;

public class LinksApiExample {

    public static void main(String[] args) {
        
        LinksApi apiInstance = new LinksApi();
        String folderId = folderId_example; // String | 
        Link body = ; // Link | 
        try {
            apiInstance.v1LinksFolderIdGet(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling LinksApi#v1LinksFolderIdGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.LinksApi;

public class LinksApiExample {

    public static void main(String[] args) {
        LinksApi apiInstance = new LinksApi();
        String folderId = folderId_example; // String | 
        Link body = ; // Link | 
        try {
            apiInstance.v1LinksFolderIdGet(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling LinksApi#v1LinksFolderIdGet");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
Link *body = ; //  (optional)

LinksApi *apiInstance = [[LinksApi alloc] init];

[apiInstance v1LinksFolderIdGetWith:folderId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.LinksApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1LinksFolderIdGet(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1LinksFolderIdGetExample
    {
        public void main()
        {

            var apiInstance = new LinksApi();
            var folderId = folderId_example;  // String | 
            var body = new Link(); // Link |  (optional) 

            try
            {
                apiInstance.v1LinksFolderIdGet(folderId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling LinksApi.v1LinksFolderIdGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiLinksApi();
$folderId = folderId_example; // String | 
$body = ; // Link | 

try {
    $api_instance->v1LinksFolderIdGet($folderId, $body);
} catch (Exception $e) {
    echo 'Exception when calling LinksApi->v1LinksFolderIdGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::LinksApi;

my $api_instance = WWW::SwaggerClient::LinksApi->new();
my $folderId = folderId_example; # String | 
my $body = WWW::SwaggerClient::Object::Link->new(); # Link | 

eval { 
    $api_instance->v1LinksFolderIdGet(folderId => $folderId, body => $body);
};
if ($@) {
    warn "Exception when calling LinksApi->v1LinksFolderIdGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.LinksApi()
folderId = folderId_example # String | 
body =  # Link |  (optional)

try: 
    api_instance.v1_links_folder_id_get(folderId, body=body)
except ApiException as e:
    print("Exception when calling LinksApi->v1LinksFolderIdGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParticipantsApi;

import java.io.File;
import java.util.*;

public class ParticipantsApiExample {

    public static void main(String[] args) {
        
        ParticipantsApi apiInstance = new ParticipantsApi();
        String folderId = folderId_example; // String | 
        ParticipantForDeletionDTO body = ; // ParticipantForDeletionDTO | 
        try {
            apiInstance.v1FolderIdParticipantsDelete(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParticipantsApi#v1FolderIdParticipantsDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParticipantsApi;

public class ParticipantsApiExample {

    public static void main(String[] args) {
        ParticipantsApi apiInstance = new ParticipantsApi();
        String folderId = folderId_example; // String | 
        ParticipantForDeletionDTO body = ; // ParticipantForDeletionDTO | 
        try {
            apiInstance.v1FolderIdParticipantsDelete(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParticipantsApi#v1FolderIdParticipantsDelete");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
ParticipantForDeletionDTO *body = ; //  (optional)

ParticipantsApi *apiInstance = [[ParticipantsApi alloc] init];

// Deletes one or more participants in a given folder.
[apiInstance v1FolderIdParticipantsDeleteWith:folderId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.ParticipantsApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdParticipantsDelete(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdParticipantsDeleteExample
    {
        public void main()
        {

            var apiInstance = new ParticipantsApi();
            var folderId = folderId_example;  // String | 
            var body = new ParticipantForDeletionDTO(); // ParticipantForDeletionDTO |  (optional) 

            try
            {
                // Deletes one or more participants in a given folder.
                apiInstance.v1FolderIdParticipantsDelete(folderId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParticipantsApi.v1FolderIdParticipantsDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParticipantsApi();
$folderId = folderId_example; // String | 
$body = ; // ParticipantForDeletionDTO | 

try {
    $api_instance->v1FolderIdParticipantsDelete($folderId, $body);
} catch (Exception $e) {
    echo 'Exception when calling ParticipantsApi->v1FolderIdParticipantsDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParticipantsApi;

my $api_instance = WWW::SwaggerClient::ParticipantsApi->new();
my $folderId = folderId_example; # String | 
my $body = WWW::SwaggerClient::Object::ParticipantForDeletionDTO->new(); # ParticipantForDeletionDTO | 

eval { 
    $api_instance->v1FolderIdParticipantsDelete(folderId => $folderId, body => $body);
};
if ($@) {
    warn "Exception when calling ParticipantsApi->v1FolderIdParticipantsDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ParticipantsApi()
folderId = folderId_example # String | 
body =  # ParticipantForDeletionDTO |  (optional)

try: 
    # Deletes one or more participants in a given folder.
    api_instance.v1_folder_id_participants_delete(folderId, body=body)
except ApiException as e:
    print("Exception when calling ParticipantsApi->v1FolderIdParticipantsDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParticipantsApi;

import java.io.File;
import java.util.*;

public class ParticipantsApiExample {

    public static void main(String[] args) {
        
        ParticipantsApi apiInstance = new ParticipantsApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FolderIdParticipantsGet(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParticipantsApi#v1FolderIdParticipantsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParticipantsApi;

public class ParticipantsApiExample {

    public static void main(String[] args) {
        ParticipantsApi apiInstance = new ParticipantsApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FolderIdParticipantsGet(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParticipantsApi#v1FolderIdParticipantsGet");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 

ParticipantsApi *apiInstance = [[ParticipantsApi alloc] init];

// Retrieves one or more participants from a given folder.
[apiInstance v1FolderIdParticipantsGetWith:folderId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.ParticipantsApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdParticipantsGet(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdParticipantsGetExample
    {
        public void main()
        {

            var apiInstance = new ParticipantsApi();
            var folderId = folderId_example;  // String | 

            try
            {
                // Retrieves one or more participants from a given folder.
                apiInstance.v1FolderIdParticipantsGet(folderId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParticipantsApi.v1FolderIdParticipantsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParticipantsApi();
$folderId = folderId_example; // String | 

try {
    $api_instance->v1FolderIdParticipantsGet($folderId);
} catch (Exception $e) {
    echo 'Exception when calling ParticipantsApi->v1FolderIdParticipantsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParticipantsApi;

my $api_instance = WWW::SwaggerClient::ParticipantsApi->new();
my $folderId = folderId_example; # String | 

eval { 
    $api_instance->v1FolderIdParticipantsGet(folderId => $folderId);
};
if ($@) {
    warn "Exception when calling ParticipantsApi->v1FolderIdParticipantsGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ParticipantsApi()
folderId = folderId_example # String | 

try: 
    # Retrieves one or more participants from a given folder.
    api_instance.v1_folder_id_participants_get(folderId)
except ApiException as e:
    print("Exception when calling ParticipantsApi->v1FolderIdParticipantsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParticipantsApi;

import java.io.File;
import java.util.*;

public class ParticipantsApiExample {

    public static void main(String[] args) {
        
        ParticipantsApi apiInstance = new ParticipantsApi();
        String folderId = folderId_example; // String | 
        ParticipantForCreationDTO body = ; // ParticipantForCreationDTO | 
        try {
            apiInstance.v1FolderIdParticipantsPost(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParticipantsApi#v1FolderIdParticipantsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParticipantsApi;

public class ParticipantsApiExample {

    public static void main(String[] args) {
        ParticipantsApi apiInstance = new ParticipantsApi();
        String folderId = folderId_example; // String | 
        ParticipantForCreationDTO body = ; // ParticipantForCreationDTO | 
        try {
            apiInstance.v1FolderIdParticipantsPost(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParticipantsApi#v1FolderIdParticipantsPost");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
ParticipantForCreationDTO *body = ; //  (optional)

ParticipantsApi *apiInstance = [[ParticipantsApi alloc] init];

// Creates one or more new participants in a given folder.
[apiInstance v1FolderIdParticipantsPostWith:folderId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.ParticipantsApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdParticipantsPost(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdParticipantsPostExample
    {
        public void main()
        {

            var apiInstance = new ParticipantsApi();
            var folderId = folderId_example;  // String | 
            var body = new ParticipantForCreationDTO(); // ParticipantForCreationDTO |  (optional) 

            try
            {
                // Creates one or more new participants in a given folder.
                apiInstance.v1FolderIdParticipantsPost(folderId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParticipantsApi.v1FolderIdParticipantsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParticipantsApi();
$folderId = folderId_example; // String | 
$body = ; // ParticipantForCreationDTO | 

try {
    $api_instance->v1FolderIdParticipantsPost($folderId, $body);
} catch (Exception $e) {
    echo 'Exception when calling ParticipantsApi->v1FolderIdParticipantsPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParticipantsApi;

my $api_instance = WWW::SwaggerClient::ParticipantsApi->new();
my $folderId = folderId_example; # String | 
my $body = WWW::SwaggerClient::Object::ParticipantForCreationDTO->new(); # ParticipantForCreationDTO | 

eval { 
    $api_instance->v1FolderIdParticipantsPost(folderId => $folderId, body => $body);
};
if ($@) {
    warn "Exception when calling ParticipantsApi->v1FolderIdParticipantsPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ParticipantsApi()
folderId = folderId_example # String | 
body =  # ParticipantForCreationDTO |  (optional)

try: 
    # Creates one or more new participants in a given folder.
    api_instance.v1_folder_id_participants_post(folderId, body=body)
except ApiException as e:
    print("Exception when calling ParticipantsApi->v1FolderIdParticipantsPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ParticipantsApi;

import java.io.File;
import java.util.*;

public class ParticipantsApiExample {

    public static void main(String[] args) {
        
        ParticipantsApi apiInstance = new ParticipantsApi();
        String folderId = folderId_example; // String | 
        ParticipantForUpdateDTOJsonPatchDocument body = ; // ParticipantForUpdateDTOJsonPatchDocument | 
        try {
            apiInstance.v1FolderIdParticipantsPut(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParticipantsApi#v1FolderIdParticipantsPut");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ParticipantsApi;

public class ParticipantsApiExample {

    public static void main(String[] args) {
        ParticipantsApi apiInstance = new ParticipantsApi();
        String folderId = folderId_example; // String | 
        ParticipantForUpdateDTOJsonPatchDocument body = ; // ParticipantForUpdateDTOJsonPatchDocument | 
        try {
            apiInstance.v1FolderIdParticipantsPut(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ParticipantsApi#v1FolderIdParticipantsPut");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
ParticipantForUpdateDTOJsonPatchDocument *body = ; //  (optional)

ParticipantsApi *apiInstance = [[ParticipantsApi alloc] init];

// Updates one or more participants in a given folder.
[apiInstance v1FolderIdParticipantsPutWith:folderId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.ParticipantsApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdParticipantsPut(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdParticipantsPutExample
    {
        public void main()
        {

            var apiInstance = new ParticipantsApi();
            var folderId = folderId_example;  // String | 
            var body = new ParticipantForUpdateDTOJsonPatchDocument(); // ParticipantForUpdateDTOJsonPatchDocument |  (optional) 

            try
            {
                // Updates one or more participants in a given folder.
                apiInstance.v1FolderIdParticipantsPut(folderId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ParticipantsApi.v1FolderIdParticipantsPut: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiParticipantsApi();
$folderId = folderId_example; // String | 
$body = ; // ParticipantForUpdateDTOJsonPatchDocument | 

try {
    $api_instance->v1FolderIdParticipantsPut($folderId, $body);
} catch (Exception $e) {
    echo 'Exception when calling ParticipantsApi->v1FolderIdParticipantsPut: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ParticipantsApi;

my $api_instance = WWW::SwaggerClient::ParticipantsApi->new();
my $folderId = folderId_example; # String | 
my $body = WWW::SwaggerClient::Object::ParticipantForUpdateDTOJsonPatchDocument->new(); # ParticipantForUpdateDTOJsonPatchDocument | 

eval { 
    $api_instance->v1FolderIdParticipantsPut(folderId => $folderId, body => $body);
};
if ($@) {
    warn "Exception when calling ParticipantsApi->v1FolderIdParticipantsPut: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ParticipantsApi()
folderId = folderId_example # String | 
body =  # ParticipantForUpdateDTOJsonPatchDocument |  (optional)

try: 
    # Updates one or more participants in a given folder.
    api_instance.v1_folder_id_participants_put(folderId, body=body)
except ApiException as e:
    print("Exception when calling ParticipantsApi->v1FolderIdParticipantsPut: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PaymentsApi;

import java.io.File;
import java.util.*;

public class PaymentsApiExample {

    public static void main(String[] args) {
        
        PaymentsApi apiInstance = new PaymentsApi();
        String folderId = folderId_example; // String | 
        String paymentId = paymentId_example; // String | 
        try {
            apiInstance.v1FolderIdPaymentsDelete(folderId, paymentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentsApi#v1FolderIdPaymentsDelete");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PaymentsApi;

public class PaymentsApiExample {

    public static void main(String[] args) {
        PaymentsApi apiInstance = new PaymentsApi();
        String folderId = folderId_example; // String | 
        String paymentId = paymentId_example; // String | 
        try {
            apiInstance.v1FolderIdPaymentsDelete(folderId, paymentId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentsApi#v1FolderIdPaymentsDelete");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
String *paymentId = paymentId_example; //  (optional)

PaymentsApi *apiInstance = [[PaymentsApi alloc] init];

// Deletes one or more payment records in a given folder.
[apiInstance v1FolderIdPaymentsDeleteWith:folderId
    paymentId:paymentId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.PaymentsApi()
var folderId = folderId_example; // {{String}} 
var opts = { 
  'paymentId': paymentId_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdPaymentsDelete(folderId, opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdPaymentsDeleteExample
    {
        public void main()
        {

            var apiInstance = new PaymentsApi();
            var folderId = folderId_example;  // String | 
            var paymentId = paymentId_example;  // String |  (optional) 

            try
            {
                // Deletes one or more payment records in a given folder.
                apiInstance.v1FolderIdPaymentsDelete(folderId, paymentId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PaymentsApi.v1FolderIdPaymentsDelete: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPaymentsApi();
$folderId = folderId_example; // String | 
$paymentId = paymentId_example; // String | 

try {
    $api_instance->v1FolderIdPaymentsDelete($folderId, $paymentId);
} catch (Exception $e) {
    echo 'Exception when calling PaymentsApi->v1FolderIdPaymentsDelete: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PaymentsApi;

my $api_instance = WWW::SwaggerClient::PaymentsApi->new();
my $folderId = folderId_example; # String | 
my $paymentId = paymentId_example; # String | 

eval { 
    $api_instance->v1FolderIdPaymentsDelete(folderId => $folderId, paymentId => $paymentId);
};
if ($@) {
    warn "Exception when calling PaymentsApi->v1FolderIdPaymentsDelete: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.PaymentsApi()
folderId = folderId_example # String | 
paymentId = paymentId_example # String |  (optional)

try: 
    # Deletes one or more payment records in a given folder.
    api_instance.v1_folder_id_payments_delete(folderId, paymentId=paymentId)
except ApiException as e:
    print("Exception when calling PaymentsApi->v1FolderIdPaymentsDelete: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PaymentsApi;

import java.io.File;
import java.util.*;

public class PaymentsApiExample {

    public static void main(String[] args) {
        
        PaymentsApi apiInstance = new PaymentsApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FolderIdPaymentsGet(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentsApi#v1FolderIdPaymentsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PaymentsApi;

public class PaymentsApiExample {

    public static void main(String[] args) {
        PaymentsApi apiInstance = new PaymentsApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FolderIdPaymentsGet(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentsApi#v1FolderIdPaymentsGet");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 

PaymentsApi *apiInstance = [[PaymentsApi alloc] init];

// Retrieves a payment.
[apiInstance v1FolderIdPaymentsGetWith:folderId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.PaymentsApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdPaymentsGet(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdPaymentsGetExample
    {
        public void main()
        {

            var apiInstance = new PaymentsApi();
            var folderId = folderId_example;  // String | 

            try
            {
                // Retrieves a payment.
                apiInstance.v1FolderIdPaymentsGet(folderId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PaymentsApi.v1FolderIdPaymentsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPaymentsApi();
$folderId = folderId_example; // String | 

try {
    $api_instance->v1FolderIdPaymentsGet($folderId);
} catch (Exception $e) {
    echo 'Exception when calling PaymentsApi->v1FolderIdPaymentsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PaymentsApi;

my $api_instance = WWW::SwaggerClient::PaymentsApi->new();
my $folderId = folderId_example; # String | 

eval { 
    $api_instance->v1FolderIdPaymentsGet(folderId => $folderId);
};
if ($@) {
    warn "Exception when calling PaymentsApi->v1FolderIdPaymentsGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.PaymentsApi()
folderId = folderId_example # String | 

try: 
    # Retrieves a payment.
    api_instance.v1_folder_id_payments_get(folderId)
except ApiException as e:
    print("Exception when calling PaymentsApi->v1FolderIdPaymentsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.PaymentsApi;

import java.io.File;
import java.util.*;

public class PaymentsApiExample {

    public static void main(String[] args) {
        
        PaymentsApi apiInstance = new PaymentsApi();
        String folderId = folderId_example; // String | 
        PaymentForCreationDTO body = ; // PaymentForCreationDTO | 
        try {
            apiInstance.v1FolderIdPaymentsPost(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentsApi#v1FolderIdPaymentsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.PaymentsApi;

public class PaymentsApiExample {

    public static void main(String[] args) {
        PaymentsApi apiInstance = new PaymentsApi();
        String folderId = folderId_example; // String | 
        PaymentForCreationDTO body = ; // PaymentForCreationDTO | 
        try {
            apiInstance.v1FolderIdPaymentsPost(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling PaymentsApi#v1FolderIdPaymentsPost");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
PaymentForCreationDTO *body = ; //  (optional)

PaymentsApi *apiInstance = [[PaymentsApi alloc] init];

// Creates a new payment.
[apiInstance v1FolderIdPaymentsPostWith:folderId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.PaymentsApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdPaymentsPost(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdPaymentsPostExample
    {
        public void main()
        {

            var apiInstance = new PaymentsApi();
            var folderId = folderId_example;  // String | 
            var body = new PaymentForCreationDTO(); // PaymentForCreationDTO |  (optional) 

            try
            {
                // Creates a new payment.
                apiInstance.v1FolderIdPaymentsPost(folderId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling PaymentsApi.v1FolderIdPaymentsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiPaymentsApi();
$folderId = folderId_example; // String | 
$body = ; // PaymentForCreationDTO | 

try {
    $api_instance->v1FolderIdPaymentsPost($folderId, $body);
} catch (Exception $e) {
    echo 'Exception when calling PaymentsApi->v1FolderIdPaymentsPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::PaymentsApi;

my $api_instance = WWW::SwaggerClient::PaymentsApi->new();
my $folderId = folderId_example; # String | 
my $body = WWW::SwaggerClient::Object::PaymentForCreationDTO->new(); # PaymentForCreationDTO | 

eval { 
    $api_instance->v1FolderIdPaymentsPost(folderId => $folderId, body => $body);
};
if ($@) {
    warn "Exception when calling PaymentsApi->v1FolderIdPaymentsPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.PaymentsApi()
folderId = folderId_example # String | 
body =  # PaymentForCreationDTO |  (optional)

try: 
    # Creates a new payment.
    api_instance.v1_folder_id_payments_post(folderId, body=body)
except ApiException as e:
    print("Exception when calling PaymentsApi->v1FolderIdPaymentsPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReferenceDocumentsApi;

import java.io.File;
import java.util.*;

public class ReferenceDocumentsApiExample {

    public static void main(String[] args) {
        
        ReferenceDocumentsApi apiInstance = new ReferenceDocumentsApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FolderIdReferencedocumentsGet(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReferenceDocumentsApi#v1FolderIdReferencedocumentsGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReferenceDocumentsApi;

public class ReferenceDocumentsApiExample {

    public static void main(String[] args) {
        ReferenceDocumentsApi apiInstance = new ReferenceDocumentsApi();
        String folderId = folderId_example; // String | 
        try {
            apiInstance.v1FolderIdReferencedocumentsGet(folderId);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReferenceDocumentsApi#v1FolderIdReferencedocumentsGet");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 

ReferenceDocumentsApi *apiInstance = [[ReferenceDocumentsApi alloc] init];

// Retrieves one or more reference documents from a given folder.
[apiInstance v1FolderIdReferencedocumentsGetWith:folderId
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.ReferenceDocumentsApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdReferencedocumentsGet(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdReferencedocumentsGetExample
    {
        public void main()
        {

            var apiInstance = new ReferenceDocumentsApi();
            var folderId = folderId_example;  // String | 

            try
            {
                // Retrieves one or more reference documents from a given folder.
                apiInstance.v1FolderIdReferencedocumentsGet(folderId);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReferenceDocumentsApi.v1FolderIdReferencedocumentsGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReferenceDocumentsApi();
$folderId = folderId_example; // String | 

try {
    $api_instance->v1FolderIdReferencedocumentsGet($folderId);
} catch (Exception $e) {
    echo 'Exception when calling ReferenceDocumentsApi->v1FolderIdReferencedocumentsGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReferenceDocumentsApi;

my $api_instance = WWW::SwaggerClient::ReferenceDocumentsApi->new();
my $folderId = folderId_example; # String | 

eval { 
    $api_instance->v1FolderIdReferencedocumentsGet(folderId => $folderId);
};
if ($@) {
    warn "Exception when calling ReferenceDocumentsApi->v1FolderIdReferencedocumentsGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReferenceDocumentsApi()
folderId = folderId_example # String | 

try: 
    # Retrieves one or more reference documents from a given folder.
    api_instance.v1_folder_id_referencedocuments_get(folderId)
except ApiException as e:
    print("Exception when calling ReferenceDocumentsApi->v1FolderIdReferencedocumentsGet: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.ReferenceDocumentsApi;

import java.io.File;
import java.util.*;

public class ReferenceDocumentsApiExample {

    public static void main(String[] args) {
        
        ReferenceDocumentsApi apiInstance = new ReferenceDocumentsApi();
        String folderId = folderId_example; // String | 
        ReferenceDocumentForCreationDTO body = ; // ReferenceDocumentForCreationDTO | 
        try {
            apiInstance.v1FolderIdReferencedocumentsPost(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReferenceDocumentsApi#v1FolderIdReferencedocumentsPost");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.ReferenceDocumentsApi;

public class ReferenceDocumentsApiExample {

    public static void main(String[] args) {
        ReferenceDocumentsApi apiInstance = new ReferenceDocumentsApi();
        String folderId = folderId_example; // String | 
        ReferenceDocumentForCreationDTO body = ; // ReferenceDocumentForCreationDTO | 
        try {
            apiInstance.v1FolderIdReferencedocumentsPost(folderId, body);
        } catch (ApiException e) {
            System.err.println("Exception when calling ReferenceDocumentsApi#v1FolderIdReferencedocumentsPost");
            e.printStackTrace();
        }
    }
}

String *folderId = folderId_example; // 
ReferenceDocumentForCreationDTO *body = ; //  (optional)

ReferenceDocumentsApi *apiInstance = [[ReferenceDocumentsApi alloc] init];

// Creates one or more reference documents in a given folder.
[apiInstance v1FolderIdReferencedocumentsPostWith:folderId
    body:body
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.ReferenceDocumentsApi()
var folderId = folderId_example; // {{String}} 

var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1FolderIdReferencedocumentsPost(folderId, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1FolderIdReferencedocumentsPostExample
    {
        public void main()
        {

            var apiInstance = new ReferenceDocumentsApi();
            var folderId = folderId_example;  // String | 
            var body = new ReferenceDocumentForCreationDTO(); // ReferenceDocumentForCreationDTO |  (optional) 

            try
            {
                // Creates one or more reference documents in a given folder.
                apiInstance.v1FolderIdReferencedocumentsPost(folderId, body);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling ReferenceDocumentsApi.v1FolderIdReferencedocumentsPost: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiReferenceDocumentsApi();
$folderId = folderId_example; // String | 
$body = ; // ReferenceDocumentForCreationDTO | 

try {
    $api_instance->v1FolderIdReferencedocumentsPost($folderId, $body);
} catch (Exception $e) {
    echo 'Exception when calling ReferenceDocumentsApi->v1FolderIdReferencedocumentsPost: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::ReferenceDocumentsApi;

my $api_instance = WWW::SwaggerClient::ReferenceDocumentsApi->new();
my $folderId = folderId_example; # String | 
my $body = WWW::SwaggerClient::Object::ReferenceDocumentForCreationDTO->new(); # ReferenceDocumentForCreationDTO | 

eval { 
    $api_instance->v1FolderIdReferencedocumentsPost(folderId => $folderId, body => $body);
};
if ($@) {
    warn "Exception when calling ReferenceDocumentsApi->v1FolderIdReferencedocumentsPost: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.ReferenceDocumentsApi()
folderId = folderId_example # String | 
body =  # ReferenceDocumentForCreationDTO |  (optional)

try: 
    # Creates one or more reference documents in a given folder.
    api_instance.v1_folder_id_referencedocuments_post(folderId, body=body)
except ApiException as e:
    print("Exception when calling ReferenceDocumentsApi->v1FolderIdReferencedocumentsPost: %s\n" % e)

import io.swagger.client.*;
import io.swagger.client.auth.*;
import io.swagger.client.model.*;
import io.swagger.client.api.UsersApi;

import java.io.File;
import java.util.*;

public class UsersApiExample {

    public static void main(String[] args) {
        
        UsersApi apiInstance = new UsersApi();
        String email = email_example; // String | 
        try {
            apiInstance.v1UsersGet(email);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#v1UsersGet");
            e.printStackTrace();
        }
    }
}

import io.swagger.client.api.UsersApi;

public class UsersApiExample {

    public static void main(String[] args) {
        UsersApi apiInstance = new UsersApi();
        String email = email_example; // String | 
        try {
            apiInstance.v1UsersGet(email);
        } catch (ApiException e) {
            System.err.println("Exception when calling UsersApi#v1UsersGet");
            e.printStackTrace();
        }
    }
}

String *email = email_example; //  (optional)

UsersApi *apiInstance = [[UsersApi alloc] init];

// Retrieves a list of one or more users.
[apiInstance v1UsersGetWith:email
              completionHandler: ^(NSError* error) {
                            if (error) {
                                NSLog(@"Error: %@", error);
                            }
                        }];

var SertifiApi = require('sertifi_api');

var api = new SertifiApi.UsersApi()
var opts = { 
  'email': email_example // {{String}} 
};
var callback = function(error, data, response) {
  if (error) {
    console.error(error);
  } else {
    console.log('API called successfully.');
  }
};
api.v1UsersGet(opts, callback);

using System;
using System.Diagnostics;
using IO.Swagger.Api;
using IO.Swagger.Client;
using IO.Swagger.Model;

namespace Example
{
    public class v1UsersGetExample
    {
        public void main()
        {

            var apiInstance = new UsersApi();
            var email = email_example;  // String |  (optional) 

            try
            {
                // Retrieves a list of one or more users.
                apiInstance.v1UsersGet(email);
            }
            catch (Exception e)
            {
                Debug.Print("Exception when calling UsersApi.v1UsersGet: " + e.Message );
            }
        }
    }
}

<?php
require_once(__DIR__ . '/vendor/autoload.php');

$api_instance = new Swagger\Client\ApiUsersApi();
$email = email_example; // String | 

try {
    $api_instance->v1UsersGet($email);
} catch (Exception $e) {
    echo 'Exception when calling UsersApi->v1UsersGet: ', $e->getMessage(), PHP_EOL;
}
?>

use Data::Dumper;
use WWW::SwaggerClient::Configuration;
use WWW::SwaggerClient::UsersApi;

my $api_instance = WWW::SwaggerClient::UsersApi->new();
my $email = email_example; # String | 

eval { 
    $api_instance->v1UsersGet(email => $email);
};
if ($@) {
    warn "Exception when calling UsersApi->v1UsersGet: $@\n";
}

from __future__ import print_statement
import time
import swagger_client
from swagger_client.rest import ApiException
from pprint import pprint

# create an instance of the API class
api_instance = swagger_client.UsersApi()
email = email_example # String |  (optional)

try: 
    # Retrieves a list of one or more users.
    api_instance.v1_users_get(email=email)
except ApiException as e:
    print("Exception when calling UsersApi->v1UsersGet: %s\n" % e)